@thincoder/core 0.9.1

package/session-rename.mjs

@@ -0,0 +1,38 @@
+/**
+ * session-rename.mjs — 槽位重命名（标题写路径）。2026-09-06 自 session-slots.mjs 拆出：
+ * §6.12 标题写契约（boolean → { ok, reason }）使 session-slots.mjs 超 500 行硬限
+ *（§6.12 模块与实现约束——超 500 行硬限即拆文件，renameSlot 一并拆出）。
+ * 原语（slotPath/manifest 读写）自 session-slots.mjs import；session.mjs re-export
+ * renameSlot 保持既有调用点（cmd-session.mjs / 测试经 session.mjs）不变。
+ */
+
+import { readFileSync, existsSync, statSync } from "node:fs"
+import { slotPath, loadManifest, saveManifest, slotDigest, writeSessionFile } from "./session-slots.mjs"
+
+/** Rename a slot: update the slot file's title + the manifest metadata (shared with VS Code).
+ *  2026-09-01 会诊 glm 🟡：写回前按 mtime 门控重读——原实现读全量→改 title→整文件写回，
+ *  窗口内并发方的最新保存会被旧数据覆盖（丢消息）；mtime 变了即放弃本次重命名。
+ *  2026-09-06 §6.12 标题写契约：契约 boolean → { ok, reason? }（file-missing/parse-failure/mtime-conflict/invalid-slot，F3 失败可见）；_stat = mtime-conflict 测试缝（默认 statSync）。 */
+export function renameSlot(cwd, slot, title, _stat = statSync) {
+  const n = Number(slot)
+  if (!Number.isInteger(n) || n < 1) return { ok: false, reason: "invalid-slot" }
+  const p = slotPath(cwd, n)
+  if (!existsSync(p)) return { ok: false, reason: "file-missing" }
+  let data
+  try {
+    data = JSON.parse(readFileSync(p, "utf8"))
+  } catch {
+    return { ok: false, reason: "parse-failure" }
+  }
+  const t0 = _stat(p).mtimeMs
+  data.title = title
+  // 读与写之间文件被并发方改过 → 放弃（保留并发内容，重命名下次重试）
+  if (_stat(p).mtimeMs !== t0) return { ok: false, reason: "mtime-conflict" }
+  writeSessionFile(p, data)
+  const m = loadManifest(cwd)
+  if (m.slots[n]) {
+    m.slots[n] = slotDigest(data)
+    saveManifest(cwd, m)
+  }
+  return { ok: true }
+}

package/session-segments.mjs

