agent-loft 0.2.32 → 0.2.34

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) => {

package/src/core/hub.ts

@@ -11,6 +11,7 @@ import crypto from "node:crypto";
 import { EventEmitter } from "node:events";
 import { config, onConfigChange, resolveWorkspacePath } from "./config.js";
 import { attachFooters, copyFooters, formatDuration, recordFooter } from "./footers.js";
+import { flushUsage, recordUsage, usageOf, type UsageTotals } from "./usage.js";
 import { interactions, SETTLEMENT_LABEL } from "./interactions.js";
 import {
   agentBinding,
@@ -65,7 +66,15 @@ export type Origin = {
 };
 
 export type ConvEvent =
-  | { type: "user"; text: string; attachments: string[]; files?: AttachmentInfo[]; origin: Origin }
+  /** id：这条消息的编号，后面的 queue 事件按它对上；queued：收到时前面还有在跑 / 在等的，要排队 */
+  | { type: "user"; text: string; attachments: string[]; files?: AttachmentInfo[]; origin: Origin; id?: string; queued?: boolean }
+  /** 排队的消息：轮到它了（started，或者被当成提问的回答用掉了），或者没发出去（dropped：停止、会话切换…） */
+  | { type: "queue"; id: string; state: "started" | "dropped" }
+  /**
+   * 这里弹出过一张授权 / 提问卡（内容和状态在 interactions 里按 id 查）。只是给卡片在对话里占个位置：
+   * 刷新页面时进行中的这一轮靠重放事件画出来，没有它卡片就丢了
+   */
+  | { type: "ix"; id: string }
   | { type: "turn_start" }
   | { type: "step"; kind: StepKind; text: string }
   | { type: "delta"; text: string }
@@ -141,6 +150,8 @@ export type ConversationInfo = {
   runtimeEffort?: string;
   /** 当前 agent 会话的上下文占用（这次启动以来跑过至少一轮才有） */
   context?: ContextUsage;
+  /** 当前 agent 会话累计消耗的 token（升级后跑过至少一轮才有） */
+  usage?: UsageTotals;
   busy: boolean;
   activeAt: number;
   createdAt: number;
@@ -190,6 +201,14 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
   private seq = 0;
   /** 每条会话还没收到结果的轮数，> 0 即忙 */
   private inflight = new Map<string, number>();
+  /**
+   * 已经交给 agent 会话、还没出结果的消息，和 inflight、turnTags 一一对应：第一条在跑，后面的在排队。
+   * 用来告诉页面哪条消息轮到了 / 被丢了，以及「打断并发送」时把哪条挪到前面
+   */
+  private turnFifo = new Map<string, { id: string; input: UserInput; queued: boolean }[]>();
+  /** 收到了、还在串行队列里没交给 agent 的消息数：这时再来的消息也算排队 */
+  private waitingSends = new Map<string, number>();
+  private msgSeq = 0;
   private announced = new Set<string>();
   /** 每条会话因缓冲区溢出被丢掉的最后一个 seq */
   private truncated = new Map<string, number>();
@@ -229,6 +248,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
   constructor() {
     super();
     this.setMaxListeners(100);
+    interactions.on("created", (i) => this.emitEvent(i.convKey, { type: "ix", id: i.id }));
     // 技能装了、改了、停用了、变量改了：受影响的人空闲的会话换上新的
     skillEvents.on("changed", (users) => this.personalChanged(new Set(users)));
     // workspaceRoot 改了：store 会把没显式 /cd 过的会话目录重置，正在跑的旧目录会话要作废
@@ -461,6 +481,10 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
         const ctx = binding.sessionId ? this.contextBySession.get(binding.sessionId) : undefined;
         return ctx ? { context: ctx } : {};
       })(),
+      ...(() => {
+        const usage = usageOf(binding.sessionId);
+        return usage ? { usage } : {};
+      })(),
       busy: this.isBusy(key),
       activeAt: conv.activeAt,
       createdAt: conv.createdAt,
@@ -581,6 +605,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
           const conv = getConversation(key);
           recordFooter(holder.session?.sessionId ?? (conv ? agentBinding(conv, agent).sessionId : undefined), result.text, footer);
           this.setInflight(key, (this.inflight.get(key) ?? 1) - 1);
+          this.finishTurn(key);
           this.refreshRuntimeOnce(key, liveId);
           this.syncTitle(key, agent);
           this.dropIfStale(key);
@@ -607,6 +632,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
             this.emitEvent(key, { type: "error", message: diagnosis.chatMessage });
           }
           this.setInflight(key, (this.inflight.get(key) ?? 1) - 1);
+          this.finishTurn(key);
           this.dropIfStale(key);
         },
         onContext: (ctx) => {
@@ -622,6 +648,14 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
           // Codex 一轮里会报好几次，数字没变就不打扰前端
           if (prev?.used !== ctx.used || prev?.window !== ctx.window) this.emitEvent(key, { type: "meta" });
         },
