agent-loft 0.2.25 → 0.2.27

package/README.md

@@ -46,6 +46,8 @@ Logo 就是这个意思：一大两小几颗星（多个 agent）站在同一张
   - 语音输入：用浏览器自带的语音识别（Chrome / Edge / Safari，需要 HTTPS）。
   - 新对话页：点大标题里的目录名，在目录树里逐层选工作目录；输入框上方选 agent，右下角选模型和思考程度。会话进行中用 `/agent` 切换 agent，模型和思考程度随时可换。
   - 输入框里的小圆环显示上下文窗口占用；模型按钮显示实际的模型和思考程度（如「Opus 5.5 high」）。
+  - 滚动和 ChatGPT 一样：发出的问题顶到最上面、下面留白，回复长到屏幕底部才跟着往下滚；回复过程中自己滚动了就不再自动滚，下次发消息再恢复。
+  - 定时发送：右上角「更多」→「定时发送」，默认排在 5 小时额度重置后 5 分钟（弹窗里提示 5 小时 / 7 天额度的重置时间），由服务端到点发出，关掉页面也会发。适合额度用完、要等刷新才能接着干活的时候。
   - 侧栏分「最近」和「项目」两组：Web 会话按工作目录归类（目录可以拖动排序，右键可置顶），飞书机器人各占一行（右键看历史会话）；分叉出来的会话用虚线挂在原会话下面；会话标题由 agent 自动生成，双击重命名。
   - 侧栏底部显示 Claude / Codex 的订阅额度（5 小时 / 7 天窗口，以及多久后重置）。
   - 「添加到主屏幕」后当 App 用；切到后台再回来会自动重连，补上错过的内容。
