@thincoder/core 0.9.5 → 0.10.2

package/session-slot-write.mjs

@@ -1,6 +1,7 @@
 /**
  * session-slot-write.mjs — 会话槽「元数据开关」写面（Parnas 边界：开关写决策组——
- * autoApprove / planMode / engineering / advisor guard，外加全新槽默认记录与落盘单点）。
+ * autoApprove / planMode / engineering / advisor guard / 会话级偏好三键
+ * （provider / model / effort——§6.21），外加全新槽默认记录与落盘单点）。
  *
  * 归属：会话数据面（同上位 `session.mjs` / `session-slots.mjs` / `session-store.mjs`）。
  * 本档 = **（cwd, slot）形态**的槽写入面（读-改-写）；另一形态 = `session.mjs` 的
@@ -23,10 +24,14 @@
 
 import { existsSync, readFileSync, renameSync, statSync } from "node:fs"
 
-import { getSessionId, loadManifest, saveManifest, slotDigest, slotPath, writeSessionFile } from "./session-slots.mjs"
-import { loadSlotFile } from "./session.mjs"
+import { getSessionId, loadManifest, saveManifest, slotDigest, slotPath, writeSessionFile, sessionEnd } from "./session-slots.mjs"
+import { loadSlotFile, isLegacyTransient } from "./session.mjs"
 // token 形态单源（格式校验 + 到期时刻）——本档的保存面合并规则复用同一判定。
 import { tokenExpiryMs } from "./token-ttl.mjs"
+// 会话级偏好写面（§6.21 判据句 3）的判据单源——档位值域（`specForModel(...).reasoningEffortEnum`）
+// 与 off 可达性（`thinkOffPath`）；两叶档（零 import）⇒ 不涉环，核内零第二份族别 / 枚举表。
+import { specForModel } from "./model-specs.mjs"
+import { thinkOffPath } from "./think-off.mjs"
 
 /** mtime 缓存（键 = 槽文件路径 → 上次所见 mtimeMs）：同一槽连写时跳过重复解析。
  *  测试复位缝（与 `_setSessionsDirForTest` 同款）：缓存为进程级单例，用例间需可复位
@@ -34,13 +39,17 @@ import { tokenExpiryMs } from "./token-ttl.mjs"
 const slotMtimeCache = new Map()
 export function _resetSlotMtimeCacheForTest() { slotMtimeCache.clear() }
 
-/** Fresh slot data default：全新空槽的规范结构（`newSession` 写盘面同形）。 */
+/** Fresh slot data default：全新空槽的规范结构（`newSession` 写盘面**同源**——SLOT-END-PARAM
+ *  批起 `newSession` 与本构造器单源；`effort: null` = 会话级档位未设态——§6.21 判据句 5 规范
+ *  结构同源；老槽无该键由读侧按 `null` 容忍）。首物化即记创建端（§6.20 判据句 4 写面：本端
+ *  物化者 = 进程端名；「禁回填」不适用——本构造器只产全新槽）。 */
 export function newSlotData(cwd) {
   return {
     version: 2, cwd, title: "", updatedAt: Date.now(),
     history: [], contextHistory: [], tasks: [],
-    planMode: false, goal: null, autoApprove: false, advisor: null,
+    planMode: false, goal: null, autoApprove: false, advisor: null, effort: null,
     pendingReminders: [], sessionStart: null,
+    createdBy: sessionEnd(),
   }
 }
 
