@thincoder/core 0.9.5 → 0.10.2

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
@@ -18,26 +19,41 @@
 
 import { existsSync } from "node:fs"
 import { resolveCompactThreshold } from "./config.mjs"
+// 槽面判据单源（#841 KD-841-2：槽渠道 key 门 + 模型面序——PROVIDER.md §6.22）。
+import { resolveProviderPlan } from "./model-ref.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 +77,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 +142,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）
@@ -140,29 +160,57 @@ export function applySession(agent, data, opts = {}) {
   } else {
     unbindRecordStore(agent)
   }
-  // ── MODEL-MERGE-SESSION 恢复（F-4——两支）──
-  const slotProvider = data.activeProvider ? agent.providers?.find((pr) => pr.name === data.activeProvider) : null
-  if (slotProvider) {
-    // ① 槽 provider 存在 → 按槽值设（不看 config）：双字段恒非空——legacy 槽 activeModel
-    //    null/空串 = 无 override——回该渠道默认模型（`providers[].model` 单值——M3）。
-    //    F-2d（MODEL-400-FIX）：`||` 非 `??`——空串也兜（activeModel="" 的槽会让 `??` 不落链 →
-    //    空槽 model 恒有值，provider.model 键不缺失）
+  // ── MODEL-MERGE-SESSION 恢复（F-4——两支；#841：槽面判据单源 = 统一解析第 1 步）──
+  // 槽渠道（`activeProvider` 在册 ∧ 持 key）⇒ 槽值设；槽无 key ∥ 不在册 ⇒ 跳过（落 config 链——
+  // 不把不可运行渠道钉进运行态；**跳过不写槽**——原槽值保留（D-S3 / KD-841-2））。判定 + 模型面
+  // 同源 = `resolveProviderPlan`（PROVIDER.md §6.22——零第二判据）。
+  const slotPlan = resolveProviderPlan({
+    providers: agent.providers,
+    defaultModel: agent.config?.defaultModel,
+    slot: { provider: data.activeProvider ?? null, model: data.activeModel ?? null },
+  })
+  if (slotPlan.source === "slot") {
+    const slotProvider = agent.providers?.find((pr) => pr.name === slotPlan.channel)
+    // ① 槽 provider 存在 → 按槽值设（不看 config）：双字段恒非空。
+    //    模型面序（#841）：槽模型 → `defaultModel` 属本渠道 ⇒ 其模型段 → 渠道默认单值
+    //    （`providers[].model`）；三档皆无 ⇒ `null`（不落 model 键——下游沿既有「model 缺失」处置）。
+    //    F-2d（MODEL-400-FIX）径保留：空串 / 非串槽模型同样兜（#638 非串 = 未登记）——slotPlan.model
+    //    已按同归一出值（单源，无第二判据）。
     const prevName = agent.activeProvider
     const prevModel = agent.activeModel ?? null
-    const slotModel = data.activeModel || slotProvider.model
+    const slotModel = slotPlan.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 有效则静默用
-  //    config/defaultModel 运行时；两方都无效由调用侧复验 validateProvider 弹重选）
+  // ② 槽无 key ∥ 不在册 → D-S3 保留——静默保持现状（落 config 链：config 统一解析产物已是
+  //    `agent.provider`；不报错不纠正——两方都无效由调用侧复验 validateProvider 弹重选）
   return false
 }
 
@@ -211,10 +259,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 +313,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 +331,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 +351,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 +374,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 }

package/session-slot-claims.mjs

@@ -0,0 +1,230 @@
+/**
+ * session-slot-claims.mjs — 认领面族（2026-09-28 拆分批 · R3——自 `session-slots-manifest.mjs`
+ * （421 > 300）外提认领面：`staleClaims` ∕ owner 三件（`ownerPid` / `ownerPids` /
+ * `ownerStateOf`）∕ `cleanDeadOwners` ∕ `ensureActive` ∕ `allocateFresh` ∕ `claimSlot` ∕
+ * `_releaseStats` ∕ `releaseClaimsAll` ∕ `activeSlot`；**逐字迁移**、零行为改——台账 #484
+ * 「认领面族拆分」顺延项落形）。
+ * 原档（`session-slots-manifest.mjs`）保留摘要 / 清单读写 / 属主健康面，并 re-export 本档
+ * 导出保既有 import 面（消费档路径与名面不动）。
+ *
+ * 静态环（与既有的 session.mjs ↔ session-slots.mjs 同形）：本档引 `session-slots.mjs` 的存储
+ * 原语（`getSessionId` / `manifestPath` / `slotPath`）与 `session-slots-manifest.mjs` 的清单
+ * 读写（`loadManifest` / `saveManifest`），后者反向 re-export 本档导出——函数声明在实例化期
+ * 已初始化、双方只在函数体内运行时使用（模块求值期零顶层调用 ⇒ 环安全）。
+ * 探测纪律（init-block 批 · F-MI7 / SESSION.md §6.2）：本档**零自有 exec、零逐 pid 探测**——
+ * 只消费调用面传入的**探测束**（`bundle`）；属主三态判据单源 = `process-probe.mjs`，
+ * `unknown`（探测失败 / 缺行）⇒ 不认领 / 不判死 / 不删（D-MI10）。
+ */
+import { existsSync } from "node:fs"
+// 探测束（判活）+ 属主三态判据 / 死主判定（本档零自有 exec——判据面与探测面分离）。
+import { probeOwnersSync, ownerState, filterDeadOwners } from "./process-probe.mjs"
+// 存储原语（路径 / 原子写 / 进程 sessionId）——静态环见头注。
+import { getSessionId, manifestPath, slotPath } from "./session-slots.mjs"
+// 清单读写（落盘单源住原档——静态环见头注；反向 re-export 保 import 面）。
+import { loadManifest, saveManifest } from "./session-slots-manifest.mjs"
+
+/** 本进程**残留认领集**（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)
+}
+
+/** 属主串 → 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 = 早退 / 失败 / **写面拒写**——`saveManifest` 返回值透传，
+ *  §6.23 判据句 3——断言面）；写失败盘面 = 认领残留 →
+ *  恢复走既有探测面（现状形态，数据零险）。 */
+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）
+    return saveManifest(cwd, m, null, { release: [] }) !== false // 保留集空 = 全释放；不 setActive；返回值透传（§6.23 判据句 3——拒写 ⇒ false）
+  } 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
+}