@@ -54,7 +56,7 @@ Logo 就是这个意思：一大两小几颗星（多个 agent）站在同一张
 - **授权**：允许一次 / 本会话全部允许 / 总是允许（按钮上写明放行范围）/ 拒绝。`/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 对话，以及绑定了飞书账号后和机器人的私聊；飞书群聊不用。别人（包括管理员）看不到你的记忆，管理员只能清空它；删用户时记忆一起删，不转给管理员。
 - **飞书账号绑定**：设置 → 账号 → 飞书账号 →「生成绑定码」，再在飞书私聊机器人发 `/bind 绑定码`（10 分钟内有效，群里发不算）。绑定后这个私聊就是你的个人会话：用你的记忆，`/sessions` 只列你的会话，`/web` 只能接上你自己的 Web 会话，管理员在 Web 上也看不到它。必须本人在两边各操作一次，管理员不能替人绑定（只能解除），否则就能借飞书读到别人的记忆。
 

package/package.json

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

package/src/channels/web/api.ts

@@ -9,6 +9,7 @@ import { hub } from "../../core/hub.js";
 import { interactions } from "../../core/interactions.js";
 import { approve, listApproved, listPending, revoke } from "../../core/pairing.js";
 import { getConversation, listConversations, updateConversation } from "../../core/store.js";
+import { addScheduled, clearScheduled, removeScheduled } from "../../core/scheduled.js";
 import { resolveUploadFile, saveBuffer, sniff, uploadKeyOf } from "../../core/uploads.js";
 import {
   createUser,
@@ -577,10 +578,35 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
       // 只是从列表里藏起来：agent 侧的会话记录还在，随时能从「历史会话」恢复
       await hub.drop(key, "会话已删除");
       updateConversation(key, { hidden: true });
+      clearScheduled(key);
       hub.emitEvent(key, { type: "meta" });
       sendJson(res, 200, { ok: true });
       return;
     }
+    // ----- 定时发送：列表随会话信息（info.scheduled）下发，这里只管增删 -----
+    if (sub === "scheduled" && method === "POST") {
+      const body = await readJsonBody<{ text?: string; at?: number }>(req);
+      const text = typeof body.text === "string" ? body.text : "";
+      const at = Number(body.at);
+      if (!text.trim()) throw new HttpError(400, "定时发送的内容不能为空");
+      if (!Number.isFinite(at) || at < Date.now() - 60_000) throw new HttpError(400, "发送时间要在现在之后");
+      if (at > Date.now() + 30 * 86400_000) throw new HttpError(400, "最多只能排到 30 天以后");
+      try {
+        addScheduled(key, text, at);
+      } catch (err) {
+        throw new HttpError(400, err instanceof Error ? err.message : String(err));
+      }
+      hub.emitEvent(key, { type: "meta" });
+      sendJson(res, 200, hub.info(key));
+      return;
+    }
+    if (sub === "scheduled" && method === "DELETE") {
+      const id = url.searchParams.get("id") ?? "";
+      if (!removeScheduled(key, id)) throw new HttpError(404, "这条定时消息已经发出或取消了");
+      hub.emitEvent(key, { type: "meta" });
+      sendJson(res, 200, hub.info(key));
+      return;
+    }
     if (sub === "history" && method === "GET") {
       // 读历史是异步的。要保证「历史快照 + 进行中这一轮的事件 + 之后的补发」首尾相接、
       // 不重不漏，只在两种情况下接受这次读到的快照：

package/src/core/hub.ts

@@ -45,6 +45,7 @@ import type {
 } from "./types.js";
 import { buildCatalog, expandCustomCommand, type AgentCommand, type CommandEntry, type CommandPrefs } from "./command-catalog.js";
 import { helpText, type ParsedCommand } from "./commands.js";
+import { listScheduled } from "./scheduled.js";
 
 // ---------- 事件 ----------
 
@@ -138,6 +139,8 @@ export type ConversationInfo = {
   mode: ConversationMode;
   /** 这条对话有主人、会用上主人的记忆（主人自己关了记忆的话实际不会注入，见 personal.ts） */
   personal?: boolean;
+  /** 排着的定时消息（见 core/scheduled.ts），按发送时间先后 */
+  scheduled?: { id: string; text: string; at: number }[];
 };
 
 /** 普通成员点了会落盘的「总是允许」 */
@@ -443,6 +446,10 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
       ...(this.drivers.get(conv.agent)?.forkAt ? { canFork: true } : {}),
       mode: conv.mode ?? "work",
       ...(memoryOwnerOf(conv) ? { personal: true } : {}),
+      ...(() => {
+        const list = listScheduled(key);
+        return list.length ? { scheduled: list.map(({ id, text, at }) => ({ id, text, at })) } : {};
+      })(),
     };
   }
 

package/src/core/scheduled.ts

@@ -0,0 +1,113 @@
+// 定时发送：额度用完了、要等刷新才能接着干活时，先把下一条消息排好，到点由服务端替用户发出去。
+//
+// 放在服务端而不是页面里：到点时浏览器可能早关了。落盘在 data/scheduled.json，重启后接着等；
+// 服务停着的那段时间里到点的，启动后立刻补发。只支持纯文字（附件是临时上传的，放不了那么久）。
+import crypto from "node:crypto";
+import path from "node:path";
+import { dataDir, readJson, writeJsonAtomic } from "../home.js";
+
+export type ScheduledMessage = {
+  id: string;
+  key: string;
+  text: string;
+  /** 什么时候发（毫秒时间戳） */
+  at: number;
+  createdAt: number;
+};
+
+/** 每条对话最多排几条 */
+export const SCHEDULED_MAX = 20;
+
+const storePath = path.join(dataDir, "scheduled.json");
+let cache: ScheduledMessage[] | null = null;
+let timer: NodeJS.Timeout | null = null;
+let fire: ((m: ScheduledMessage) => void) | null = null;
+
+function load(): ScheduledMessage[] {
+  cache ??= readJson<ScheduledMessage[]>(storePath, []).filter((m) => m && typeof m.text === "string" && Number.isFinite(m.at));
+  return cache;
+}
+
+function save(): void {
+  writeJsonAtomic(storePath, load());
+}
+
+export function listScheduled(key: string): ScheduledMessage[] {
+  return load()
+    .filter((m) => m.key === key)
+    .sort((a, b) => a.at - b.at);
+}
+
+export function addScheduled(key: string, text: string, at: number): ScheduledMessage {
+  if (!text.trim()) throw new Error("定时发送的内容不能为空");
+  if (!Number.isFinite(at)) throw new Error("时间不对");
+  if (listScheduled(key).length >= SCHEDULED_MAX) throw new Error(`这条对话最多排 ${SCHEDULED_MAX} 条定时消息`);
+  const item: ScheduledMessage = { id: crypto.randomBytes(6).toString("hex"), key, text, at, createdAt: Date.now() };
+  load().push(item);
+  save();
+  arm();
+  return item;
+}
+
+export function removeScheduled(key: string, id: string): boolean {
+  const list = load();
+  const i = list.findIndex((m) => m.id === id && m.key === key);
+  if (i < 0) return false;
+  list.splice(i, 1);
+  save();
+  arm();
+  return true;
+}
+
+/** 对话被删 / 换了主人之类：把它排着的全清掉 */
+export function clearScheduled(key: string): void {
+  const list = load();
+  const kept = list.filter((m) => m.key !== key);
+  if (kept.length === list.length) return;
+  cache = kept;
+  save();
+  arm();
+}
+
+/** 定时器只挂最近的那一条；setTimeout 最长约 24.8 天，更远的先睡到上限再重新算 */
+function arm(): void {
+  if (timer) clearTimeout(timer);
+  timer = null;
+  if (!fire) return;
+  const next = load().reduce<number | null>((min, m) => (min === null || m.at < min ? m.at : min), null);
+  if (next === null) return;
+  const delay = Math.min(Math.max(next - Date.now(), 0), 2 ** 31 - 1);
+  timer = setTimeout(tick, delay);
+  timer.unref();
+}
+
+function tick(): void {
+  timer = null;
+  const now = Date.now();
+  const list = load();
+  const due = list.filter((m) => m.at <= now).sort((a, b) => a.at - b.at);
+  if (due.length) {
+    cache = list.filter((m) => m.at > now);
+    save();
+    for (const m of due) {
+      try {
+        fire?.(m);
+      } catch (err) {
+        console.error(`[定时发送] ${m.key} 发送失败:`, err instanceof Error ? err.message : err);
+      }
+    }
+  }
+  arm();
+}
+
+/** 启动调度。onFire 负责真正把消息发出去（由 main.ts 接到 hub 上，这里不依赖 hub） */
+export function startScheduler(onFire: (m: ScheduledMessage) => void): void {
+  fire = onFire;
+  arm();
+}
+
+export function stopScheduler(): void {
+  fire = null;
+  if (timer) clearTimeout(timer);
+  timer = null;
+}

package/src/main.ts

@@ -10,6 +10,7 @@ import { startFeishu, stopFeishu } from "./channels/feishu/index.js";
 import { startWeb, stopWeb } from "./channels/web/server.js";
 import { home } from "./home.js";
 import { startMemoryCurator } from "./core/memory-curator.js";
+import { startScheduler, stopScheduler } from "./core/scheduled.js";
 
 async function startDriver(id: "claude" | "codex"): Promise<void> {
   const driver = hub.driver(id);
@@ -45,6 +46,12 @@ async function main(): Promise<void> {
 
   startFeishu();
   if (config().web.enabled) await startWeb();
+  // 定时发送：等 agent 和渠道都起来了再开始，服务停着时到点的这时补发
+  startScheduler((m) => {
+    if (!getConversation(m.key)) return;
+    hub.send(m.key, { text: m.text, attachments: [] }, { channel: "schedule", channelId: "schedule", name: "定时发送" });
+    hub.emitEvent(m.key, { type: "meta" });
+  });
   // 先查一遍 agent 装没装、登没登录，网页打开时新对话里就只列出能用的
   void agentHealth().catch(() => {});
 
@@ -60,6 +67,7 @@ async function main(): Promise<void> {
     console.log(`[退出] 收到 ${signal}，正在收尾…`);
     const force = setTimeout(() => process.exit(0), 8000);
     force.unref();
+    stopScheduler();
     stopFeishu();
     await stopWeb();
     await hub.shutdown().catch(() => {});

package/web/app.js

@@ -38,6 +38,8 @@ 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>',
   fork: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="6" cy="5" r="2"/><circle cx="6" cy="19" r="2"/><circle cx="18" cy="7" r="2"/><path d="M6 7v10"/><path d="M18 9c0 5-6 4-11.2 8.6"/></svg>',
@@ -461,6 +463,7 @@ function onWsMessage(msg) {
       if (msg.info.key === S.current) {
         renderTopbar();
         setBusy(msg.info.busy);
+        renderScheduled();
       }
       scheduleSidebar();
       return;
@@ -681,8 +684,14 @@ 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.messages = h("div", { class: "messages" }, ui.msgInner);
+  ui.spacer = h("div", { class: "messages-spacer", "aria-hidden": "true" });
+  ui.messages = h("div", { class: "messages", tabindex: "-1" }, ui.msgInner, ui.spacer);
+  ui.toBottom = h("button", { class: "to-bottom", title: "回到底部", hidden: true, onclick: () => scrollToBottom() }, icon("down"));
+  ui.follow = true;
+  bindScrollWatch();
   ui.composerWrap = h("div", { class: "composer-wrap" });
   ui.main = h("main", { class: "main" }, ui.topbar, ui.messages, ui.composerWrap);
   ui.layout = h("div", { class: "layout" }, ui.sidebar, h("div", { class: "scrim", onclick: closeSide }), ui.main);
@@ -1284,10 +1293,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 || "";
 }
@@ -1711,7 +1732,11 @@ function newDraft() {
   S.turnAi = null;
   turnStartAt = null;
   S.uploads = [];
+  S.pinNext = false;
+  ui.pinEl = null;
+  ui.follow = true;
   setBusy(false);
+  renderScheduled();
   history.replaceState(null, "", location.pathname);
   WS.presence();
   renderTopbar();
@@ -1751,7 +1776,11 @@ async function openConversation(key) {
   S.turnAi = null;
   turnStartAt = null;
   S.uploads = [];
+  S.pinNext = false;
+  ui.pinEl = null;
+  ui.follow = true;
   renderChips();
+  renderScheduled();
   history.replaceState(null, "", `#${encodeURIComponent(key)}`);
   WS.presence();
   renderTopbar();
