agent-loft 0.2.26 → 0.2.28

package/README.md

@@ -40,14 +40,14 @@ Logo 就是这个意思：一大两小几颗星（多个 agent）站在同一张
   - 思考和工具调用显示在实时刷新的过程卡片里，最终回复是普通消息。
   - 陌生人发消息会拿到配对码，在设置页批准后才能使用；每个机器人单独授权。
 - **Web 工作台**：电脑和手机都能用，界面参照 ChatGPT。
-  - 回复逐字显示，markdown 和代码高亮，思考过程和工具调用可以折叠；每条回复下方显示用时、费用和完成时间，可以复制，也可以「从这里分叉」成一条新会话（原会话不动）。
+  - 回复逐字显示，markdown 和代码高亮，思考过程和工具调用可以折叠；每条回复下方显示用时、费用和完成时间，可以复制，也可以「从这里分叉」成一条新会话（原会话不动）；自己发的消息也能一键复制。
   - 授权卡、提问卡直接在页面上点。
   - 附件：粘贴、拖拽，手机上可以拍照；可以预览和下载。附件存在服务端的专用上传目录里，开新会话或切换目录时清理。
   - 语音输入：用浏览器自带的语音识别（Chrome / Edge / Safari，需要 HTTPS）。
   - 新对话页：点大标题里的目录名，在目录树里逐层选工作目录；输入框上方选 agent，右下角选模型和思考程度。会话进行中用 `/agent` 切换 agent，模型和思考程度随时可换。
   - 输入框里的小圆环显示上下文窗口占用；模型按钮显示实际的模型和思考程度（如「Opus 5.5 high」）。
   - 滚动和 ChatGPT 一样：发出的问题顶到最上面、下面留白，回复长到屏幕底部才跟着往下滚；回复过程中自己滚动了就不再自动滚，下次发消息再恢复。
-  - 定时发送：输入框左下角的时钟按钮，选好时间（有「额度重置后」的快捷选项）由服务端到点发出，关掉页面也会发。适合额度用完、要等刷新才能接着干活的时候。
+  - 定时发送：右上角「更多」→「定时发送」，默认排在 5 小时额度重置后 5 分钟（弹窗里提示 5 小时 / 7 天额度的重置时间），由服务端到点发出，关掉页面也会发。适合额度用完、要等刷新才能接着干活的时候。
   - 侧栏分「最近」和「项目」两组：Web 会话按工作目录归类（目录可以拖动排序，右键可置顶），飞书机器人各占一行（右键看历史会话）；分叉出来的会话用虚线挂在原会话下面；会话标题由 agent 自动生成，双击重命名。
   - 侧栏底部显示 Claude / Codex 的订阅额度（5 小时 / 7 天窗口，以及多久后重置）。
   - 「添加到主屏幕」后当 App 用；切到后台再回来会自动重连，补上错过的内容。
@@ -56,8 +56,8 @@ Logo 就是这个意思：一大两小几颗星（多个 agent）站在同一张
 - **授权**：允许一次 / 本会话全部允许 / 总是允许（按钮上写明放行范围）/ 拒绝。`/autoedit on` 让 Claude Code 在这条会话里改工作目录内的文件不再询问（Bash 仍询问）。超时一律按拒绝处理。
 - **设置都在网页上**：工作目录、会话闲置过期时间、局域网访问和端口、各 agent 的默认模型和思考程度、可选模型、Codex 沙箱、飞书机器人、配对批准、Claude 的「总是允许」名单、通知设备、登录设备管理、用户管理、服务端升级。
 - **多用户**（信任型）：管理员在 设置 → 用户 里给别人建账号。每个人只看得到自己的对话、授权和通知，设置只有管理员能改，见下面「安全」。