@@ -0,0 +1,99 @@
+/**
+ * session-segments.mjs — 记录存储的段文件原语 + 人读线条目形态（TUI-OOM-ROOTCAUSE 批）。
+ *
+ * 机制契约全文 = docs/core/design/SESSION.md §6.14（D2 单一权威源）；本文件 = 「段 IO + 条目
+ * 形态」叶子层（`session-store.mjs` 拆分产物——503+ 行越 500 硬限，§6.14 表列模块按职责
+ * 拆分；store 继续 re-export 全部公开名，调用面零改）。零项目内依赖（仅 `node:`）。
+ */
+
+import { readdirSync, readFileSync } from "node:fs"
+
+/** 常量单源（§6.14）：每段消息数 / sidecar 目录后缀。 */
+export const RECORD_SEG_MESSAGES = 100
+export const RECORD_DIR_SUFFIX = ".d"
+
+/** 观测计数（测试缝——AC-RS9「恢复只读末段」以段读次数断言）。 */
+export const _storeStats = { segmentReads: 0, segmentWrites: 0, appendedEntries: 0, catchUpRetries: 0 }
+
+const LEGACY_TRANSIENT_PREFIXES = [
+  "[System reminder: working directory snapshot:",
+  "[Relevant memories from previous sessions",
+]
+
+/** legacy transient 判定（旧进程写进人读线的机器注入——落盘/展示均跳过）。 */
+export function isLegacyTransient(m) {
+  return (
+    m?.role === "user" &&
+    typeof m.content === "string" &&
+    LEGACY_TRANSIENT_PREFIXES.some((p) => m.content.startsWith(p))
+  )
+}
+
+/** Slim the HUMAN line for storage（自 session.mjs 迁出——§6.14）：机器线（contextHistory）
+ *  逐字节保持。Copy-on-write ONLY（两线经 pushReal 共享对象引用）：tool args → 300 字符头
+ *  截断 / tool content → 500 / 多模态 user → 保留 text、丢 image_url。 */
+export function slimForDisplay(m) {
+  if (m && Array.isArray(m.content)) {
+    const textParts = m.content.filter((p) => p?.type !== "image_url")
+    if (textParts.length === m.content.length) return m
+    return { ...m, content: textParts }
+  }
+  if (m && m.role === "assistant" && Array.isArray(m.tool_calls)) {
+    let changed = false
+    const tool_calls = m.tool_calls.map((tc) => {
+      const args = tc.function?.arguments
+      if (typeof args === "string" && args.length > 300) {
+        changed = true
+        return { ...tc, function: { ...tc.function, arguments: args.slice(0, 300) + "…" } }
+      }
+      return tc
+    })
+    return changed ? { ...m, tool_calls } : m
+  }
+  if (m && m.role === "tool" && typeof m.content === "string" && m.content.length > 500) {
+    return { ...m, content: m.content.slice(0, 500) + "\n… (truncated for storage)" }
+  }
+  return m
+}
+
+/** 记录条目过滤（与 saveSession 同源）：transient 机器注入与 legacy-transient 前缀不进记录。 */
+export function shouldAppend(m) {
+  return !!m && typeof m === "object" && !m.transient && !isLegacyTransient(m)
+}
+
+/** 真实 user 消息（turnCount/firstMessage 口径——同 session-slots.extractSlotMeta）。
+ *  单源 = `history-window.mjs`（本档只 re-export 保既有消费面：session-store 等）。 */
+export { isRealUserMsg } from "./history-window.mjs"
+
+/** sidecar 目录路径（`{slot 文件路径}.d`——同目录同前缀）。 */
+export function recordDirOf(slotFile) { return slotFile + RECORD_DIR_SUFFIX }
+
+/** 段文件名（六位零填充）。 */
+export function segName(n) { return `seg-${String(n).padStart(6, "0")}.jsonl` }
+
+/** 段号升序表（readdir——不读内容）。 */
+export function listSegments(dir) {
+  let names
+  try { names = readdirSync(dir) } catch { return [] }
+  const out = []
+  for (const n of names) {
+    const m = /^seg-(\d+)\.jsonl$/.exec(n)
+    if (m) out.push(Number(m[1]))
+  }
+  return out.sort((a, b) => a - b)
+}
+
+/** 读段（原始行——去尾空行）；读失败按空段容忍（读路径尽力面）。 */
+export function readSegmentLines(path) {
+  _storeStats.segmentReads++
+  let text
+  try { text = readFileSync(path, "utf8") } catch { return [] }
+  const lines = text.split("\n")
+  if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop()
+  return lines
+}
+
+/** 逐行容错解析：半行/损坏行 → undefined（调用方跳过——不抛、不自动修复）。 */
+export function tryParse(line) {
+  try { return JSON.parse(line) } catch { return undefined }
+}

package/session-slot-write.mjs