@@ -1800,18 +1829,82 @@ async function openConversation(key) {
   setBusy(data.info.busy);
   renderTopbar();
   WS.subscribe(key, S.seq.get(key));
-  scrollToBottom(true);
+  renderScheduled();
+  scrollToBottom();
 }
 
 // ---------- 消息渲染 ----------
 
-function nearBottom() {
+// 滚动规则（和 ChatGPT 一样）：
+//   - 自己发出一条消息后，把它顶到视口最上面，下面留白；回复往下长，长到屏幕底部之后才跟着往下滚。
+//     留白靠消息列表后面的 ui.spacer 撑出来：高度 = 刚好够那条消息滚到顶，回复越长它越矮，到 0 为止。
+//   - 回复过程中只要用户自己滚了（滚轮、触摸、拖滚动条、键盘翻页），就不再自动滚，直到下一次发消息。
+//     ui.follow 记着现在要不要自动滚。
+
+function nearBottom(gap = 120) {
   const m = ui.messages;
-  return m.scrollHeight - m.scrollTop - m.clientHeight < 120;
+  return m.scrollHeight - m.scrollTop - m.clientHeight < gap;
+}
+
+/** 内容变了之后：重算留白，要跟随的话贴到底（有留白时「底」正好就是被顶上去的那条消息） */
+function afterLayout() {
+  if (!ui.messages) return;
+  fitSpacer();
+  if (ui.follow && performance.now() > (ui.smoothUntil ?? 0)) ui.messages.scrollTop = ui.messages.scrollHeight;
+  updateToBottomBtn();
+}
+
+function fitSpacer() {
+  const pin = ui.pinEl;
+  if (!pin?.isConnected) {
+    ui.pinEl = null;
+    ui.spacer.style.height = "0px";
+    return;
+  }
+  // 顶栏是叠在消息区上面的：让出它的高度，再留一点空
+  const covered = Math.max(0, ui.topbar.getBoundingClientRect().bottom - ui.messages.getBoundingClientRect().top);
+  const top = Math.max(0, pin.offsetTop - covered - 12);
+  const need = top + ui.messages.clientHeight - ui.msgInner.offsetHeight;
+  ui.spacer.style.height = `${Math.max(0, Math.ceil(need))}px`;
+}
+
+/** 回到跟随模式并贴到底：打开会话、点「回到底部」时用 */
+function scrollToBottom() {
+  ui.follow = true;
+  afterLayout();
+}
+
+/** 把刚发出的这条消息顶到最上面 */
+function pinToTop(el) {
+  ui.pinEl = el;
+  ui.follow = true;
+  fitSpacer();
+  ui.smoothUntil = performance.now() + 450;
+  ui.messages.scrollTo({ top: ui.messages.scrollHeight, behavior: "smooth" });
+  updateToBottomBtn();
+}
+
+/** 用户自己动了滚动：停止自动滚动 */
+function userScrolled() {
+  ui.follow = false;
+  ui.smoothUntil = 0;
+}
+
+function updateToBottomBtn() {
+  if (ui.toBottom) ui.toBottom.hidden = nearBottom(200);
 }
 
-function scrollToBottom(force) {
-  if (force || ui.stick) ui.messages.scrollTop = ui.messages.scrollHeight;
+function bindScrollWatch() {
+  const m = ui.messages;
+  m.addEventListener("wheel", userScrolled, { passive: true });
+  m.addEventListener("touchmove", userScrolled, { passive: true });
+  // 点在滚动条上时事件目标就是滚动容器本身（点在内容上的是里面的元素）
+  m.addEventListener("pointerdown", (e) => e.target === m && userScrolled());
+  m.addEventListener("keydown", (e) => {
+    if (["PageUp", "PageDown", "ArrowUp", "ArrowDown", "Home", "End", " "].includes(e.key)) userScrolled();
+  });
+  m.addEventListener("scroll", updateToBottomBtn, { passive: true });
+  addEventListener("resize", () => afterLayout());
 }
 
 /** 只有最后一条回复默认显示底部的操作栏（复制 / 分叉 / 用时…），前面的 hover 才出来 */
@@ -1829,13 +1922,12 @@ function markLatestAi() {
 
 function addItem(item) {
   ui.msgInner.querySelector(".empty")?.remove();
-  const stick = nearBottom();
   item.el = renderItem(item);
   ui.msgInner.append(item.el);
   S.items.push(item);
   markLatestAi();
   updateCtxVisibility();
-  if (stick) scrollToBottom(true);
+  afterLayout();
   return item;
 }
 
@@ -1847,7 +1939,6 @@ function updateItem(item) {
   flushScheduled = true;
   requestAnimationFrame(() => {
     flushScheduled = false;
-    const stick = nearBottom();
     for (const it of dirty) {
       if (!it.el?.isConnected) continue;
       const next = renderItem(it);
@@ -1856,7 +1947,7 @@ function updateItem(item) {
     }
     dirty.clear();
     markLatestAi();
-    if (stick) scrollToBottom(true);
+    afterLayout();
   });
 }
 
@@ -2054,7 +2145,12 @@ function applyEvent(env) {
       }
       // 上一轮还没结束时发的消息会排队，不改正在进行那一轮的开始时间
       if (!S.turnAi || S.turnAi.done) turnStartAt = env.ts;
-      addItem({ type: "user", text: ev.text, files: ev.files ?? ev.attachments, origin: ev.origin });
+      const it = addItem({ type: "user", text: ev.text, files: ev.files ?? ev.attachments, origin: ev.origin });
+      // 这个页面刚发的：顶到最上面
+      if (S.pinNext && ev.origin?.channel === "web") {
+        S.pinNext = false;
+        pinToTop(it.el);
+      }
       currentAi(env.ts);
       return;
     }
@@ -2299,9 +2395,9 @@ 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 });
   ui.slashMenu = h("div", { class: "slash-menu", hidden: true });
   ui.composer = h(
     "div",
@@ -2328,18 +2424,132 @@ function renderComposer() {
       ui.fileInput,
       h("span", { class: "spacer" }),
       ui.ctxRing,
-      ui.modeSlot,
       ui.modelSlot,
       ui.micBtn,
       ui.sendBtn,
     ),
   );
   fill(ui.composerWrap,
-    h("div", { class: "composer-box" }, ui.ctxBar, ui.composer),
+    ui.toBottom,
+    h("div", { class: "composer-box" }, ui.schedBar, ui.ctxBar, ui.composer),
   );
   ui.input.addEventListener("input", updateSendBtn);
   updateSendBtn();
   renderContext();
+  renderScheduled();
+}
+
+// ---------- 定时发送 ----------
+// 额度用完、要等刷新才能接着干活时：先把下一条排好，到点由服务端发出（页面关了也会发）。只支持文字。
+
+function fmtWhen(ms) {
+  const d = new Date(ms);
+  const now = new Date();
+  const hm = `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+  const day = (x) => new Date(x.getFullYear(), x.getMonth(), x.getDate()).getTime();
+  const diff = Math.round((day(d) - day(now)) / 86400000);
+  if (diff === 0) return `今天 ${hm}`;
+  if (diff === 1) return `明天 ${hm}`;
+  if (diff === 2) return `后天 ${hm}`;
+  return `${d.getMonth() + 1}月${d.getDate()}日 ${hm}`;
+}
+
+/** <input type="datetime-local"> 要的本地时间格式 */
+function toLocalInput(ms) {
+  const d = new Date(ms);
+  const p = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}T${p(d.getHours())}:${p(d.getMinutes())}`;
+}
+
+/** 输入框上方：这条对话排着的定时消息，可以取消 */
+function renderScheduled() {
+  if (!ui.schedBar) return;
+  const list = (S.current && S.convs.get(S.current)?.scheduled) || [];
+  ui.schedBar.hidden = list.length === 0;
+  fill(ui.schedBar,
+    list.map((m) =>
+      h(
+        "div",
+        { class: "sched-item", title: m.text },
+        icon("clock"),
+        h("span", { class: "sched-when" }, fmtWhen(m.at)),
+        h("span", { class: "sched-text" }, oneLine(m.text, 200)),
+        h("button", { class: "sched-act", title: "改时间或内容", onclick: () => openSchedule(m) }, "编辑"),
+        h("button", { class: "sched-act", title: "取消这条定时消息", onclick: () => cancelScheduled(m.id) }, "取消"),
+      ),
+    ),
+  );
+}
+
+async function cancelScheduled(id, quiet) {
+  const key = S.current;
+  if (!key) return false;
+  try {
+    const info = await api(`/api/conversations/${encodeURIComponent(key)}/scheduled?id=${encodeURIComponent(id)}`, { method: "DELETE" });
+    S.convs.set(info.key, info);
+    renderScheduled();
+    return true;
+  } catch (err) {
+    if (!quiet) toast(err.message);
+    return false;
+  }
+}
+
+/** 选时间的弹窗。edit：改已经排着的那条（先删旧的再排新的） */
+function openSchedule(edit) {
+  if (!edit && S.uploads.length) return toast("定时发送暂不支持附件，先移除附件");
+  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" });
+  // 当前 agent 的额度窗口（5 小时 / 7 天）什么时候重置：小字提示，默认排在 5 小时窗口重置后 5 分钟
+  const agent = currentAgentId();
+  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("label", { class: "sched-row" }, h("span", {}, "发送时间"), when),
+    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) });
+  text.focus();
+  go.onclick = async () => {
+    const at = new Date(when.value).getTime();
+    if (!text.value.trim()) return toast("内容不能为空");
+    if (!Number.isFinite(at)) return toast("选一下发送时间");
+    if (at <= Date.now()) return toast("发送时间要在现在之后");
+    go.disabled = true;
+    try {
+      const key = await ensureConversation();
+      // 先排新的再删旧的：中途失败也不会把原来那条弄丢
+      const info = await api(`/api/conversations/${encodeURIComponent(key)}/scheduled`, { method: "POST", body: { text: text.value, at } });
+      S.convs.set(info.key, info);
+      if (edit) await cancelScheduled(edit.id, true);
+      renderScheduled();
+      // 用的是输入框里的草稿：排好了就清掉
+      if (!edit && text.value === ui.input.value) {
+        ui.input.value = "";
+        autosize();
+        updateSendBtn();
+      }
+      close();
+      toast(`已排好，${fmtWhen(at)} 发送`);
+    } catch (err) {
+      go.disabled = false;
+      toast(err.message);
+    }
+  };
 }
 
 // ---------- 语音输入（浏览器自带 Web Speech API） ----------