+        // 不用另发 meta：一轮结束的 result / error 会把会话信息（含用量）推给页面
+        onUsage: (usage, cumulative) => {
+          if (!alive()) return;
+          // 模型用来按单价估算没报费用的 agent（Codex）的金额
+          const current = getConversation(key);
+          const model = current ? this.displayRuntime(current, agentBinding(current, agent)).model : undefined;
+          recordUsage(holder.session?.sessionId, usage, cumulative, { owner: current?.owner, agent, model });
+        },
         onDropped: (n) => {
           if (!alive() || n <= 0) return;
           // 丢的是排在最后、还没开始的那 n 条（Codex 先报正在跑的那轮出错、再报丢弃，那时队头已经取走了）
@@ -630,6 +664,10 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
             if (tag) this.emit("task", { ...tag, key, status: "interrupted", text: "排队时被停止了" });
           }
           this.setInflight(key, (this.inflight.get(key) ?? n) - n);
+          // 第一条是在跑的那一轮（它自己会报结果），丢的只会是后面排队的
+          const fifo = this.turnFifo.get(key) ?? [];
+          const k = Math.min(n, Math.max(0, fifo.length - 1));
+          for (const e of fifo.splice(fifo.length - k, k)) this.emitEvent(key, { type: "queue", id: e.id, state: "dropped" });
         },
         onSessionId: (sessionId) => {
           // 切走之后旧会话晚到的回调不该覆盖新绑定
@@ -703,6 +741,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
     this.live.delete(key);
     for (const tag of this.turnTags.get(key) ?? []) if (tag) this.emit("task", { ...tag, key, status: "interrupted", text: note });
     this.turnTags.delete(key);
+    this.clearFifo(key);
     this.setInflight(key, 0);
     if (!existing) return;
     // dispose 卡住（CLI 不响应）不能把这条会话的操作队列永远堵死
@@ -831,6 +870,8 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
       attachments: input.attachments.map((a) => `${KIND_LABEL[a.kind]} ${a.name}`),
       files: input.attachments.map(attachmentInfo),
       origin,
+      id: `m${++this.msgSeq}`,
+      queued: false,
     };
     const by = `${origin.name ?? "用户"}以消息作答`;
 
@@ -865,29 +906,42 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
       updateConversation(key, { title: shown.text.trim().replace(/\s+/g, " ").slice(0, 40), titleAuto: true });
       this.emitEvent(key, { type: "meta" });
     }
+    // 前面有在跑的、或者还在串行队列里等着的：这条要排队
+    shown.queued = this.isBusy(key) || (this.waitingSends.get(key) ?? 0) > 0;
     this.emitEvent(key, shown);
+    const dropped = () => this.emitEvent(key, { type: "queue", id: shown.id, state: "dropped" });
     const gone = (text: string) => {
+      dropped();
       if (task) this.emit("task", { ...task, key, status: "interrupted", text });
     };
