@thincoder/core 0.9.4 → 0.10.1

package/session-gc.mjs

@@ -3,7 +3,9 @@
  *
  * F1 残留 GC（自动）：进程启动时对当前 cwd hash 前缀做一次轻量清理——.corrupted /
  * .unreadable / .manifest.corrupted / .bak-* 保留 30 天，孤儿 .tmp 保留 7 天
- *（mtime < now − retention 才删，等于保留期保留——older-than 边界语义）。
+ *（mtime < now − retention 才删，等于保留期保留——older-than 边界语义）；**孤儿 sidecar
+ * 记录目录 `.d`**（主文件 `{prefix}.{N}` 不存在）保留 30 天（数据现场族口径）⇒ **回收**
+ *（rename 进 `sessions-trash`——目录承载记录存储本体，不可直删；D-SE36 同语义）。
  * 安全（N1）：活跃槽（主文件在 + manifest slotSessions[N] 属主活）的现场一律保留；
  * manifest 主文件 / end marker / 数据主文件永不进入候选（后缀预过滤只匹配残留后缀）。
  *
@@ -35,6 +37,9 @@ import { configDir } from "./config.mjs"
 import { sessionPath, ownerPid } from "./session-slots.mjs"
 import { probeOwnersAsync, ownerState } from "./process-probe.mjs"
 import { listStaleCwds, deleteStaleCwd, recycleGroup, sweepStale, trashRootFor } from "./session-stale.mjs"
+// sidecar 记录目录后缀常量（单源 = `session-segments.mjs:13`——本档经该常量判后缀形态；
+// 两处名形匹配式（`classifyResidue` / `sweepOrphanRecordDirs`）按 `{prefix}.{N}` + 后缀内联，不构成第二单源）。
+import { RECORD_DIR_SUFFIX } from "./session-segments.mjs"
 
 /** 保留期（§6.12）：损坏现场（.corrupted/.unreadable/.manifest.corrupted）与并发轮转
  *  备份（.bak-*）30 天；孤儿 .tmp 7 天（崩溃现场恢复窗口）。 */