@@ -2682,12 +2892,15 @@ async function sendMessage() {
   let key;
   let res;
   setSending(true);
+  // 发出去之后恢复自动滚动；回显的那条用户消息到了就顶到最上面（见 applyEvent）
+  S.pinNext = true;
   try {
     key = await ensureConversation();
     if ("Notification" in window && Notification.permission === "default") void Notification.requestPermission();
     // 命令（比如 /status 要现读额度）可能比普通发送慢，多给点时间
     res = await WS.request({ t: "send", key, text, uploads: S.uploads.map((u) => u.id) }, 45000);
   } catch (err) {
+    S.pinNext = false;
     toast(err.message);
     return;
   } finally {
@@ -2703,9 +2916,12 @@ async function sendMessage() {
   S.uploads = [];
   renderChips();
   updateSendBtn();
-  ui.stick = true;
-  if (res?.reply) await showCommandReply(text.trim(), res.reply, res.info);
-  scrollToBottom(true);
+  if (res?.reply) {
+    // 命令不进会话记录，没有回显：直接贴到底看结果
+    S.pinNext = false;
+    await showCommandReply(text.trim(), res.reply, res.info);
+    scrollToBottom();
+  } else if (!ui.pinEl) ui.follow = true;
 }
 
 /** 会改变当前会话（换会话、换目录、换 agent）的命令，执行完要重拉一遍 */
@@ -5308,10 +5524,6 @@ async function systemTab(cfg, panel) {
 
 // ---------- 启动 ----------
 
-boot()
-  .then(() => {
-    ui.messages?.addEventListener("scroll", () => (ui.stick = nearBottom()), { passive: true });
-  })
-  .catch((err) => {
+boot().catch((err) => {
     fill($app, h("div", { class: "auth" }, h("div", { class: "auth-card" }, h("p", {}, `加载失败：${err.message}`))));
   });

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

@@ -984,6 +984,46 @@ button.conv-group:hover {
   overflow-y: auto;
   overscroll-behavior: contain;
   scroll-behavior: auto;
+  /* 留白（.messages-spacer）按消息的 offsetTop 计算，要以滚动容器为准 */
+  position: relative;
+  outline: none;
+}
+
+/* 发出消息后把它顶到最上面用的留白，高度由 app.js 算 */
+.messages-spacer {
+  height: 0;
+  flex-shrink: 0;
+}
+
+/* 自己往上翻了之后出现：点一下回到底部、恢复自动滚动 */
+.to-bottom {
+  position: absolute;
+  left: 50%;
+  bottom: calc(100% + 10px);
+  transform: translateX(-50%);
+  z-index: 5;
+  width: 34px;
+  height: 34px;
+  border-radius: 50%;
+  display: grid;
+  place-items: center;
+  background: var(--bg);
+  color: var(--fg-soft);
+  border: 1px solid var(--border);
+  box-shadow: var(--shadow);
+}
+
+.to-bottom:hover {
+  color: var(--fg);
+}
+
+.to-bottom[hidden] {
+  display: none;
+}
+
+.to-bottom svg {
+  width: 18px;
+  height: 18px;
 }
 
 .messages-inner {
@@ -1998,6 +2038,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);
 }
@@ -3319,3 +3369,103 @@ button.list-item:hover {
 .in-desktop .side-top :is(button, a, input, select, textarea, label) {
   -webkit-app-region: no-drag;
 }
+
+/* ---------- 定时发送 ---------- */
+
+.sched-bar {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  margin: 0 14px 6px;
+}
+
+.sched-bar[hidden] {
+  display: none;
+}
+
+.sched-item {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  min-width: 0;
+  padding: 6px 6px 6px 10px;
+  border: 1px solid var(--border);
+  border-radius: 12px;
+  background: var(--bg-soft);
+  font-size: 13px;
+  color: var(--fg-soft);
+}
+
+.sched-item svg {
+  width: 15px;
+  height: 15px;
+  flex-shrink: 0;
+  color: var(--accent);
+}
+
+.sched-when {
+  flex-shrink: 0;
+  color: var(--fg);
+  font-weight: 500;
+}
+
+.sched-text {
+  flex: 1;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.sched-act {
+  flex-shrink: 0;
+  padding: 3px 8px;
+  border-radius: 8px;
+  font-size: 12px;
+  color: var(--fg-soft);
+}
+
+.sched-act:hover {
+  background: var(--bg-hover);
+  color: var(--fg);
+}
+
+.sched-input {
+  width: 100%;
+  box-sizing: border-box;
+  resize: vertical;
+  padding: 10px 12px;
+  border: 1px solid var(--border);
+  border-radius: 10px;
+  background: var(--bg-input);
+  color: var(--fg);
+  font: inherit;
+}
+
+.sched-hint {
+  font-size: 12px;
+  line-height: 1.6;
+}
+
+.sched-row {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+}
+
+.sched-time {
+  flex: 1;
+  padding: 7px 10px;
+  border: 1px solid var(--border);
+  border-radius: 10px;
+  background: var(--bg-input);
+  color: var(--fg);
+  font: inherit;
+  color-scheme: light dark;
+}
+
+/* iOS 上双击会放大页面：关掉双击缩放（双指缩放照常） */
+html,
+body {
+  touch-action: manipulation;
+}