mingdao-harness 0.6.22 → 0.6.24

package/docs/CONFIG.md

@@ -406,9 +406,10 @@ completion 计费，防止推理吃满上限时空轮白烧）、`compactTrigger
 
 `GET /api/session?file=` 的每条消息**只增** `ts`（ISO 字符串）。旧会话（v0.6.21 及以前写的
 JSONL 没有 `ts`）返回 `"ts": null`，其余字段语义不变；WebUI 对 `ts` 为 `null` 的消息不渲染时间，
-不会出现 `Invalid Date` / `undefined`。新消息在**服务端落盘时**写入 `ts`（压缩重写保留已有值），
-前端不自行推算历史消息时间。分组（今天/昨天/本周/更早）与时间显示都在 `src/web/app.js`；
-分组只在会话列表刷新时计算一次，不引入轮询。
+不会出现 `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）
 
@@ -924,11 +925,29 @@ mingdao ledger verify <runId> --key <文件>     # 用指定公钥验签（本
   顺手一次就会把签名密钥清掉、让全部历史账本变成"另一把密钥签发"。
 - **默认开启**：新账本在首次收尾时若本机还没有密钥会**自动生成**并签名（可选签名在合规上等于
   没有签名）。封条里带 `sig{alg,keyId,value}`，`run.end` 链内带 `sigKey`（公钥指纹）。
-- **`run.start.permissionSource`（v0.6.17 §3.64）**：记录本回合生效权限的**来源**——`explicit`
-  （用户/调用方显式选择，如 WebUI 权限档）/ `preset`（预设声明生效）/ `config`（`config.json`
-  的 `permission`）/ `cli`（后台/调度任务由 CLI 参数指定）/ `default`（以上都没有，落到内置缺省
-  `ask`；WebUI 的 `config` 分支在缺字段时也归 `config`）。`permission` 仍是生效值、`LEDGER_VERSION`
-  不变；旧账本没有该字段照样 `verify` 通过（`show` 只是少一行可选的「权限来源」）。
+- **`run.start.permissionSource`（v0.6.17 §3.64，v0.6.24 §3.89 补全 worker/REPL）**：记录本回合
+  生效权限的**来源**。`permission` 仍是生效值，两者分开记——单看生效值无法回答「是谁定的」。
+  **完整枚举**（`src/ledger.js` 的 `PERMISSION_SOURCES`；缺失/非法一律写 `null`，不猜）：
+
+  | 值 | 含义 |
+  | --- | --- |
+  | `explicit` | 用户/调用方在**本回合交互**里显式选择（WebUI 权限档） |
+  | `preset` | 预设声明并被采纳的 `permission`（已过反提权判定） |
+  | `config` | `config.json` 的 `permission` |
+  | `cli` | 前台 CLI 显式参数（保留值；`mingdao run --permission` 属后台任务，按下面的 `job` 记） |
+  | `job` | **后台任务/调度**的任务规格显式指定 `permission`（`mingdao run --permission ...`、`schedule add --permission ...`）。v0.6.24 §3.89 新增；刻意不复用 `explicit`，避免与「用户跑的时候按了权限档」混淆 |
+  | `default` | 以上都没有，落到内置缺省 `ask` |
+
+  **各入口取值口径**：
+
+  | 入口 | 写入值 | 时机 |
+  | --- | --- | --- |
+  | WebUI | `explicit` / `preset` / `config` | 显式权限档 → `explicit`；预设声明 → `preset`；都不发 → `config`（`resolveTurnPermission` 的既有语义，配置缺字段也归 `config`） |
+  | CLI 单次问答 | `preset` / `config` / `default` | `--preset` 声明 permission → `preset`；`config.permission` 存在 → `config`；否则 → `default` |
+  | 后台 worker / 调度 | `job` / `config` / `default` | 任务规格（含 `mingdao run --permission`、schedule 的 `permission`）显式指定 → `job`；否则 `config.permission` → `config`；都没有 → `default`。worker 的 `ask → readonly` 降级只改生效值，来源仍按上述口径记 |
+  | REPL | `preset` / `config` / `default` | 启动时 `--preset` 已声明 permission → `preset`；否则 `config`（有 `permission`）/ `default`（无）。会话内 `/preset` 且预设 permission 被采纳 → `preset`；仅换提示词/工具白名单的预设不冒充来源，沿用切换前的值。当前没有 `/permission` 命令 |
+
+  `LEDGER_VERSION` 不变；旧账本没有该字段照样 `verify` 通过（`show` 只是少一行可选的「权限来源」）。
 - **`ledger verify` 的三种结论**（前两者退出码 0，第三者非 0）：
 
   | 结论 | 含义 | 退出码 |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mingdao-harness",