@@ -0,0 +1,168 @@
+/**
+ * session-slot-write.mjs — 会话槽「元数据开关」写面（Parnas 边界：开关写决策组——
+ * autoApprove / planMode / engineering / advisor guard，外加全新槽默认记录与落盘单点）。
+ *
+ * 归属：会话数据面（同上位 `session.mjs` / `session-slots.mjs` / `session-store.mjs`）。
+ * 本档 = **（cwd, slot）形态**的槽写入面（读-改-写）；另一形态 = `session.mjs` 的
+ * `saveSession(agent)` 全量面。两者共用同一批原语（`loadSlotFile` / `writeSessionFile` /
+ * `slotDigest`）与同一 F2 轮转判据（见下），差别只在入参来源。
+ *
+ * 轮转判据（与 `session-guard.mjs` 的 agent 面守卫**同判据集**）：磁盘槽文件
+ * version>2 / 异 cwd / 会话不符（sessionStart 不一致）→ 先轮转 `.bak` 保留现场再写；
+ * 解析失败（损坏 / 半写）→ 改名 `.corrupted` 保留。本面额外收**同会话并发追加**
+ * （磁盘 history 比本次待写长 = 窗口内有外部写入 ⇒ 对方现场先轮转 `.bak` 保下，
+ * **本快照随后落位**——不静默覆盖，但档位以本次快照为准，较新内容只在 `.bak` 里）。
+ * 检查按 mtime 缓存：
+ * 文件自上次检查/自写未变就跳过全量解析。
+ *
+ * token 台账字段（`engDesignTokens`）的**槽 I/O 面**不在本档——单源 = `token-ttl.mjs`
+ * （settle 落盘 / 门禁回读 / 链终清理三面齐备）；本档只承载其**保存面合并规则**
+ * （`mergeEngTokensForSave`——空态保留 + 并集 + 新铸者胜，纯函数）。槽标题写面同样不在
+ * 本档——单源 = `session-rename.mjs` 的 `renameSlot`（同 `{ok, reason}` 契约 + mtime 门控）。
+ */
+
+import { existsSync, readFileSync, renameSync, statSync } from "node:fs"
+
+import { getSessionId, loadManifest, saveManifest, slotDigest, slotPath, writeSessionFile } from "./session-slots.mjs"
+import { loadSlotFile } from "./session.mjs"
+// token 形态单源（格式校验 + 到期时刻）——本档的保存面合并规则复用同一判定。
+import { tokenExpiryMs } from "./token-ttl.mjs"
+
+/** mtime 缓存（键 = 槽文件路径 → 上次所见 mtimeMs）：同一槽连写时跳过重复解析。
+ *  测试复位缝（与 `_setSessionsDirForTest` 同款）：缓存为进程级单例，用例间需可复位
+ *  ——否则同一路径在同一 mtime tick 内被直接重写时，轮转判定会因「mtime 未变」早退。 */
+const slotMtimeCache = new Map()
+export function _resetSlotMtimeCacheForTest() { slotMtimeCache.clear() }
+
+/** Fresh slot data default：全新空槽的规范结构（`newSession` 写盘面同形）。 */
+export function newSlotData(cwd) {
+  return {
+    version: 2, cwd, title: "", updatedAt: Date.now(),
+    history: [], contextHistory: [], tasks: [],
+    planMode: false, goal: null, autoApprove: false, advisor: null,
+    pendingReminders: [], sessionStart: null,
+  }
+}
+
+/**
+ * 轮转判定（写前）：命中即把现场改名 `.bak-<ts>` 保留，返回该路径或 null。
+ * 判据四项——version>2（新版文件，非本版可写）/ 异 cwd（别的项目文件误落本路径）/
+ * sessionStart 不符（另一会话现场）/ 磁盘 history 更长（同会话并发追加——对方现场先轮转保下，
+ * 本快照随后落位）。
+ */
+function rotateIfForeign(p, slot, data) {
+  try {
+    if (!existsSync(p)) return null
+    const st = statSync(p)
+    if (st.mtimeMs === slotMtimeCache.get(p)) return null // 自上次检查/自写未变——磁盘态已知
+    const disk = JSON.parse(readFileSync(p, "utf8"))
+    slotMtimeCache.set(p, st.mtimeMs)
+    const diskIsNewer = typeof disk?.version === "number" && disk.version > 2
+    const diskForeign = typeof disk?.cwd === "string" && typeof data?.cwd === "string" &&
+      disk.cwd.toLowerCase() !== data.cwd.toLowerCase()
+    const diskStart = disk?.sessionStart ?? null
+    const myStart = data?.sessionStart ?? null
+    const diskLonger = Array.isArray(disk?.history) && Array.isArray(data?.history) &&
+      disk.history.length > data.history.length
+    if (!(diskIsNewer || diskForeign || (diskStart && diskStart !== myStart) || diskLonger)) return null
+    const bak = `${p}.bak-${Date.now()}`
+    renameSync(p, bak)
+    console.error(`[session] slot ${slot} holds ${diskIsNewer ? `a newer-version file (v${disk.version})` : diskForeign ? `a foreign-cwd file (${disk.cwd})` : diskLonger ? `a longer record (${disk.history.length} > ${data.history.length} messages — concurrent append)` : `another session (start ${diskStart}, ours ${myStart})`} — preserved as ${bak}`)
+    return bak
+  } catch (e) {
+    // 文件存在但不可读（损坏 / 半写）：改名保留现场，不覆盖
+    let preserved = false
+    if (existsSync(p)) {
+      try { renameSync(p, `${p}.corrupted`); preserved = true } catch {}
+    }
+    // 排障面：区分「现场不可读」与「轮转失败」——静默会让半写/占用现场无从定位。
+    console.error(`[session] slot ${slot}: pre-write rotation check failed (${e?.message ?? e}) —${preserved ? " preserved as .corrupted" : " the scene could NOT be preserved"}`)
+    return null
+  }
+}
+
+/**
+ * 槽落盘单点（读-改-写面共用）：轮转判定 → 写槽文件 → 回写 manifest 摘要。
+ * 返回轮转出的 `.bak` 路径或 null（调用方按需透出）。
+ */
+export function saveSlotData(cwd, slot, data) {
+  data.updatedAt = Date.now()
+  const p = slotPath(cwd, slot)
+  const rotated = rotateIfForeign(p, slot, data)
+  writeSessionFile(p, data)
+  slotMtimeCache.set(p, (() => { try { return statSync(p).mtimeMs } catch { return 0 } })())
+  try {
+    const m = loadManifest(cwd)
+    m.slots[slot] = slotDigest(data)
+    saveManifest(cwd, m)
+  } catch { /* 摘要失败非致命——数据已安全，元数据下次 listSlots 惰性恢复 */ }
+  return rotated
+}
+
+/**
+ * 读槽供开关写入。返回已解析槽数据；当槽**尚无数据文件**但本进程已认领该槽
+ * （认领先行、首保存落盘前）→ 返回全新默认记录。其余失败（version>2 / 异 cwd /
+ * 损坏 / 未知槽）返回 null——保持「未识别的槽 ⇒ 开关写返回 false」的契约。
+ */
+function loadSlotForWrite(cwd, slot) {
+  const data = loadSlotFile(cwd, slot)
+  if (data || !slot) return data
+  const m = loadManifest(cwd)
+  if (m.slotSessions?.[slot] !== getSessionId()) return null
+  if (existsSync(slotPath(cwd, slot))) return null // 文件已在但不可读 → 不覆盖
+  return newSlotData(cwd)
+}
+
+/** 开关写单点：读 → 改一枚开关 → 落盘；槽不可读 ⇒ false（写未发生）。 */
+function writeFlag(cwd, slot, mutate) {
+  const data = loadSlotForWrite(cwd, slot)
+  if (!data) return false
+  mutate(data)
+  saveSlotData(cwd, slot, data)
+  return true
+}
+
+/** 会话级 autoApprove 开关（槽字段，非配置文件）。槽不可读 ⇒ false。 */
+export function setSlotAutoApprove(cwd, slot, value) {
+  return writeFlag(cwd, slot, (d) => { d.autoApprove = value })
+}
+
+/** 会话级 planMode 开关（与 autoApprove 同层）。 */
+export function setSlotPlanMode(cwd, slot, value) {
+  return writeFlag(cwd, slot, (d) => { d.planMode = value })
+}
+
+/** 会话级 engineering 开关——槽是会话真值来源（配置文件只作初始默认 / 跨端镜像）。 */
+export function setSlotEngineering(cwd, slot, value) {
+  return writeFlag(cwd, slot, (d) => { d.engineering = value })
+}
+
+/** advisor 守卫开关（`advisor: { guard }`——空值升格为对象）。 */
+export function setSlotAdvisorGuard(cwd, slot, value) {
+  return writeFlag(cwd, slot, (d) => {
+    d.advisor = { ...(typeof d.advisor === "object" && d.advisor !== null ? d.advisor : {}), guard: value }
+  })
+}
+
+/**
+ * 保存面 token 台账合并规则（纯函数——槽 = 权威台账，保存时不得把内存快照的缺席
+ * 当成删除）：
+ *  - `incoming === undefined`（调用方未携带该字段）⇒ 保留槽值（空态不触发清理）；
+ *  - incoming 空值 ⇒ 槽有值则保留槽、槽也空 ⇒ null（写 null = 清字段）；
+ *  - 两端都有 ⇒ 并集：槽独有项保留（consume 已对称删盘，不复活）；同 key 以**新铸者胜**
+ *    （token 尾 `:expiresAt` 大者 = 后铸）；平手 / 无法解析 ⇒ 保留槽值（fail-safe）。
+ * 槽 I/O 面（读/写/清）在 `token-ttl.mjs`——本函数只产出「应写什么」。
+ */
+export function mergeEngTokensForSave(incoming, existing) {
+  if (incoming === undefined) return existing ?? null
+  const hasNew = incoming && typeof incoming === "object" && !Array.isArray(incoming) && Object.keys(incoming).length > 0
+  const slotHas = existing && typeof existing === "object" && !Array.isArray(existing) && Object.keys(existing).length > 0
+  if (!hasNew) return slotHas ? existing : null
+  if (!slotHas) return incoming
+  const expiry = (t) => tokenExpiryMs(t) ?? -Infinity
+  const out = { ...existing }
+  for (const [key, tok] of Object.entries(incoming)) {
+    if (!(key in out) || expiry(tok) > expiry(out[key])) out[key] = tok
+  }
+  return out
+}