-- **聊天模式 / 工作模式**：输入框右下角的「💬 聊天 / 🛠 工作」，或者发 `/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 对话，以及绑定了飞书账号后和机器人的私聊；飞书群聊不用。别人（包括管理员）看不到你的记忆，管理员只能清空它；删用户时记忆一起删，不转给管理员。
+- **聊天模式 / 工作模式**：右上角的「💬 聊天 / 🛠 工作」，或者发 `/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 对话，以及绑定了飞书账号后和机器人的私聊；飞书群聊不用。别人（包括管理员）看不到你的记忆，管理员只能清空它；删用户时记忆一起删，不转给管理员。
 - **飞书账号绑定**：设置 → 账号 → 飞书账号 →「生成绑定码」，再在飞书私聊机器人发 `/bind 绑定码`（10 分钟内有效，群里发不算）。绑定后这个私聊就是你的个人会话：用你的记忆，`/sessions` 只列你的会话，`/web` 只能接上你自己的 Web 会话，管理员在 Web 上也看不到它。必须本人在两边各操作一次，管理员不能替人绑定（只能解除），否则就能借飞书读到别人的记忆。
 
 ## 安装

package/package.json

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

package/src/agents/claude/driver.ts

@@ -224,7 +224,7 @@ export class ClaudeDriver implements AgentDriver {
   }
 
   async statusLines(): Promise<string[]> {
-    return describeUsage(await readUsage());
+    return config().web.quotaEnabled ? describeUsage(await readUsage()) : [];
   }
 
   async quota(): Promise<QuotaInfo | null> {

package/src/agents/codex/driver.ts

@@ -212,7 +212,7 @@ export class CodexDriver implements AgentDriver {
   }
 
   async statusLines(): Promise<string[]> {
-    const quota = describeRateLimits(await readRateLimits());
+    const quota = config().web.quotaEnabled ? describeRateLimits(await readRateLimits()) : [];
     return [`沙箱：${config().agents.codex.sandbox}`, ...(quota.length > 0 ? ["", ...quota] : [])];
   }
 

package/src/channels/web/api.ts

@@ -218,6 +218,7 @@ function applyConfig(input: Partial<AppConfig>): void {
     if (Number.isInteger(Number(port)) && Number(port) >= 1 && Number(port) <= 65535) next.web.port = Number(port);
     const q = Number(next.web.quotaRefreshMin);
     next.web.quotaRefreshMin = Number.isFinite(q) ? Math.max(0, Math.min(1440, Math.round(q))) : 10;
+    next.web.quotaEnabled = next.web.quotaEnabled !== false;
   }
   if (input.commands) {
     // 只收字符串数组，别的一律当没传
@@ -484,6 +485,7 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
       bots: admin ? config().feishu.bots.map((b) => ({ id: b.id, name: b.name, agents: b.agents, enabled: b.enabled })) : [],
       workspaceRoot: config().workspaceRoot,
       quotaRefreshMin: config().web.quotaRefreshMin,
+      quotaEnabled: config().web.quotaEnabled,
       conversations: hub.list(visible),
       pending: interactions.listPending().filter((i) => visible(getConversation(i.convKey))),
       user: publicMe(user),
@@ -783,6 +785,11 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
   }
   if (p === "/api/quota" && method === "GET") {
     // ?agent=claude,codex：只问这几个。桌面端连着多台同账号的服务器时，同一个账号只在一台上问
+    // 设置里关了查额度：不去问任何 agent
+    if (!config().web.quotaEnabled) {
+      sendJson(res, 200, { quotas: [], at: Date.now(), disabled: true });
+      return;
+    }
     const only = url.searchParams.get("agent")?.split(",").filter(Boolean);
     const results = await Promise.all(
       hub.enabledAgents().filter((d) => !only || only.includes(d.id)).map(async (d) => {

package/src/core/config.ts

@@ -67,6 +67,8 @@ export type AppConfig = {
     trustedProxies: string[];
     /** 侧栏额度空闲时多久自动刷新一次（分钟），0 = 不自动刷新 */
     quotaRefreshMin: number;
+    /** 查不查 agent 的账号额度。关了侧栏、/status、桌面端都不再去问 agent */
+    quotaEnabled: boolean;
   };
   /** 输入「/」时命令列表的顺序和隐藏项，按 agent 分开（设置 → 命令） */
   commands: { claude: CommandPrefs; codex: CommandPrefs };
@@ -96,7 +98,7 @@ export function defaultConfig(): AppConfig {
         models: [],
       },
     },
-    web: { enabled: true, host: "0.0.0.0", port: 8800, passwordHash: "", trustedProxies: ["127.0.0.1", "::1"], quotaRefreshMin: 10 },
+    web: { enabled: true, host: "0.0.0.0", port: 8800, passwordHash: "", trustedProxies: ["127.0.0.1", "::1"], quotaRefreshMin: 10, quotaEnabled: true },
     commands: { claude: { order: [], hidden: [], custom: [] }, codex: { order: [], hidden: [], custom: [] } },
     feishu: { watchdogMs: 10 * 60 * 1000, bots: [] },
   };

package/src/core/memory-curator.ts

@@ -8,6 +8,7 @@
 //   3. 整理：把上次整理之后新说的话交给模型（用户在记忆设置里选 agent 和模型，默认最省的），
 //      让它对照现有记忆给出新增 / 更新 / 删除。用户自己加的条目它动不了。什么时候整理也由用户定
 //      （CurateSettings.when）：每段聊完后 / 每天一次把当天的合起来 / 只在点「现在整理」时 / 不整理。
+//      整理哪些也由用户定（CurateSettings.scope）：全部 / 只整理聊天模式的 / 只整理工作模式的。
 import { hub } from "./hub.js";
 import {
   appendRecords,
@@ -27,6 +28,7 @@ import {
   readMemory,
   removeMemoryItem,
   updateMemoryItem,
+  type CurateScope,
   type CurateSettings,
   type UserMemory,
 } from "./memory.js";
@@ -361,12 +363,18 @@ export async function curateBatch(
   return log;
 }
 
-/** 某个用户等着整理的对话。删掉的对话直接记成整理过；正在回复的这次先不碰 */
+/** 这段对话在不在用户选的整理范围里（按现在的模式算，中途切过模式的整段归现在的） */
+function inScope(conv: { mode?: "chat" }, scope: CurateScope): boolean {
+  return scope === "all" || (scope === "chat") === (conv.mode === "chat");
+}
+
+/** 某个用户等着整理的对话。删掉的、不在整理范围里的直接记成整理过（之后改范围也不补整理）；正在回复的这次先不碰 */
 function collect(userId: string, settleMs: number, now?: number): Pending[] {
+  const scope = readMemory(userId).curate.scope;
   const out: Pending[] = [];
   for (const p of pendingConversations(userId, settleMs, now)) {
     const conv = hub.conversation(p.key);
-    if (!conv || conv.hidden) {
+    if (!conv || conv.hidden || !inScope(conv, scope)) {
       markExtracted(userId, p.key, p.last);
       continue;
     }
@@ -426,7 +434,11 @@ export function curateNow(userId: string, opts: { now?: number } = {}): Promise<
 
 /** 还没整理的对话有几段（设置页显示「有 N 段对话等着整理」） */
 export function pendingCount(userId: string): number {
-  return pendingConversations(userId, 0).filter((p) => !hub.conversation(p.key)?.hidden).length;
+  const scope = readMemory(userId).curate.scope;
+  return pendingConversations(userId, 0).filter((p) => {
+    const conv = hub.conversation(p.key);
+    return conv && !conv.hidden && inScope(conv, scope);
+  }).length;
 }
 
 export function startMemoryCurator(): void {

package/src/core/memory.ts

@@ -44,8 +44,12 @@ export type UserMemory = {
  */
 export type CurateWhen = "idle" | "daily" | "manual" | "off";
 
+/** 整理哪些对话：全部 / 只整理聊天模式的 / 只整理工作模式的（按整理那一刻对话的模式算） */
+export type CurateScope = "all" | "chat" | "work";
+
 export type CurateSettings = {
   when: CurateWhen;
+  scope: CurateScope;
   idleMinutes: number;
   dailyHour: number;
   /** auto：Claude 能用就用 Claude，否则 Codex */
@@ -54,17 +58,19 @@ export type CurateSettings = {
   model: string;
 };
 
-export const DEFAULT_CURATE: CurateSettings = { when: "daily", idleMinutes: 30, dailyHour: 4, agent: "auto", model: "" };
+export const DEFAULT_CURATE: CurateSettings = { when: "daily", scope: "all", idleMinutes: 30, dailyHour: 4, agent: "auto", model: "" };
 
 function cleanCurate(raw: Partial<CurateSettings> | undefined, base: CurateSettings): CurateSettings {
   const r = raw ?? {};
   const when = (["idle", "daily", "manual", "off"] as const).find((w) => w === r.when) ?? base.when;
+  const scope = (["all", "chat", "work"] as const).find((s) => s === r.scope) ?? base.scope;
   const idle = Math.round(Number(r.idleMinutes ?? base.idleMinutes));
   const hour = Math.round(Number(r.dailyHour ?? base.dailyHour));
   const agent = (["auto", "claude", "codex"] as const).find((a) => a === r.agent) ?? base.agent;
   const model = typeof r.model === "string" ? r.model.trim().slice(0, 100) : base.model;
   return {
     when,
+    scope,
     idleMinutes: Number.isFinite(idle) ? Math.max(5, Math.min(24 * 60, idle)) : base.idleMinutes,
     dailyHour: Number.isFinite(hour) ? Math.max(0, Math.min(23, hour)) : base.dailyHour,
     agent,

package/web/app.js

@@ -38,6 +38,7 @@ const ICON = {
   stop: '<svg viewBox="0 0 24 24" fill="currentColor"><rect x="7" y="7" width="10" height="10" rx="1.5"/></svg>',
   clip: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="m21.4 11.6-9.2 9.2a6 6 0 0 1-8.5-8.5l9.2-9.2a4 4 0 0 1 5.7 5.7l-9.2 9.2a2 2 0 0 1-2.8-2.8l8.5-8.5"/></svg>',
   mic: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="9" y="2" width="6" height="12" rx="3"/><path d="M5 10a7 7 0 0 0 14 0M12 17v5"/></svg>',
+  more: '<svg viewBox="0 0 24 24" fill="currentColor"><circle cx="5" cy="12" r="1.8"/><circle cx="12" cy="12" r="1.8"/><circle cx="19" cy="12" r="1.8"/></svg>',
   clock: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="9"/><path d="M12 7v5l3 2"/></svg>',
   down: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4" stroke-linecap="round"><path d="m6 9 6 6 6-6"/></svg>',
   gear: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="3"/><path d="M19.4 15a1.7 1.7 0 0 0 .3 1.8l.1.1a2 2 0 1 1-2.8 2.8l-.1-.1a1.7 1.7 0 0 0-1.8-.3 1.7 1.7 0 0 0-1 1.5V21a2 2 0 1 1-4 0v-.1a1.7 1.7 0 0 0-1.1-1.5 1.7 1.7 0 0 0-1.8.3l-.1.1a2 2 0 1 1-2.8-2.8l.1-.1a1.7 1.7 0 0 0 .3-1.8 1.7 1.7 0 0 0-1.5-1H3a2 2 0 1 1 0-4h.1a1.7 1.7 0 0 0 1.5-1.1 1.7 1.7 0 0 0-.3-1.8l-.1-.1a2 2 0 1 1 2.8-2.8l.1.1a1.7 1.7 0 0 0 1.8.3H9a1.7 1.7 0 0 0 1-1.5V3a2 2 0 1 1 4 0v.1a1.7 1.7 0 0 0 1 1.5 1.7 1.7 0 0 0 1.8-.3l.1-.1a2 2 0 1 1 2.8 2.8l-.1.1a1.7 1.7 0 0 0-.3 1.8V9a1.7 1.7 0 0 0 1.5 1H21a2 2 0 1 1 0 4h-.1a1.7 1.7 0 0 0-1.5 1Z"/></svg>',
@@ -574,6 +575,7 @@ async function boot() {
   S.bots = data.bots;
   S.workspaceRoot = data.workspaceRoot;
   S.quotaRefreshMin = data.quotaRefreshMin ?? 10;
+  S.quotaEnabled = data.quotaEnabled !== false;
   S.convs = new Map(data.conversations.map((c) => [c.key, c]));
   S.pending = new Map(data.pending.map((i) => [i.id, i]));
   const enabled = usableAgents().map((a) => a.id);
@@ -683,6 +685,8 @@ function renderLayout() {
     h("div", { class: "side-resizer", title: "拖动调整宽度，双击恢复默认", onpointerdown: startSideResize, ondblclick: () => setSideWidth(null) }),
   );
   ui.topbar = h("div", { class: "topbar" });
+  // 聊天 / 工作切换在顶栏右上角；先建好，renderTopbar 每次把它放回去
+  ui.modeSlot = h("span", { class: "mode-slot" });
   ui.msgInner = h("div", { class: "messages-inner" });
   ui.spacer = h("div", { class: "messages-spacer", "aria-hidden": "true" });
   ui.messages = h("div", { class: "messages", tabindex: "-1" }, ui.msgInner, ui.spacer);
@@ -746,14 +750,20 @@ function stopMarquee() {
 //   - 有会话跑完一轮：10 秒后拉；若那时服务端缓存还没过期，就推迟到过期之后，保证拿到新数据；
 //   - 切回前台：距上次超过一个刷新间隔就拉；
 //   - 点一下额度区域：立刻拉（可能拿到 60 秒内的缓存）。
+// 设置 → 通用里关了「查询额度」（S.quotaEnabled）：以上全都不做，侧栏也不显示额度。
 // 在桌面端里（desktopQuota）以上全都不做：桌面端统一去查（同一个账号的多台服务器只问一台），
 // 查好推过来；点一下额度区域是请桌面端去刷新。
 
 const quotaState = { data: null, at: 0, loading: false, timer: 0, idle: 0 };
 const QUOTA_SERVER_CACHE = 60_000;
-const quotaInterval = () => (S.quotaRefreshMin ?? 10) * 60_000;
+const quotaInterval = () => (S.quotaEnabled ? (S.quotaRefreshMin ?? 10) * 60_000 : 0);
 
 async function loadQuota() {
+  if (!S.quotaEnabled) {
+    quotaState.data = null;
+    renderQuota();
+    return;
+  }
   if (desktopQuota) {
     ui.quota?.classList.add("loading");
     desktop.refreshQuota();
@@ -800,7 +810,7 @@ function scheduleIdleQuota() {
 /** 一轮跑完：10 秒后拉；服务端缓存那时还没过期就推迟到过期之后 */
 function scheduleQuota() {
   // 桌面端里：它从页面报的运行数看出跑完了一轮，自己会去查
-  if (desktopQuota) return;
+  if (desktopQuota || !S.quotaEnabled) return;
   const wait = Math.max(10_000, quotaState.at + QUOTA_SERVER_CACHE + 1000 - Date.now());
   clearTimeout(quotaState.timer);
   quotaState.timer = setTimeout(() => void loadQuota(), wait);
@@ -828,7 +838,7 @@ function quotaLevel(p) {
 
 function renderQuota() {
   if (!ui.quota) return;
-  const list = quotaState.data ?? [];
+  const list = S.quotaEnabled ? (quotaState.data ?? []) : [];
   if (list.length === 0) return fill(ui.quota);
   const rows = list.map((q) =>
     h(
@@ -1290,10 +1300,22 @@ function renderTopbar() {
   fill(ui.topbar,
     h("button", { class: "icon-btn menu-btn", onclick: openSide, title: "会话列表" }, icon("menu")),
     h("div", { class: "top-title" }, c ? h("span", { class: "conv-name", title: convTitle(c) }, convTitle(c)) : null),
+    ui.modeSlot,
+    h("button", { class: "icon-btn top-more", title: "更多", onclick: (e) => openTopMore(e.currentTarget) }, icon("more")),
   );
   renderContext();
 }
 
+/** 顶栏右上角「更多」 */
+function openTopMore(anchor) {
+  if (ui.menu?.anchor === anchor) return closeMenu();
+  showMenu(anchor, [{ label: "定时发送…", onclick: () => openSchedule() }]);
+  ui.menu.anchor = anchor;
+  // 贴着按钮右边对齐，别超出屏幕
+  const r = anchor.getBoundingClientRect();
+  ui.menu.style.left = `${Math.max(8, r.right - ui.menu.offsetWidth)}px`;
+}
+
 function baseName(p) {
   return (p ?? "").split(/[\\/]/).filter(Boolean).pop() || p || "";
 }
@@ -2024,6 +2046,9 @@ function renderItem(item) {
         !item.text && origin ? h("span", { class: "origin" }, origin) : null,
         renderUserFiles(item.files),
         item.text ? h("div", { class: "msg-user" }, origin ? h("span", { class: "origin" }, origin) : null, item.text) : null,
+        item.text
+          ? h("div", { class: "user-actions" }, h("button", { class: "icon-btn", title: "复制", onclick: () => copyText(item.text) }, icon("copy")))
+          : null,
       );
     }
     case "ai":
@@ -2279,10 +2304,10 @@ function renderInteraction(item) {
         : h(
             "div",
             { class: "ix-buttons" },
-            h("button", { class: "btn accent", onclick: () => ixOp(ix.id, "decide", { decision: "allow-once" }) }, "允许一次"),
             spec.allowSession
-              ? h("button", { class: "btn", onclick: () => ixOp(ix.id, "decide", { decision: "allow-session" }) }, "本会话全部允许")
+              ? h("button", { class: "btn accent", onclick: () => ixOp(ix.id, "decide", { decision: "allow-session" }) }, "本会话全部允许")
               : null,
+            h("button", { class: `btn${spec.allowSession ? "" : " accent"}`, onclick: () => ixOp(ix.id, "decide", { decision: "allow-once" }) }, "允许一次"),
             // 会落盘、对所有人生效的「总是允许」只给管理员
             spec.alwaysLabel && (!spec.alwaysGlobal || isAdmin())
               ? h("button", { class: "btn", onclick: () => ixOp(ix.id, "decide", { decision: "allow-always" }) }, spec.alwaysLabel)
@@ -2380,7 +2405,6 @@ function renderComposer() {
     : null;
   ui.ctxBar = h("div", { class: "ctx-bar" });
   ui.modelSlot = h("span", { class: "model-slot" });
-  ui.modeSlot = h("span", { class: "mode-slot" });
   ui.ctxRing = h("span", { class: "ctx-ring-slot" });
   ui.chips = h("div", { class: "chips" });
   ui.schedBar = h("div", { class: "sched-bar", hidden: true });
@@ -2407,11 +2431,9 @@ function renderComposer() {
       "div",
       { class: "composer-row" },
       h("button", { class: "icon-btn add-btn", title: "添加附件", onclick: () => ui.fileInput.click() }, icon("plus")),
-      h("button", { class: "icon-btn add-btn", title: "定时发送", onclick: () => openSchedule() }, icon("clock")),
       ui.fileInput,
       h("span", { class: "spacer" }),
       ui.ctxRing,
-      ui.modeSlot,
       ui.modelSlot,
       ui.micBtn,
       ui.sendBtn,
@@ -2489,33 +2511,25 @@ function openSchedule(edit) {
   const text = h("textarea", { class: "sched-input", rows: 4, placeholder: "到点要发的内容" });
   text.value = edit ? edit.text : ui.input.value;
   const when = h("input", { type: "datetime-local", class: "sched-time" });
-  const setAt = (ms) => (when.value = toLocalInput(ms));
-  setAt(edit ? edit.at : Date.now() + 5 * 3600_000);
-  // 快捷时间：当前 agent 的额度窗口重置后一分钟，再加几个常用的
+  // 当前 agent 的额度窗口（5 小时 / 7 天）什么时候重置：小字提示，默认排在 5 小时窗口重置后 5 分钟
   const agent = currentAgentId();
-  const presets = [];
-  for (const q of quotaState.data ?? []) {
-    if (q.agent !== agent) continue;
-    for (const w of q.windows) {
-      if (w.resetsAt && w.resetsAt > Date.now()) presets.push({ label: `${w.label}重置后（${fmtWhen(w.resetsAt + 60_000)}）`, at: w.resetsAt + 60_000 });
-    }
-  }
-  const tomorrow9 = new Date();
-  tomorrow9.setDate(tomorrow9.getDate() + 1);
-  tomorrow9.setHours(9, 0, 0, 0);
-  presets.push(
-    { label: "1 小时后", at: Date.now() + 3600_000 },
-    { label: "3 小时后", at: Date.now() + 3 * 3600_000 },
-    { label: "5 小时后", at: Date.now() + 5 * 3600_000 },
-    { label: "明早 9:00", at: tomorrow9.getTime() },
-  );
+  const windows = (quotaState.data ?? []).find((q) => q.agent === agent)?.windows ?? [];
+  const resets = windows.filter((w) => /^(5h|7d)$/.test(w.short) && w.resetsAt > Date.now());
+  const session = resets.find((w) => w.short === "5h");
+  when.value = toLocalInput(edit ? edit.at : session ? session.resetsAt + 5 * 60_000 : Date.now() + 5 * 3600_000);
   const body = h(
     "div",
     { class: "modal-body sched-body" },
     text,
-    h("div", { class: "sched-presets" }, presets.map((p) => h("button", { class: "btn", onclick: () => setAt(p.at) }, p.label))),
     h("label", { class: "sched-row" }, h("span", {}, "发送时间"), when),
-    h("div", { class: "muted" }, "到点由服务端发出，关掉页面也会发。到点时 agent 还在忙的话，会排在当前这轮之后。"),
+    h(
+      "div",
+      { class: "muted sched-hint" },
+      resets.length
+        ? `额度重置：${resets.map((w) => `${w.short === "5h" ? "5 小时" : "7 天"}额度 ${fmtWhen(w.resetsAt)}`).join("，")}。`
+        : "",
+      "到点由服务端发出，关掉页面也会发。",
+    ),
   );
   const go = h("button", { class: "btn primary" }, edit ? "保存" : "定时发送");
   const close = modal({ title: edit ? "编辑定时消息" : "定时发送", body, foot: h("div", { class: "modal-foot" }, go) });
@@ -3828,9 +3842,14 @@ async function saveConfig(cfg, patch) {
     S.agents = boot2.agents;
     S.bots = boot2.bots;
     S.workspaceRoot = boot2.workspaceRoot;
-    if (boot2.quotaRefreshMin !== S.quotaRefreshMin) {
+    const quotaOn = boot2.quotaEnabled !== false;
+    if (boot2.quotaRefreshMin !== S.quotaRefreshMin || quotaOn !== S.quotaEnabled) {
+      const turnedOn = quotaOn && !S.quotaEnabled;
       S.quotaRefreshMin = boot2.quotaRefreshMin ?? 10;
-      scheduleIdleQuota();
+      S.quotaEnabled = quotaOn;
+      // 刚打开就马上查一次；关掉就清掉侧栏的额度
+      if (turnedOn || !quotaOn) void loadQuota();
+      else scheduleIdleQuota();
     }
     renderTopbar();
     renderSidebar();
@@ -3904,6 +3923,7 @@ function generalTab(cfg, panel) {
   const approval = h("input", { type: "number", min: 1, value: Math.round(cfg.approvalTimeoutMs / 60000) });
   const ttl = h("input", { type: "number", min: 0, value: Math.round(cfg.sessionTtlMs / 3600000) });
   const quotaMin = h("input", { type: "number", min: 0, max: 1440, value: cfg.web?.quotaRefreshMin ?? 10 });
+  const quotaOn = h("input", { type: "checkbox", checked: cfg.web?.quotaEnabled !== false });
   panel.append(
     h(
       "div",
@@ -3912,6 +3932,8 @@ function generalTab(cfg, panel) {
       field("工作目录（workspace）", root, "所有会话的默认目录，/cd 只能在它之内"),
       field("授权等待超时（分钟）", approval, "超时按拒绝处理"),
       field("会话闲置多久自动开新会话（小时）", ttl, "0 表示永不过期"),
+      h("label", { class: "check" }, quotaOn, "查询账号额度"),
+      h("div", { class: "muted" }, "关掉后侧栏、/status、桌面端都不再去问 agent 的额度（Claude 每次要临时起一个 CLI 进程才查得到）"),
       field(
         "额度自动刷新间隔（分钟）",
         quotaMin,
@@ -3931,7 +3953,7 @@ function generalTab(cfg, panel) {
                 workspaceRoot: root.value,
                 approvalTimeoutMs: Number(approval.value) * 60000,
                 sessionTtlMs: Number(ttl.value) * 3600000,
-                web: { quotaRefreshMin: Number(quotaMin.value) },
+                web: { quotaRefreshMin: Number(quotaMin.value), quotaEnabled: quotaOn.checked },
               }),
           },
           "保存",
@@ -5175,6 +5197,16 @@ function curateSection(mem, reload) {
       ],
       (v) => save({ when: v }),
     );
+    // 换了范围，等着整理的段数也跟着变：重新读一遍
+    const scope = select(
+      c.scope,
+      [
+        ["all", "全部对话"],
+        ["chat", "只整理聊天模式的对话"],
+        ["work", "只整理工作模式的对话"],
+      ],
+      (v) => save({ scope: v }).then(reload),
+    );
     const timing =
       c.when === "idle"
         ? field("停下来多久算聊完", select(c.idleMinutes, [10, 30, 60, 120, 240].map((m) => [m, m < 60 ? `${m} 分钟` : `${m / 60} 小时`]), (v) => save({ idleMinutes: Number(v) })))
@@ -5252,6 +5284,7 @@ function curateSection(mem, reload) {
         }[c.when],
       ),
       timing,
+      c.when === "off" ? null : field("整理哪些对话", scope, "按整理时对话所在的模式算；不在范围里的对话直接跳过，之后改回来也不会补整理"),
       c.when === "off" ? null : field("用哪个 agent", agent),
       c.when === "off" ? null : model,
       h("div", { class: "row", style: { alignItems: "center", gap: "10px" } }, nowBtn, h("span", { class: "muted" }, `${mem.pending ? `有 ${mem.pending} 段对话等着整理。` : ""}${lastText}`)),

package/web/index.html

@@ -2,7 +2,7 @@
 <html lang="zh-CN">
   <head>
     <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover, interactive-widget=resizes-content" />
+    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, viewport-fit=cover, interactive-widget=resizes-content" />
     <meta name="theme-color" content="#ffffff" media="(prefers-color-scheme: light)" />
     <meta name="theme-color" content="#1f1f1f" media="(prefers-color-scheme: dark)" />
     <meta name="apple-mobile-web-app-capable" content="yes" />

package/web/style.css

@@ -1682,6 +1682,35 @@ a.att-file:hover {
   }
 }
 
+/* 用户消息下面的复制：hover 时才出来，和回复的操作栏一样用 opacity 占着位置 */
+.user-actions {
+  display: flex;
+  margin-top: -4px;
+  opacity: 0;
+  transition: opacity 0.15s;
+}
+
+.msg-user-group:hover .user-actions,
+.user-actions:focus-within {
+  opacity: 1;
+}
+
+@media (hover: none) {
+  .user-actions {
+    opacity: 1;
+  }
+}
+
+.user-actions .icon-btn {
+  width: 26px;
+  height: 26px;
+}
+
+.user-actions .icon-btn svg {
+  width: 15px;
+  height: 15px;
+}
+
 .ai-actions .footer-note {
   margin-left: 4px;
 }
@@ -2038,6 +2067,16 @@ button.ctx-item:hover {
   color: var(--accent);
 }
 
+.topbar .mode-slot {
+  display: inline-flex;
+  flex-shrink: 0;
+}
+
+.topbar .top-more svg {
+  width: 20px;
+  height: 20px;
+}
+
 .composer.drag {
   border-color: var(--accent);
 }
@@ -3432,14 +3471,9 @@ button.list-item:hover {
   font: inherit;
 }
 
-.sched-presets {
-  display: flex;
-  flex-wrap: wrap;
-  gap: 6px;
-}
-
-.sched-presets .btn {
-  font-size: 13px;
+.sched-hint {
+  font-size: 12px;
+  line-height: 1.6;
 }
 
 .sched-row {
@@ -3458,3 +3492,9 @@ button.list-item:hover {
   font: inherit;
   color-scheme: light dark;
 }
+
+/* iOS 上双击会放大页面：关掉双击缩放（双指缩放照常） */
+html,
+body {
+  touch-action: manipulation;
+}