+    this.waitingSends.set(key, (this.waitingSends.get(key) ?? 0) + 1);
     void this.serial(key, async () => {
-      if (cancelled()) return gone("没有发出（停止了或者会话被切换了）");
-      if (questionAtEntry && tryAnswer(questionAtEntry)) return;
-      // 收到之后发生过显式切换（恢复 / 分叉 / 新会话…）：用户已经明确指定了会话，不再按旧的闲置时间作废它。
-      // 定时任务也不按闲置过期：每天跑一次的任务要接着上次的上下文
-      const ttl = config().sessionTtlMs;
-      const switchedAfterEntry = (this.lastSwitch.get(key)?.at ?? 0) >= g.at;
-      const expired = !task && !switchedAfterEntry && ttl > 0 && Date.now() - lastActive > ttl;
-      if (expired) {
-        await this.expireNow(key);
-        // 清理要等旧会话 dispose，期间可能又点了停止
-        if (cancelled()) return;
-      }
-      const blocked = await this.blockedSlash(key, input.text);
-      if (blocked) {
-        this.emitEvent(key, { type: "notice", text: blocked });
-        return gone(blocked);
+      try {
+        if (cancelled()) return gone("没有发出（停止了或者会话被切换了）");
+        if (questionAtEntry && tryAnswer(questionAtEntry)) {
+          // 被当成提问的回答用掉了：不再排队
+          if (shown.queued) this.emitEvent(key, { type: "queue", id: shown.id, state: "started" });
+          return;
+        }
+        // 收到之后发生过显式切换（恢复 / 分叉 / 新会话…）：用户已经明确指定了会话，不再按旧的闲置时间作废它。
+        // 定时任务也不按闲置过期：每天跑一次的任务要接着上次的上下文
+        const ttl = config().sessionTtlMs;
+        const switchedAfterEntry = (this.lastSwitch.get(key)?.at ?? 0) >= g.at;
+        const expired = !task && !switchedAfterEntry && ttl > 0 && Date.now() - lastActive > ttl;
+        if (expired) {
+          await this.expireNow(key);
+          // 清理要等旧会话 dispose，期间可能又点了停止
+          if (cancelled()) return dropped();
+        }
+        const blocked = await this.blockedSlash(key, input.text);
+        if (blocked) {
+          this.emitEvent(key, { type: "notice", text: blocked });
+          return gone(blocked);
+        }
+        this.sendNow(key, this.withMentions(key, input), task ?? null, { id: shown.id, queued: shown.queued });
+      } finally {
+        this.waitingSends.set(key, Math.max(0, (this.waitingSends.get(key) ?? 1) - 1));
       }
-      this.sendNow(key, this.withMentions(key, input), task ?? null);
     });
   }
 
@@ -946,7 +1000,8 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
     this.emitEvent(key, { type: "meta" });
   }
 