-  "version": "0.6.22",
+  "version": "0.6.24",
   "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/commands/repl.js

@@ -96,8 +96,16 @@ export async function runRepl(ctx) {
   const { io, cfg, home, pc0, opts, permission, workingDir, sessionUndoStore, mcpFacade, sessionRef, preset, withJournal, tuiState } = ctx;
   let presetBlock = ctx.presetBlock || ''; // v0.4.0 Agent Preset 系统提示定制段（/preset 可切换）
   let permissionNow = permission; // /preset 可换权限模式
-  // v0.4.0 Agent Preset：agent 用 agentCfg（预设 overlay 会话级生效）；cfg 保持干净供 saveConfig 持久化
-  let agentCfg = ctx.agentCfg || cfg;
+  // v0.4.0 Agent Preset：agent 用 agentCfg（预设 overlay 会话级生效）；cfg 保持干净供 saveConfig 持久化。
+  // v0.6.24 §3.89：REPL 启动时的来源沿用入口（cli.js）算好的值：未切预设 → `config`（config.json
+  // 有 permission）或 `default`（内置缺省）；`--preset` 已声明 permission → `preset`。这里只兜底
+  // 补齐、绝不写 null——"来源未知"与"来源就是配置"是两件事，REPL 属于后者。
+  // 这里**保持同一对象**（不拷贝）：cli.js 装配的首回合 agent 持有的 cfg 就是这个 agentCfg，
+  // 原地补来源才能让首回合同样可见；拷贝会让下面的补齐对已有 agent 失效。
+  let agentCfg = ctx.agentCfg || { ...cfg };
+  if (!agentCfg.permissionSource) {
+    agentCfg.permissionSource = cfg.permission !== undefined && cfg.permission !== null ? 'config' : 'default';
+  }
   let mcpManager = ctx.mcpManager;
   let modelName = ctx.modelName;
   let provider = ctx.provider;
@@ -300,7 +308,18 @@ export async function runRepl(ctx) {
         } else if (p.permission !== undefined) {
           over.permission = permOv.permission;
         }
-        agentCfg = { ...cfg, ...over, presetName: p.name };
+        // v0.6.24 §3.89：`/preset` 换了本会话的规则环境，来源必须跟着换。只有预设真的声明、
+        // 并被反提权判定采纳了 permission 才记 `preset`（与 cli.js 的 hasOwnProperty 同一口径）；
+        // 仅换提示词/工具白名单/模型的预设不冒充来源，沿用切换前的来源。
+        const permissionFromPreset = Object.prototype.hasOwnProperty.call(over, 'permission');
+        agentCfg = {
+          ...cfg,
+          ...over,
+          presetName: p.name,
+          permissionSource: permissionFromPreset
+            ? 'preset'
+            : agentCfg.permissionSource ?? (cfg.permission !== undefined && cfg.permission !== null ? 'config' : 'default'),
+        };
         if (over.model) await switchToModel(over.model, { silent: true, persist: false });
         presetBlock = presetSystemBlock(p);
         permissionNow = createPermission(agentCfg.permission ?? 'ask', io);

package/src/ledger.js

@@ -44,13 +44,23 @@ export const LEDGER_VERSION = 1;
  * 一次"来源不可见"的坑（界面选了自动、却被只读预设压着跑）迫使我们把来源写进账本：
  * 事后自查时，`permission:"auto"` 单看无法区分"用户显式选的"与"config 里本来就是 auto"。
  *
- * - `explicit`：用户/调用方在本回合显式选择（WebUI 的权限档、CLI 的显式参数）；
+ * - `explicit`：用户/调用方在**本回合**显式选择（WebUI 的权限档；前台 CLI 暂无 `--permission` 入口）；
  * - `preset`：由预设声明的 permission 生效（反提权判定已通过）；
  * - `config`：来自 `config.json` 的 `permission`；
- * - `cli`：后台/调度任务由 CLI 参数指定（`mingdao run --permission ...`）；
+ * - `cli`：保留给前台 CLI 的显式权限参数（当前没有前台 `--permission` 入口；
+ *   后台任务的 `--permission` 属于任务规格，按下面的 `job` 记）；
+ * - `job`：**后台任务/调度**的任务规格显式指定（`mingdao run --permission ...` /
+ *   `schedule add --permission ...` 落进 task/job 的 permission）——v0.6.24 §3.89 新增。
+ *   刻意不复用 `explicit`：那个值表示「用户在本回合的交互里选的」，而后台任务的权限
+ *   是**提交任务时写进规格**的，事后看到 `explicit` 会误以为有人在跑的时候按了权限档；
  * - `default`：以上都没有，落到内置缺省（`ask`）。
+ *
+ * 各入口的取值口径（完整表见 `docs/CONFIG.md`「账本来源签名」一节）：
+ *   WebUI → explicit / preset / config；CLI 前台 → preset / config / default（`cli` 为保留值，当前无写入路径）；
+ *   后台 worker → job（任务规格显式） / config（否则）；REPL → preset（本回合切了声明
+ *   permission 的预设） / config / default（启动时未切预设）。
  */
-export const PERMISSION_SOURCES = Object.freeze(['explicit', 'preset', 'config', 'cli', 'default']);
+export const PERMISSION_SOURCES = Object.freeze(['explicit', 'preset', 'config', 'cli', 'job', 'default']);
 /** 默认保留最近多少次运行（超出按 mtime 删最旧） */
 const DEFAULT_MAX_RUNS = 200;
 const GENESIS = '0'.repeat(16);
@@ -897,7 +907,7 @@ export function exportRun(/** @type {any} */ runId, { format = 'json' } = {}) {
   lines.push(`- 模型：${start?.model ?? '—'} · 会话：${start?.session ?? '—'} · 权限：${start?.permission ?? '—'}`);
   // v0.6.17 §3.64：来源是**可选**字段——旧账本没有它，这一行就整行不出现（输出契约不变）；
   // 新账本才有，且只增行、不改上面那行「权限：…」的既有形状。
-  if (start?.permissionSource) lines.push(`- 权限来源：${start.permissionSource}（explicit=显式选择 / preset=预设 / config=配置 / cli=命令行 / default=内置缺省）`);
+  if (start?.permissionSource) lines.push(`- 权限来源：${start.permissionSource}（explicit=显式选择 / preset=预设 / config=配置 / cli=命令行 / job=后台任务规格 / default=内置缺省）`);
   lines.push(`- 开始：${start?.at ? new Date(start.at).toISOString() : '—'}`);
   lines.push(`- 结束：${end ? `${end.status}（${end.ms}ms，${end.steps} 步）` : '未结束'}`);
   lines.push(`- 费用：${end?.priced ? `¥${Number(end.yuanTotal ?? 0).toFixed(4)}` : '**无法估算**（模型无价，不是 0 元）'}`);

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/tasks/worker.js

@@ -49,6 +49,16 @@ export async function runWorkerTask(id, question, { permission, model, offpeak }
       perm = 'readonly';
       note = 'ask 权限下后台任务按只读执行';
     }
+    // v0.6.24 §3.89：把权限来源写进账本。此前 worker 路径恒写 null，后台任务/调度会话的
+    // `permission` 是 auto 还是 readonly 单看生效值无法区分「任务规格显式定的」与「配置来的」。
+    //   · 任务规格/CLI 显式给了 permission → `job`（**不复用 explicit**：那个值表示
+    //     "用户在本回合交互里选的"，提交任务时写进规格是另一回事；spawn 时它经
+    //     `--permission` 传入，语义仍是任务规格）；
+    //   · 否则权限口径来自 `config.json` → `config`；
+    //   · 配置里也没有 → 内置缺省 `default`（不冒充 config）。
+    // 生效值必须用**降级后**的 perm（ask → readonly 已在上面完成），否则账本会记下实际没生效的 ask。
+    const permissionSource = permission ? 'job' : cfg.permission !== undefined && cfg.permission !== null ? 'config' : 'default';
+    const agentCfg = { ...cfg, permission: perm, permissionSource };
     // 避峰（评估 A2/Kimi P-1）：高峰时段（北京工作日 9:00–12:00、14:00–18:00）
     // 自动顺延到最近闲时起点（12:00 / 18:00）执行，输入价省 50%
     if (offpeak && isPeakHour(new Date())) {
@@ -93,7 +103,7 @@ export async function runWorkerTask(id, question, { permission, model, offpeak }
       io,
       modelName,
       workingDir,
-      cfg,
+      cfg: agentCfg,
       mcp: mcpFacade || undefined,
       sessionRef,
       onCompact: (/** @type {any} */ msgs) => {

package/src/web/app.js

@@ -298,6 +298,191 @@ function msgTimeText(ts, now) {
 let generating = false; // 生成中：发送按钮复用为停止按钮
 let currentSession = null, thinking = null;
 
+// ==== v0.6.24 §3.88：左侧栏（会话列） ====
+// 只做「展示 + 转发」：会话数据来自 refreshSessions() 已有的 sessionsGroupedCache（不新增请求、
+// 不引入轮询）；点会话写回 #sessions 并派发 change（复用既有切换逻辑）；新建对话 / 工作空间
+// 分别复用 #newChat 与 #wsSel 的 handler。折叠偏好记忆在 localStorage。
+const SIDE_NAV_STORAGE_KEY = 'mingdao-sidenav-collapsed';
+let sideNavUserCollapsed = false;
+
+/** @param {any} storage */
+function sideNavCollapsedPref(storage) {
+  try { return !!storage && storage.getItem(SIDE_NAV_STORAGE_KEY) === '1'; } catch { return false; }
+}
+/** @param {any} storage @param {boolean} collapsed */
+function writeSideNavCollapsed(storage, collapsed) {
+  try { if (storage) storage.setItem(SIDE_NAV_STORAGE_KEY, collapsed ? '1' : '0'); } catch {}
+  return !!collapsed;
+}
+/** 三档断点：≥1180 三栏 / 900–1180 左栏自动折叠 / <900 抽屉。 */
+function sideNavBreakpoint(width) {
+  const w = Number(width) || 0;
+  if (w >= 1180) return 'wide';
+  if (w >= 900) return 'mid';
+  return 'drawer';
+}
+function sideNavLayout(width, pref) {
+  const mode = sideNavBreakpoint(width);
+  const collapsed = mode === 'mid' || (mode === 'wide' && !!pref);
+  return { mode, collapsed, width: mode === 'drawer' ? 0 : (collapsed ? 48 : 240), drawer: mode === 'drawer' };
+}
+function sideNavClassNames(layout) {
+  const out = [];
+  if (layout.mode === 'wide') out.push('side-wide');
+  if (layout.mode === 'mid') out.push('side-mid');
+  if (layout.mode === 'drawer') out.push('side-drawer');
+  if (layout.mode === 'wide' && layout.collapsed) out.push('side-collapsed');
+  return out;
+}
+/**
+ * 渲染左栏会话列表：只读分组缓存，四个分组标题 + 条目；当前会话高亮。
+ * @param {any} container @param {any[]} groups @param {any} current @param {(s:any)=>void} [onPick]
+ * @returns {number} 渲染的会话条数
+ */
+function renderSideNavSessions(container, groups, current, onPick) {
+  if (!container) return 0;
+  while (container.firstChild) container.removeChild(container.firstChild);
+  const list = Array.isArray(groups) ? groups : [];
+  if (!list.length) {
+    const empty = document.createElement('div');
+    empty.className = 'sn-empty';
+    empty.textContent = '暂无会话';
+    container.appendChild(empty);
+    return 0;
+  }
+  let n = 0;
+  for (const g of list) {
+    const head = document.createElement('div');
+    head.className = 'sn-group';
+    head.textContent = String(g.title || '');
+    container.appendChild(head);
+    for (const s of (Array.isArray(g.items) ? g.items : [])) {
+      const item = document.createElement('button');
+      item.type = 'button';
+      item.className = 'sn-item' + (s.file === current ? ' on' : '');
+      item.dataset.file = String(s.file || '');
+      item.title = String(s.label || s.file || '');
+      if (s.file === current) item.setAttribute('aria-current', 'true');
+      const ico = document.createElement('span');
+      ico.className = 'sn-item-ico';
+      ico.setAttribute('aria-hidden', 'true');
+      ico.textContent = '💬';
+      const label = document.createElement('span');
+      label.className = 'sn-item-label';
+      label.textContent = String(s.label || s.file || '');
+      item.appendChild(ico);
+      item.appendChild(label);
+      item.addEventListener('click', () => { if (typeof onPick === 'function') onPick(s); });
+      container.appendChild(item);
+      n += 1;
+    }
+  }
+  return n;
+}
+/** 点击左栏会话：写回顶栏 #sessions 并派发 change（复用既有 onchange 切换逻辑）。 */
+function pickSessionFromSideNav(s) {
+  const sel = $('#sessions');
+  if (!sel || !s || !s.file) return;
+  sel.value = s.file;
+  sel.dispatchEvent(new Event('change'));
+}
+/** 工作空间镜像：选项与选中值从顶栏 #wsSel 同步，切换仍交给原控件 handler。 */
+function syncSideNavWorkspace() {
+  const src = $('#wsSel'), dst = $('#sideNavWs');
+  if (!src || !dst) return;
+  while (dst.firstChild) dst.removeChild(dst.firstChild);
+  for (const o of src.options) {
+    const n = document.createElement('option');
+    n.value = o.value;
+    n.textContent = o.textContent;
+    dst.appendChild(n);
+  }
+  dst.value = src.value;
+  const icon = $('#sideNavWsIcon');
+  if (icon) {
+    const cur = src.options[src.selectedIndex];
+    icon.title = '工作空间' + (cur && cur.value ? '：' + String(cur.textContent || '').replace(/^●\s*/, '') : '（点此切换）');
+  }
+}
+/** 当前会话高亮（只切类，不重建列表，避免搜索/滚动位置抖动）。 */
+function syncSideNavActive() {
+  const box = $('#sideNavSessions');
+  if (!box) return;
+  for (const el of box.querySelectorAll('.sn-item')) {
+    const on = !!(currentSession && el.dataset && el.dataset.file === currentSession);
+    el.classList.toggle('on', on);
+    if (on) el.setAttribute('aria-current', 'true'); else el.removeAttribute('aria-current');
+  }
+}
+function syncSideNavToggle() {
+  const btn = $('#sideNavCollapse');
+  const mode = sideNavBreakpoint(window.innerWidth || 0);
+  const drawerOpen = document.body.classList.contains('side-drawer-open');
+  if (btn) {
+    btn.textContent = mode === 'drawer' ? (drawerOpen ? '×' : '☰') : (sideNavUserCollapsed ? '»' : '«');
+    btn.setAttribute('aria-expanded', String(mode === 'drawer' ? drawerOpen : !sideNavUserCollapsed));
+    btn.title = mode === 'drawer' ? (drawerOpen ? '关闭会话侧栏' : '打开会话侧栏') : (sideNavUserCollapsed ? '展开侧栏' : '折叠侧栏');
+  }
+  const rail = $('#sideNavRailBtn');
+  if (rail) { rail.classList.toggle('on', drawerOpen); rail.title = drawerOpen ? '关闭会话侧栏' : '打开会话侧栏'; }
+}
+function applySideNavLayout(width) {
+  const w = width == null ? (Number(window.innerWidth) || 0) : (Number(width) || 0);
+  const layout = sideNavLayout(w, sideNavUserCollapsed);
+  const names = sideNavClassNames(layout);
+  for (const c of ['side-wide', 'side-mid', 'side-drawer', 'side-collapsed']) {
+    document.body.classList.toggle(c, names.includes(c));
+  }
+  if (layout.mode !== 'drawer') document.body.classList.remove('side-drawer-open');
+  const nav = $('#sideNav');
+  if (nav) nav.classList.toggle('collapsed', layout.collapsed);
+  syncSideNavToggle();
+}
+function toggleSideNav() {
+  const mode = sideNavBreakpoint(window.innerWidth || 0);
+  if (mode === 'drawer') {
+    document.body.classList.toggle('side-drawer-open');
+    syncSideNavToggle();
+    return;
+  }
+  if (mode === 'mid') return; // 900–1180：自动折叠，不提供手动展开（避免挤窄主区）
+  sideNavUserCollapsed = !sideNavUserCollapsed;
+  let storage = null;
+  try { storage = window.localStorage; } catch {}
+  writeSideNavCollapsed(storage, sideNavUserCollapsed);
+  applySideNavLayout(window.innerWidth || 0);
+}
+function initSideNav() {
+  let storage = null;
+  try { storage = window.localStorage; } catch {}
+  sideNavUserCollapsed = sideNavCollapsedPref(storage);
+  const newBtn = $('#sideNavNew');
+  if (newBtn) newBtn.onclick = () => { const b = $('#newChat'); if (b) b.click(); };
+  const collapse = $('#sideNavCollapse');
+  if (collapse) collapse.onclick = toggleSideNav;
+  const rail = $('#sideNavRailBtn');
+  if (rail) rail.onclick = toggleSideNav;
+  const ws = $('#sideNavWs');
+  if (ws) ws.addEventListener('change', () => {
+    const main = $('#wsSel');
+    if (!main) return;
+    main.value = ws.value;
+    main.dispatchEvent(new Event('change'));
+  });
+  const wsIcon = $('#sideNavWsIcon');
+  if (wsIcon) wsIcon.onclick = () => {
+    const main = $('#wsSel');
+    if (!main) return;
+    try { main.focus(); } catch {}
+    try { if (typeof main.showPicker === 'function') { main.showPicker(); return; } } catch {}
+    try { main.click(); } catch {}
+  };
+  syncSideNavWorkspace();
+  renderSideNavSessions($('#sideNavSessions'), sessionsGroupedCache, currentSession, pickSessionFromSideNav);
+  applySideNavLayout();
+}
+// ==== /v0.6.24 §3.88 ====
+
 
 
 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; }
@@ -1337,6 +1522,7 @@ function applyResponsiveLayout(width) {
   const cls = layoutClassesFor(w);
   document.body.classList.toggle('narrow-side', cls.narrow);
   document.body.classList.toggle('narrow-run', cls.narrowRun);
+  applySideNavLayout(w); // §3.88：左栏三档断点与主区推开量
   syncRunPanel();
 }
 function initResponsive() {
@@ -2340,6 +2526,7 @@ function renderCrumb(){
   const w=$('#crumbWs'); if(w) w.textContent=currentWorkspaceName||'工作空间';
   const cur=sessionsCache.find((s)=>s&&s.file===currentSession);
   const c=$('#crumbSession'); if(c) c.textContent=cur?(cur.label||cur.file):(currentSession?String(currentSession).replace(/\.jsonl$/,''):'新对话');
+  syncSideNavActive();
 }
 async function refreshSessions(q){
   const u=q?'/api/sessions?q='+encodeURIComponent(q):'/api/sessions';
@@ -2354,6 +2541,8 @@ async function refreshSessions(q){
     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);
   }
+  // §3.88：左栏只读同一份分组缓存（不额外请求/不轮询）
+  renderSideNavSessions($('#sideNavSessions'), sessionsGroupedCache, currentSession, pickSessionFromSideNav);
   if(currentSession&&!q) sel.value=currentSession;
   renderCrumb();
 }
@@ -2511,6 +2700,7 @@ async function refreshWsSel(){
   const mgr=document.createElement('option'); mgr.value='__manage__'; mgr.textContent='管理（重命名/删除/改目录）…';
   sel.appendChild(mgr);
   renderCrumb();
+  syncSideNavWorkspace(); // §3.88：左栏工作空间镜像顶栏选项/选中值
 }
 /** 命令面板与顶栏下拉共用的工作空间切换（携带当前会话，语义与旧路径一致）。 */
 async function applyWorkspaceSwitch(name){
@@ -2957,4 +3147,6 @@ async function openSessModal(){
 }
 $('#sessions').onchange=e=>{ if(e.target.value){ loadSession(e.target.value); } else { finalizeCurrentSession(); currentSession=null; chatEl.innerHTML=''; resetTraceState(); renderEmptyState(); renderCrumb(); } };
 if('serviceWorker' in navigator){ navigator.serviceWorker.register('/sw.js').catch(()=>{}); }
+// §3.88：左栏先接线（读折叠偏好 + 渲染一次）；init() 里的 refreshSessions 会再次用最新数据刷新。
+initSideNav();
 init();

package/src/web/index.html

@@ -640,9 +640,71 @@ body.run-open #sessSheet{right:318px}
 #emptyState .es-lead,
 .empty-step .es-main span,
 .empty-step .es-state{color:var(--dim)}
+
+/* ============================================================================
+   v0.6.24 §3.88 左侧栏（设计稿三栏的标志性部分）
+   ——只新增左栏自己的样式，复用既有 token；不改顶栏高度、#runPanel 宽度、
+     既有断点与字号阶。布局：现有窄条 #trajRail(42) → 本栏(240/48) → 主区 → 右栏。
+   ============================================================================ */
+#sideNav{position:fixed;left:42px;top:52px;bottom:0;width:240px;min-width:0;background:var(--bg2);border-right:1px solid var(--border);z-index:34;display:flex;flex-direction:column;overflow:hidden;transition:width .16s ease}
+#sideNav .sn-head{flex:none;display:flex;align-items:center;gap:8px;padding:10px 12px;border-bottom:1px solid var(--border)}
+#sideNav .sn-title{flex:1;min-width:0;font-size:12px;font-weight:600;color:var(--dim);letter-spacing:.03em;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+#sideNavCollapse{flex:none;width:26px;height:26px;padding:0;border-radius:7px;background:var(--bg3);font-size:13px;line-height:1;display:inline-flex;align-items:center;justify-content:center}
+#sideNav .sn-body{flex:1;min-height:0;display:flex;flex-direction:column;gap:8px;padding:10px 8px;overflow-y:auto;overscroll-behavior:contain}
+#sideNavNew{display:flex;align-items:center;justify-content:center;gap:8px;width:100%;min-width:0;padding:8px 10px;border-radius:9px;border:1px solid var(--border);background:var(--bg3);color:var(--text);font-size:13px;font-weight:600;white-space:nowrap}
+#sideNavNew:hover{border-color:var(--accent2);color:var(--accent2)}
+#sideNavNew .sn-label{overflow:hidden;text-overflow:ellipsis}
+.sn-ws{display:flex;align-items:center;gap:6px;min-width:0;padding:0 2px}
+.sn-ws .sn-ws-ico{flex:none;font-size:13px;line-height:1;color:var(--dim)}
+#sideNavWs{flex:1;min-width:0;max-width:none;background:var(--bg3);border:1px solid var(--border);border-radius:8px;padding:5px 6px;font-size:12px}
+#sideNavWsIcon{display:none;align-items:center;justify-content:center;width:36px;height:30px;padding:0;border-radius:8px;background:var(--bg3);font-size:14px;line-height:1}
+#sideNav .sn-sec-title{flex:none;font-size:10.5px;color:var(--dim);letter-spacing:.05em;padding:2px 6px;white-space:nowrap}
+#sideNavSessions{display:flex;flex-direction:column;gap:1px;min-width:0}
+#sideNavSessions .sn-group{font-size:10.5px;line-height:1.6;color:var(--dim);padding:7px 6px 2px;letter-spacing:.02em;white-space:nowrap}
+#sideNavSessions .sn-item{display:flex;align-items:center;gap:8px;width:100%;min-width:0;padding:6px 8px;border:0;border-radius:8px;background:transparent;color:var(--dim);text-align:left;font-size:12.5px;line-height:1.5;cursor:pointer}
+#sideNavSessions .sn-item:hover{background:var(--bg3);color:var(--text)}
+#sideNavSessions .sn-item.on{background:var(--bg3);color:var(--text);font-weight:600;box-shadow:inset 2px 0 0 var(--accent)}
+#sideNavSessions .sn-item-ico{flex:none;width:16px;text-align:center;font-size:13px}
+#sideNavSessions .sn-item-label{flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+#sideNavSessions .sn-empty{font-size:11.5px;color:var(--dim);padding:8px 6px;white-space:nowrap}
+#trajRail #sideNavRailBtn{display:none}
+/* —— 三档断点：≥1180 展开(240) / 900–1180 自动折叠(48) / <900 抽屉（默认收起） —— */
+body.side-wide #sideNav{width:240px}
+body.side-wide.side-collapsed #sideNav{width:48px}
+body.side-mid #sideNav{width:48px}
+body.side-drawer #sideNav{display:none;width:240px}
+body.side-drawer.side-drawer-open #sideNav{display:flex;z-index:55;box-shadow:12px 0 32px rgba(0,0,0,.45)}
+body.side-drawer #trajRail #sideNavRailBtn{display:flex}
+/* 主区/输入区右移，左栏不遮正文；顶栏保持整条横贯（高度/入口不动） */
+body.side-wide main,body.side-wide footer{margin-left:282px}
+body.side-wide.side-collapsed main,body.side-wide.side-collapsed footer{margin-left:90px}
+body.side-mid main,body.side-mid footer{margin-left:90px}
+body.side-drawer main,body.side-drawer footer{margin-left:0}
+/* 折叠态：只留图标 + tooltip（label/分组标题隐藏；折叠按钮本身是图标，保留用于展开） */
+body.side-collapsed .sn-title,
+body.side-mid .sn-title,
+body.side-collapsed #sideNavNew .sn-label,
+body.side-mid #sideNavNew .sn-label,
+body.side-collapsed .sn-sec-title,
+body.side-mid .sn-sec-title,
+body.side-collapsed #sideNavSessions .sn-group,
+body.side-mid #sideNavSessions .sn-group,
+body.side-collapsed #sideNavSessions .sn-item-label,
+body.side-mid #sideNavSessions .sn-item-label,
+body.side-collapsed .sn-ws,
+body.side-mid .sn-ws,
+body.side-mid #sideNavCollapse{display:none}
+body.side-mid .sn-head::before{content:'💬';font-size:14px;line-height:1;color:var(--dim)}
+body.side-collapsed #sideNavWsIcon,
+body.side-mid #sideNavWsIcon{display:inline-flex}
+body.side-collapsed .sn-head,body.side-mid .sn-head{padding:10px 6px;justify-content:center}
+body.side-collapsed #sideNav .sn-body,body.side-mid #sideNav .sn-body{padding:10px 6px;align-items:center}
+body.side-collapsed #sideNavNew,body.side-mid #sideNavNew{width:36px;padding:8px 0;gap:0}
+body.side-collapsed #sideNavSessions .sn-item,body.side-mid #sideNavSessions .sn-item{width:36px;justify-content:center;padding:6px 0;gap:0}
+body.side-collapsed #sideNavSessions .sn-item.on,body.side-mid #sideNavSessions .sn-item.on{box-shadow:inset 0 0 0 1px var(--accent)}
 </style>
 </head>
-<body>
+<body class="side-wide">
 <header>
   <div class="logo">MingDao <span>Harness</span></div>
   <!-- v0.6.21 小步重排（§3.81）：顶栏只保留「我在哪」的当前位置；模型/预设/权限只在 #sessSheet 里改。 -->
@@ -666,7 +728,28 @@ body.run-open #sessSheet{right:318px}
 <div id="trajRail">
   <button class="rail-btn" id="trajRailBtn" title="轨迹（点击查看详情）">🧭</button>
   <button class="rail-btn" id="subRailBtn" title="子 Agent">🤖<span class="rail-badge" id="subBadge" style="display:none"></span></button>
+  <!-- §3.88：<900 时左栏收成抽屉，这个窄条图标负责打开/关闭（≥900 隐藏）。 -->
+  <button class="rail-btn" id="sideNavRailBtn" title="会话侧栏（打开/关闭）">☰</button>
 </div>
+<!-- v0.6.24 §3.88 左侧栏：设计稿三栏的会话列。只新增；顶栏既有入口一个不删。
+     数据复用 refreshSessions() 的 sessionsGroupedCache；切换走 #sessions change；
+     工作空间镜像 #wsSel（原控件保留在顶栏原位）；新建对话复用 #newChat handler。 -->
+<aside id="sideNav" aria-label="会话侧栏">
+  <div class="sn-head">
+    <span class="sn-title">会话</span>
+    <button id="sideNavCollapse" type="button" title="折叠侧栏" aria-label="折叠侧栏" aria-expanded="true">«</button>
+  </div>
+  <div class="sn-body">
+    <button id="sideNavNew" type="button" title="新建对话">＋<span class="sn-label">新建对话</span></button>
+    <div class="sn-ws">
+      <span class="sn-ws-ico" aria-hidden="true">📁</span>
+      <select id="sideNavWs" title="工作空间（与顶栏 #wsSel 同源，切换走同一个 handler）"></select>
+    </div>
+    <button id="sideNavWsIcon" type="button" title="工作空间" aria-label="工作空间">📁</button>
+    <div class="sn-sec-title">最近会话</div>
+    <div id="sideNavSessions" role="list" aria-label="会话列表"></div>
+  </div>
+</aside>
 <main>
   <!-- P1-6 空态三步引导（v0.6.19 §3.70）：无会话 / 无消息时显示；示例任务只填入输入框，不自动发送。 -->
   <div id="emptyState" hidden>

package/src/web/server.js

@@ -77,24 +77,8 @@ import { syncStatus, syncLogin, syncLogout, syncPush, syncPull, syncRemoteList,
 
 const INDEX_HTML = path.join(path.dirname(fileURLToPath(import.meta.url)), 'index.html');
 
-/**
- * v0.6.22（§3.84）：落盘前给**新增**消息补 ISO 时间戳。
- *
- * 只补缺 ts 的消息（`{...m, ts}` 不改动原对象），已有 ts 的原样保留：
- * 旧会话/旧消息不会被"补写"成另一个时间；压缩重写时也不会把历史时间冲掉。
- * 时间只在服务端落盘这一刻取，前端渲染用同一字段——不引入第二套时间来源。
- * @template T
- * @param {T[]} messages
- * @param {Date} [now]
- * @returns {T[]}
- */
-function stampMessageTs(messages, now = new Date()) {
-  const ts = now.toISOString();
-  return messages.map((/** @type {any} */ m) => {
-    if (!m || typeof m !== 'object' || m.ts) return m;
-    return { ...m, ts };
-  });
-}
+// 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']);
@@ -902,13 +886,14 @@ export async function runWebServer({ host = '127.0.0.1', port = 3820, authToken,
     }
     messages.push({ role: 'user', content: built.content });
     // 落盘用文本版（图文数组只发给模型，会话文件保持字符串可渲染）。
-    // v0.6.22（§3.84）：同一次落盘的时间戳也写回内存里的这条消息——后续自动压缩整文件重写时
-    // 不会把这一轮刚写下的 ts 冲掉；历史消息（已有/缺失 ts）不在这里补。
-    const userTs = new Date().toISOString();
-    await withSessionLock(session.file, () => appendMessages(session.file, [{ role: 'user', content: built.persistText, ts: userTs }]));
+    // 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) lastUserMsg.ts = userTs;
+      if (lastUserMsg && typeof lastUserMsg === 'object' && !lastUserMsg.ts && persistUser.ts) lastUserMsg.ts = persistUser.ts;
     }
     let persistedBefore = messages.length;
 
@@ -1091,13 +1076,11 @@ 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) };
-      // v0.6.22（§3.84）：本回合新增的 assistant/tool 消息落盘时补 ts，并同步回内存数组，
-      // 让之后发生的自动压缩整文件重写保留这些时间戳（历史消息不动）。
+      // v0.6.23（§3.87）：本回合新增的 assistant/tool 消息由 appendMessages 就地补 ts，
+      // 内存数组随之带上时间戳——之后自动压缩整文件重写保留这些时间（历史消息不动）。
       {
         const tail = messages.slice(persistedBefore);
-        const stamped = stampMessageTs(tail);
-        for (let i = 0; i < stamped.length; i += 1) messages[persistedBefore + i] = stamped[i];
-        await withSessionLock(session.file, () => appendMessages(session.file, stamped));
+        await withSessionLock(session.file, () => appendMessages(session.file, tail));
       }
       io.printUsageLine({ modelName: runModel, usage: r.usage, durationMs: r.durationMs });
       // v0.4.4：补记最后一轮 + 兜底总结的剩余 usage（自动续跑轮已在 onUsage 逐轮入账，避免重复计）