@@ -62,8 +71,11 @@ function rotateIfForeign(p, slot, data) {
       disk.cwd.toLowerCase() !== data.cwd.toLowerCase()
     const diskStart = disk?.sessionStart ?? null
     const myStart = data?.sessionStart ?? null
+    // 盘面长度与快照**同口径**（#441①）：快照 `data` 来自读槽回放（`loadSlotFile` 已按
+    // `isLegacyTransient` 过滤，`session.mjs` 读面）⇒ 盘侧同滤——否则坏档里的 legacy 注入
+    // 条目会凭空把盘面算长，无并发追加也误判轮转（.bak 白产 + 误报 concurrent append）。
     const diskLonger = Array.isArray(disk?.history) && Array.isArray(data?.history) &&
-      disk.history.length > data.history.length
+      disk.history.filter((m) => !isLegacyTransient(m)).length > data.history.length
     if (!(diskIsNewer || diskForeign || (diskStart && diskStart !== myStart) || diskLonger)) return null
     const bak = `${p}.bak-${Date.now()}`
     renameSync(p, bak)
@@ -84,16 +96,24 @@ function rotateIfForeign(p, slot, data) {
 /**
  * 槽落盘单点（读-改-写面共用）：轮转判定 → 写槽文件 → 回写 manifest 摘要。
  * 返回轮转出的 `.bak` 路径或 null（调用方按需透出）。
+ *
+ * 创建端（SLOT-END-PARAM 批 §6.20 判据句 4 写面）：入参无 `createdBy` **且**槽文件不在盘
+ * （**轮转后**判据——`rotateIfForeign` 已让位现场）⇒ 本端即将首物化 ⇒ 落进程端名；
+ * 文件在盘（含老槽无键）⇒ 不动（禁回填）。
  */
 export function saveSlotData(cwd, slot, data) {
   data.updatedAt = Date.now()
   const p = slotPath(cwd, slot)
   const rotated = rotateIfForeign(p, slot, data)
+  if (data.createdBy === undefined && !existsSync(p)) data.createdBy = sessionEnd()
   writeSessionFile(p, data)
-  slotMtimeCache.set(p, (() => { try { return statSync(p).mtimeMs } catch { return 0 } })())
+  // 写后取 mtime 单次采集（读失败 ⇒ `0` = 不可得）：缓存（本档路径键）+ 摘要 `ts` 地板入参
+  // （#503——保存面写后取 mtime，同族先例 `session-slot-verify.mjs:99`）。
+  const wroteMtime = (() => { try { return statSync(p).mtimeMs } catch { return 0 } })()
+  slotMtimeCache.set(p, wroteMtime)
   try {
     const m = loadManifest(cwd)
-    m.slots[slot] = slotDigest(data)
+    m.slots[slot] = slotDigest(data, wroteMtime)
     saveManifest(cwd, m)
   } catch { /* 摘要失败非致命——数据已安全，元数据下次 listSlots 惰性恢复 */ }
   return rotated
@@ -166,3 +186,49 @@ export function mergeEngTokensForSave(incoming, existing) {
   }
   return out
 }
+
+/** 会话级偏好（§6.21）键闭集——表外键 = 整 patch 拒（写未发生）。 */
+const SLOT_PREF_KEYS = new Set(["provider", "model", "effort"])
+
+/**
+ * 会话级档位归一（§6.21 判据句 3——纯函数、不抛）：`level` → 槽 `effort` 值。
+ *  - `null` / `undefined` / `"auto"` ⇒ `null`（未设 ⇒ 回落配置面 / 渠道默认）；
+ *  - `"off"` ⇒ 该模型**有 off 路径**（判据单源 = `thinkOffPath`，勿在本档重写族别判定）
+ *    ⇒ `"off"`、否则 `null`；
+ *  - 其余 ⇒ 逐模型枚举（单源 = `specForModel(model).reasoningEffortEnum`）含之 ⇒ 原字面、
+ *    不含 / 无枚举 ⇒ `null`。
+ *  `model` 非串（外端脏载 / 手工档）⇒ 按**未登记**归一（`DEFAULT_SPEC` 径）——「不抛」契约。
+ *  写面归一只此一处；读侧另容忍表外串（applySession 边界表——不设，不静默改写）。
+ */
+export function resolveEffortPatch(level, model) {
+  if (level == null || level === "auto") return null
+  const spec = specForModel(typeof model === "string" ? model : "")
+  if (level === "off") return thinkOffPath(spec) ? "off" : null
+  return (spec?.reasoningEffortEnum ?? []).includes(level) ? level : null
+}
+
+/**
+ * 会话级偏好写出口（§6.21 判据句 2——沿 `setSlotAutoApprove` 同形，复用 `writeFlag` 单点）：
+ * `patch` 键闭集 = `provider` / `model` / `effort`，**至少一键**（零键 / 表外键 ⇒ `false`，写未
+ * 发生）；槽不可读 ⇒ `false`。`provider` / `model` 键入参映射既有槽字段 `activeProvider` /
+ * `activeModel`（不新增字段；`null` = 缺键语义——`provider` / `model` 无「未设」态）；`effort` 经
+ * `resolveEffortPatch` 归一（`model` 取 `patch.model ?? 槽现值 activeModel`），归一 `null` = 未设
+ * （回落配置面 / 渠道默认）——**值置 `null` 不删键**（与 `newSlotData` 规范结构同源）。
+ * 只写盘：不碰当前内存态（施加面唯一 = `applySession`——§6.21 判据句 4 / 边界表第 5 行）。
+ *
+ * **值域面（#441② 明文——核侧有意不校）**：本出口只校**键闭集**，**不校值域**——`provider` /
+ * `model` 传 `null`（或表外字面）按**缺键语义**零改（不报错；`null` 仅对 `effort` 有「未设」
+ * 语义）；值域名（`null` 仅 `effort` + `provider` / `model` 非空）由**端侧契约**把守
+ * （桌面 IPC「会话级偏好注」；端侧拒例 = `thincoder-desktop/src/main/agent-host.mjs`
+ * `prefsPatchFailure`）——读侧容忍为有意（跨端 / 手工改写档零行为变更），核内不立第二份值域校验。
+ */
+export function setSlotPrefs(cwd, slot, patch) {
+  if (!patch || typeof patch !== "object" || Array.isArray(patch)) return false
+  const keys = Object.keys(patch)
+  if (keys.length === 0 || keys.some((k) => !SLOT_PREF_KEYS.has(k))) return false
+  return writeFlag(cwd, slot, (d) => {
+    if (patch.provider != null) d.activeProvider = patch.provider
+    if (patch.model != null) d.activeModel = patch.model
+    if ("effort" in patch) d.effort = resolveEffortPatch(patch.effort, patch.model ?? d.activeModel)
+  })
+}

package/session-slots-manifest.mjs

@@ -5,7 +5,18 @@
  * 摘要面（`extractSlotMeta` / `slotDigest`）· 清单读写（`loadManifest` / `saveManifest`）·
  * 属主面（`ownerPid` / `ownerPids` / `ownerStateOf` / `ownerArgs` / `cleanDeadOwners`）·
  * 认领面（`ensureActive` / `allocateFresh` / `claimSlot` / `activeSlot` / **认领释放集
- * `staleClaims`**——F-CR1 · SESSION-CLAIM 批：判据单源，`saveManifest` 落盘 + 各落点共用）。
+ * `staleClaims`**——F-CR1 · SESSION-CLAIM 批：判据单源，`saveManifest` 落盘 + 各落点共用；
+ * **属主 ∕ 认领两族已随 2026-09-28 拆分迁出 `session-slot-claims.mjs`——见下**）。
+ *
+ * LEDGER-RELIABILITY 批（2026-09-28 · SESSION.md §6.25）：补摘要谓词 `healNeeded` + 落点 A 顺手补写
+ * `healDigest` / `slotMtime`（判据句 3）· 账本面写安全（判据句 5）· 账本健康出口 `ledgerHealth`（判据句 4）。
+ *
+ * 2026-09-28 拆分批（R3——本档 421 > 300）：**认领面族**（`staleClaims` ∕ owner 三件 ∕
+ * `cleanDeadOwners` ∕ `ensureActive` ∕ `allocateFresh` ∕ `claimSlot` ∕ `_releaseStats` ∕
+ * `releaseClaimsAll` ∕ `activeSlot`）外提 `./session-slot-claims.mjs`（verbatim——台账 #484
+ * 顺延项落形）；本档保留摘要 / 清单读写 / 属主健康面，并 re-export 该档导出保既有 import 面
+ * （消费档路径与名面不动）。新增静态环：本档 ↔ `session-slot-claims.mjs`（`loadManifest` ∕
+ * `saveManifest` ↔ 认领面族——环安全同下）。
  *
  * 静态环（与既有的 session.mjs ↔ session-slots.mjs 同形）：本档引 `session-slots.mjs` 的
  * 存储原语（`getSessionId` / `manifestPath` / `slotPath` / `writeSessionFile`），
@@ -18,14 +29,14 @@
  * 属主三态（`ownerState`）判据单源 = `process-probe.mjs`。`unknown`（探测失败 / 缺行）⇒
  * 不认领 / 不判死 / 不删（方向不对称见 process-probe.mjs 头注 · D-MI10）。
  */
-
-import { existsSync, readFileSync, renameSync } from "node:fs"
+import { existsSync, readFileSync, renameSync, statSync } from "node:fs"
 // 「真实用户消息」谓词单源（`history-window.mjs`——人读线窗口与槽摘要同判据）。
 import { isRealUserMsg } from "./history-window.mjs"
-// 探测束（判活）+ 属主三态判据 / 死主判定（本档零自有 exec——判据面与探测面分离）。
-import { probeOwnersSync, ownerState, filterDeadOwners } from "./process-probe.mjs"
 // 存储原语（路径 / 原子写 / 进程 sessionId）——静态环见头注。
 import { getSessionId, manifestPath, slotPath, writeSessionFile } from "./session-slots.mjs"
+// 认领面（2026-09-28 拆分外提——见头注）：本档 import `staleClaims` 供 dropStaleClaims 取用，
+// 并在下方 re-export 全族保既有 import 面。
+import { staleClaims } from "./session-slot-claims.mjs"
 
 /** Extract slot metadata from history (shared by slotDigest and loadSlotMeta) */
 export function extractSlotMeta(history, activeProvider, updatedAt, title = "") {
@@ -42,11 +53,49 @@ export function extractSlotMeta(history, activeProvider, updatedAt, title = "")
 }
 
 /** Extract preview summary from session data for manifest storage (with current timestamp)
- *  MODEL-MERGE-SESSION：摘要升级带 activeModel——listSlots 合成显 "p:m"（双端同规则）。 */
-export function slotDigest(data) {
+ *  MODEL-MERGE-SESSION：摘要升级带 activeModel——listSlots 合成显 "p:m"（双端同规则）。
+ *  SLOT-END-PARAM 批（SESSION.md §6.20 判据句 4 读面）：创建端**有值才带**（老槽无键 ⇒
+ *  键缺席 = 未知——禁回填、禁以占用端冒充）。
+ *  #503：`ts` 经打点单源 `digestTs(mtimeMs)`——`mtimeMs`（可选）= 该档保存面**写后**取的 mtime
+ *  （地板）；缺省 / 不可得 ⇒ 裸墙钟回溯（旧调用点零改）。 */
+export function slotDigest(data, mtimeMs) {
   const meta = extractSlotMeta(data.history ?? [], data.activeProvider, data.updatedAt, data.title ?? "")
   if (data.activeModel) meta.activeModel = data.activeModel
-  return { ts: Date.now(), ...meta }
+  if (data.createdBy) meta.createdBy = data.createdBy
+  return { ts: digestTs(mtimeMs), ...meta }
+}
+
+const isNum = (v) => typeof v === "number" && Number.isFinite(v)
+
+/** 摘要 `ts` 打点（**单源** · #503 地板）：`max(墙钟, mtimeMs)`；`mtimeMs` 不可得（缺省 / 非数）⇒
+ *  裸墙钟回溯。沿先例 `session-slot-verify.mjs:99`（回写面地板）：**平台文件时间戳可领先
+ *  `Date.now()` 数 ms**——无地板则保存面刚写的摘要会被 `needsVerify`（`ts < mtime`）判「陈旧」
+ *  一次（有界自纠，非数据面）；地板后 `ts ≥ mtime` 恒成立（同一 stat 值即比较对象）。 */
+export function digestTs(mtimeMs) {
+  return isNum(mtimeMs) ? Math.max(Date.now(), mtimeMs) : Date.now()
+}
+
+/** 摘要补写谓词（§6.25 判据句 3 · **单源**）：缺失 ∨ 陈旧（`ts < mtime`）⇒ 补写；新鲜 ⇒ 不写（幂等）。 */
+export function healNeeded(entry, mtime) {
+  if (!entry || typeof entry !== "object") return true
+  if (!isNum(entry.ts)) return true
+  return isNum(mtime) ? entry.ts < mtime : false
+}
+
+/** 落点 A 顺手补写（§6.25 判据句 3 · 打开 / 切槽）：数据**已在手** ⇒ 置入调用方 manifest 对象，随其
+ *  既有那次 `saveManifest` 落盘（**零额外槽文件读 + 零额外写**）；`mtime` 不可得 ⇒ 不妄断陈旧。
+ *  `ts` 携同一 `mtime` 地板（#503——否则 mtime 领先墙钟时刚补写的条目又判陈旧）。 */
+export function healDigest(m, slot, data, mtime) {
+  if (!data || typeof data !== "object") return false
+  if (!healNeeded(m.slots?.[slot], mtime)) return false
+  m.slots ??= {}
+  m.slots[slot] = slotDigest(data, mtime)
+  return true
+}
+
+/** 槽文件 mtime（`healDigest` 新鲜度判据入参——读失败 ⇒ `null` = 不可得）。 */
+export function slotMtime(cwd, slot) {
+  try { return statSync(slotPath(cwd, slot)).mtimeMs } catch { return null }
 }
 
 export function loadManifest(cwd) {
@@ -60,6 +109,62 @@ export function loadManifest(cwd) {
   } catch { return { slots: {}, sessionId: null } }
 }
 
+/** 可信合并基座判据（§6.23 判据句 1 · ②）：顶层非 null 非数组对象 ∧（`slots` / `slotSessions`
+ *  缺席或为对象）。**假值（null / `0` / `""` / `false`）按缺席归一**——判据线单源 = `loadManifest`
+ *  的 `!m.slots → {}`（同向：空基座可合并、不拒写；展开后自然落 `{}`）；真值非对象（`42` / `"x"`）
+ *  与数组 ⇒ 不可信。形态非法 ⇒ 不写盘（判据句 2(c)）。 */
+function isTrustedBase(fresh) {
+  if (!fresh || typeof fresh !== "object" || Array.isArray(fresh)) return false
+  const mapField = (v) => !v || (typeof v === "object" && !Array.isArray(v))
+  return mapField(fresh.slots) && mapField(fresh.slotSessions)
+}
+
+/** (b)(c) 现场保全：原字节改名 `{manifest 路径}.corrupted`（与槽文件面同形）——同名已存在 ⇒
+ *  覆盖（单槽位 · last-wins）；改名失败被吞、**不阻断拒写**（§6.23 判据句 2）。返回值为**改名目标
+ *  路径**（拒写 loud 行的 `preserved=` 即取此）——非存在性保证：改名失败面 = `.corrupted` 缺席自证。 */
+function preserveScene(p) {
+  const dst = `${p}.corrupted`
+  try { renameSync(p, dst) } catch {}
+  return dst
+}
+
+/** 账本健康计数（§6.25 判据句 4——**本进程累计**）：拒写（§6.23）+ 写后读回失败次数与最近一条。 */
+const ledgerRefusals = { refused: 0, lastReason: null, lastPath: null, lastAt: null }
+const noteRefusal = (reason, p) => Object.assign(ledgerRefusals, { refused: ledgerRefusals.refused + 1, lastReason: reason, lastPath: p, lastAt: Date.now() })
+
+/** 账本健康出口（§6.25 判据句 4 · **判据单源**）：`refused` = 本进程累计（§6.23 拒写 + 判据句 5 读回
+ *  失败）+ `lastReason` ∈ 四类（read-failed / parse-failed / shape-invalid / readback-failed）；`scene` =
+ *  该 cwd 的 `{manifest}.corrupted` 在盘（损坏现场——随 30 天 GC / 手工清除而止）。 */
+export function ledgerHealth(cwd) {
+  let scene = false
+  try { scene = existsSync(`${manifestPath(cwd)}.corrupted`) } catch { /* cwd 不可解析 ⇒ 无现场 */ }
+  return { ...ledgerRefusals, scene }
+}
+
+/** 拒写（§6.23 判据句 2/3）：不调 `writeSessionFile`（本次调用对盘面零字节写），stderr 一行 loud，返回 `false`。 */
+function refuseManifestWrite(p, reason, preserved = null) {
+  noteRefusal(reason, p)
+  console.error(`[session] saveManifest: write refused (reason=${reason}) path=${p}${preserved ? ` preserved=${preserved}` : ""}`)
+  return false
+}
+
+/** 写后钩子缝（§6.25 判据句 5：写后 / 读回前注入；生产零消费）：`fn({ path, tmp })`。 */
+let manifestWriteHook = null
+export function _setManifestWriteHookForTest(fn) { manifestWriteHook = fn }
+
+/** 账本面写（两路共用 · D-SE65）：独占临时名 + **写后结构读回**（判据单源 = `isTrustedBase`）；不过 ⇒
+ *  loud 一行 + 现场改名 `.corrupted`（解封下一写）+ `false`。**非逐字节相等**（并发合法后写会假红——明裁）。 */
+function writeManifestBase(p, m) {
+  const tmp = writeSessionFile(p, m, { tmpUnique: true })
+  manifestWriteHook?.({ path: p, tmp })
+  let trusted = false
+  try { trusted = isTrustedBase(JSON.parse(readFileSync(p, "utf8"))) } catch { trusted = false }
+  if (trusted) return true
+  noteRefusal("readback-failed", p)
+  console.error(`[session] saveManifest: readback-failed path=${p} preserved=${preserveScene(p)}`)
+  return false
+}
+
 export function saveManifest(cwd, m, deletions = null, opts = {}) {
   // 2026-08-31 会诊 kimi/deepseek 🟡：写前重读并按"条目级"合并——原实现把"读时快照"
   // 整对象写回，另一进程在窗口内对 slots/slotSessions/active 的变更被覆盖抹除（被抹
@@ -74,49 +179,52 @@ export function saveManifest(cwd, m, deletions = null, opts = {}) {
   // （落点槽 ∪ 本进程其余活绑定槽；被占落点 ⇒ 空集）。③ 内存认领表先移除残留条目（否则下方
   // 条目级合并会把它从内存复活回写）——先于 try（fresh 不可读时亦须生效）。
   if (opts.release) dropStaleClaims(m, opts.release)
+  // MANIFEST-WRITE-GUARD 批（2026-09-28 · SESSION.md §6.23 判据句 1–3 / D-SE59）：写前分类——只有
+  // 「① 合法创建（ENOENT）」与「② 可信合并基座」两路通向 writeSessionFile；文件在盘而基座不可信
+  // （读失败 / 解析失败 / 形态非法）⇒ **拒绝写**（不整档替换——#476 实证：读不可信窗口内一次保存把
+  // manifest 永久缩水且零告警）。拒写 = stderr 一行 + 返回 false（唯一消费点 = releaseClaimsAll 透传；
+  // 其余调用点忽略返回值——零行为变化）；拒写不回滚调用方内存态（认领等内存变更归调用方所有，
+  // 下一次保存重试——与 F-XR1 同向的失败容忍形态）。
+  const p = manifestPath(cwd)
+  let fresh
   try {
-    const fresh = JSON.parse(readFileSync(manifestPath(cwd), "utf8"))
-    if (fresh && typeof fresh === "object" && fresh.slots && typeof fresh.slots === "object") {
-      const merged = { ...fresh }
-      if (opts.setActive) merged.active = m.active
-      merged.slots = { ...fresh.slots, ...(m.slots ?? {}) }
-      merged.slotSessions = { ...(fresh.slotSessions ?? {}), ...(m.slotSessions ?? {}) }
-      if (m.sessionId) merged.sessionId = m.sessionId
-      // ① 释放集按**本次 fresh 快照**取值（不得以陈旧内存 manifest 构 deletions）；② **值条件删除**
-      // （仅当 fresh 属主仍为本进程——窗口内他人的新认领不在集内、不被误删）⇒ 并入本次 deletions。
-      if (opts.release) {
-        const released = staleClaims(fresh, opts.release)
-        if (released.length > 0) {
-          deletions = { ...(deletions ?? {}), slotSessions: [...(deletions?.slotSessions ?? []), ...released] }
-        }
-      }
-      if (deletions) {
-        for (const [section, keys] of Object.entries(deletions)) {
-          for (const k of keys) delete merged[section]?.[k]
-        }
-      }
-      m = merged
+    fresh = JSON.parse(readFileSync(p, "utf8"))
+  } catch (err) {
+    // ① 合法创建：路径不存在（首建）⇒ 以调用方对象建新档（现行为保留）
+    if (err?.code === "ENOENT") {
+      m.sessionId = getSessionId()
+      return writeManifestBase(p, m)
     }
-  } catch {
-    // 首次创建或 manifest 不可读：用传入对象。2026-09-01 advisor 🟡：解析失败时先改名
-    // 保留现场（与 loadSlotFile 对 slot 文件的 .corrupted 原则一致）——否则覆盖后全部
-    // 槽位元数据（digest/title/updatedAt）永久丢失，/session 列表变空。文件不存在时
-    // rename 抛错被吞，无害。
-    try { renameSync(manifestPath(cwd), `${manifestPath(cwd)}.corrupted`) } catch {}
+    // (a) 读失败（非 ENOENT：EISDIR / EPERM / EBUSY 等）⇒ 拒写 · 不改名（读不到 ≠ 损坏——现场
+    // 原样保留；该窗口正是 #476 缩水损伤的成因窗口）
+    if (!(err instanceof SyntaxError)) return refuseManifestWrite(p, "read-failed")
+    // (b) 解析失败 ⇒ 拒写 · 保底改名 .corrupted（现场保全 + 解封下一写——原路径不重建）
+    return refuseManifestWrite(p, "parse-failed", preserveScene(p))
   }
+  // (c) 形态非法（顶层非 null 非数组对象 / `slots` 非对象 / `slotSessions` 非对象）⇒ 同 (b)
+  if (!isTrustedBase(fresh)) return refuseManifestWrite(p, "shape-invalid", preserveScene(p))
+  // ② 可信合并基座：读-合并-写（条目级合并 / deletions / setActive / opts.release 四判据零改）
+  const merged = { ...fresh }
+  if (opts.setActive) merged.active = m.active
+  merged.slots = { ...fresh.slots, ...(m.slots ?? {}) }
+  merged.slotSessions = { ...(fresh.slotSessions ?? {}), ...(m.slotSessions ?? {}) }
+  if (m.sessionId) merged.sessionId = m.sessionId
+  // ① 释放集按**本次 fresh 快照**取值（不得以陈旧内存 manifest 构 deletions）；② **值条件删除**
+  // （仅当 fresh 属主仍为本进程——窗口内他人的新认领不在集内、不被误删）⇒ 并入本次 deletions。
+  if (opts.release) {
+    const released = staleClaims(fresh, opts.release)
+    if (released.length > 0) {
+      deletions = { ...(deletions ?? {}), slotSessions: [...(deletions?.slotSessions ?? []), ...released] }
+    }
+  }
+  if (deletions) {
+    for (const [section, keys] of Object.entries(deletions)) {
+      for (const k of keys) delete merged[section]?.[k]
+    }
+  }
+  m = merged
   m.sessionId = getSessionId()
-  writeSessionFile(manifestPath(cwd), m)
-}
-
-/** 本进程**残留认领集**（F-CR1 释放谓词 —— **判据单源** · SESSION.md §6.2 / §6.16）：
- *  「释放 A ⟺ `slotSessions[A]` 为本进程 ∧ `A ∉ 保留集`」。`keep` = 保留集 = 落点槽 ∪ 本进程
- *  其余活绑定槽（单绑定落点 ⇒ `{落点槽}`；被占落点 ⇒ 空集）。返回槽号（**字符串键**形态）。 */
-export function staleClaims(src, keep = []) {
-  const keepSet = new Set((keep ?? []).filter((s) => s != null).map(Number))
-  const mySessionId = getSessionId()
-  return Object.entries(src?.slotSessions ?? {})
-    .filter(([slot, owner]) => owner === mySessionId && !keepSet.has(Number(slot)))
-    .map(([slot]) => slot)
+  return writeManifestBase(p, m)
 }
 
 /** 从**内存**认领表移除本进程残留条目（判据③——与写盘同一时机；见 `saveManifest`）。 */
@@ -125,197 +233,11 @@ function dropStaleClaims(m, keep) {
   for (const slot of staleClaims(m, keep)) delete m.slotSessions[slot]
 }
 
-/** 属主串 → pid（`"pid-ts-rand"`——`owner.split("-")[0]` 格式判据单源：session-slots ↔
- *  session-lifecycle 共用，防两处漂移）。不可解析 ⇒ NaN——判据层按 dead 处理
- *  （见 process-probe `ownerState`）。 */
-export function ownerPid(owner) { return parseInt(owner.split("-")[0]) }
-
-/** manifest 属主 pid 全量清单（**非本进程**——束入参：一次探测覆盖所有待判 pid；
- *  空清单 ⇒ 探测面零 exec 早退）。`exclude` 缺省 = 本进程 sessionId。 */
-export function ownerPids(m, exclude = getSessionId()) {
-  const pids = []
-  for (const owner of Object.values(m.slotSessions ?? {})) {
-    if (!owner || owner === exclude) continue
-    const pid = ownerPid(owner)
-    if (pid) pids.push(pid)
-  }
-  return pids
-}
-
-/** 束 → 属主三态（判据单源 = process-probe `ownerState`；束缺失 / 探测失败 ⇒ "unknown"——
- *  保守保留，**不得**当全死）。 */
-export function ownerStateOf(owner, bundle) {
-  const pid = ownerPid(owner)
-  return ownerState(pid, { aliveSet: bundle?.aliveSet ?? null, cmds: bundle?.cmds ?? null })
-}
-
-/** 束 → `filterDeadOwners` 入参（清理面 API 保面——三态 `alive`：无束 / 失败 ⇒ undefined = 未知）。 */
-function ownerArgs(owner, bundle) {
-  const pid = ownerPid(owner)
-  const aliveSet = bundle?.aliveSet ?? null
-  return [pid, { alive: aliveSet ? aliveSet.has(pid) : undefined, cmdline: bundle?.cmds?.get?.(pid) }]
-}
-
-/** 死主条目清理（2026-08-31 会诊 F4 + 2026-09-01 会诊 deepseek/kimi 🔴 语义原样抽取——
- *  ensureActive/resumeSlot 共用）：删除 owner 进程已死的 slotSessions 条目。死主判定必须跑
- *  判据（不能以"文件缺失"短路——活进程在"认领 → 首次保存"窗口文件暂缺，误删会
- *  致双进程同槽），但**不自行探测**：判活 / 命令行来自调用面同一探测束（F-MI7——
- *  零逐 pid exec）。返回 deletions 计算函数（调用时按 m 当前状态过滤刚重新认领的槽——防删
- *  掉自己的新属主），无清理返回 null。删除须经 saveManifest 的 deletions 显式落盘——条目级
- *  合并会把磁盘死条目从 fresh 复活回写（N1 + 会诊 🔴）。
- *
- * 身份复核（批 1 · F-MI6 / D-MI11——判据单源 `filterDeadOwners`）：pid 活 + 命令行**明确
- *  可得且非本产品** ⇒ 同判可删（pid 复用即此场景）；探测失败 / 缺行 ⇒ 保守保留（D-MI10）。 */
-export function cleanDeadOwners(m, bundle) {
-  const mySessionId = getSessionId()
-  const entries = Object.entries(m.slotSessions).filter(([, o]) => o && o !== mySessionId)
-  const deadSlots = []
-  for (const [slot, owner] of entries) {
-    const [pid, args] = ownerArgs(owner, bundle)
-    if (filterDeadOwners(pid, args)) {
-      delete m.slotSessions[slot]
-      deadSlots.push(slot)
-    }
-  }
-  return deadSlots.length === 0 ? null : () => ({ slotSessions: deadSlots.filter((s) => m.slotSessions[s] !== mySessionId) })
-}
-
-/**
- * Claim a slot for this process and set it as active. Idempotent.
- * Preference order:
- *  1. The current active slot, if it is unowned / ours / its owner is dead — reuse it.
- *  2. Any slot that is unowned or owned by a dead process (reclaim).  → allocateFresh
- *  3. A brand-new slot when all are owned by live processes.          → allocateFresh
- * The owner is recorded in m.slotSessions so other processes (CLI ↔ VS Code) can
- * see which slots are taken and avoid them.
- *
- * F-MI7（同步例外收窄）：粘性早退（已拥有 active）**零探测**（无束、无 exec）；
- * 冷路径 = 一次有界同步束（`probeOwnersSync`）——清理 / 占用 / 空闲全部查表。
- */
-function ensureActive(cwd, m) {
-  const mySessionId = getSessionId()
-  if (!m.slotSessions) m.slotSessions = {}
-
-  // Already own the active slot — nothing to do. 粘性早退：**零探测**（死项清理交给
-  // 非粘性路径——resumeSlot 每次进程入口的异步束 / 冷路径同步束都会清并落盘）。
-  if (m.active && m.slotSessions[m.active] === mySessionId) return
-
-  // 冷路径：入口一次有界同步束（每 exec ≤ SYNC_PROBE_MS）覆盖全量属主 pid。
-  const bundle = probeOwnersSync(ownerPids(m))
-  const deadParam = cleanDeadOwners(m, bundle)
-
-  const isFree = (slot) => {
-    const owner = m.slotSessions[slot]
-    if (!owner || owner === mySessionId) return true
-    // 未知（探测失败 / 缺行）⇒ 不认为是空闲（不认领——D-MI10）
-    return ownerStateOf(owner, bundle) === "dead"
-  }
-
-  // 1. Prefer the current active slot if we can take it (preserves "resume where you left off").
-  if (m.active && m.slots[m.active] && isFree(m.active)) {
-    m.slotSessions[m.active] = mySessionId
-    saveManifest(cwd, m, deadParam?.() ?? null, { setActive: true })
-    return
-  }
-
-  // 2/3. 分支 2/3 已抽取为 allocateFresh（2026-09-05 §6.10 D-2——resumeSlot 全新分配复用）。
-  allocateFresh(cwd, m, deadParam, bundle)
-}
-
-/**
- * Allocate a slot with ensureActive 分支 2/3 语义（2026-09-05 §6.10 D-2 抽取——resumeSlot
- * 步骤③"其余一切 → 全新分配"复用；与 newSession 选号语义对齐）：
- *  2. Reclaim a manifest slot whose FILE does not exist (never held a session)；
- *  3. A brand-new slot when none is free / all numbers are taken.
- * 记录所有权 + active 指针（setActive）并落盘。返回分配的槽号。
- * F-MI7：占用 / 空闲判据全部查**调用面束**（`bundle`——零自有探测）；缺省 null ⇒
- * 全部属主按 unknown 论（只可能取全新号——保守，不认领陌生人）。
- */
-export function allocateFresh(cwd, m, deadParam = null, bundle = null) {
-  const mySessionId = getSessionId()
-  if (!m.slotSessions) m.slotSessions = {}
-  const isFree = (slot) => {
-    const owner = m.slotSessions[slot]
-    if (!owner || owner === mySessionId) return true
-    return ownerStateOf(owner, bundle) === "dead" // 未知 ⇒ 非空闲（不认领——D-MI10）
-  }
-
-  // 2. Reclaim a slot whose FILE does not exist (never held a session). 2026-08-31 会诊 F4：
-  //    原实现认领"编号最小的空闲 slot"——死主的旧 slot 文件仍在，新进程会 resume 进
-  //    陌生会话（"会话乱了"实锤）且退出时覆盖它。只有文件缺失的空 slot 才允许回收。
-  const allSlots = Object.keys(m.slots).filter((n) => /^\d+$/.test(n)).map(Number).sort((a, b) => a - b)
-  for (const slot of allSlots) {
-    if (isFree(slot) && !existsSync(slotPath(cwd, slot))) {
-      m.active = slot
-      m.slotSessions[slot] = mySessionId
-      saveManifest(cwd, m, deadParam?.() ?? null, { setActive: true })
-      return slot
-    }
-  }
-
-  // 3. All slots owned by live processes — allocate a new one (no limit).
-  // 2026-08-31 advisor round2 🟡：新号从 max+1 起逐号跳过"已被活进程认领但尚未落盘"
-  // 的号（认领→首次保存窗口：slotSessions 有条目、m.slots 无条目、文件不存在——
-  // 仅凭 m.slots/existsSync 查不到 → 双进程认领同一号 → 同槽双写/互旋）。
-  // 2026-09-01 会诊 kimi 🟡：同时跳过文件仍存在的号（与 newSession 对齐）——manifest
-  // 条目丢失/损坏时 max+1 会撞上孤儿槽文件 → F2 把真会话轮转成不可见的 .bak。
-  // 另：allSlots 已升序，取 max 用 allSlots[allSlots.length-1]（数万槽位时 Math.max
-  // spread 有 RangeError 风险）。
-  const liveClaimed = (n) => {
-    const owner = m.slotSessions?.[n]
-    if (!owner || owner === mySessionId) return false
-    return ownerStateOf(owner, bundle) !== "dead" // 活 / 未知 ⇒ 视为已占（跳号——保守）
-  }
-  let newSlot = allSlots.length > 0 ? allSlots[allSlots.length - 1] + 1 : 1
-  while (liveClaimed(newSlot) || existsSync(slotPath(cwd, newSlot))) newSlot++
-  m.active = newSlot
-  m.slotSessions[newSlot] = mySessionId
-  saveManifest(cwd, m, deadParam?.() ?? null, { setActive: true })
-  return newSlot
-}
-
-/** 认领指定槽为本进程所有并置为 active（2026-09-05 §6.10 D-2 resumeSlot 认领路径——调用方
- *  已按"属主 空/死/本进程"判据校验可用性；幂等）。manifest active 保留为共享指针（D-6：
- *  旧版端/ACP 恢复依据 + 无记录端一次性继承源 + 列表回退高亮——不再作本端恢复第一依据）。
- *  deadParam 在写入所有权之后求值（防 deletions 删掉本调用刚认领的槽——ensureActive
- *  deadParam 同型过滤）。
- *  F-CR1（2026-09-21 · SESSION-CLAIM 批）：认领落点释放本进程残留认领（保留集 = {认领槽}——
- *  §6.2 公式代入）；本函数 = 启动恢复 / 本端恢复落点（核 `resumeSlot` 与 VSC 端壳
- *  `resumeSlot` 共用），落盘判据（fresh 快照 / 值条件删除 / 内存移除）见 `saveManifest`。 */
-export function claimSlot(cwd, slot, m = loadManifest(cwd), deadParam = null) {
-  m.slotSessions ??= {}
-  m.slotSessions[slot] = getSessionId()
-  m.active = slot // 认领即翻共享指针（setActive 写 m.active——不更新则落快照旧值）
-  saveManifest(cwd, m, deadParam?.() ?? null, { setActive: true, release: [slot] })
-}
-
-/** 观测计数（测试缝——`_storeStats` / `_staleHooks` 同惯例）：`releaseClaimsAll` 调用计数。
- *  端壳「工作区转空 ⇒ 旧 cwd 释放恰一次」类断言以此为桩计数（生产零消费）。 */
-export const _releaseStats = { calls: 0 }
-
-/** 退出全释放（EXIT-CLAIM-RELEASE 批 · F-XR1 · SESSION.md §6.18 D-SE41）：优雅退出前释放
- *  本进程**全部**槽认领（保留集空——`staleClaims` 释放谓词单源）；落盘判据 = `saveManifest`
- *  `opts.release` 三条自动继承（fresh 同次快照取释放集 / 值条件删除——他人窗口内新认领不误删 /
- *  内存认领表同步移除）。**零触碰 marker 面**（F-XR2 路标保留——下次启动经 `usableSlot`
- *  无属主短路零探测直达恢复）；崩溃路径不经此（信号无 JS 钩子——F-XR3）。
- *  早退面：磁盘无 manifest ⇒ `existsSync` 单条目早退**零写**（不造盘面）；本进程无认领 ⇒
- *  零写返回 false。失败容忍（F-XR1「退出恒达」）：整体 try/catch **永不抛出**，返回 boolean
- *  （true = 有释放且落盘成功；false = 早退 / 失败——断言面）；写失败盘面 = 认领残留 →
- *  恢复走既有探测面（现状形态，数据零险）。 */
-export function releaseClaimsAll(cwd) {
-  _releaseStats.calls += 1
-  try {
-    if (!existsSync(manifestPath(cwd))) return false // 无 manifest ⇒ 零写（不造盘面）
-    const m = loadManifest(cwd)
-    if (staleClaims(m, []).length === 0) return false // 无本进程认领 ⇒ 零写（免白刷共享 sessionId）
-    saveManifest(cwd, m, null, { release: [] }) // 保留集空 = 全释放；不 setActive（active 共享指针不动）
-    return true
-  } catch { return false } // F-XR1：退出恒达（写失败 = 认领残留 → 恢复走探测面）
-}
-
-/** Return the active slot number for this process, claiming one if necessary */
-export function activeSlot(cwd) {
-  const m = loadManifest(cwd)
-  ensureActive(cwd, m)
-  return m.active
-}
+// ========== 认领面（2026-09-28 拆分外提至 ./session-slot-claims.mjs——见头注）==========
+// 认领面族（staleClaims / ownerPid / ownerPids / ownerStateOf / cleanDeadOwners / ensureActive /
+// allocateFresh / claimSlot / _releaseStats / releaseClaimsAll / activeSlot）语义原样迁至
+// `session-slot-claims.mjs`；本档上方 import 取用（dropStaleClaims）、re-export 保既有 import 面。
+export {
+  staleClaims, ownerPid, ownerPids, ownerStateOf, cleanDeadOwners,
+  allocateFresh, claimSlot, _releaseStats, releaseClaimsAll, activeSlot,
+} from "./session-slot-claims.mjs"