-  private sendNow(key: string, input: UserInput, tag: TaskTurn | null): void {
+  /** msg：页面上那条消息的编号和收到时是否排队（见 send 里的 shown） */
+  private sendNow(key: string, input: UserInput, tag: TaskTurn | null, msg: { id: string; queued: boolean }): void {
     const fail = (err: unknown) => {
       const message = err instanceof Error ? err.message : String(err);
       this.emitEvent(key, { type: "error", message });
@@ -963,12 +1018,22 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
     const tags = this.turnTags.get(key) ?? [];
     tags.push(tag);
     this.turnTags.set(key, tags);
+    const fifo = this.turnFifo.get(key) ?? [];
+    fifo.push({ id: msg.id, input, queued: msg.queued });
+    this.turnFifo.set(key, fifo);
     try {
       session.send(input);
     } catch (err) {
       tags.pop();
+      fifo.pop();
       this.setInflight(key, (this.inflight.get(key) ?? 1) - 1);
       fail(err);
+      return;
+    }
+    // 收到时在排队（前面的在串行队列里等着），交出去时前面已经空了：这就开始了
+    if (fifo.length === 1 && msg.queued) {
+      fifo[0]!.queued = false;
+      this.emitEvent(key, { type: "queue", id: msg.id, state: "started" });
     }
   }
 
@@ -1247,10 +1312,51 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
     // 和 inflight 一起清零：被打断的那一轮不一定还会报结果，留着的话下一轮的结果会被当成定时任务的
     for (const tag of this.turnTags.get(key) ?? []) if (tag) this.emit("task", { ...tag, key, status: "interrupted", text: "被停止了" });
     this.turnTags.delete(key);
+    this.clearFifo(key);
     this.setInflight(key, 0);
     return "已请求中断。";
   }
 
+  /**
+   * 打断并发送：停掉正在跑的这一轮，排着队的 id 这条挪到最前面，马上处理它；其余排着的照常接在后面。
+   * 和停止不同，不丢排队的消息、也不清计数 —— 被打断的这一轮会正常报结果（已中断），之后就轮到它
+   */
+  async jump(key: string, id: string): Promise<string> {
+    const fifo = this.turnFifo.get(key) ?? [];
+    const idx = fifo.findIndex((e) => e.id === id);
+    if (idx === 0) return "这条已经在处理了。";
+    const live = this.live.get(key);
+    if (idx < 0 || !live) return "这条消息已经不在排队了。";
+    const [entry] = fifo.splice(idx, 1);
+    fifo.splice(1, 0, entry!);
+    // turnTags 和 fifo 一一对应，一起挪
+    const tags = this.turnTags.get(key);
+    if (tags && tags.length === fifo.length) tags.splice(1, 0, ...tags.splice(idx, 1));
+    this.stoppedAt.set(key, Date.now());
+    interactions.cancelAll(key, "本轮已中断");
+    await live.session.interrupt({ keepQueue: true, first: entry!.input });
+    return "已打断，马上处理这条。";
+  }
+
+  /** 一轮出结果了：队首出队，下一条要是排过队的，告诉页面轮到它了 */
+  private finishTurn(key: string): void {
+    const fifo = this.turnFifo.get(key);
+    if (!fifo) return;
+    fifo.shift();
+    const next = fifo[0];
+    if (next?.queued) {
+      next.queued = false;
+      this.emitEvent(key, { type: "queue", id: next.id, state: "started" });
+    }
+    if (fifo.length === 0) this.turnFifo.delete(key);
+  }
+
+  /** 停止 / 会话丢了：在跑的那条不管（它的结果或中断自己会报），排着队的都没发出 */
+  private clearFifo(key: string): void {
+    for (const e of (this.turnFifo.get(key) ?? []).slice(1)) this.emitEvent(key, { type: "queue", id: e.id, state: "dropped" });
+    this.turnFifo.delete(key);
+  }
+
   private async cdNow(key: string, dir: string, op: SwitchOp): Promise<string> {
     const resolved = resolveWorkspacePath(dir);
     if (!resolved) return `不允许：目录必须存在，且在 ${config().workspaceRoot} 之内（不能经符号链接跳出去）。`;
@@ -1515,6 +1621,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }>
   async shutdown(): Promise<void> {
     for (const key of [...this.live.keys()]) await this.drop(key, "服务正在重启");
     for (const driver of this.drivers.values()) await driver.stop().catch(() => {});
+    flushUsage();
   }
 }
 

package/src/core/model-prices.json

