mingdao-harness 0.6.21 → 0.6.23

package/docs/CONFIG.md

@@ -394,6 +394,23 @@ completion 计费，防止推理吃满上限时空轮白烧）、`compactTrigger
 
 长期偏好仍走用户记忆（`AGENTS.md`，见上），不受此开关影响。
 
+### WebUI 会话列表字段与消息时间（v0.6.22，§3.84）
+
+`GET /api/sessions` 的每一项在既有 `file` / `mtime` / `label` 之外**只增**三个只读字段：
+
+| 字段 | 含义 | 来源 |
+| --- | --- | --- |
+| `updatedAt` | 会话最后更新时间，ISO 字符串 | 会话文件 mtime |
+| `messageCount` | 该会话的 JSONL 消息条数（坏行跳过） | 只读解析文件 |
+| `title` | 会话标题（已有文件名即标题；自动标题/重命名都落在文件名上） | 文件名去 `.jsonl` |
+
+`GET /api/session?file=` 的每条消息**只增** `ts`（ISO 字符串）。旧会话（v0.6.21 及以前写的
+JSONL 没有 `ts`）返回 `"ts": null`，其余字段语义不变；WebUI 对 `ts` 为 `null` 的消息不渲染时间，
+不会出现 `Invalid Date` / `undefined`。`ts` 由 `session.appendMessages` **统一补齐**（v0.6.23，§3.87）：
+CLI / REPL / 调度 / Web 写入都走这一个入口，只补缺少 `ts` 的消息、已有值原样保留（重复写入与压缩
+重写不刷新时间）；读取路径不回填、不改写旧文件，因此旧会话仍返回 `null`。前端不自行推算历史消息时间。
+分组（今天/昨天/本周/更早）与时间显示都在 `src/web/app.js`；分组只在会话列表刷新时计算一次，不引入轮询。
+
 ## 模型名称以 API 为准（v0.6.19，§3.67）
 
 **仓库不维护具体版本号，只维护「家族能力 / 定价模式」。** 官方改名、升版本（例如

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mingdao-harness",
-  "version": "0.6.21",
+  "version": "0.6.23",
   "description": "MingDao Harness —— 开源智能体框架（Agent Harness）。零依赖、开箱即用，针对 DeepSeek-V4 系列优化，开放主流模型接入。",
   "type": "module",
   "bin": {

package/src/atomic-write.js

@@ -26,12 +26,79 @@ import { AsyncLocalStorage } from 'node:async_hooks';
 import { setTimeout as sleepAsync } from 'node:timers/promises';
 import { procAlive } from './proc.js';
 
+// ---------------------------------------------------------------------------
+// 瞬时拒绝（Windows）与有界重试（v0.6.23，§3.86）
+//
+// 证据：CI Windows 腿的 BUG-068（8 个子进程并发 saveTaskStateMerge）曾出现 7/8、6/8，
+// rerun 换运气；macOS/Linux 万条×5 轮、64 进程×5 轮 0 丢。子进程把 saveTaskStateMerge 的
+// {ok:false} 丢进 stdio:'ignore' 后照常 exit 0，所以父进程只看到一个没有归因的差数。
+// 复查后确认：丢更新不是原因，**瞬时拒绝被当成永久失败**才是——NTFS 上刚 unlink 的
+// `.lock` 仍处于 delete-pending 时 `open(…,'wx')` 会被拒 EACCES/EPERM；Defender/索引器
+// 正在扫描刚写出的 `.tmp` 时 `rename` 会被拒 EACCES/EPERM/EBUSY。这两种都不是"权限配错"，
+// 也不是"别人长期持锁"，而是**争用的一种**：等几十~几百毫秒就会自己消失。
+//
+// 所以把 EACCES/EPERM/EBUSY 与 EEXIST 一样纳入"等待 + 重试"，但**单独给 2 秒预算**：
+//   · 初始 5ms：锁刚被 unlink 时 delete-pending 通常几个 tick 就清掉，早试能少等；
+//   · 每次 ×2、封顶 100ms：既不在前 100ms 里高频敲文件系统（杀软扫描时高频重试只会更糟），
+//     又保证晚期的恢复延迟不超过 100ms；
+//   · 总预算 2000ms：Windows 杀软/索引器的单文件扫描窗口在数十~数百 ms 量级，
+//     2s 有约 10~100 倍余量；同时**有界**——真正的 ACL/只读目录问题不会把进程永久冻住，
+//     也不会把一次保存拖成整个 WebUI 的几十秒卡顿（同步锁仍走 Atomics.wait）。
+//   · EEXIST（确实有人在持锁）不适用这个 2s 预算：它继续走原来的 timeoutMs(5s)/staleMs(4s)。
+// 预算耗尽时**原样抛出原始错误**（保留 errno/path），不折成"锁超时"——后者会把权限/杀软
+// 问题伪装成死锁，用户按提示删锁也没用。
+// ---------------------------------------------------------------------------
+const TRANSIENT_DENY_CODES = new Set(['EACCES', 'EPERM', 'EBUSY']);
+const TRANSIENT_RETRY_INITIAL_MS = 5;
+const TRANSIENT_RETRY_MAX_MS = 100;
+const TRANSIENT_RETRY_BUDGET_MS = 2000;
+
+/** 某个 errno 是否属于「等一会儿可能自己好」的瞬时拒绝。 @param {any} code */
+export function isTransientDenyCode(code) {
+  return TRANSIENT_DENY_CODES.has(String(code || ''));
+}
+
+/** 退避参数（导出供诊断与测试断言「5–10ms 起 / 封顶 / 总预算有界」）。 */
+export function retryDefaults() {
+  return {
+    initialMs: TRANSIENT_RETRY_INITIAL_MS,
+    maxDelayMs: TRANSIENT_RETRY_MAX_MS,
+    budgetMs: TRANSIENT_RETRY_BUDGET_MS,
+    codes: [...TRANSIENT_DENY_CODES],
+  };
+}
+
+const sleepBuf = new Int32Array(new SharedArrayBuffer(4));
+const sleepMs = (/** @type {number} */ ms) => Atomics.wait(sleepBuf, 0, 0, ms);
+
+/**
+ * 在 deadline 之前对瞬时拒绝做指数退避重试；非瞬时错误与预算耗尽都**原样抛出**。
+ * deadline 由调用方传入：一次原子写的 write+rename 共享同一份预算，避免两段各等 2 秒。
+ * @template T @param {() => T} fn @param {number} deadline @returns {T}
+ */
+function retryTransientSync(fn, deadline) {
+  let delay = TRANSIENT_RETRY_INITIAL_MS;
+  for (;;) {
+    try {
+      return fn();
+    } catch (err) {
+      if (!isTransientDenyCode(/** @type {any} */ (err)?.code)) throw err;
+      const remain = deadline - Date.now();
+      if (remain <= 0) throw err;
+      sleepMs(Math.min(delay, remain));
+      delay = Math.min(delay * 2, TRANSIENT_RETRY_MAX_MS);
+    }
+  }
+}
+
 export function atomicWriteFileSync(/** @type {string} */ target, /** @type {string|Buffer} */ data, /** @type {any} */ options = {}) {
   const dir = path.dirname(target);
   const tmp = path.join(dir, `.${path.basename(target)}.${process.pid}.${crypto.randomBytes(4).toString('hex')}.tmp`);
+  const deadline = Date.now() + TRANSIENT_RETRY_BUDGET_MS;
   try {
-    fs.writeFileSync(tmp, data, options);
-    fs.renameSync(tmp, target);
+    // Windows：杀软/索引器短暂持有新建的 .tmp（EACCES/EPERM/EBUSY）或拒绝覆盖目标，都等一等再试。
+    retryTransientSync(() => fs.writeFileSync(tmp, data, options), deadline);
+    retryTransientSync(() => fs.renameSync(tmp, target), deadline);
   } catch (err) {
     try {
       fs.unlinkSync(tmp);
@@ -81,8 +148,6 @@ export function atomicWriteJsonSync(/** @type {string} */ target, /** @type {any
 
 // 极简互斥锁：O_EXCL 创建 lockfile；持锁期间执行 fn（同步/异步）；异常/完成释放。
 // 进程崩溃遗留的陈旧锁自动回收，避免永久卡死。
-const sleepBuf = new Int32Array(new SharedArrayBuffer(4));
-const sleepMs = (/** @type {number} */ ms) => Atomics.wait(sleepBuf, 0, 0, ms);
 
 // 可重入集合按**调用链**隔离（见文件头注释：异步临界区会 yield，进程级 Set 会让并发任务互相穿透）
 const lockScope = new AsyncLocalStorage();
@@ -95,16 +160,23 @@ function runWithHeld(fn) {
 }
 
 /**
- * 尝试独占创建锁文件。EEXIST 表示别人持有（返回 false，由调用方决定等待或重试）；
- * 其它错误（权限/路径非法）**直接抛出**——那不是"有人在用"，装成争用只会掩盖真问题。
+ * 尝试独占创建锁文件。**返回结构化结果而不是用异常表达"忙"**：
+ *   · `{ok:true}` —— 拿到了锁；
+ *   · `{ok:false, code:'EEXIST', error}` —— 锁确实被别人持有（按 timeoutMs 等待，可回收陈旧锁）；
+ *   · `{ok:false, code:'EACCES'|'EPERM'|'EBUSY', error}` —— Windows 的**瞬时拒绝**：NTFS
+ *     delete-pending / 杀软/索引器扫描 / 共享冲突。它既不是"权限配错"也不是"长期持锁"，
+ *     由调用方走独立的 2s 退避预算；预算耗尽时抛 `error`（保留 errno 原文）。
+ * 其余错误（路径非法等）仍**直接抛出**——那不是争用，装成争用只会掩盖真问题。
  * @param {string} lockPath
+ * @returns {{ok: true} | {ok: false, code: string, error: any}}
  */
 function tryAcquire(lockPath) {
   let fd;
   try {
     fd = fs.openSync(lockPath, 'wx');
   } catch (err) {
-    if (/** @type {any} */ (err)?.code === 'EEXIST') return false;
+    const code = String(/** @type {any} */ (err)?.code || '');
+    if (code === 'EEXIST' || isTransientDenyCode(code)) return { ok: false, code, error: err };
     throw err;
   }
   try {
@@ -124,7 +196,7 @@ function tryAcquire(lockPath) {
   } finally {
     fs.closeSync(fd);
   }
-  return true;
+  return { ok: true };
 }
 
 /** @param {string} lockPath */
@@ -217,39 +289,34 @@ export function withFileLockSync(/** @type {string} */ lockPath, /** @type {() =
     if (held.has(lockPath)) return fn();
     fs.mkdirSync(path.dirname(lockPath), { recursive: true });
     const t0 = Date.now();
+    let delay = TRANSIENT_RETRY_INITIAL_MS;
+    // 第一次遇到瞬时拒绝的时刻（EEXIST 不参与这个预算，见文件头参数说明）
+    let transientSince = 0;
     for (;;) {
-      // v0.4.7：区分「抢锁阶段」与「执行 fn 阶段」。此前 fn 自身抛出的 EEXIST 也会落进下方的
-      // 锁重试分支，而 finally 已释放锁 → 重抢成功后再次执行 fn → 再次抛出 → **同步死循环**
-      // （100% CPU，连超时分支都不可达）。acquiring 在 fn 开始执行前置 false。
-      let acquiring = true;
-      try {
-        if (!tryAcquire(lockPath)) {
-          const e = /** @type {any} */ (new Error('EEXIST'));
-          e.code = 'EEXIST';
-          throw e;
-        }
+      const got = tryAcquire(lockPath);
+      if (got.ok) {
         held.add(lockPath);
-        acquiring = false; // 锁已持有：此后 fn 的任何异常都不得进入锁重试分支
+        // v0.4.7：fn 在 try/finally 里直接执行，**不进入抢锁的 catch**——
+        // 否则 fn 自身抛出的 EEXIST 会被当成抢锁失败，重抢后再次执行 fn → 同步死循环。
         try {
           return fn();
         } finally {
           held.delete(lockPath);
           releaseLock(lockPath);
         }
-      } catch (err) {
-        if (!acquiring) throw err; // fn 自身的异常绝不进入锁重试
-        if (/** @type {any} */ (err).code !== 'EEXIST') throw err;
-        // 审计 BUG-047（实测复现）：回收陈旧锁的分支原先直接 `continue`，**跳过了下面的超时判断**——
-        // 当陈旧锁删不掉（只读目录 / EPERM / EIO；实测 chmod 555 即可复现）时 reclaimIfStale
-        // 永远返回 true，于是无限空转：99% CPU、5 秒超时失效、进程不返回。
-        // 「回收过」不构成「可以不计时地重试」，两条路径都必须过超时闸。
-        const reclaimed = reclaimIfStale(lockPath, staleMs);
-        if (Date.now() - t0 > timeoutMs) {
-          throw lockTimeoutError(lockPath, timeoutMs);
-        }
-        sleepMs(25);
-        if (reclaimed) continue; // 回收后立刻重试；否则同样按 25ms 节流再试
       }
+      if (got.code === 'EEXIST') {
+        // 审计 BUG-047：回收陈旧锁的分支不得绕过超时闸，否则陈旧锁删不掉（只读目录/EPERM）
+        // 时 reclaimIfStale 恒返回 true → 无限空转、超时失效。
+        reclaimIfStale(lockPath, staleMs);
+        if (Date.now() - t0 > timeoutMs) throw lockTimeoutError(lockPath, timeoutMs);
+      } else {
+        // EACCES/EPERM/EBUSY：Windows 的瞬时拒绝，走独立的 2s 预算；耗尽时抛原始 errno。
+        if (!transientSince) transientSince = Date.now();
+        if (Date.now() - transientSince >= TRANSIENT_RETRY_BUDGET_MS) throw got.error;
+      }
+      sleepMs(delay);
+      delay = Math.min(delay * 2, TRANSIENT_RETRY_MAX_MS);
     }
   });
 }
@@ -262,15 +329,21 @@ export function withFileLockSync(/** @type {string} */ lockPath, /** @type {() =
  * 为什么值得单独一个函数而不是把同步版改成异步：调用链里不少地方本身就是同步的
  * （CLI 一次性命令、调度守护进程内部的读-改-写），强行异步化会把 async 传染到 24 个调用点，
  * 回归风险大于收益。做法是**逐个判断**：请求路径上的迁移，纯同步链保留同步版。
+ *
+ * 等待策略与同步版逐字一致：EEXIST 走 timeoutMs，EACCES/EPERM/EBUSY 走 2s 瞬时预算；
+ * `pollMs` 是**首次**等待时长，之后每次 ×2、封顶 100ms（旧版是固定 25ms 轮询）。
  * @param {string} lockPath @param {() => any} fn
  */
-export async function withFileLock(/** @type {string} */ lockPath, /** @type {() => any} */ fn, { timeoutMs = DEFAULT_TIMEOUT_MS, staleMs = DEFAULT_STALE_MS, pollMs = 25 } = {}) {
+export async function withFileLock(/** @type {string} */ lockPath, /** @type {() => any} */ fn, { timeoutMs = DEFAULT_TIMEOUT_MS, staleMs = DEFAULT_STALE_MS, pollMs = TRANSIENT_RETRY_INITIAL_MS } = {}) {
   return runWithHeld(async (held) => {
     if (held.has(lockPath)) return fn();
     fs.mkdirSync(path.dirname(lockPath), { recursive: true });
     const t0 = Date.now();
+    let delay = Number(pollMs) > 0 ? Number(pollMs) : TRANSIENT_RETRY_INITIAL_MS;
+    let transientSince = 0;
     for (;;) {
-      if (tryAcquire(lockPath)) {
+      const got = tryAcquire(lockPath);
+      if (got.ok) {
         held.add(lockPath);
         try {
           return await fn();
@@ -281,13 +354,16 @@ export async function withFileLock(/** @type {string} */ lockPath, /** @type {()
           releaseLock(lockPath);
         }
       }
-      // 与同步版同一条修正（审计 BUG-047）：回收分支不得绕过超时闸，否则陈旧锁删不掉时永远自旋
-      const reclaimed = reclaimIfStale(lockPath, staleMs);
-      if (Date.now() - t0 > timeoutMs) {
-        throw lockTimeoutError(lockPath, timeoutMs);
+      if (got.code === 'EEXIST') {
+        // 与同步版同一条修正（审计 BUG-047）：回收分支不得绕过超时闸，否则陈旧锁删不掉时永远自旋
+        reclaimIfStale(lockPath, staleMs);
+        if (Date.now() - t0 > timeoutMs) throw lockTimeoutError(lockPath, timeoutMs);
+      } else {
+        if (!transientSince) transientSince = Date.now();
+        if (Date.now() - transientSince >= TRANSIENT_RETRY_BUDGET_MS) throw got.error;
       }
-      await sleepAsync(pollMs);
-      if (reclaimed) continue;
+      await sleepAsync(delay);
+      delay = Math.min(delay * 2, TRANSIENT_RETRY_MAX_MS);
     }
   });
 }

package/src/session.js

@@ -60,9 +60,30 @@ export function createSession(home) {
   return { file, name: path.basename(file) };
 }
 
+/**
+ * v0.6.23（§3.87）：会话消息 `ts` 的**唯一补齐点**。
+ *
+ * 为什么放在这一层：CLI / REPL / 调度 worker / Web 落盘最终都走 appendMessages；
+ * 此前只有 Web server 在落盘前自己 stamp，导致旧会话与非 Web 会话的消息在界面上没有时间。
+ * 规则：只给**缺少 ts** 的消息补一个 ISO 字符串，已有 ts 原样保留（重复写入不刷新时间）；
+ * 就地写回同一批消息对象，这样自动压缩的整文件重写（rewriteSession）能带上刚写下的 ts。
+ * 读取路径不调用它：旧会话缺 ts 仍返回 null，绝不回填/改写历史文件。
+ * @param {any[]} messages
+ * @param {Date} [now]
+ */
+export function stampMessageTs(messages, now = new Date()) {
+  const ts = now.toISOString();
+  for (const m of messages) {
+    if (!m || typeof m !== 'object' || m.ts) continue;
+    m.ts = ts;
+  }
+  return messages;
+}
+
 /** @param {any} file @param {any} messages */
 export function appendMessages(file, messages) {
   if (!messages?.length) return;
+  stampMessageTs(messages); // 单一来源：所有写入路径在这里补 ts（已有 ts 不覆盖）
   const lines = messages.map((/** @type {any} */ m) => JSON.stringify(m)).join('\n') + '\n';
   appendFilePrivateSync(file, lines);
 }

package/src/web/app.js

@@ -224,16 +224,87 @@ chatEl.addEventListener('click', (e) => {
   const done = () => { b.textContent = '已复制'; setTimeout(() => { b.textContent = '复制'; }, 1200); };
   if (navigator.clipboard?.writeText) navigator.clipboard.writeText(t).then(done).catch(() => {});
 });
+// ==== v0.6.22 §3.84 会话分组 + 消息时间（纯函数，test/ui-sessions.js 可直接抽取执行）====
+// 只做展示：分组顺序固定「今天 → 昨天 → 本周 → 更早」，组标题不可点击/不可折叠。
+// 「现在」一律由调用方传入（默认 new Date()），测试用固定 now 避免跨午夜抖动。
+const SESSION_GROUP_ORDER = ['today', 'yesterday', 'week', 'earlier'];
+const SESSION_GROUP_TITLES = { today: '今天', yesterday: '昨天', week: '本周', earlier: '更早' };
+
+/** 取本地时区某一天的 00:00（用日期构造器而非减 86400000，跨夏令时也不会偏一小时）。 */
+function localDayStart(d) {
+  return new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
+}
+
+/**
+ * 单个会话落在哪个分组。时间不可解析/缺失 → earlier（绝不抛错）。
+ * 边界：今天 00:00 起算今天；昨天 00:00 起算昨天；本周从周一 00:00 起算。
+ * @param {string|number|Date|undefined|null} updatedAt
+ * @param {Date} [now]
+ * @returns {string}
+ */
+function sessionGroupKey(updatedAt, now) {
+  const t = new Date(updatedAt == null ? NaN : updatedAt).getTime();
+  const n = now instanceof Date ? now : new Date(now == null ? Date.now() : now);
+  if (!Number.isFinite(t) || Number.isNaN(n.getTime())) return 'earlier';
+  const today = localDayStart(n);
+  if (t >= today) return 'today';
+  const yesterday = new Date(n.getFullYear(), n.getMonth(), n.getDate() - 1).getTime();
+  if (t >= yesterday) return 'yesterday';
+  const dow = (n.getDay() + 6) % 7; // 周一 = 0
+  const weekStart = new Date(n.getFullYear(), n.getMonth(), n.getDate() - dow).getTime();
+  if (t >= weekStart) return 'week';
+  return 'earlier';
+}
+
+/**
+ * 一次性把会话列表分到四个桶（空桶不返回；顺序固定）。调用方只在数据刷新时调用一次，
+ * 渲染函数只读 `sessionsGroupedCache`——不得在每次渲染时重算。
+ * @param {any[]} sessions
+ * @param {Date} [now]
+ * @returns {{key:string,title:string,items:any[]}[]}
+ */
+function groupSessionsByUpdatedAt(sessions, now) {
+  /** @type {Record<string, any[]>} */
+  const buckets = { today: [], yesterday: [], week: [], earlier: [] };
+  for (const s of sessions || []) {
+    // updatedAt 是 v0.6.22 新增字段；mtime 是旧接口既有字段（毫秒），两者都能分组。
+    buckets[sessionGroupKey(s && (s.updatedAt ?? s.mtime), now)].push(s);
+  }
+  return SESSION_GROUP_ORDER
+    .filter((key) => buckets[key].length > 0)
+    .map((key) => ({ key, title: SESSION_GROUP_TITLES[key], items: buckets[key] }));
+}
+
+/**
+ * 消息时间文案：同一天 `14:32`；跨天 `10-19 14:32`；缺失/非法 → ''（前端不渲染任何节点，
+ * 所以不会出现 "Invalid Date" / "undefined"）。
+ * @param {any} ts
+ * @param {Date} [now]
+ * @returns {string}
+ */
+function msgTimeText(ts, now) {
+  if (typeof ts !== 'string' || !ts.trim()) return '';
+  const d = new Date(ts);
+  if (Number.isNaN(d.getTime())) return '';
+  const n = now instanceof Date ? now : new Date(now == null ? Date.now() : now);
+  if (Number.isNaN(n.getTime())) return '';
+  const hm = String(d.getHours()).padStart(2, '0') + ':' + String(d.getMinutes()).padStart(2, '0');
+  const sameDay = d.getFullYear() === n.getFullYear() && d.getMonth() === n.getMonth() && d.getDate() === n.getDate();
+  if (sameDay) return hm;
+  return String(d.getMonth() + 1).padStart(2, '0') + '-' + String(d.getDate()).padStart(2, '0') + ' ' + hm;
+}
+// ==== /v0.6.22 §3.84 ====
+
 let generating = false; // 生成中：发送按钮复用为停止按钮
 let currentSession = null, thinking = null;
 
 
 
-function newAiMsg(){ const el=document.createElement('div'); el.className='msg-ai'; chatEl.appendChild(el); scrollBottom(); return el; }
+function newAiMsg(ts){ const el=document.createElement('div'); el.className='msg-ai'; const t=msgTimeText(ts); if(t){ const m=document.createElement('div'); m.className='msg-time'; m.textContent=t; el.appendChild(m); } chatEl.appendChild(el); scrollBottom(); return el; }
 function aiContent(msg){ const c=msg.querySelector('.content'); return c || (()=>{const d=document.createElement('div');d.className='content';msg.appendChild(d);return d;})(); }
 function addReasoning(msg){ const d=document.createElement('details'); d.className='reasoning'; d.innerHTML='<summary>思考过程</summary><div class="body"></div>'; msg.appendChild(d); return d.querySelector('.body'); }
 
-function addUser(text){ const el=document.createElement('div'); el.className='msg-user'; el.innerHTML='<div class="bubble">'+esc(text)+'</div>'; chatEl.appendChild(el); renderEmptyState(); scrollBottom(); }
+function addUser(text, ts){ const el=document.createElement('div'); el.className='msg-user'; const t=msgTimeText(ts); el.innerHTML='<div class="bubble">'+esc(text)+(t?'<span class="msg-time">'+esc(t)+'</span>':'')+'</div>'; chatEl.appendChild(el); renderEmptyState(); scrollBottom(); }
 
 const runningTools = new Map();
 // P1-1 工具时间线（v0.6.19 §3.70）保留为轨迹详情的渲染原语（toolStepNode/paintToolStep/
@@ -484,8 +555,8 @@ async function send(){
   if(attachments.length) payload.attachments=attachments;
   const sentAttachments=attachments;
   attachments=[]; renderAttachments();
-  addUser(text||(sentAttachments.map(a=>(a.type==='image'?'🖼 ':'📄 ')+a.name).join(' ')));
-  const msg=newAiMsg(); const content=aiContent(msg); let raw='';
+  addUser(text||(sentAttachments.map(a=>(a.type==='image'?'🖼 ':'📄 ')+a.name).join(' ')), new Date().toISOString());
+  const msg=newAiMsg(new Date().toISOString()); const content=aiContent(msg); let raw='';
   activeAiMsg=msg; msg._traj=[]; msg._steps=0; msg._round=++turnSeq; msg._startedAt=Date.now(); msg._endedAt=null; pendingSubagent=null; curSteps=0; curWorkT0=Date.now();
   // P0-1：本轮开始 → 运行状态条归零（上一轮的费用/首帧/工具数不许泄漏到本轮；上下文基数保留）
   runState.rawPhase='发请求（等首帧）'; runState.phase='等首帧'; runState.aborted=false;
@@ -1159,6 +1230,8 @@ function layoutClassesFor(width) {
 // 快捷键表 / 会话设置 / 空态 / 设置搜索 / 诊断。全部消费上面纯函数的结果。
 // ============================================================================
 let sessionsCache = [];
+// §3.84：分组只在 refreshSessions 里算一次；下拉/会话管理列表都只读这份缓存（不随渲染重算）。
+let sessionsGroupedCache = [];
 let workspacesCache = [];
 let currentWorkspaceName = '';
 let modelsCache = [];
@@ -2273,8 +2346,14 @@ async function refreshSessions(q){
   const r=await fetch(u).catch(()=>null); if(!r)return;
   const j=await r.json();
   sessionsCache=Array.isArray(j.sessions)?j.sessions:[];
+  sessionsGroupedCache=groupSessionsByUpdatedAt(sessionsCache); // 一次性分组（性能：不在渲染时重算）
   const sel=$('#sessions'); sel.innerHTML='<option value="">历史会话</option>';
-  for(const s of sessionsCache){ const o=document.createElement('option'); o.value=s.file; o.textContent=s.label; sel.appendChild(o); }
+  for(const g of sessionsGroupedCache){
+    // 原生 optgroup 的组标题由系统渲染：不可点击、不可折叠——正好符合"保持简单"。
+    const og=document.createElement('optgroup'); og.label=g.title;
+    for(const s of g.items){ const o=document.createElement('option'); o.value=s.file; o.textContent=s.label; og.appendChild(o); }
+    sel.appendChild(og);
+  }
   if(currentSession&&!q) sel.value=currentSession;
   renderCrumb();
 }
@@ -2850,7 +2929,7 @@ function finalizeCurrentSession(){
   if(!currentSession) return;
   fetch('/api/session-finalize',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({file:currentSession})}).catch(()=>{});
 }
-async function loadSession(file){ if(currentSession && currentSession!==file) finalizeCurrentSession(); currentSession=file; chatEl.innerHTML=''; resetTraceState(); const r=await fetch('/api/session?file='+encodeURIComponent(file)); const j=await r.json(); for(const m of j.messages||[]){ if(typeof m.content==='string'&&m.content.startsWith('（系统提示）')) continue; if(m.role==='user') addUser(m.content); else { const el=newAiMsg(); aiContent(el).innerHTML=renderMarkdown(m.content); } } if(j.workspace){ const sel=$('#wsSel'); const has=[...sel.options].some(o=>o.value===j.workspace); if(has){ sel.value=j.workspace; } else { refreshWsSel(); } renderBanner({text:'↩ 已回到该会话的工作空间：'+j.workspace}); } if(j.taskState&&(j.taskState.status==='cap'||j.taskState.status==='interrupted')){ renderBanner({text:'⚠ 该会话有未完成任务（步数上限中断）——直接发送消息即可从断点续跑，已完成文件不会重复做。', warn:true}); } scrollBottom(); renderEmptyState(); renderCrumb(); }
+async function loadSession(file){ if(currentSession && currentSession!==file) finalizeCurrentSession(); currentSession=file; chatEl.innerHTML=''; resetTraceState(); const r=await fetch('/api/session?file='+encodeURIComponent(file)); const j=await r.json(); for(const m of j.messages||[]){ if(typeof m.content==='string'&&m.content.startsWith('（系统提示）')) continue; if(m.role==='user') addUser(m.content, m.ts); else { const el=newAiMsg(m.ts); aiContent(el).innerHTML=renderMarkdown(m.content); } } if(j.workspace){ const sel=$('#wsSel'); const has=[...sel.options].some(o=>o.value===j.workspace); if(has){ sel.value=j.workspace; } else { refreshWsSel(); } renderBanner({text:'↩ 已回到该会话的工作空间：'+j.workspace}); } if(j.taskState&&(j.taskState.status==='cap'||j.taskState.status==='interrupted')){ renderBanner({text:'⚠ 该会话有未完成任务（步数上限中断）——直接发送消息即可从断点续跑，已完成文件不会重复做。', warn:true}); } scrollBottom(); renderEmptyState(); renderCrumb(); }
 
 // §138：主按钮在生成态=停止，必须走**同一个**停止出口（stopTurnFromButton → stopTurn → POST /api/abort）
 sendBtn.onclick=()=>{ if(generating){ stopTurnFromButton(); } else { send(); } };
@@ -2861,15 +2940,19 @@ $('#sessMgrBtn').onclick=openSessModal;
 $('#sessClose').onclick=()=>{ $('#sessModal').style.display='none'; };
 async function openSessModal(){
   $('#sessModal').style.display='flex';
-  const r=await fetch('/api/sessions',{cache:'no-store'}); const j=await r.json();
+  await refreshSessions(); // 复用同一次分组缓存：打开管理面板不再单独算一遍
   const list=$('#sessList'); list.innerHTML='';
-  if(!j.sessions.length){ list.innerHTML='<div style="color:var(--faint);font-size:12px;padding:6px">暂无会话</div>'; return; }
-  for(const s of j.sessions){
-    const div=document.createElement('div'); div.style.cssText='display:flex;align-items:center;gap:8px;padding:6px 0;border-bottom:1px solid var(--border);font-size:12.5px';
-    div.innerHTML='<span style="flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap">'+esc(s.label)+'</span>';
-    const rn=document.createElement('button'); rn.textContent='重命名'; rn.style.cssText='padding:1px 8px;font-size:11px'; rn.onclick=async()=>{ const t=await uiPrompt('新标题：', s.file.replace(/\.jsonl$/,'')); if(!t) return; const rr=await fetch('/api/session',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({action:'rename',file:s.file,title:t})}); const jj=await rr.json().catch(()=>({error:'失败'})); if(jj.ok){ refreshSessions(); openSessModal(); } else uiAlert(jj.error||'重命名失败'); };
-    const dl=document.createElement('button'); dl.textContent='删除'; dl.className='danger'; dl.style.cssText='padding:1px 8px;font-size:11px'; dl.onclick=async()=>{ if(!await uiConfirm('删除会话 '+s.file+'？此操作不可恢复。')) return; const rr=await fetch('/api/session',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({action:'delete',file:s.file})}); const jj=await rr.json().catch(()=>({error:'失败'})); if(jj.ok){ if(currentSession===s.file){ currentSession=null; chatEl.innerHTML=''; renderEmptyState(); } refreshSessions(); openSessModal(); } else uiAlert(jj.error||'删除失败'); };
-    div.appendChild(rn); div.appendChild(dl); list.appendChild(div);
+  if(!sessionsCache.length){ list.innerHTML='<div style="color:var(--faint);font-size:12px;padding:6px">暂无会话</div>'; return; }
+  for(const g of sessionsGroupedCache){
+    // 小号次要文本、不可点击、不可折叠；只是分组标签。
+    const gh=document.createElement('div'); gh.className='sess-group'; gh.textContent=g.title; list.appendChild(gh);
+    for(const s of g.items){
+      const div=document.createElement('div'); div.style.cssText='display:flex;align-items:center;gap:8px;padding:6px 0;border-bottom:1px solid var(--border);font-size:12.5px';
+      div.innerHTML='<span style="flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap">'+esc(s.label)+'</span>';
+      const rn=document.createElement('button'); rn.textContent='重命名'; rn.style.cssText='padding:1px 8px;font-size:11px'; rn.onclick=async()=>{ const t=await uiPrompt('新标题：', s.file.replace(/\.jsonl$/,'')); if(!t) return; const rr=await fetch('/api/session',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({action:'rename',file:s.file,title:t})}); const jj=await rr.json().catch(()=>({error:'失败'})); if(jj.ok){ await refreshSessions(); openSessModal(); } else uiAlert(jj.error||'重命名失败'); };
+      const dl=document.createElement('button'); dl.textContent='删除'; dl.className='danger'; dl.style.cssText='padding:1px 8px;font-size:11px'; dl.onclick=async()=>{ if(!await uiConfirm('删除会话 '+s.file+'？此操作不可恢复。')) return; const rr=await fetch('/api/session',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({action:'delete',file:s.file})}); const jj=await rr.json().catch(()=>({error:'失败'})); if(jj.ok){ if(currentSession===s.file){ currentSession=null; chatEl.innerHTML=''; renderEmptyState(); } await refreshSessions(); openSessModal(); } else uiAlert(jj.error||'删除失败'); };
+      div.appendChild(rn); div.appendChild(dl); list.appendChild(div);
+    }
   }
 }
 $('#sessions').onchange=e=>{ if(e.target.value){ loadSession(e.target.value); } else { finalizeCurrentSession(); currentSession=null; chatEl.innerHTML=''; resetTraceState(); renderEmptyState(); renderCrumb(); } };

package/src/web/index.html

@@ -173,6 +173,12 @@ main{flex:1;overflow-y:auto;padding:18px 0 12px;min-width:0}
 .msg-user{display:flex;justify-content:flex-end}
 .msg-user .bubble{background:var(--user);border:1px solid rgba(255,255,255,.08);border-radius:22px;padding:10px 16px;max-width:min(525px,82%);white-space:pre-wrap;word-break:break-word;font-size:16px;line-height:24px}
 .msg-ai{display:flex;flex-direction:column;gap:10px;font-size:15px;color:var(--text)}
+/* §3.84：消息时间——小号次要文本；缺失 ts 时前端根本不渲染此节点（不会出现 Invalid Date / undefined）。 */
+.msg-time{font-size:11px;line-height:1.4;color:var(--dim);font-variant-numeric:tabular-nums}
+.msg-user .bubble .msg-time{display:block;text-align:right;margin-top:4px}
+.msg-ai>.msg-time{margin-bottom:-4px}
+/* §3.84：会话分组标题（今天/昨天/本周/更早）——不可点击、不折叠。 */
+.sess-group{font-size:11px;line-height:1.6;color:var(--dim);padding:7px 4px 2px;letter-spacing:.02em}
 .msg-ai .content{white-space:normal;word-break:break-word;line-height:1.75}
 .msg-ai .content h1,.msg-ai .content h2,.msg-ai .content h3,.msg-ai .content h4{color:var(--text);font-weight:700;line-height:1.4}
 .msg-ai .content h1{font-size:20px;margin:18px 0 10px;padding-bottom:8px;border-bottom:1px solid var(--border)}

package/src/web/routes/domains/sessions.js

@@ -19,6 +19,35 @@ import {
   removeSessionWorkspace,
 } from '../../../workspace.js';
 
+/**
+ * v0.6.22（§3.84）：会话列表的**只增**元数据。
+ *
+ * 只读文件、绝不改写；坏行/不可读文件按 0 条处理，不得让整个列表接口 500——
+ * 真机上确实存在历史遗留的半截 JSONL（进程被 kill 时最后一行可能不完整）。
+ * 标题沿用既有事实来源：会话文件名（自动标题 / 手工重命名都会落到文件名）。
+ * @param {string} file 会话文件绝对路径
+ * @param {string} name 会话文件名
+ * @returns {{messageCount:number,title:string}}
+ */
+function sessionMeta(file, name) {
+  let messageCount = 0;
+  try {
+    const raw = fs.readFileSync(file, 'utf8');
+    for (const line of raw.split('\n')) {
+      if (!line.trim()) continue;
+      try {
+        const m = JSON.parse(line);
+        if (m && typeof m === 'object' && ['system', 'user', 'assistant', 'tool'].includes(m.role)) messageCount += 1;
+      } catch {
+        // 单行损坏只跳过该行：旧会话/半截写入都不能把整个列表打挂。
+      }
+    }
+  } catch {
+    // 文件在 readdir 之后被删除/无权限：计数按 0，元数据仍可返回。
+  }
+  return { messageCount, title: name.replace(/\.jsonl$/, '') };
+}
+
 /**
  * 会话域路由。命中返回 true，未命中返回 false。
  * @param {{req:any,res:any,method:any,p:any,url:any}} ctx
@@ -33,9 +62,22 @@ export async function handle({ req, res, method, p, url }, deps, shared) {
 
   if (method === 'GET' && p === '/api/sessions') {
     const q = url.searchParams.get('q');
+    // v0.6.22（§3.84）：每项**只增** updatedAt / messageCount / title 三个字段；
+    // file / mtime / label 的既有语义与顺序不变（前端 crumb、命令面板、同步等仍按旧字段消费）。
+    const decorate = (/** @type {any} */ s, /** @type {string} */ label) => {
+      const meta = sessionMeta(path.join(home, 'sessions', path.basename(s.name)), s.name);
+      return {
+        file: s.name,
+        mtime: s.mtime,
+        label,
+        updatedAt: new Date(s.mtime).toISOString(),
+        messageCount: meta.messageCount,
+        title: meta.title,
+      };
+    };
     const found = q
-      ? searchSessions(home, q, { limit: 30 }).map((/** @type {any} */ s) => ({ file: s.name, mtime: s.mtime, label: `${relativeTime(s.mtime)} · ${s.snippet}` }))
-      : listSessions(home).slice(0, 30).map((s) => ({ file: s.name, mtime: s.mtime, label: `${relativeTime(s.mtime)} · ${sessionPreview(s.file)}` }));
+      ? searchSessions(home, q, { limit: 30 }).map((/** @type {any} */ s) => decorate(s, `${relativeTime(s.mtime)} · ${s.snippet}`))
+      : listSessions(home).slice(0, 30).map((s) => decorate(s, `${relativeTime(s.mtime)} · ${sessionPreview(s.file)}`));
     json(res, 200, { ok: true, sessions: found });
     return true;
   }
@@ -54,7 +96,11 @@ export async function handle({ req, res, method, p, url }, deps, shared) {
       }
       json(res, 200, {
         ok: true,
-        messages: loaded.messages.filter((m) => m.role === 'user' || m.role === 'assistant').map((m) => ({ role: m.role, content: m.content ?? '' })),
+        // v0.6.22（§3.84）：只增 ts。旧会话消息没有 ts → **null**（前端据此不显示时间），
+        // 绝不在这里用文件 mtime 冒充消息时间，也绝不因缺字段报错。
+        messages: loaded.messages
+          .filter((m) => m.role === 'user' || m.role === 'assistant')
+          .map((m) => ({ role: m.role, content: m.content ?? '', ts: typeof m.ts === 'string' && m.ts ? m.ts : null })),
         workspace: ws?.name || null,
         // v0.3.0 P0-2：未完成检查点（供前端提示续跑）
         taskState: loadTaskState(path.basename(file)),

package/src/web/server.js

@@ -77,6 +77,9 @@ import { syncStatus, syncLogin, syncLogout, syncPush, syncPull, syncRemoteList,
 
 const INDEX_HTML = path.join(path.dirname(fileURLToPath(import.meta.url)), 'index.html');
 
+// v0.6.23（§3.87）：Web 落盘**不再自建 stamp**——ts 的唯一补齐点是 `src/session.js` 的
+// `appendMessages()`（CLI / REPL / 调度 / Web 共用）；下面两处 chat 落盘都只调它，不引入第二套时间来源。
+
 /** 合法权限模式（与 /api/config 的校验同一口径：非法值一律忽略，绝不 fail-open）。 */
 const PERMISSION_MODES = new Set(['ask', 'auto', 'readonly']);
 /** 各档位的"会发生什么"人话说明（可见说明与前端提示共用同一份文案）。 */
@@ -882,8 +885,16 @@ export async function runWebServer({ host = '127.0.0.1', port = 3820, authToken,
       }
     }
     messages.push({ role: 'user', content: built.content });
-    // 落盘用文本版（图文数组只发给模型，会话文件保持字符串可渲染）
-    await withSessionLock(session.file, () => appendMessages(session.file, [{ role: 'user', content: built.persistText }]));
+    // 落盘用文本版（图文数组只发给模型，会话文件保持字符串可渲染）。
+    // v0.6.23（§3.87）：ts 由 session.appendMessages 统一补齐（唯一来源）；把落盘对象上的 ts
+    // 同步回内存里的这条消息，后续自动压缩整文件重写时才不会把这一轮刚写下的时间冲掉。
+    /** @type {any} */
+    const persistUser = { role: 'user', content: built.persistText };
+    await withSessionLock(session.file, () => appendMessages(session.file, [persistUser]));
+    {
+      const lastUserMsg = messages[messages.length - 1];
+      if (lastUserMsg && typeof lastUserMsg === 'object' && !lastUserMsg.ts && persistUser.ts) lastUserMsg.ts = persistUser.ts;
+    }
     let persistedBefore = messages.length;
 
     // 权限/选择类交互：发 ask 事件（带 taskId），等待 POST /api/permission 应答
@@ -1065,7 +1076,12 @@ export async function runWebServer({ host = '127.0.0.1', port = 3820, authToken,
       // 会话级路由统计（Hermes C2 升级检测）：累计工具步数与截断次数，粘滞 flash 会话复杂度上来后自动升 planner
       const st = session.routeStats || { steps: 0, truncated: 0 };
       session.routeStats = { steps: st.steps + (io.stats().toolCount || 0), truncated: st.truncated + (r.truncated ? 1 : 0) };
-      await withSessionLock(session.file, () => appendMessages(session.file, messages.slice(persistedBefore)));
+      // v0.6.23（§3.87）：本回合新增的 assistant/tool 消息由 appendMessages 就地补 ts，
+      // 内存数组随之带上时间戳——之后自动压缩整文件重写保留这些时间（历史消息不动）。
+      {
+        const tail = messages.slice(persistedBefore);
+        await withSessionLock(session.file, () => appendMessages(session.file, tail));
+      }
       io.printUsageLine({ modelName: runModel, usage: r.usage, durationMs: r.durationMs });
       // v0.4.4：补记最后一轮 + 兜底总结的剩余 usage（自动续跑轮已在 onUsage 逐轮入账，避免重复计）
       const remaining = {