@@ -46,8 +51,9 @@ export const COLD_CWD_RETENTION_MS = 90 * 24 * 3600 * 1000
 function sessionsDir() { return join(configDir, "sessions") }
 
 /** 残留分类（§6.12 后缀表）：name 须以 `${prefix}.` 开头（prefix = `${hash}.json`）。
- *  返回 { retention, slot, tmp } 或 null（主文件/end marker/他前缀——不动）。
- *  slot = 关联槽号（`.N.` 段），无则 null（如 .manifest.corrupted）。 */
+ *  返回 { retention, slot, tmp, dir } 或 null（主文件/end marker/他前缀——不动）。
+ *  slot = 关联槽号（`.N.` 段），无则 null（如 .manifest.corrupted）；`dir` = sidecar 记录目录
+ *  形（`{prefix}.{N}.d`——孤儿判据反向：**主文件在 ⇒ 跳过**）。 */
 function classifyResidue(name, prefix) {
   if (!name.startsWith(prefix + ".")) return null
   const slotMatch = name.slice(prefix.length).match(/^\.(\d+)\./)
@@ -55,6 +61,7 @@ function classifyResidue(name, prefix) {
   if (name.endsWith(".corrupted") || name.endsWith(".unreadable")) return { retention: RESIDUE_RETENTION_MS, slot, tmp: false }
   if (/\.bak-\d+$/.test(name)) return { retention: RESIDUE_RETENTION_MS, slot, tmp: false }
   if (name.endsWith(".tmp")) return { retention: ORPHAN_TMP_RETENTION_MS, slot, tmp: true }
+  if (name.endsWith(RECORD_DIR_SUFFIX) && /\.\d+\.d$/.test(name)) return { retention: RESIDUE_RETENTION_MS, slot, tmp: false, dir: true }
   return null
 }
 
@@ -105,17 +112,60 @@ export async function gcResidue({ dir = sessionsDir(), prefix, now = Date.now(),
     if (c.slot !== null && active.has(c.slot)) continue // N1：活跃槽现场一律保留（T3）
     const p = join(dir, c.name)
     if (c.tmp && existsSync(p.slice(0, -".tmp".length))) continue // 非孤儿 .tmp（主文件在——写中/回退候选）
+    if (c.dir && existsSync(p.slice(0, -RECORD_DIR_SUFFIX.length))) continue // 非孤儿 sidecar（主文件在 ⇒ 记录存储本体——不动；仅孤儿目录入候选）
     let st
     try { st = await stat(p) } catch { continue }
     if (st.mtimeMs >= now - c.retention) continue // 边界：older-than 才删，等于保留期保留（§6.12）
     result.candidates.push(c.name)
-    if (!dryRun) {
-      try { await unlink(p); result.deleted.push(c.name) } catch { /* 占用/竞态——跳过 */ }
+    if (dryRun) continue
+    if (c.dir) {
+      // 目录承载记录存储本体 ⇒ **回收**（rename 进 `sessions-trash/<批次>/`——不 unlink / 不同步 fs；
+      // 失败 ⇒ 跳过并计数（candidates − deleted）+ 原目录零删除）
+      const r = await recycleGroup({ prefix, files: [c.name] }, { dir, now })
+      if (r.moved.length) result.deleted.push(c.name)
+      continue
     }
+    try { await unlink(p); result.deleted.push(c.name) } catch { /* 占用/竞态——跳过 */ }
   }
   return result
 }
 
+/** ② 显式面清运腿（§6.12 / §6.17 补充——存量通路）：全目录孤儿 sidecar 记录目录
+ *（`{prefix}.{N}.d`——主文件不存在 ∧ 该槽非活跃）⇒ 逐条**回收**（rename 进 `sessions-trash/<批次>/`，同 ① 语义）。
+ *  与 ① 两面之差：① = 自动面（单前缀 / 当前 cwd / **带 30 天保留期**——只治本前缀未来新增）；
+ *  本函数 = **用户显式面**（跳前缀遍历全目录 / **不设保留期**——存量孤儿跨多前缀且多为近期孤儿，
+ *  自动面望不到；进程入口 = `--dry-run` 先列 / `--confirm --all` 才动，且回收可回退）。
+ *  `dryRun` ⇒ 只列不删；目录不可读 ⇒ 空集。失败 ⇒ 跳过（不 unlink 兜底——原目录零删除）。 */
+export async function sweepOrphanRecordDirs({ dir = sessionsDir(), now = Date.now(), dryRun = false, probeFn = probeOwnersAsync, entries = null } = {}) {
+  const out = { candidates: [], recycled: [] }
+  let names = entries
+  if (!names) {
+    try { names = await readdir(dir) } catch { return out }
+  }
+  const present = new Set(names)
+  const byPrefix = new Map() // prefix → [{ name, slot }]
+  for (const name of names) {
+    const m = /^(.+\.json)\.(\d+)\.d$/.exec(name)
+    if (!m) continue
+    if (present.has(`${m[1]}.${m[2]}`)) continue // 主文件在 ⇒ 非孤儿（记录存储本体——不动）
+    if (!byPrefix.has(m[1])) byPrefix.set(m[1], [])
+    byPrefix.get(m[1]).push({ name, slot: Number(m[2]) })
+  }
+  for (const [prefix, items] of byPrefix) {
+    const active = await liveSlots(dir, prefix, probeFn) // N1：活跃槽现场一律保留
+    for (const it of items) {
+      if (active.has(it.slot)) continue
+      let st
+      try { st = await stat(join(dir, it.name)) } catch { continue }
+      if (st) out.candidates.push(it.name)
+      if (dryRun) continue
+      const r = await recycleGroup({ prefix, files: [it.name] }, { dir, now })
+      if (r.moved.length) out.recycled.push(it.name)
+    }
+  }
+  return out
+}
+
 /** 启动**窗外延迟拍** pass（§6.17 编排——点火见 `scheduleSessionGC`）：① 一次**异步目录快照**
  *  （readdir 恰一次——两面共享）② 残留面（gcResidue 既有判据）③ 存量面（总评估有界
  *  ≤ STALE_SWEEP_LIMIT（含 ① 面 manifest 读——D-SE40）+ 超期回收批清运）。
@@ -265,6 +315,10 @@ export async function runSessionGc(args, { dir = sessionsDir(), prefix = null, c
     const residue = p ? await gcResidue({ dir, prefix: p, now, dryRun: true, probeFn }) : { candidates: [] }
     out(`Residue candidates for current project (${p ?? "unknown"}): ${residue.candidates.length}`)
     for (const name of residue.candidates) out(`  ${name}`)
+    // 孤儿 sidecar 记录目录（② 存量面——全目录；主文件不在 + 该槽非活跃——不设保留期）
+    const orphanDirs = await sweepOrphanRecordDirs({ dir, now, dryRun: true, probeFn })
+    out(`Orphan record-dir (.d) candidates (main file gone; explicit face — no retention): ${orphanDirs.candidates.length}`)
+    for (const name of orphanDirs.candidates) out(`  ${name}`)
     out(`Cold/stale project candidates (cold = manifest idle > 90 days; stale = no live owner + cwd unreachable/empty + 7-day window): ${candidates.length}`)
     for (const c of candidates) out(`  ${c.hash}  reason ${c.reason}  files ${c.files.length}`)
     if (candidates.length >= GC_PROGRESS_MIN) out(`Estimate: ${fmtGcEstimate(candidates.length)} to scan ${candidates.length} candidates (measured ≈${GC_MS_PER_CANDIDATE}ms/candidate).`)
@@ -279,7 +333,9 @@ export async function runSessionGc(args, { dir = sessionsDir(), prefix = null, c
     try { loopEntries = await readdir(dir) } catch { loopEntries = null }
   }
   const targets = confirmTarget === "--all" ? candidates : candidates.filter((c) => c.hash === confirmTarget)
-  if (!targets.length) {
+  // ② 面候选预列（孤儿 sidecar 记录目录——存量通路；只列不删——实回收在组循环后）
+  const orphanDirs = confirmTarget === "--all" ? await sweepOrphanRecordDirs({ dir, now, dryRun: true, probeFn, entries: loopEntries }) : { candidates: [] }
+  if (!targets.length && !orphanDirs.candidates.length) {
     err(`Refused: ${confirmTarget} is not a cold/stale project (active, recent, or unknown) — nothing deleted.`)
     return 1
   }
@@ -299,5 +355,10 @@ export async function runSessionGc(args, { dir = sessionsDir(), prefix = null, c
     }
     out(`Moved ${r.deleted.length} files for ${t.hash} into the recycle bin (${r.batch})${r.skipped?.length ? ` — skipped ${r.skipped.length} (locked/racing, kept in place)` : ""}.`)
   }
+  // ② 显式面清运腿（孤儿 sidecar 记录目录——存量通路；与 ① 同语义：rename 进回收批）
+  if (confirmTarget === "--all" && orphanDirs.candidates.length) {
+    const moved = await sweepOrphanRecordDirs({ dir, now, probeFn, entries: loopEntries })
+    out(`Orphan record dirs (.d): moved ${moved.recycled.length}/${moved.candidates.length} into the recycle bin (${trashRootFor(dir)}).`)
+  }
   return 0
 }

package/session-guard.mjs

@@ -4,20 +4,29 @@
  * 行随迁，verbatim 零语义变）：saveSession 与 token-ttl persistEngTokens 共用同一份。
  * 写前校验磁盘槽文件是否本进程会话的现场——磁盘文件 sessionStart 与本进程会话不符
  * （另一进程/会话的现场）/版本更新/异 cwd → 先轮转 .bak 保留再写。检查按 mtime 缓存
- * （agent._slotMtime）：文件自上次检查/自写未变就跳过全量解析——每次保存都
+ * （agent._slotMtime = `{p, mtimeMs}`——**按槽文件路径**命中，见 #386 复核）：文件自上次检查/自写未变就跳过全量解析——每次保存都
  * readFileSync+JSON.parse 多 MB 会话 → O(n²) 退化。文件存在但不可读（损坏/半写）→
  * 改名 .corrupted 保留现场。返回轮转的 .bak 路径或 null。
+ *
+ * 创建端取值链（SLOT-END-PARAM 批 §6.20 判据句 4）：本守卫是全量解析盘面的唯一写前窗口
+ * ⇒ 创建端**顺带解析**（副作用回写 `agent._slotCreatedBy`，供 saveSession 在守卫**之后**
+ * 注入 fields——分支：文件不在盘 / 轮转 / 损坏改名 ⇒ `sessionEnd()`（本端将首物化这份文件）；
+ * 解析通过未轮转 ⇒ `disk.createdBy ?? null`（透传盘上键；老槽无键 ⇒ null ⇒ 禁回填）；
+ * mtime 命中 ⇒ 本函数未解析盘面 ⇒ 值不动）。
  */
 
 import { existsSync, readFileSync, renameSync, statSync } from "node:fs"
 import { basename } from "node:path"
-// §14.3.8①（修正轮 #1）：.bak 轮转对**非本会话活动绑定面**联动改名 sidecar（`{p}.d → {bak}.d`）。
+// SESSION.md §6.12①（修正轮 #1）：.bak 轮转对**非本会话活动绑定面**联动改名 sidecar（`{p}.d → {bak}.d`）。
 import { RECORD_DIR_SUFFIX } from "./session-store.mjs"
+// 本进程端名（创建端取值链缺省值）——静态环：本档 ↔ session-slots.mjs（经 session.mjs，同
+// 两档头注：函数体内运行时使用、求值期零顶层调用 ⇒ 环安全）。
+import { sessionEnd } from "./session-slots.mjs"
 
 /** 轮转时随迁记录存储（.bak 路径联动）——本会话活动绑定面跳过（防拔掉活动存储）。 */
 function moveSidecar(src, dst, agent) {
   const dir = src + RECORD_DIR_SUFFIX
-  if (agent?._recordStore?.dir === dir) return // 本会话活动绑定面——原地保留（§14.3.8①）
+  if (agent?._recordStore?.dir === dir) return // 本会话活动绑定面——原地保留（SESSION.md §6.12①）
   try {
     if (existsSync(dir)) renameSync(dir, dst + RECORD_DIR_SUFFIX)
   } catch { /* 随迁失败不阻断轮转（现场原地保留——读侧身份核验兜底） */ }
@@ -25,9 +34,17 @@ function moveSidecar(src, dst, agent) {
 
 export function guardForeignSlotFile(agent, p, slot) {
   try {
-    if (!existsSync(p)) return null
+    if (!existsSync(p)) {
+      agent._slotCreatedBy = sessionEnd() // 文件不在盘 ⇒ 本端即将首物化（= 创建端）
+      return null
+    }
     const st = statSync(p)
-    if (st.mtimeMs === (agent._slotMtime ?? -1)) return null
+    // mtime 命中（**同路径** ∧ 同 mtime）：未解析盘面 ⇒ 值不动。缓存带路径标签（#386 复核）——
+    // 单 agent 换槽复用（`_slot` 直钉新槽，未经 applySession / resetSessionState 清缓存）时，
+    // 旧槽 mtime 不得命中新槽（同 mtime 巧合 ⇒ 漏轮转 / 漏 createdBy 透传）；「换槽即清缓存」
+    // 不再是被依赖的隐式前提。
+    const hit = agent._slotMtime
+    if (hit && hit.p === p && st.mtimeMs === hit.mtimeMs) return null
     const disk = JSON.parse(readFileSync(p, "utf8"))
     // version>2 的新版文件无论 sessionStart 一律轮转（loadSlotFile 对 v3 返回 null 不动
     // 文件——若其 sessionStart 为 null，旧版首次保存会静默覆盖；轮转 .bak 保证新版文件
@@ -42,10 +59,12 @@ export function guardForeignSlotFile(agent, p, slot) {
       renameSync(p, bak)
       moveSidecar(p, bak, agent)
       console.error(`[session] slot ${slot} holds ${diskIsNewer ? `a newer-version file (v${disk.version})` : diskForeign ? `a foreign-cwd file (${disk.cwd})` : `another session (start ${diskStart}, ours ${myStart})`} — preserved as ${basename(bak)}`)
-      agent._slotMtime = st.mtimeMs
+      agent._slotMtime = { p, mtimeMs: st.mtimeMs }
+      agent._slotCreatedBy = sessionEnd() // 轮转：现场已让位 ⇒ 本端将首物化新文件
       return bak
     }
-    agent._slotMtime = st.mtimeMs
+    agent._slotMtime = { p, mtimeMs: st.mtimeMs }
+    agent._slotCreatedBy = disk?.createdBy ?? null // 解析通过：透传盘上键（无键 ⇒ null ⇒ 禁回填）
     return null
   } catch {
     // 文件存在但不可读（损坏/半写）：改名 .corrupted 保留现场（2026-09-01 advisor 🔵——
@@ -54,6 +73,7 @@ export function guardForeignSlotFile(agent, p, slot) {
     if (existsSync(p)) {
       try { renameSync(p, `${p}.corrupted`) } catch {}
     }
+    agent._slotCreatedBy = sessionEnd() // 损坏改名：现场已让位 ⇒ 本端将首物化新文件
     return null
   }
 }

package/session-lifecycle.mjs

@@ -3,7 +3,8 @@
  * 硬限；各函数语义原样外提，SESSION.md §6.10 D-2 / §6.12 / §6.11 注记随迁）：
  * 本端恢复入口包装（resumeSlot——残留 GC 钩子）/ 槽数据应用（applySession）/ 新建槽
  * （newSession）/ 运行态清空（resetSessionState）/ 槽切换（switchToSlot）/ 占用查询
- * （slotOccupancy）/ v1 老文件清扫（stripTruncatedToolArgs）。
+ * （slotOccupancy）/ 打开态读数（sessionReading——§6.24 只读纯投影，桌面残余批落）/
+ * v1 老文件清扫（stripTruncatedToolArgs）。
  *
  * 静态环（与 session-slots.mjs ↔ session.mjs 同形）：本档引 `session.mjs` 的
  * `loadSlotFile`（data 层读留 session.mjs——2026-09-05 §6.10 D-2 拆分点），session.mjs re-export
@@ -20,24 +21,37 @@ import { existsSync } from "node:fs"
 import { resolveCompactThreshold } from "./config.mjs"
 import {
   slotPath, loadManifest, saveManifest, slotDigest, writeSessionFile, getSessionId,
-  writeEndMarker, ownerPid, ownerPids,
+  writeEndMarker, sessionEnd, ownerPid, ownerPids,
   resumeSlot as slotsResumeSlot,
 } from "./session-slots.mjs"
 import { probeOwnersSync, probeOwnersAsync, ownerState } from "./process-probe.mjs"
+// 落点 A 顺手补写（§6.25 判据句 3 · LEDGER-RELIABILITY 批）——判据单源住清单档（与 resumeSlot 同函数）。
+import { healDigest, slotMtime } from "./session-slots-manifest.mjs"
 // 环 import：见头注（loadSlotFile 属 session.mjs 的 data 层读面）。
 import { loadSlotFile } from "./session.mjs"
+// 全新槽首物化构造器单源（SLOT-END-PARAM 批 §6.20 判据句 4 写面：「`newSession` 并入」——
+// 与 VSC `newSlot` / `loadSlotForWrite` 全新分支同一构造器；环 import 同上，函数体内运行时使用）。
+import { newSlotData } from "./session-slot-write.mjs"
 import { mergeAdjacentAssistantEchoes } from "./context.mjs"
+// 打开态读数公式（§6.24 判据句 2——与 CLI 状态行 / VSC 同式；零新公式，只组合）。
+import { historyPercent } from "./token-window.mjs"
 import { scheduleSessionGC } from "./session-gc.mjs"
 import { restoreEngTokens } from "./token-ttl.mjs"
 import { clearPlanMode } from "./agent-tools/plan.mjs"
 import { bindRecordStore, unbindRecordStore, RECORD_WINDOW_MESSAGES } from "./session-store.mjs"
+// 会话级档位（§6.21 判据句 4）判据单源：off 形族（`think-off.mjs`）+ 逐模型枚举
+// （`model-specs.mjs`）——两叶档（零 import）⇒ 不新增环，核内零第二份族别表。
+import { specForModel } from "./model-specs.mjs"
+import { thinkOffShape, thinkOffPath } from "./think-off.mjs"
 
 /** 恢复决策包装（SESSION.md §6.12 启动钩子，2026-09-06）：本端恢复入口触发一次残留 GC——
  *  scheduleSessionGC 内部**启动窗外延迟拍**（`GC_PASS_DELAY_MS` = 3s）+ 每进程每前缀去重，
- *  **异步非阻塞**启动路径（N4；§6.17 D-SE39）；**async**（F-MI7——调用面必须 await）。 */
-export async function resumeSlot(cwd) {
+ *  **异步非阻塞**启动路径（N4；§6.17 D-SE39）；**async**（F-MI7——调用面必须 await）。
+ *  `opts.end`（§6.20 判据句 2——显式端参 > 进程端名）：本端记录端名透传（端壳经绑定转口
+ *  传本端常量；缺省 = 进程端名 ⇒ CLI 全调用点零改）。 */
+export async function resumeSlot(cwd, { end = sessionEnd() } = {}) {
   scheduleSessionGC(cwd)
-  return slotsResumeSlot(cwd)
+  return slotsResumeSlot(cwd, { end })
 }
 
 /** slimForDisplay 截断的 arguments 以 U+2026（…）结尾——不是合法 JSON 的完整值。
@@ -61,9 +75,9 @@ function stripTruncatedToolArgs(m) {
  *
  *  MODEL-MERGE-SESSION（F-4）applySession 重写为两支 + 删旧支（评审 #7/#9 措辞——防
  *  "三支"误读）：
- *  ① 槽 provider 存在 → provider/model 按槽值设（双字段恒非空——模型取 data.activeModel，
- *     legacy 槽 null/空串回该渠道默认模型 `providers[].model`（单值——2026-09-10 MODEL-SELECTION
- *     v2；老 models[] 首候选形态已退场））+ 重算
+ *  ① 槽 provider 存在 → provider/model 按槽值设（双字段恒非空——模型取 data.activeModel（**串值**；
+ *     非串 ∕ null ∕ 空串 = 未登记 ⇒ 回该渠道默认模型 `providers[].model` 单值——2026-09-10 MODEL-SELECTION
+ *     v2；老 models[] 首候选形态已退场）+ 重算
  *     compactThreshold（auto 时——按恢复后模型）——不看 config（defaultModel 只是新会话起点）；
  *  ② 槽 provider 没了 → D-S3 保留——静默保持现状（config 有效则有效——两方都无效由调用侧
  *     复验 validateProvider 弹重选）。
@@ -126,6 +140,10 @@ export function applySession(agent, data, opts = {}) {
   agent._verifyPassed = false
   agent._slot = null // 粘性缓存清空——切换后重新认领（F1b）
   agent._slotMtime = null
+  // 会话级档位携带（§6.21 判据句 5——保存面的一半）：值 = 本槽 `effort` **原样**携带（表外 /
+  // 不可 off 的原值不静默改写——写面归一只在 `setSlotPrefs`）；缺键（老槽）⇒ `undefined` ⇒
+  // `saveSession` 不落该键（禁回填——同 `createdBy` 先例；键在而值为 `null` ⇒ 原样携 `null`）。
+  agent._slotEffort = Object.hasOwn(data, "effort") ? (data.effort ?? null) : undefined
   // ── 记录存储绑定（TUI-OOM-ROOTCAUSE · SESSION.md §6.14 绑定与对账 / 追加时点）──
   // opts.slot 在场（启动恢复 / 非占用的 /session 切换 / ACP 钉槽）→ 绑定（身份核验 + 对账 +
   // 窗口）——人读线 = store.tail(200)；未传（模式 F：被他人活进程占用的槽 / 测试 / ACP fork）
@@ -149,16 +167,37 @@ export function applySession(agent, data, opts = {}) {
     //    空槽 model 恒有值，provider.model 键不缺失）
     const prevName = agent.activeProvider
     const prevModel = agent.activeModel ?? null
-    const slotModel = data.activeModel || slotProvider.model
+    // #638（adoption 边界归一）：非串 `data.activeModel`（外端脏载 / 手工档）= 未登记 ⇒ 回退渠道
+    // 模型——类型脏值不入两状态字段（镜下方阈值重算门 ∕ 档位块 ∕ VSC `panel-turn-stages.mjs:53` 同形门）。
+    const slotModel = (typeof data.activeModel === "string" && data.activeModel) ? data.activeModel : slotProvider.model
     const switched = prevName !== slotProvider.name || prevModel !== slotModel
     agent.activeProvider = slotProvider.name
     agent.activeModel = slotModel
     agent.provider = { ...slotProvider }
     if (slotModel) agent.provider.model = slotModel
-    // 重算 compactThreshold（auto 时——阈值跟模型走；原在 bin 的 switched 分支——收拢本处）
-    if (switched && agent.config?.agent?.compactThresholdAuto && agent.provider.model) {
+    // 重算 compactThreshold（auto 时——阈值跟模型走；原在 bin 的 switched 分支——收拢本处）。
+    // 非串 model（外端脏载 / 手工档）⇒ 不重算（#638 后查表族恒 total，本门保留为同形防御——与
+    // 下方档位块同口径）；类型脏载不中断恢复。
+    if (switched && agent.config?.agent?.compactThresholdAuto && typeof agent.provider.model === "string" && agent.provider.model) {
       agent.config.agent.compactThreshold = resolveCompactThreshold(null, agent.provider).value
     }
+    // 会话级档位施加（§6.21 判据句 4——在模型合并支之后，以**合并后**的 `provider.model` 判 spec；
+    // 三端共用本施加面）：`"off"` 记号 ⇒ 该模型有 off 路径才设关思考形（effort 族该形为 `null`
+    // ⇒ 另置 `reasoningEffort: "none"`——§16.4 载荷门，单源 = `think-off.mjs`）；枚举字面 ⇒ 直置；
+    // `null` / 缺键 / 表外串 ⇒ 不动（边界表第 1–3 行：老槽零行为变更，表外不静默改写）。
+    if (data.effort != null) {
+      // 非串 model（外端脏载 / 手工档）按未登记归一——本块不因类型脏载抛（同 `resolveEffortPatch` 口径）
+      const spec = specForModel(typeof agent.provider.model === "string" ? agent.provider.model : "")
+      if (data.effort === "off") {
+        if (thinkOffPath(spec)) {
+          const shape = thinkOffShape(spec)
+          agent.provider.thinking = shape
+          if (shape === null) agent.provider.reasoningEffort = "none"
+        }
+      } else if (spec?.reasoningEffortEnum?.includes(data.effort)) {
+        agent.provider.reasoningEffort = data.effort
+      }
+    }
     return switched
   }
   // ② 槽 provider 没了 → D-S3 保留——静默保持现状（不报错不纠正——config 有效则静默用
@@ -211,10 +250,13 @@ export async function newSession(cwd, opts = {}) {
   while (m.slots[slot] || existsSync(slotPath(cwd, slot)) || liveClaimed(slot)) slot++
 
   // Write empty session — 2026-09-01 advisor 🔵：补 contextHistory/planMode 字段与
-  // VS Code newSlot 对齐（SESSION.md §6.3 v2 格式双端一致；两端读侧均有兜底，功能等价）
-  const data = { version: 2, cwd, title: "", updatedAt: Date.now(), history: [], contextHistory: [], tasks: [], planMode: false, goal: null, autoApprove: false, advisor: null, pendingReminders: [], sessionStart: null }
+  // VS Code newSlot 对齐（SESSION.md §6.3 v2 格式双端一致；两端读侧均有兜底，功能等价）。
+  // SLOT-END-PARAM 批（§6.20 判据句 4 写面）：改用首物化构造器单源 `newSlotData(cwd)`
+  // （原字面逐字同形——并入后随其带创建端 = 本端名）。
+  const data = newSlotData(cwd)
   writeSessionFile(slotPath(cwd, slot), data)
-  m.slots[slot] = slotDigest(data)
+  // 摘要 `ts` 地板入参（#503 同族随动——保存面写后取 mtime；`slotMtime` 读失败 ⇒ null ⇒ 裸墙钟）
+  m.slots[slot] = slotDigest(data, slotMtime(cwd, slot))
   m.active = slot
   // 2026-08-31 advisor round1 🟡：与 ensureActive 认领模型一致——立即记录新 slot 所有权，
   // 否则 /new 后到首次保存之间并发方（VS Code/另一 CLI）会把新 active 槽当"空闲可恢复"
@@ -262,6 +304,7 @@ export function resetSessionState(agent) {
   agent._pendingReminders = []
   agent._slot = null
   agent._slotMtime = null
+  agent._slotEffort = null // 新会话无档位（§6.21 判据句 5：全新槽规范形 = `effort: null`）
   agent._osReminderInjected = false
   // §6.11（2026-09-08）：一次性注入标志换名——_restartReminderInjected 推断退役（F3——
   // _sessionStart != null 伪触发）；/new 清零新标记——恢复武装/启动句标志不跨会话复活
@@ -279,11 +322,16 @@ export function resetSessionState(agent) {
  *  （无认领副作用）；目标槽空闲则一并认领、被另一活进程占用则不认领（slotOccupancy——
  *  下次保存经 activeSlot 自然 fork 到新槽）；只改 manifest 指针（setActive 意图）。
  *  2026-09-01 会诊三家 🟡：saveManifest 条目级合并 + setActive（不把并发方刚翻的指针回滚）。 */
-export function switchToSlot(cwd, slot) {
+export function switchToSlot(cwd, slot, { end = sessionEnd() } = {}) {
   const m = loadManifest(cwd)
-  if (!m.slots[slot]) return null
+  // §6.22 判据句 4（SESSION-LIST-DISK 批）：准入 = 盘面文件存在 ∨ manifest 有条目——盘上独有槽
+  // 可切；旧分支逐字保留（有条目无文件 ⇒ 读槽返 null 同今日）。
+  if (!m.slots[slot] && !existsSync(slotPath(cwd, slot))) return null
   const data = loadSlotFile(cwd, slot)
   if (!data) return null
+  // 落点 A（§6.25 判据句 3）：数据已在手 ⇒ 摘要顺手补写——随本次 saveManifest 落（**零额外读 /
+  // 零额外写**；新鲜条目不写——幂等，§6.25 谓词单源 `healNeeded`）。
+  healDigest(m, slot, data, slotMtime(cwd, slot))
   m.active = slot
   const occ = slotOccupancy(cwd, slot)
   if (!occ.occupied) {
@@ -294,8 +342,9 @@ export function switchToSlot(cwd, slot) {
   // （不认领目标 + 旧认领一并释放——下次保存经 `allocateFresh` fork，既有语义）。核受占 =
   // 切换成立（D-SE33：指针 / 记录按 D-6 / D-4 落点——fork 面依赖指针翻至目标槽）。
   saveManifest(cwd, m, null, { setActive: true, release: occ.occupied ? [] : [slot] })
-  // 2026-09-05 §6.10 D-4：/session N 跟随"最后查看的槽"（成功切换才写）
-  writeEndMarker(cwd, slot)
+  // 2026-09-05 §6.10 D-4：/session N 跟随"最后查看的槽"（成功切换才写）；§6.20 判据句 2：
+  // 写点端名随动（显式端参 > 进程端名——端壳经绑定转口传本端常量）
+  writeEndMarker(cwd, slot, end)
   return data
 }
 
@@ -316,3 +365,26 @@ export function slotOccupancy(cwd, slot) {
   if (st === "unknown") return { occupied: true, unknown: true, owner }
   return { occupied: false }
 }
+
+/** 打开态读数（SESSION.md §6.24 · 桌面残余批——恢复态播种的读数**单源**）：槽数据 ⇒ 状态行上下文
+ *  读数百分数（整数）。与 `applySession` 后读数**同源同式**（四事同判——组合既有件，零新公式）：
+ *  ① 线选 = `contextHistory` 非空取之，否则 `history` 经 `stripTruncatedToolArgs` 回退（同 applySession）；
+ *  ② 回声归并 = `mergeAdjacentAssistantEchoes`（同 applySession 装线前一步）；
+ *  ③ 渠道合并 = `providers` 命中 `data.activeProvider` ⇒ 串值 `activeModel` 覆盖 `entry.model`（非串 ∕
+ *     空串 = 未登记 ⇒ 回退 `entry.model`——模型合并支 ① 同归一）；未命中 ⇒ `fallback`（支 ②「静默保持现状」的装配口径 = `loadConfig().provider`）；
+ *  ④ 公式 = `historyPercent`（`thincoder-core/token-window.mjs`——与 CLI 状态行 / VSC 同式）。
+ *  **零副作用**：`data` / `providers` / `fallback` 皆入参（不读盘、不写盘、不改任何进程态）；
+ *  `data` 非对象 ⇒ `0`（与空历史同值——「非正 ⇒ 零节点」显示门归端侧，沿 `historyPercent` 空历史口径）。 */
+export function sessionReading(data, { providers, fallback } = {}) {
+  if (data === null || typeof data !== "object") return 0
+  const full = Array.isArray(data.history) ? data.history : []
+  const ch = data.contextHistory
+  const machine = (Array.isArray(ch) && ch.length > 0) ? ch : full.map(stripTruncatedToolArgs)
+  const line = mergeAdjacentAssistantEchoes(machine)
+  const entry = data.activeProvider ? providers?.find((pr) => pr.name === data.activeProvider) : null
+  // #638：非串 `activeModel` 归一（与 applySession 模型合并支 ① 同判）——脏值不达 `historyPercent`。
+  const provider = entry
+    ? { ...entry, model: (typeof data.activeModel === "string" && data.activeModel) ? data.activeModel : entry.model }
+    : fallback
+  return historyPercent(line, provider)
+}

package/session-rename.mjs

@@ -29,9 +29,13 @@ export function renameSlot(cwd, slot, title, _stat = statSync) {
   // 读与写之间文件被并发方改过 → 放弃（保留并发内容，重命名下次重试）
   if (_stat(p).mtimeMs !== t0) return { ok: false, reason: "mtime-conflict" }
   writeSessionFile(p, data)
+  // 写后取 mtime（标题写也是一次落盘）——摘要 `ts` 地板入参（#503 同族随动；读失败 ⇒ 缺省回溯墙钟。
+  // `statSync` 是真实 stat——`_stat` 只为 mtime-conflict 判据注入，地板不共用该缝）。
+  let wroteMtimeMs
+  try { wroteMtimeMs = statSync(p).mtimeMs } catch { /* 不可得 ⇒ 裸墙钟 */ }
   const m = loadManifest(cwd)
   if (m.slots[n]) {
-    m.slots[n] = slotDigest(data)
+    m.slots[n] = slotDigest(data, wroteMtimeMs)
     saveManifest(cwd, m)
   }
   return { ok: true }