package/session-slots-manifest.mjs

@@ -0,0 +1,264 @@
+/**
+ * session-slots-manifest.mjs — 清单 / 认领 / 属主面（init-block 批 · F-MI7 拆分：
+ * `session-slots.mjs` 探测束接线后实读 517 行，破 490 判定线并越 500 硬限 ⇒ 按
+ * `CORE-UNIFICATION.md` §2.8.1 表第 3 行随批执行外提；各函数语义**原样**迁移）：
+ * 摘要面（`extractSlotMeta` / `slotDigest`）· 清单读写（`loadManifest` / `saveManifest`）·
+ * 属主面（`ownerPid` / `ownerPids` / `ownerStateOf` / `ownerArgs` / `cleanDeadOwners`）·
+ * 认领面（`ensureActive` / `allocateFresh` / `claimSlot` / `activeSlot`）。
+ *
+ * 静态环（与既有的 session.mjs ↔ session-slots.mjs 同形）：本档引 `session-slots.mjs` 的
+ * 存储原语（`getSessionId` / `manifestPath` / `slotPath` / `writeSessionFile`），
+ * `session-slots.mjs` 反向 re-export 本档导出保持既有 import 面——函数声明在实例化期已
+ * 初始化、双方只在函数体内运行时使用（模块求值期零顶层调用 ⇒ 环安全；同 session-slots.mjs
+ * 头注）。存储契约（路径 / 原子写 / 属主串格式）单源仍在 `session-slots.mjs`，本档零副本。
+ *
+ * 探测纪律（init-block 批 · F-MI7 / SESSION.md §6.2）：本档**零自有 exec、零逐 pid 探测**——
+ * 只消费调用面传入的**探测束**（`bundle` = `probeOwnersSync` / `probeOwnersAsync` 输出）；
+ * 属主三态（`ownerState`）判据单源 = `process-probe.mjs`。`unknown`（探测失败 / 缺行）⇒
+ * 不认领 / 不判死 / 不删（方向不对称见 process-probe.mjs 头注 · D-MI10）。
+ */
+
+import { existsSync, readFileSync, renameSync } 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"
+
+/** Extract slot metadata from history (shared by slotDigest and loadSlotMeta) */
+export function extractSlotMeta(history, activeProvider, updatedAt, title = "") {
+  const userMsgs = history.filter(isRealUserMsg)
+  const first = userMsgs[0]?.content ?? ""
+  return {
+    messageCount: history.length,
+    turnCount: userMsgs.length,
+    firstMessage: first.slice(0, 80),
+    activeProvider: activeProvider ?? "",
+    updatedAt: updatedAt ?? Date.now(),
+    title,
+  }
+}
+
+/** Extract preview summary from session data for manifest storage (with current timestamp)
+ *  MODEL-MERGE-SESSION：摘要升级带 activeModel——listSlots 合成显 "p:m"（双端同规则）。 */
+export function slotDigest(data) {
+  const meta = extractSlotMeta(data.history ?? [], data.activeProvider, data.updatedAt, data.title ?? "")
+  if (data.activeModel) meta.activeModel = data.activeModel
+  return { ts: Date.now(), ...meta }
+}
+
+export function loadManifest(cwd) {
+  try {
+    const p = manifestPath(cwd)
+    if (!existsSync(p)) return { slots: {}, sessionId: null }
+    const m = JSON.parse(readFileSync(p, "utf8"))
+    if (!m.slots) m.slots = {} // 2026-09-01 会诊 deepseek 🔵：损坏的 {} manifest 不再让调用方抛 TypeError
+    if (!m.sessionId) m.sessionId = null
+    return m
+  } catch { return { slots: {}, sessionId: null } }
+}
+
+export function saveManifest(cwd, m, deletions = null, opts = {}) {
+  // 2026-08-31 会诊 kimi/deepseek 🟡：写前重读并按"条目级"合并——原实现把"读时快照"
+  // 整对象写回，另一进程在窗口内对 slots/slotSessions/active 的变更被覆盖抹除（被抹
+  // 认领的槽变"文件在、无属主"→ 第三方可认领 → 双属主 → F2 互旋）。无锁文件无法
+  // 完全原子，重读合并把丢失更新窗口缩到最小；删除意图经 deletions 参数显式表达
+  // （deleteSlot：{ slots: [n], slotSessions: [n] }）。
+  // 2026-09-01 会诊 deepseek/kimi/glm 🟡：active 是单值——只有显式翻指针的调用方
+  // （ensureActive 分支、newSession、switchToSlot、deleteSlot 删到 active 时）传
+  // opts.setActive；其余调用方（saveSession/ACP 认领/死项清理）默认保留磁盘 fresh 的
+  // active，否则毫秒窗口内会把并发方刚翻的 active 回滚（F1 防漂移的反向变体）。
+  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
+      if (deletions) {
+        for (const [section, keys] of Object.entries(deletions)) {
+          for (const k of keys) delete merged[section]?.[k]
+        }
+      }
+      m = merged
+    }
+  } catch {
+    // 首次创建或 manifest 不可读：用传入对象。2026-09-01 advisor 🟡：解析失败时先改名
+    // 保留现场（与 loadSlotFile 对 slot 文件的 .corrupted 原则一致）——否则覆盖后全部
+    // 槽位元数据（digest/title/updatedAt）永久丢失，/session 列表变空。文件不存在时
+    // rename 抛错被吞，无害。
+    try { renameSync(manifestPath(cwd), `${manifestPath(cwd)}.corrupted`) } catch {}
+  }
+  m.sessionId = getSessionId()
+  writeSessionFile(manifestPath(cwd), m)
+}
+
+/** 属主串 → 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 同型过滤）。 */
+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 })
+}
+
+/** 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
+}