@thincoder/core 0.9.1

package/session-gc.mjs

@@ -0,0 +1,248 @@
+/**
+ * session-gc.mjs — 会话目录残留 GC + 冷 cwd 报告/删除（SESSION.md §6.12，2026-09-06）。
+ *
+ * F1 残留 GC（自动）：进程启动时对当前 cwd hash 前缀做一次轻量清理——.corrupted /
+ * .unreadable / .manifest.corrupted / .bak-* 保留 30 天，孤儿 .tmp 保留 7 天
+ *（mtime < now − retention 才删，等于保留期保留——older-than 边界语义）。
+ * 安全（N1）：活跃槽（主文件在 + manifest slotSessions[N] 属主活）的现场一律保留；
+ * manifest 主文件 / end marker / 数据主文件永不进入候选（后缀预过滤只匹配残留后缀）。
+ *
+ * F2 冷 cwd（手动——12.2.4 三步，v1 不自动删 manifest）：
+ *   判定：manifest mtime 距今 > 90 天 且 无任何活跃数据文件（.json.N 不存在或全部属死主）；
+ *   报告：thincoder session gc --dry-run（跨 cwd 枚举，不删除）；
+ *   删除：thincoder session gc --confirm <hash|--all>（整前缀清空——manifest+marker+
+ *         .json.N 死主数据+裸 v1 {hash}.json（§6.12 D-V1）+残留；删除前重校验冷态——
+ *         TOCTOU 防护 T12）。
+ *
+ * 拆分理由（§6.12 review #1）：session-slots.mjs 已在 500 行硬限零余量，GC 是独立决策
+ * （"何时清何种残留"），独立成模块；原语（sessionPath / ownerPid）自 session-slots
+ * import，启动钩子（session.mjs resumeSlot 包装）只一行调用。
+ *
+ * F-MI7（2026-09-18）：判活 = **核探测束**（`process-probe.mjs` `probeOwnersAsync`）+ `ownerState`
+ * 三态查表——本档**零逐 pid 探测**；**未知 ⇒ 保留 / 不判冷**（D-MI10 同向）；入口面异步（启动钩子
+ * 延后执行，不阻塞启动路径）。死主数据文件 / 活跃槽判定与认领面同源判据。
+ */
+
+import { readdirSync, readFileSync, statSync, unlinkSync, existsSync, rmSync } from "node:fs"
+import { join, dirname, basename } from "node:path"
+import { configDir } from "./config.mjs"
+import { sessionPath, ownerPid } from "./session-slots.mjs"
+import { probeOwnersAsync, ownerState } from "./process-probe.mjs"
+
+/** 保留期（§6.12）：损坏现场（.corrupted/.unreadable/.manifest.corrupted）与并发轮转
+ *  备份（.bak-*）30 天；孤儿 .tmp 7 天（崩溃现场恢复窗口）。 */
+export const RESIDUE_RETENTION_MS = 30 * 24 * 3600 * 1000
+export const ORPHAN_TMP_RETENTION_MS = 7 * 24 * 3600 * 1000
+/** 冷 cwd 阈值（§6.12）：manifest mtime 距今 > 90 天（保守——正常开发会频繁触碰）。 */
+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）。 */
+function classifyResidue(name, prefix) {
+  if (!name.startsWith(prefix + ".")) return null
+  const slotMatch = name.slice(prefix.length).match(/^\.(\d+)\./)
+  const slot = slotMatch ? Number(slotMatch[1]) : null
+  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 }
+  return null
+}
+
+/** 活跃槽集合（§6.12 T3/T12 操作定义）：.json.N 主文件存在 且 manifest slotSessions[N]
+ *  属主进程存活。manifest 缺失/损坏 → 空集（无活跃槽——不阻碍残留清理）。
+ *  探测 = **入口一次异步束**（零逐 pid exec）；三态消费：活 ⇒ 活跃；死 ⇒ 非活跃；
+ *  **未知（探测失败 / 缺行）⇒ 计为活跃**（现场保留——D-MI10 同向）。 */
+async function liveSlots(dir, prefix, probeFn) {
+  const active = new Set()
+  let m
+  try { m = JSON.parse(readFileSync(join(dir, `${prefix}.manifest`), "utf8")) } catch { return active }
+  const entries = []
+  for (const [n, owner] of Object.entries(m.slotSessions ?? {})) {
+    if (!/^\d+$/.test(n) || !owner) continue
+    if (!existsSync(join(dir, `${prefix}.${n}`))) continue
+    const pid = ownerPid(owner)
+    if (pid) entries.push([Number(n), pid])
+  }
+  if (!entries.length) return active
+  const bundle = await probeFn([...new Set(entries.map(([, pid]) => pid))])
+  for (const [n, pid] of entries) {
+    if (ownerState(pid, bundle) !== "dead") active.add(n)
+  }
+  return active
+}
+
+/**
+ * 残留 GC（§6.12——单 cwd 前缀，不跨 cwd 扫描）：返回 { candidates, deleted }
+ * （dryRun 时 candidates 照列、deleted 为空——只列不删，N2 可预览）。
+ * 扫描先按后缀预过滤（N4——只 stat 残留候选），再对候选做活跃槽/孤儿/保留期判定；
+ * 无残留候选 ⇒ **零探测早退**（不发起探测束）。probeFn = 测试注入缝（缺省核异步束）。
+ */
+export async function gcResidue({ dir = sessionsDir(), prefix, now = Date.now(), dryRun = false, probeFn = probeOwnersAsync } = {}) {
+  const result = { candidates: [], deleted: [] }
+  let entries
+  try { entries = readdirSync(dir) } catch { return result }
+  const candidates = []
+  for (const name of entries) {
+    const c = classifyResidue(name, prefix)
+    if (c) candidates.push({ name, ...c })
+  }
+  if (!candidates.length) return result
+  const active = await liveSlots(dir, prefix, probeFn)
+  for (const c of candidates) {
+    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（主文件在——写中/回退候选）
+    let st
+    try { st = statSync(p) } catch { continue }
+    if (st.mtimeMs >= now - c.retention) continue // 边界：older-than 才删，等于保留期保留（§6.12）
+    result.candidates.push(c.name)
+    if (!dryRun) {
+      try { unlinkSync(p); result.deleted.push(c.name) } catch { /* 占用/竞态——跳过 */ }
+    }
+  }
+  return result
+}
+
+const scheduledPrefixes = new Set()
+
+/** 启动钩子（§6.12 review #8——N4）：GC 延后到进程启动完成后空闲执行（setImmediate），
+ *  不阻塞启动路径；每进程每前缀一次（Set 去重——resumeSlot 可多次进入）。 */
+export function scheduleSessionGC(cwd) {
+  let base
+  try { base = sessionPath(cwd) } catch { return }
+  if (scheduledPrefixes.has(base)) return
+  scheduledPrefixes.add(base)
+  setImmediate(() => {
+    gcResidue({ dir: dirname(base), prefix: basename(base) }).catch(() => { /* 清理失败静默——不影响主流程 */ })
+  })
+}
+
+/**
+ * 冷 cwd 枚举（§6.12 步骤 1/2——跨 cwd 报告面，仅手动命令调用）：候选 =
+ * manifest mtime 距今 > 90 天 且 无活跃数据文件（.json.N 主文件不存在或全部属死主进程）。
+ * 返回 [{ hash, prefix, manifestMtime, dataFiles, files }]（files = 整前缀全部文件——
+ * 含裸 v1 `{hash}.json`，§6.12 D-V1——dataFiles 仅 .json.N，v1 不参与冷态判定）。
+ * 探测 = **全部候选前缀一次异步束**（两遍：先筛候选并收 pid，再一次判活 + 三态）；
+ * **未知 ⇒ 非冷（保留）**——探测失败不得判冷（D-MI10 同向）。
+ */
+export async function listColdCwds({ dir = sessionsDir(), now = Date.now(), probeFn = probeOwnersAsync } = {}) {
+  let entries
+  try { entries = readdirSync(dir) } catch { return [] }
+  const cands = []
+  for (const name of entries) {
+    if (!name.endsWith(".json.manifest")) continue // end marker（.manifest.cli/.vscode）与 .manifest.corrupted 天然排除
+    const prefix = name.slice(0, -".manifest".length) // `${hash}.json`
+    let st
+    try { st = statSync(join(dir, name)) } catch { continue }
+    if (st.mtimeMs >= now - COLD_CWD_RETENTION_MS) continue // 近期活跃（<90 天阈值——T10）
+    let m
+    try { m = JSON.parse(readFileSync(join(dir, name), "utf8")) } catch { continue } // 损坏 manifest 不判冷（.corrupted 归残留 GC）
+    const dataFiles = entries.filter((e) => e.startsWith(prefix + ".") && /^\d+$/.test(e.slice(prefix.length + 1)))
+    const owners = dataFiles.map((e) => {
+      const slotName = e.slice(prefix.length + 1)
+      const pid = ownerPid(m.slotSessions?.[slotName] ?? "")
+      return pid || 0
+    })
+    cands.push({ prefix, manifestMtime: st.mtimeMs, dataFilesLen: dataFiles.length, owners })
+  }
+  if (!cands.length) return []
+  const pids = [...new Set(cands.flatMap((c) => c.owners).filter(Boolean))]
+  const bundle = await probeFn(pids) // 空清单 ⇒ 探测面零 exec 早退
+  const cold = []
+  for (const c of cands) {
+    // 死主数据文件判定：三态——活 / 未知 ⇒ 非冷（保守保留）；无非自身属主 ⇒ 无活跃数据文件
+    const hasLive = c.owners.some((pid) => pid && ownerState(pid, bundle) !== "dead")
+    if (hasLive) continue // 有活跃数据文件 → 非冷（T12）；探测失败 ⇒ 未知 ⇒ 同向保留
+    cold.push({
+      hash: c.prefix.slice(0, -".json".length),
+      prefix: c.prefix,
+      manifestMtime: c.manifestMtime,
+      dataFiles: c.dataFilesLen,
+      files: entries.filter((e) => e.startsWith(c.prefix + ".") || e === c.prefix), // 整前缀清空含裸 v1 {hash}.json（§6.12 D-V1）
+    })
+  }
+  return cold
+}
+
+/**
+ * 删除指定冷 cwd 的整个前缀（§6.12 步骤 3——manifest+end marker+.json.N 死主数据+
+ * 裸 v1 {hash}.json（§6.12 D-V1）+残留；只删 manifest 留数据文件会制造孤儿数据，整前缀清空才真正释放）。
+ * 删除前重跑冷 cwd 判定（TOCTOU 防护，T12——期间变活跃则拒绝）。
+ */
+export async function deleteColdCwd(hash, { dir = sessionsDir(), now = Date.now(), probeFn = probeOwnersAsync } = {}) {
+  const target = (await listColdCwds({ dir, now, probeFn })).find((c) => c.hash === hash)
+  if (!target) return { ok: false, reason: "not-cold", deleted: [] }
+  const deleted = []
+  for (const name of target.files) {
+    const p = join(dir, name)
+    try {
+      // §6.14（TUI-OOM-ROOTCAUSE）：目录项（记录存储 sidecar `{prefix}.N.d`）递归删——
+      // 现 unlinkSync 对目录静默跳过（旧实现漏删 sidecar）；数据文件维持 unlink。
+      if (statSync(p).isDirectory()) rmSync(p, { recursive: true, force: true })
+      else unlinkSync(p)
+      deleted.push(name)
+    } catch { /* 占用/竞态——跳过 */ }
+  }
+  return { ok: true, deleted }
+}
+
+/**
+ * ④ 端差段 · 手动执行面（§6.12）——仅命令行壳提供（另一形态无 shell 子命令通道）；
+ * 本段**核内零消费方**（结构机检③）：核内保存实现（取一侧），命令接线属壳侧（S2）。
+ *
+ * `thincoder session gc` 子命令分发（§6.12 手动面——F2 执行入口仅命令行壳，
+ * 另一形态无 shell 子命令通道，review #7）：
+ *   --dry-run          报告当前 cwd 残留候选 + 跨 cwd 冷候选（只列不删，N2 预览）
+ *   --confirm <hash>   删除指定冷 cwd 整前缀（警告 + 文件清单 + TOCTOU 重校验）
+ *   --confirm --all    逐冷 cwd 同型警告删除
+ * 返回进程退出码（0/1）。dir/prefix/now/out/err/probeFn 为测试注入缝（默认生产行为）。
+ */
+export async function runSessionGc(args, { dir = sessionsDir(), prefix = null, cwd = process.cwd(), now = Date.now(), out = console.log, err = console.error, probeFn = probeOwnersAsync } = {}) {
+  const dryRun = args.includes("--dry-run")
+  const confirmIdx = args.indexOf("--confirm")
+  const hasConfirm = confirmIdx >= 0
+  const confirmTarget = hasConfirm ? args[confirmIdx + 1] : null
+  // --dry-run 与 --confirm 互斥（review 🔵#4——同给时不得静默忽略 confirm；无值 --confirm 同为用法错误）
+  if (args[0] !== "gc" || (!dryRun && !hasConfirm) || (dryRun && hasConfirm) || (hasConfirm && !confirmTarget)) {
+    err("Usage: thincoder session gc --dry-run | --confirm <hash> | --confirm --all")
+    return 1
+  }
+
+  if (dryRun) {
+    out("Session GC dry-run — no files will be deleted.")
+    // 当前 cwd 残留（§6.12 删除面——自动 GC 的预览）
+    let p = prefix
+    if (!p) { try { p = basename(sessionPath(cwd)) } catch { p = null } }
+    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}`)
+  }
+
+  const cold = await listColdCwds({ dir, now, probeFn })
+  if (dryRun) {
+    out(`Cold project candidates (manifest idle > 90 days, no live data files): ${cold.length}`)
+    for (const c of cold) {
+      out(`  ${c.hash}  manifest mtime ${new Date(c.manifestMtime).toISOString()}  data files ${c.dataFiles}  total files ${c.files.length}`)
+    }
+    if (cold.length) out('Run "thincoder session gc --confirm <hash>" (or --confirm --all) to permanently delete a cold project prefix.')
+    return 0
+  }
+
+  // --confirm：删除前警告（N2 可逆——文件清单 + 永久删除提示）；deleteColdCwd 内部重校验冷态（TOCTOU）
+  const targets = confirmTarget === "--all" ? cold : cold.filter((c) => c.hash === confirmTarget)
+  if (!targets.length) {
+    err(`Refused: ${confirmTarget} is not a cold project (active, recent, or unknown) — nothing deleted.`)
+    return 1
+  }
+  for (const t of targets) {
+    out(`WARNING: 此操作永久删除该 cwd 的全部会话历史 (hash ${t.hash}, ${t.files.length} files):`)
+    for (const name of t.files) out(`  ${name}`)
+    const r = await deleteColdCwd(t.hash, { dir, now, probeFn })
+    if (!r.ok) { err(`Refused: ${t.hash} is no longer cold (became active) — skipped.`) ; continue }
+    out(`Deleted ${r.deleted.length} files for ${t.hash}.`)
+  }
+  return 0
+}

package/session-guard.mjs

@@ -0,0 +1,59 @@
+/**
+ * session-guard.mjs — F2 轮转守卫（2026-08-31 会诊 F2 🔴；2026-09-08 DESIGN-TOKEN-
+ * SETTLEMENT D1 自 session-slots.mjs 提取——session-slots 再越 500 行硬限，本守卫约 41
+ * 行随迁，verbatim 零语义变）：saveSession 与 token-ttl persistEngTokens 共用同一份。
+ * 写前校验磁盘槽文件是否本进程会话的现场——磁盘文件 sessionStart 与本进程会话不符
+ * （另一进程/会话的现场）/版本更新/异 cwd → 先轮转 .bak 保留再写。检查按 mtime 缓存
+ * （agent._slotMtime）：文件自上次检查/自写未变就跳过全量解析——每次保存都
+ * readFileSync+JSON.parse 多 MB 会话 → O(n²) 退化。文件存在但不可读（损坏/半写）→
+ * 改名 .corrupted 保留现场。返回轮转的 .bak 路径或 null。
+ */
+
+import { existsSync, readFileSync, renameSync, statSync } from "node:fs"
+import { basename } from "node:path"
+// §14.3.8①（修正轮 #1）：.bak 轮转对**非本会话活动绑定面**联动改名 sidecar（`{p}.d → {bak}.d`）。
+import { RECORD_DIR_SUFFIX } from "./session-store.mjs"
+
+/** 轮转时随迁记录存储（.bak 路径联动）——本会话活动绑定面跳过（防拔掉活动存储）。 */
+function moveSidecar(src, dst, agent) {
+  const dir = src + RECORD_DIR_SUFFIX
+  if (agent?._recordStore?.dir === dir) return // 本会话活动绑定面——原地保留（§14.3.8①）
+  try {
+    if (existsSync(dir)) renameSync(dir, dst + RECORD_DIR_SUFFIX)
+  } catch { /* 随迁失败不阻断轮转（现场原地保留——读侧身份核验兜底） */ }
+}
+
+export function guardForeignSlotFile(agent, p, slot) {
+  try {
+    if (!existsSync(p)) return null
+    const st = statSync(p)
+    if (st.mtimeMs === (agent._slotMtime ?? -1)) return null
+    const disk = JSON.parse(readFileSync(p, "utf8"))
+    // version>2 的新版文件无论 sessionStart 一律轮转（loadSlotFile 对 v3 返回 null 不动
+    // 文件——若其 sessionStart 为 null，旧版首次保存会静默覆盖；轮转 .bak 保证新版文件
+    // 保留）。磁盘文件 cwd 不匹配（异项目文件误落本路径）同样轮转——与 loadSlotFile/
+    // legacy 读的"别人的文件不动"原则对齐。
+    const diskIsNewer = typeof disk?.version === "number" && disk.version > 2
+    const diskStart = disk?.sessionStart ?? null
+    const myStart = agent._sessionStart ?? null
+    const diskForeign = typeof disk?.cwd === "string" && disk.cwd.toLowerCase() !== agent.cwd.toLowerCase()
+    if (diskIsNewer || diskForeign || (diskStart && diskStart !== myStart)) {
+      const bak = `${p}.bak-${Date.now()}`
+      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
+      return bak
+    }
+    agent._slotMtime = st.mtimeMs
+    return null
+  } catch {
+    // 文件存在但不可读（损坏/半写）：改名 .corrupted 保留现场（2026-09-01 advisor 🔵——
+    // 与自身 loadSlotFile 的 .corrupted 约定 + VS Code saveSessionToSlot 对齐；.bak 保留
+    // 给 F2 轮转路径，损坏现场不再混入轮转后缀）。
+    if (existsSync(p)) {
+      try { renameSync(p, `${p}.corrupted`) } catch {}
+    }
+    return null
+  }
+}

package/session-lifecycle.mjs

@@ -0,0 +1,305 @@
+/**
+ * session-lifecycle.mjs — 会话生命周期面（init-block 批 · F-MI7 拆分——`session.mjs` 500 行
+ * 硬限；各函数语义原样外提，SESSION.md §6.10 D-2 / §6.12 / §6.11 注记随迁）：
+ * 本端恢复入口包装（resumeSlot——残留 GC 钩子）/ 槽数据应用（applySession）/ 新建槽
+ * （newSession）/ 运行态清空（resetSessionState）/ 槽切换（switchToSlot）/ 占用查询
+ * （slotOccupancy）/ v1 老文件清扫（stripTruncatedToolArgs）。
+ *
+ * 静态环（与 session-slots.mjs ↔ session.mjs 同形）：本档引 `session.mjs` 的
+ * `loadSlotFile`（data 层读留 session.mjs——2026-09-05 §6.10 D-2 拆分点），session.mjs re-export
+ * 本档函数保持既有 import 面 —— 函数声明在实例化期已初始化、仅函数体内运行时使用（环安全；
+ * 同 session-slots.mjs 头注）。
+ *
+ * 探测纪律（F-MI7 · SESSION.md §6.2）：本档**零同步 exec 扫描**——`newSession` 走入口一次
+ * **异步束**（`probeOwnersAsync` + `ownerState` 三态查表）；`slotOccupancy` = **有界同步例外**
+ * （`probeOwnersSync`，每 exec ≤ SYNC_PROBE_MS；探测失败 ⇒ `{ occupied: true, unknown: true }`
+ * 保守占位——未知不认领，D-MI10）。
+ */
+
+import { existsSync } from "node:fs"
+import { resolveCompactThreshold } from "./config.mjs"
+import {
+  slotPath, loadManifest, saveManifest, slotDigest, writeSessionFile, getSessionId,
+  writeEndMarker, ownerPid, ownerPids,
+  resumeSlot as slotsResumeSlot,
+} from "./session-slots.mjs"
+import { probeOwnersSync, probeOwnersAsync, ownerState } from "./process-probe.mjs"
+// 环 import：见头注（loadSlotFile 属 session.mjs 的 data 层读面）。
+import { loadSlotFile } from "./session.mjs"
+import { mergeAdjacentAssistantEchoes } from "./context.mjs"
+import { scheduleSessionGC } from "./session-gc.mjs"
+import { restoreEngTokens } from "./token-ttl.mjs"
+import { bindRecordStore, unbindRecordStore, RECORD_WINDOW_MESSAGES } from "./session-store.mjs"
+
+/** 恢复决策包装（SESSION.md §6.12 启动钩子，2026-09-06）：本端恢复入口触发一次残留 GC——
+ *  scheduleSessionGC 内部 setImmediate 空闲执行 + 每进程每前缀去重，不阻塞启动路径（N4）。
+ *  **async**（F-MI7——整链异步：探测不阻塞事件循环；调用面必须 await）。 */
+export async function resumeSlot(cwd) {
+  scheduleSessionGC(cwd)
+  return slotsResumeSlot(cwd)
+}
+
+/** slimForDisplay 截断的 arguments 以 U+2026（…）结尾——不是合法 JSON 的完整值。
+ *  v1 老文件回退播种机器线时置为 {}（合法空参数），防止半截 \\uXXXX 毒化发送载荷（会诊 F6）。 */
+function stripTruncatedToolArgs(m) {
+  if (m?.role !== "assistant" || !Array.isArray(m.tool_calls)) return m
+  let changed = false
+  const tool_calls = m.tool_calls.map((tc) => {
+    const args = tc?.function?.arguments
+    if (typeof args === "string" && args.endsWith("…")) {
+      changed = true
+      return { ...tc, function: { ...tc.function, arguments: "{}" } }
+    }
+    return tc
+  })
+  return changed ? { ...m, tool_calls } : m
+}
+
+/** Apply loaded session data onto an agent object; returns true if the runtime composite
+ *  was switched. 2026-08-31 会诊 F1：清空 _slot/_slotMtime 缓存——切换后下次保存重新认领。
+ *
+ *  MODEL-MERGE-SESSION（F-4）applySession 重写为两支 + 删旧支（评审 #7/#9 措辞——防
+ *  "三支"误读）：
+ *  ① 槽 provider 存在 → provider/model 按槽值设（双字段恒非空——模型取 data.activeModel，
+ *     legacy 槽 null/空串回该渠道默认模型 `providers[].model`（单值——2026-09-10 MODEL-SELECTION
+ *     v2；老 models[] 首候选形态已退场））+ 重算
+ *     compactThreshold（auto 时——按恢复后模型）——不看 config（defaultModel 只是新会话起点）；
+ *  ② 槽 provider 没了 → D-S3 保留——静默保持现状（config 有效则有效——两方都无效由调用侧
+ *     复验 validateProvider 弹重选）。
+ *  删旧支："activeModel==null 清 stale override 回渠道默认"——前提 = 渠道默认字段——已随
+ *  三旧层删除消失——双字段恒非空故不可能触发（评审 #7）。 */
+export function applySession(agent, data, opts = {}) {
+  // 机读线语义（历史注释保留）：data.history = FULL 未压缩记录（人读线）；data.contextHistory =
+  // 压缩后机器线——恢复各从其源（保留压缩收益——从完整 history 重建会塞回中间过程——实测
+  // prompt 膨胀 283%）。v1 老文件（无 contextHistory）回退播种，剥离被 slimForDisplay 截断的
+  // tool_calls.arguments（… 结尾 → 置 {}——截断可劈断 \\uXXXX 产生 400 毒载荷）。length > 0 才
+  // 当机读线（contextHistory: [] 是"无机读线"而非空机器线——空机器线静默丢全部上下文）。
+  agent.config ??= {} // ACP test mocks may omit config; be defensive like the ??= below
+  const full = Array.isArray(data.history) ? data.history : []
+  // SESSION.md §6.11（2026-09-08——F2/F3）：恢复事件按当前 data 重定——载入历史非空 = 会话
+  // 恢复 → 下个 depth-0 回合 env-state resumed:yes 一次（pushEnvStateReminder 读即清——每次恢复
+  // 一次）。/new 与空历史槽切换不武装（显式清 false）——无恢复事件恒 no（F3 伪触发消除——不再靠
+  // _sessionStart != null 推断；已武装 agent 切到空历史槽也不残留上次恢复事件——评审 round2 🟡）。
+  // _processRestartPending 不在此清——由启动路径（bin/thincoder.mjs）设、prepareRun 发句清
+  // （N6——双信号独立：切槽不报进程重启）。
+  // 跨端异名互指（结构债批 5 N7——双端同语义各自独立实现、命名不统一是刻意——SESSION.md
+  // §6.11）：VSC 端同机制载体异名 = agent._resumedPending（src/agent/setup.mjs hydrateRun——
+  // restore:true 工厂 + fullHistory 非空时武装——每槽恢复一次）+ 模块级 restartDetectionDone
+  // 一次性闸（src/agent/setup-reminders.mjs——process restarted 句的进程级信号）。
+  agent._envResumed = full.length > 0
+  const ch = data.contextHistory
+  const machine = (Array.isArray(ch) && ch.length > 0) ? ch : full.map(stripTruncatedToolArgs)
+  // D-CC19 恢复面回声归并（CONTEXT-COMPACTION §6.10 #8）：已落盘机读线原样装回会复活
+  // D-CC18 病态形态（无 reasoning_content 的 assistant 紧邻 assistant ⇒ 首请求 400）——
+  // machine 定线后、装线前扫描归并（干净输入返回同一引用——零拷贝零回归）。
+  const machineMerged = mergeAdjacentAssistantEchoes(machine)
+  // 绑定态（opts.slot 在场）：人读线 = 记录存储尾窗（下方绑定块填充）——不复制全量 JSON 数组
+  agent._fullHistory = opts.slot != null ? [] : [...full]
+  agent.history = [...machineMerged]
+  agent.title = data.title ?? ""
+  agent.tasks = data.tasks ?? []
+  agent.planMode = data.planMode ?? false
+  agent.autoApprove = data.autoApprove ?? false
+  agent.goal = data.goal ?? null
+  agent._pendingReminders = data.pendingReminders ?? []
+  agent._sessionStart = data.sessionStart ?? null
+  // R16 token 字段恢复（过期过滤——见 token-ttl.mjs restoreEngTokens）
+  restoreEngTokens(agent, data)
+  // engineering is session-level (2026-08-29): the slot value is the CLI session's authority
+  // — config.json is only the initial default / cross-end mirror. A legacy slot without the
+  // field keeps whatever config.json seeded (unchanged behavior).
+  if (data.engineering !== undefined) {
+    agent.config.agent ??= {}
+    agent.config.agent.engineering = data.engineering === true
+  }
+  if (data.advisor) {
+    agent.config.advisor = { ...data.advisor }
+  }
+  // Reset stall/compaction state on session switch
+  agent._compressFailures = 0
+  agent._verifyRetries = 0
+  agent._verifyPassed = false
+  agent._slot = null // 粘性缓存清空——切换后重新认领（F1b）
+  agent._slotMtime = null
+  // ── 记录存储绑定（TUI-OOM-ROOTCAUSE · SESSION.md §6.14 绑定与对账 / 追加时点）──
+  // opts.slot 在场（启动恢复 / 非占用的 /session 切换 / ACP 钉槽）→ 绑定（身份核验 + 对账 +
+  // 窗口）——人读线 = store.tail(200)；未传（模式 F：被他人活进程占用的槽 / 测试 / ACP fork）
+  // → 解绑——人读线维持全量数组（D-SE26 模式 F 零回归）。
+  if (opts.slot != null) {
+    const store = bindRecordStore(agent, {
+      slotFile: slotPath(agent.cwd, opts.slot),
+      identity: data.sessionStart ?? null,
+      baseHistory: full,
+    })
+    agent._fullHistory = store.tail(RECORD_WINDOW_MESSAGES)
+  } 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 键不缺失）
+    const prevName = agent.activeProvider
+    const prevModel = agent.activeModel ?? null
+    const slotModel = 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) {
+      agent.config.agent.compactThreshold = resolveCompactThreshold(null, agent.provider).value
+    }
+    return switched
+  }
+  // ② 槽 provider 没了 → D-S3 保留——静默保持现状（不报错不纠正——config 有效则静默用
+  //    config/defaultModel 运行时；两方都无效由调用侧复验 validateProvider 弹重选）
+  return false
+}
+
+/**
+ * Create a new session slot: allocate a free slot number,
+ * write an empty session, and mark it as the active slot.
+ * No limit on the number of sessions.
+ * **async**（F-MI7：入口一次异步束——探测不阻塞事件循环；调用面必须 await）。
+ */
+export async function newSession(cwd) {
+  const m = loadManifest(cwd)
+
+  // 2026-09-01 advisor 🔵：先清理死主条目（与 ensureActive 分支2 语义一致）——否则
+  // "死主 + 文件缺失"的空槽（m.slots 有条目、无文件、属主已死）永不复用，槽号持续
+  // 增长。死主且无文件 = 该会话从未落盘（进程死了没保存），条目可安全删除回收。
+  // 2026-09-01 会诊 deepseek/glm 🟡：清理必须经 deletions 显式落盘——saveManifest 条目级
+  // 合并会把磁盘死条目从 fresh 复活回写，仅传 m 等于没删（VS Code newSlot 已修，CLI 对称）。
+  // F-MI7：判活来自**入口一次异步束**（零自有 exec / 零逐 pid exec）；判据查表——
+  // unknown（探测失败 / 缺行）⇒ 保守保留条目（D-MI10）。
+  const mySessionId = getSessionId()
+  const bundle = await probeOwnersAsync(ownerPids(m, mySessionId))
+  const deadSlots = []
+  for (const [s, owner] of Object.entries(m.slotSessions ?? {})) {
+    if (!owner || owner === mySessionId) continue
+    if (ownerState(ownerPid(owner), bundle) !== "dead") continue
+    delete m.slotSessions[s]
+    if (!existsSync(slotPath(cwd, Number(s)))) delete m.slots[s]
+    deadSlots.push(s)
+  }
+
+  // Find next available slot number — 2026-08-31 会诊 deepseek 🟡：不能只看 manifest
+  // 条目（丢失更新可能让条目消失而文件仍在）——复用该号会直接覆写真实会话
+  // （F2 防护不覆盖 newSession 的空数据直写）。
+  // 2026-08-31 advisor round2 🟡：同时跳过"已被另一活进程认领但尚未落盘"的号
+  // （slotSessions 有条目、slots 无条目、文件不存在）——否则双进程会认领同一号。
+  // F-MI7：活 / 未知属主 ⇒ 视为已占（跳号——保守），判据同查束。
+  const liveClaimed = (n) => {
+    const owner = m.slotSessions?.[n]
+    if (!owner || owner === mySessionId) return false
+    return ownerState(ownerPid(owner), bundle) !== "dead"
+  }
+  let slot = 1
+  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 }
+  writeSessionFile(slotPath(cwd, slot), data)
+  m.slots[slot] = slotDigest(data)
+  m.active = slot
+  // 2026-08-31 advisor round1 🟡：与 ensureActive 认领模型一致——立即记录新 slot 所有权，
+  // 否则 /new 后到首次保存之间并发方（VS Code/另一 CLI）会把新 active 槽当"空闲可恢复"
+  // 认领 → 双进程写同一槽（F2 轮转互旋）。
+  m.slotSessions ??= {}
+  m.slotSessions[slot] = mySessionId
+  // 2026-09-01 会诊三家 🟡：显式翻 active 的调用点传 setActive（saveManifest 默认保留
+  // 磁盘 fresh.active，避免把并发方刚翻的指针回滚）
+  // 2026-09-01 会诊 deepseek/glm 🟡：deletions 过滤掉本调用刚重新认领的槽（防删掉自己的
+  // 新属主）——与 ensureActive deadParam / VS Code newSlot 同型。
+  const deletions = deadSlots.length
+    ? {
+        slotSessions: deadSlots.filter((s) => m.slotSessions[s] !== mySessionId),
+        slots: deadSlots.filter((s) => !m.slots[s]),
+      }
+    : null
+  saveManifest(cwd, m, deletions, { setActive: true })
+  // 2026-09-05 §6.10 D-4：/new 落点写本端记录（显式切换跟随——T-M8）
+  writeEndMarker(cwd, slot)
+  return slot
+}
+
+/** 清空会话运行态（/new 用，2026-08-31 会诊 F3）：_fullHistory/title/_sessionStart 等
+ *  全部会话级状态 + 一次性注入标志必须全清——否则新会话首次落盘把旧会话完整人类线 +
+ *  旧标题写进新槽（实锤 .19/.3 双副本）；注入标志不清则 /new 后新会话永不注入
+ *  OS/cwd reminder（2026-09-01 会诊 glm 🟡）。autoApprove 是用户偏好，跨会话保留（有意）。 */
+export function resetSessionState(agent) {
+  agent._fullHistory = []
+  agent.history = []
+  agent.title = ""
+  agent.tasks = []
+  agent._sessionStart = null
+  // DESIGN-TOKEN-SETTLEMENT D3（2026-09-08）：单值镜像 `_engDesignToken` 退役——不再维护
+  agent._engDesignTokens = new Map() // multi-design slots die with the session (2026-09-01 fix #2)
+  agent._compressFailures = 0
+  agent._verifyRetries = 0
+  agent._verifyPassed = undefined
+  agent._runStartHistoryLen = 0
+  agent._lastPromptTokens = null
+  agent._usageAtLen = null
+  agent.planMode = false
+  agent.goal = null
+  agent._pendingReminders = []
+  agent._slot = null
+  agent._slotMtime = null
+  agent._osReminderInjected = false
+  // §6.11（2026-09-08）：一次性注入标志换名——_restartReminderInjected 推断退役（F3——
+  // _sessionStart != null 伪触发）；/new 清零新标记——恢复武装/启动句标志不跨会话复活
+  agent._envResumed = false
+  agent._processRestartPending = false
+  agent._lastEngState = false
+  // /new 或切换：记录存储解绑（新槽由 cmd-new / 首保存补绑重新挂载——§6.14 绑定与对账）
+  unbindRecordStore(agent)
+}
+
+/** Switch the manifest active pointer to a slot. Returns the slot's session data
+ *  (null if the slot doesn't exist / can't be read). 2026-08-31 会诊 deepseek 🔴：
+ *  原实现经 loadSession → activeSlot 有认领副作用——目标槽被活进程占用时 ensureActive
+ *  分支 3 会把 active 拨到新空槽并读回 null + 劫持对方指针。现改为 loadSlotFile 直接读
+ *  （无认领副作用）；目标槽空闲则一并认领、被另一活进程占用则不认领（slotOccupancy——
+ *  下次保存经 activeSlot 自然 fork 到新槽）；只改 manifest 指针（setActive 意图）。
+ *  2026-09-01 会诊三家 🟡：saveManifest 条目级合并 + setActive（不把并发方刚翻的指针回滚）。 */
+export function switchToSlot(cwd, slot) {
+  const m = loadManifest(cwd)
+  if (!m.slots[slot]) return null
+  const data = loadSlotFile(cwd, slot)
+  if (!data) return null
+  m.active = slot
+  const occ = slotOccupancy(cwd, slot)
+  if (!occ.occupied) {
+    m.slotSessions ??= {}
+    m.slotSessions[slot] = getSessionId()
+  }
+  saveManifest(cwd, m, null, { setActive: true })
+  // 2026-09-05 §6.10 D-4：/session N 跟随"最后查看的槽"（成功切换才写）
+  writeEndMarker(cwd, slot)
+  return data
+}
+
+/** 目标槽是否被另一活进程占用（2026-09-01 会诊/advisor 🟡）：排除本进程属主——
+ *  /session 重选当前槽不误报；同进程双会话防护由 ACP sameProcessPinned 承担。
+ *  F-MI7（**有界同步例外**——D-MI14 登记）：零探测早退（无属主 / 本进程属主）；冷路径单 pid
+ *  **同步束**（每 exec ≤ SYNC_PROBE_MS）；探测失败 ⇒ 未知 ⇒ `{ occupied: true, unknown: true }`
+ *  （保守占位——未知不认领，D-MI10）。 */
+export function slotOccupancy(cwd, slot) {
+  const m = loadManifest(cwd)
+  const owner = m.slotSessions?.[slot]
+  if (!owner) return { occupied: false }
+  if (owner === getSessionId()) return { occupied: false }
+  const pid = ownerPid(owner)
+  if (!pid) return { occupied: false }
+  const st = ownerState(pid, probeOwnersSync([pid]))
+  if (st === "alive") return { occupied: true, owner }
+  if (st === "unknown") return { occupied: true, unknown: true, owner }
+  return { occupied: false }
+}

package/session-migrate.mjs

@@ -0,0 +1,48 @@
+/**
+ * session-migrate.mjs — one-time migration of legacy short-hash session files to the
+ * full 40-char sha1 hash. Extracted from session.mjs (file-size split).
+ */
+import { createHash } from "node:crypto"
+import { renameSync, existsSync } from "node:fs"
+import { join } from "node:path"
+import { configDir } from "./config.mjs"
+
+/** One-time migration: rename legacy short-hash session files to the full 40-char hash.
+ *  Idempotent; runs on first access per cwd.
+ *  Historical hash algorithms (all sha1, none normalized the drive letter):
+ *    - CLI:      sha1(cwd).slice(0, 12)      — cwd comes from process.cwd() (uppercase drive on Windows)
+ *    - VS Code:  sha1(cwd).slice(0, 16)      — cwd comes from uri.fsPath (LOWERCASE drive on Windows)
+ *  Plus the previous migration attempt's assumption (normalized 12 = first 12 of the full hash).
+ *  Every combination is tried — a migration that only checks one candidate misses real
+ *  legacy files (drive-letter case differs between CLI and VS Code historical paths). */
+/** 2026-09-01 advisor 🔵（VS Code 侧已修，CLI 对称补齐）：已迁移/确认无 legacy 的 hash
+ *  记录在 Set 中短路——否则每次 sessionPath() 都重跑 5 候选 × 3 existsSync 的系统调用。 */
+const migratedHashes = new Set() // full 40-char hash → migration already attempted (found none or done)
+
+export function migrateHashLength(cwd, fullHash) {
+  if (migratedHashes.has(fullHash)) return false
+  const dir = join(configDir, "sessions")
+  const lower = cwd.replace(/^([A-Z]):/, (_, d) => d.toLowerCase() + ":")
+  const candidates = [
+    createHash("sha1").update(cwd).digest("hex").slice(0, 12),
+    createHash("sha1").update(cwd).digest("hex").slice(0, 16),
+    createHash("sha1").update(lower).digest("hex").slice(0, 12),
+    createHash("sha1").update(lower).digest("hex").slice(0, 16),
+    fullHash.slice(0, 12),
+  ]
+  const newBase = join(dir, `${fullHash}.json`)
+  let migrated = false
+  for (const short of new Set(candidates)) {
+    const legacyBase = join(dir, `${short}.json`)
+    if (!existsSync(legacyBase) && !existsSync(`${legacyBase}.manifest`) && !existsSync(`${legacyBase}.1`)) continue
+    migrated = true
+    try {
+      for (const suffix of ["", ".manifest", ...Array.from({ length: 64 }, (_, i) => `.${i + 1}`)]) {
+        const from = legacyBase + suffix
+        if (existsSync(from) && !existsSync(newBase + suffix)) renameSync(from, newBase + suffix)
+      }
+    } catch { /* best-effort; leave files in place on failure */ }
+  }
+  migratedHashes.add(fullHash)
+  return migrated
+}