@@ -0,0 +1,103 @@
+{
+  "chat-latest": [5,0.5,30],
+  "computer-use-preview": [3,null,12],
+  "computer-use-preview-2025-03-11": [3,null,12],
+  "daybreak-blue-latest": [4,0.4,20],
+  "daybreak-red-latest": [12.5,1.25,75],
+  "ft:gpt-3.5-turbo": [3,null,6],
+  "ft:gpt-3.5-turbo-0125": [3,null,6],
+  "ft:gpt-3.5-turbo-0613": [3,null,6],
+  "ft:gpt-3.5-turbo-1106": [3,null,6],
+  "ft:gpt-4-0613": [30,null,60],
+  "ft:gpt-4.1-2025-04-14": [3,0.75,12],
+  "ft:gpt-4.1-mini-2025-04-14": [0.8,0.2,3.2],
+  "ft:gpt-4.1-nano-2025-04-14": [0.2,0.05,0.8],
+  "ft:gpt-4o-2024-08-06": [3.75,1.875,15],
+  "ft:gpt-4o-2024-11-20": [3.75,null,15],
+  "ft:gpt-4o-mini-2024-07-18": [0.3,0.15,1.2],
+  "ft:o4-mini-2025-04-16": [4,1,16],
+  "gpt-3.5-turbo": [0.5,null,1.5],
+  "gpt-3.5-turbo-0125": [0.5,null,1.5],
+  "gpt-3.5-turbo-1106": [1,null,2],
+  "gpt-3.5-turbo-16k": [3,null,4],
+  "gpt-4": [30,null,60],
+  "gpt-4-0613": [30,null,60],
+  "gpt-4-1106-preview": [10,null,30],
+  "gpt-4-turbo": [10,null,30],
+  "gpt-4-turbo-2024-04-09": [10,null,30],
+  "gpt-4.1": [2,0.5,8],
+  "gpt-4.1-2025-04-14": [2,0.5,8],
+  "gpt-4.1-mini": [0.4,0.1,1.6],
+  "gpt-4.1-mini-2025-04-14": [0.4,0.1,1.6],
+  "gpt-4.1-nano": [0.1,0.025,0.4],
+  "gpt-4.1-nano-2025-04-14": [0.1,0.025,0.4],
+  "gpt-4o": [2.5,1.25,10],
+  "gpt-4o-2024-05-13": [5,null,15],
+  "gpt-4o-2024-08-06": [2.5,1.25,10],
+  "gpt-4o-2024-11-20": [2.5,1.25,10],
+  "gpt-4o-mini": [0.15,0.075,0.6],
+  "gpt-4o-mini-2024-07-18": [0.15,0.075,0.6],
+  "gpt-5": [1.25,0.125,10],
+  "gpt-5-2025-08-07": [1.25,0.125,10],
+  "gpt-5-chat": [1.25,0.125,10],
+  "gpt-5-chat-latest": [1.25,0.125,10],
+  "gpt-5-codex": [1.25,0.125,10],
+  "gpt-5-mini": [0.25,0.025,2],
+  "gpt-5-mini-2025-08-07": [0.25,0.025,2],
+  "gpt-5-nano": [0.05,0.005,0.4],
+  "gpt-5-nano-2025-08-07": [0.05,0.005,0.4],
+  "gpt-5-pro": [15,null,120],
+  "gpt-5-pro-2025-10-06": [15,null,120],
+  "gpt-5.1": [1.25,0.125,10],
+  "gpt-5.1-2025-11-13": [1.25,0.125,10],
+  "gpt-5.1-chat-latest": [1.25,0.125,10],
+  "gpt-5.1-codex": [1.25,0.125,10],
+  "gpt-5.1-codex-max": [1.25,0.125,10],
+  "gpt-5.1-codex-mini": [0.25,0.025,2],
+  "gpt-5.2": [1.75,0.175,14],
+  "gpt-5.2-2025-12-11": [1.75,0.175,14],
+  "gpt-5.2-chat-latest": [1.75,0.175,14],
+  "gpt-5.2-codex": [1.75,0.175,14],
+  "gpt-5.2-pro": [21,null,168],
+  "gpt-5.2-pro-2025-12-11": [21,null,168],
+  "gpt-5.3-chat-latest": [1.75,0.175,14],
+  "gpt-5.3-codex": [1.75,0.175,14],
+  "gpt-5.4": [2.5,0.25,15],
+  "gpt-5.4-2026-03-05": [2.5,0.25,15],
+  "gpt-5.4-mini": [0.75,0.075,4.5],
+  "gpt-5.4-mini-2026-03-17": [0.75,0.075,4.5],
+  "gpt-5.4-nano": [0.2,0.02,1.25],
+  "gpt-5.4-nano-2026-03-17": [0.2,0.02,1.25],
+  "gpt-5.4-pro": [30,null,180],
+  "gpt-5.4-pro-2026-03-05": [30,null,180],
+  "gpt-5.5": [5,0.5,30],
+  "gpt-5.5-2026-04-23": [5,0.5,30],
+  "gpt-5.5-cyber": [12.5,1.25,75],
+  "gpt-5.5-cyber-preview": [12.5,1.25,75],
+  "gpt-5.5-pro": [30,null,180],
+  "gpt-5.5-pro-2026-04-23": [30,null,180],
+  "gpt-5.6": [4,0.4,20],
+  "gpt-5.6-cyber": [12.5,1.25,75],
+  "gpt-5.6-luna": [0.2,0.02,1.2],
+  "gpt-5.6-sol": [4,0.4,20],
+  "gpt-5.6-terra": [2,0.2,12],
+  "gpt-6-astra": [10,1,50],
+  "gpt-6-luna": [0.1,0.01,0.5],
+  "gpt-6-sol": [2,0.2,10],
+  "gpt-6.1-sol": [2,0.1,10],
+  "gpt-daybreak-blue-latest": [4,0.4,20],
+  "gpt-daybreak-red-latest": [12.5,1.25,75],
+  "gpt-rosalind-discovery": [5,0.5,25],
+  "o1": [15,7.5,60],
+  "o1-2024-12-17": [15,7.5,60],
+  "o1-pro": [150,null,600],
+  "o1-pro-2025-03-19": [150,null,600],
+  "o3": [2,0.5,8],
+  "o3-2025-04-16": [2,0.5,8],
+  "o3-mini": [1.1,0.55,4.4],
+  "o3-mini-2025-01-31": [1.1,0.55,4.4],
+  "o3-pro": [20,null,80],
+  "o3-pro-2025-06-10": [20,null,80],
+  "o4-mini": [1.1,0.275,4.4],
+  "o4-mini-2025-04-16": [1.1,0.275,4.4]
+}

