agent-loft 0.2.32 → 0.2.33

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,8 @@ 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) => alive() && recordUsage(holder.session?.sessionId, usage, cumulative),
         onDropped: (n) => {
           if (!alive() || n <= 0) return;
           // 丢的是排在最后、还没开始的那 n 条（Codex 先报正在跑的那轮出错、再报丢弃，那时队头已经取走了）
@@ -630,6 +658,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 +735,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 +864,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 +900,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 +994,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 +1012,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 +1306,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 +1615,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/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>;
   /** 手上已知的模型 / 思考程度，同步返回：不拉起进程、不发请求 */

package/src/core/usage.ts

@@ -0,0 +1,70 @@
+// 每个 agent 会话累计消耗的 token（页面右上角「更多」里显示分布）。
+//
+// Claude 每轮结束报一次这个会话的累计值（恢复 / 分叉来的会话也接着原来的总数算）；Codex 每次模型请求报一次增量。
+// 都按会话 id 记在这里：页面重新加载、服务重启后还在。
+// 按 agent 会话算，不按对话：/new、恢复旧会话、切 agent 之后显示的都是现在这个会话的。
+// Codex 升级前跑过的轮次没有记录，从升级后开始算。
+import path from "node:path";
+import { dataDir, readJson, writeJsonAtomic } from "../home.js";
+import type { TokenUsage } from "./types.js";
+
+export type UsageTotals = Required<Omit<TokenUsage, "costUsd">> & { costUsd?: number; at: number };
+type Store = Record<string, UsageTotals>;
+
+const FILE = () => path.join(dataDir, "usage.json");
+const MAX_SESSIONS = 1000;
+
+let store: Store | null = null;
+let timer: NodeJS.Timeout | null = null;
+
+function load(): Store {
+  return (store ??= readJson<Store>(FILE(), {}));
+}
+
+function write(): void {
+  const s = load();
+  // 只留最近用过的会话
+  const keys = Object.keys(s).sort((a, b) => s[b]!.at - s[a]!.at);
+  for (const k of keys.slice(MAX_SESSIONS)) delete s[k];
+  writeJsonAtomic(FILE(), s);
+}
+
+function persistSoon(): void {
+  if (timer) return;
+  timer = setTimeout(() => {
+    timer = null;
+    write();
+  }, 1000);
+  timer.unref();
+}
+
+/** 退出前把还没写的落盘 */
+export function flushUsage(): void {
+  if (!timer) return;
+  clearTimeout(timer);
+  timer = null;
+  write();
+}
+
+const num = (v: unknown): number => (typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0);
+
+const FIELDS = ["input", "cacheRead", "cacheWrite", "output", "reasoning"] as const;
+
+/**
+ * cumulative：报的是累计值，每项取较大的（累计值只增不减；恢复的会话万一没从原来的总数接着算，
+ * 宁可先少算，也不把之前的再加一遍）。否则是增量，加上去
+ */
+export function recordUsage(sessionId: string | undefined, usage: TokenUsage, cumulative = false): void {
+  if (!sessionId) return;
+  const s = load();
+  const t = (s[sessionId] ??= { input: 0, cacheRead: 0, cacheWrite: 0, output: 0, reasoning: 0, at: 0 });
+  for (const f of FIELDS) t[f] = cumulative ? Math.max(t[f], num(usage[f])) : t[f] + num(usage[f]);
+  const cost = num(usage.costUsd);
+  if (cost) t.costUsd = cumulative ? Math.max(t.costUsd ?? 0, cost) : (t.costUsd ?? 0) + cost;
+  t.at = Date.now();
+  persistSoon();
+}
+
+export function usageOf(sessionId: string | undefined): UsageTotals | undefined {
+  return sessionId ? load()[sessionId] : undefined;
+}

package/web/css/composer.css

@@ -167,31 +167,6 @@ button.ctx-item:hover {
   flex-shrink: 0;
 }
 
-.mode-pill {
-  display: inline-flex;
-  align-items: center;
-  height: 32px;
-  padding: 0 10px;
-  border-radius: 999px;
-  font-size: 13px;
-  color: var(--fg-faint);
-  white-space: nowrap;
-}
-
-.mode-pill:hover {
-  background: var(--bg-hover);
-  color: var(--fg);
-}
-
-.mode-pill.chat {
-  color: var(--accent);
-}
-
-.topbar .mode-slot {
-  display: inline-flex;
-  flex-shrink: 0;
-}
-
 .topbar .top-more svg {
   width: 20px;
   height: 20px;

package/web/css/messages.css

@@ -227,6 +227,26 @@ a.att-file:hover {
   word-break: break-word;
 }
 
+/* 太长的用户消息：收起到约 10 行，底部淡出，下面一个「展开显示」 */
+.msg-user.clamped {
+  max-height: 260px;
+  overflow: hidden;
+  -webkit-mask-image: linear-gradient(to bottom, #000 calc(100% - 56px), transparent);
+  mask-image: linear-gradient(to bottom, #000 calc(100% - 56px), transparent);
+}
+
+.msg-more {
+  margin-top: -2px;
+  padding: 2px 8px;
+  border-radius: 6px;
+  font-size: 13px;
+  color: var(--fg-faint);
+}
+
+.msg-more:hover {
+  color: var(--fg);
+}
+
 .msg-user .origin {
   display: block;
   font-size: 12px;
@@ -732,3 +752,152 @@ a.att-file:hover {
 .lightbox-dl:hover {
   background: rgba(255, 255, 255, 0.26);
 }
+
+/* ---------- 右边的快速定位：每条用户消息一道横线，鼠标移上去展开成列表 ---------- */
+.msg-nav {
+  position: absolute;
+  right: 14px;
+  top: 45%;
+  transform: translateY(-50%);
+  z-index: 4;
+  display: flex;
+  align-items: center;
+}
+
+.msg-nav[hidden],
+.main.tasks-view .msg-nav {
+  display: none;
+}
+
+.msg-nav-ticks {
+  display: flex;
+  flex-direction: column;
+  max-height: 50vh;
+  overflow-y: auto;
+  scrollbar-width: none;
+  opacity: 0.55;
+  transition: opacity 0.2s;
+}
+
+.msg-nav-ticks::-webkit-scrollbar {
+  display: none;
+}
+
+.msg-nav.scrolling .msg-nav-ticks,
+.msg-nav:hover .msg-nav-ticks {
+  opacity: 1;
+}
+
+/* 点击范围比横线大：整个 20×10 都能点 */
+.msg-nav-tick {
+  flex-shrink: 0;
+  width: 20px;
+  height: 10px;
+  padding: 0;
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+}
+
+.msg-nav-tick i {
+  display: block;
+  width: 10px;
+  height: 2px;
+  border-radius: 1px;
+  background: var(--fg-faint);
+  transition: width 0.15s, background 0.15s;
+}
+
+.msg-nav-tick:hover i {
+  background: var(--fg-soft);
+}
+
+.msg-nav-tick.on i {
+  width: 16px;
+  background: var(--fg);
+}
+
+/* 展开的列表：在横线左边，鼠标移开就收起 */
+.msg-nav-panel {
+  position: absolute;
+  right: calc(100% + 4px);
+  top: 50%;
+  transform: translateY(-50%);
+  width: 260px;
+  max-height: 60vh;
+  overflow-y: auto;
+  padding: 6px;
+  display: flex;
+  flex-direction: column;
+  gap: 1px;
+  background: var(--bg);
+  border: 1px solid var(--border);
+  border-radius: 12px;
+  box-shadow: var(--shadow);
+  opacity: 0;
+  visibility: hidden;
+  transition: opacity 0.12s, visibility 0.12s;
+}
+
+/* 键盘 Tab 进来时也展开；鼠标点过之后不因为焦点还在就一直开着 */
+.msg-nav:hover .msg-nav-panel,
+.msg-nav:has(:focus-visible) .msg-nav-panel {
+  opacity: 1;
+  visibility: visible;
+}
+
+.msg-nav-row {
+  flex-shrink: 0;
+  text-align: left;
+  padding: 6px 10px;
+  border-radius: 8px;
+  font-size: 13px;
+  color: var(--fg-soft);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.msg-nav-row:hover {
+  background: var(--bg-hover);
+  color: var(--fg);
+}
+
+.msg-nav-row.on {
+  color: var(--fg);
+  font-weight: 500;
+}
+
+/* 手机上没地方放，也没有悬停 */
+@media (max-width: 768px) {
+  .msg-nav {
+    display: none;
+  }
+}
+
+/* 排队中的消息：「排队中 · 打断并发送」 */
+.queue-note {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  margin-top: -2px;
+  font-size: 12px;
+  color: var(--fg-faint);
+}
+
+.queue-note.dropped {
+  color: var(--danger);
+}
+
+.queue-jump {
+  padding: 2px 8px;
+  border-radius: 6px;
+  font-size: 12px;
+  color: var(--fg-soft);
+  border: 1px solid var(--border);
+}
+
+.queue-jump:hover {
+  color: var(--fg);
+  background: var(--bg-hover);
+}

package/web/css/sidebar.css

@@ -324,13 +324,13 @@ button.conv-group:hover {
   min-height: 48px;
 }
 
-.side-gear {
-  margin-left: auto;
+/* 没有额度可显示：连上面的分隔线一起藏起来 */
+.side-bottom[hidden] {
+  display: none;
 }
 
-/* 桌面端里：设置在顶栏「更多」里，侧栏底部只留额度（额度由桌面端统一查好推过来） */
-.desktop-settings .side-gear {
-  display: none;
+.conv-item .chat-mark {
+  color: var(--fg-soft);
 }
 
 /* ---- 侧栏底部的额度 ---- */

package/web/css/skills.css

@@ -1,4 +1,4 @@
-/* ---------- 技能页（版式沿用定时任务页的 .tasks-page / .task-card） ---------- */
+/* ---------- 技能（设置里的一页，卡片沿用定时任务页的 .task-card） ---------- */
 
 .skill-head-btns {
   display: flex;
@@ -366,3 +366,20 @@
     flex: 1 1 100%;
   }
 }
+
+/* 设置里的技能页 */
+.skills-page {
+  display: flex;
+  flex-direction: column;
+  gap: 14px;
+}
+
+.skills-head {
+  display: flex;
+  align-items: flex-start;
+  gap: 16px;
+}
+
+.skills-head .skill-note {
+  flex: 1;
+}