package/src/core/pricing.ts

@@ -0,0 +1,93 @@
+// 按单价估算没报费用的 agent（Codex）的金额：Token × 单价。
+//
+// 单价来自 LiteLLM 公开维护的价格表（model_prices_and_context_window.json），只取 OpenAI 的对话模型。
+// 内置一份快照（model-prices.json，[输入, 缓存读取, 输出]，美元 / 百万 token），连得上 GitHub 时
+// 每天更新一次存到 data/model-prices.json，连不上就一直用快照。
+// 只按基础单价算：长上下文加价、priority / flex 档位都不管，所以是估算。
+import fs from "node:fs";
+import path from "node:path";
+import { dataDir, readJson, writeJsonAtomic } from "../home.js";
+import type { TokenUsage } from "./types.js";
+
+/** [输入, 缓存读取（null 表示按输入算）, 输出]，美元 / 百万 token */
+type Price = [number, number | null, number];
+type Table = Record<string, Price>;
+type Cache = { at: number; prices: Table };
+
+const SOURCE = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json";
+const CACHE_FILE = () => path.join(dataDir, "model-prices.json");
+const MAX_AGE = 24 * 3600_000;
+/** 拉失败了隔多久再试 */
+const RETRY = 3600_000;
+
+const snapshot: Table = JSON.parse(fs.readFileSync(new URL("./model-prices.json", import.meta.url), "utf8"));
+let cache: Cache | null = null;
+let fetching = false;
+let lastTry = 0;
+
+function loadCache(): Cache {
+  return (cache ??= readJson<Cache>(CACHE_FILE(), { at: 0, prices: {} }));
+}
+
+/** 从 LiteLLM 的整张表里挑出 OpenAI 对话模型，换成每百万 token 的价格 */
+export function pickOpenAiPrices(raw: Record<string, unknown>): Table {
+  const perM = (v: unknown): number | null =>
+    typeof v === "number" && Number.isFinite(v) && v >= 0 ? Math.round(v * 1e12) / 1e6 : null;
+  const out: Table = {};
+  for (const [name, entry] of Object.entries(raw)) {
+    if (!entry || typeof entry !== "object") continue;
+    const e = entry as Record<string, unknown>;
+    if (e.litellm_provider !== "openai" || (e.mode !== "chat" && e.mode !== "responses")) continue;
+    const input = perM(e.input_cost_per_token);
+    const output = perM(e.output_cost_per_token);
+    if (input === null || output === null) continue;
+    out[name] = [input, perM(e.cache_read_input_token_cost), output];
+  }
+  return out;
+}
+
+async function refresh(): Promise<void> {
+  fetching = true;
+  lastTry = Date.now();
+  try {
+    const res = await fetch(SOURCE, { signal: AbortSignal.timeout(30_000) });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    const prices = pickOpenAiPrices((await res.json()) as Record<string, unknown>);
+    if (Object.keys(prices).length === 0) throw new Error("价格表里没有 OpenAI 模型");
+    cache = { at: Date.now(), prices };
+    writeJsonAtomic(CACHE_FILE(), cache);
+  } catch (err) {
+    console.warn("[pricing] 更新模型单价失败，先用内置的:", err instanceof Error ? err.message : err);
+  } finally {
+    fetching = false;
+  }
+}
+
+/** 过期了就在后台更新一次（不等它，这次先用手上的） */
+function refreshIfStale(): void {
+  // 跑测试时不联网
+  if (process.env.NODE_TEST_CONTEXT) return;
+  if (fetching || Date.now() - loadCache().at < MAX_AGE || Date.now() - lastTry < RETRY) return;
+  void refresh();
+}
+
+/** 模型的单价。认不出来返回 undefined。名字带 openai/ 前缀、日期后缀（-2026-03-05）的也认 */
+export function priceOf(model: string | undefined): Price | undefined {
+  if (!model) return undefined;
+  refreshIfStale();
+  const table = loadCache().prices;
+  const base = model.replace(/^openai\//, "");
+  for (const name of [base, base.replace(/-\d{4}-\d{2}-\d{2}$/, "")]) {
+    const p = table[name] ?? snapshot[name];
+    if (p) return p;
+  }
+  return undefined;
+}
+
+/** 按单价估算的金额（美元）。output 已经含推理，不再单算 reasoning；认不出模型返回 undefined */
+export function estimateCost(model: string | undefined, usage: TokenUsage): number | undefined {
+  const p = priceOf(model);
+  if (!p) return undefined;
+  const [input, cacheRead, output] = p;
+  return (usage.input * input + usage.cacheRead * (cacheRead ?? input) + usage.cacheWrite * input + usage.output * output) / 1e6;
+}

package/src/core/skill-runtime.ts

@@ -345,7 +345,7 @@ export function skillsText(owner: string | undefined): string {
   if (loft.length) {
     lines.push(`**能用的技能（${loft.length} 个）**`, "", ...loft.map((t) => `- \`@${t.name}\` ${t.description}`));
   } else {
-    lines.push("还没有启用任何技能。可以在网页侧栏「技能」里新建、上传，或者从技能广场安装；也可以直接让 agent「把刚才的做法存成技能」。");
+    lines.push("还没有启用任何技能。可以在网页「设置 → 技能」里新建、上传；也可以直接让 agent「把刚才的做法存成技能」。");
   }
   if (machine.length) lines.push("", `**本机技能（只有管理员能用，${machine.length} 个）**：${machine.map((t) => `\`@${t.name}\``).join(" ")}`);
   lines.push("", "在消息里写 @名字 点名使用；工作模式下 agent 也会自己挑合适的用。");

package/src/core/skills.ts

@@ -1,7 +1,8 @@
 // 技能（skill）：一份 SKILL.md 加上它附带的脚本、资料，agent 需要时照着做。和 Claude Code / Codex 自己的
 // skill 是同一种格式，只是由 agent-loft 按人管理：
 //   - 谁都能建（网页上写、上传技能包，或者让 agent 在对话里生成），建的人是作者；
-//   - 作者决定谁看得到：只有自己 / 指定的几个人 / 所有人。看得到的人在「技能广场」里安装；
+//   - 作者决定谁看得到：只有自己 / 指定的几个人 / 所有人，看得到的人可以安装。网页上已经不再提供分享和技能广场
+//     （新建的都是仅自己），这套数据留着是为了以前分享、安装过的照常能用；
 //   - 安装的是作者那一份本身，不是副本：作者改了，装了的人下一条消息起就用上新的；
 //   - 技能可以声明要用的环境变量（API 地址、密钥之类），值由每个用户自己填，只注入到他自己的会话里。
 //

package/src/core/types.ts

@@ -100,11 +100,22 @@ export type AgentEvents = {
   onDropped?: (n: number) => void;
   /** 上下文窗口占用更新了（一般在每轮结束后） */
   onContext?: (ctx: ContextUsage) => void;
+  /**
+   * token 用量更新了。cumulative = 报的是这个会话到目前的累计值（Claude，每轮结束报一次）；
+   * 否则是新增的量（Codex，每次模型请求报一次），由核心累加
+   */
+  onUsage?: (usage: TokenUsage, cumulative?: boolean) => void;
 };
 
 /** 上下文窗口占用：used / window 都是 token 数，percent 是 0-100（可能略超 100） */
 export type ContextUsage = { used: number; window: number; percent: number };
 
+/**
+ * token 用量。input 是没命中缓存的输入；cacheRead 是命中缓存读的；cacheWrite 是写进缓存的（Claude 单独计费）；
+ * output 含推理，reasoning 是其中推理的部分（Codex 才有）。costUsd 是 agent 自己算的费用（Claude 才有）
+ */
+export type TokenUsage = { input: number; cacheRead: number; cacheWrite: number; output: number; reasoning?: number; costUsd?: number };
+
 /** 账号额度（订阅的用量窗口）。没有订阅额度（API key 之类）时 driver 返回 null */
 export type QuotaInfo = {
   plan?: string;
@@ -148,8 +159,13 @@ export type SessionSummary = {
 };
 
 export type HistoryMessage = {
-  role: "user" | "assistant";
+  /** question：agent 问过的问题和你的回答（答过的提问卡，刷新后照样显示） */
+  role: "user" | "assistant" | "question";
   text: string;
+  /** 助手消息：被提问卡打断的前半段（只显示过程，不带复制 / 分叉 / 脚注） */
+  segment?: boolean;
+  /** 提问：问了什么、选了哪些（按问题下标）、自由作答的内容；skipped = 没作答（跳过 / 超时） */
+  question?: { id: string; title: string; questions: QuestionSpec[]; selections: number[][]; freeText: Record<number, string>; skipped?: boolean };
   /** 助手这一条之前的过程摘要 */
   steps?: string[];
   /** 毫秒时间戳；助手消息是这一轮结束的时间 */
@@ -213,10 +229,16 @@ export type SessionSkills = {
 
 export type ConversationMode = "chat" | "work";
 
+/**
+ * 中断的方式。默认（停止）：这一轮和排着队的都不要了。
+ * keepQueue（打断并发送）：只停这一轮，排着的留着；给了 first 就把它挪到最前面，这一轮一结束就轮到它
+ */
+export type InterruptOptions = { keepQueue?: boolean; first?: UserInput };
+
 export interface AgentSession {
   readonly sessionId: string | undefined;
   send(input: UserInput): void;
-  interrupt(): Promise<void>;
+  interrupt(opts?: InterruptOptions): Promise<void>;
   setModel(model?: string, effort?: string): Promise<void>;
   describeRuntime(): Promise<RuntimeInfo>;
   /** 手上已知的模型 / 思考程度，同步返回：不拉起进程、不发请求 */