thincoder 0.12.62 → 0.12.64

package/src/session-gc.mjs

@@ -1,221 +0,0 @@
-/**
- * session-gc.mjs — 会话目录残留 GC + 冷 cwd 报告/删除（SESSION.md §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（§12.7 D-V1）+残留；删除前重校验冷态——
- *         TOCTOU 防护 T12）。
- *
- * 拆分理由（§12.3 review #1）：session-slots.mjs 已在 500 行硬限零余量，GC 是独立决策
- * （"何时清何种残留"），独立成模块；原语（sessionPath/isProcessAlive）自 session-slots
- * import，启动钩子（session.mjs resumeSlot 包装）只一行调用。
- */
-
-import { readdirSync, readFileSync, statSync, unlinkSync, existsSync, rmSync } from "node:fs"
-import { join, dirname, basename } from "node:path"
-import { configDir } from "./config.mjs"
-import { sessionPath, isProcessAlive } from "./session-slots.mjs"
-
-/** 保留期（§12.2.2）：损坏现场（.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 阈值（§12.2.4）：manifest mtime 距今 > 90 天（保守——正常开发会频繁触碰）。 */
-export const COLD_CWD_RETENTION_MS = 90 * 24 * 3600 * 1000
-
-function sessionsDir() { return join(configDir, "sessions") }
-
-/** 残留分类（§12.2.2 后缀表）：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
-}
-
-/** 活跃槽集合（§12.4 T3/T12 操作定义）：.json.N 主文件存在 且 manifest slotSessions[N]
- *  属主进程存活。manifest 缺失/损坏 → 空集（无活跃槽——不阻碍残留清理）。 */
-function liveSlots(dir, prefix, aliveFn) {
-  const active = new Set()
-  try {
-    const m = JSON.parse(readFileSync(join(dir, `${prefix}.manifest`), "utf8"))
-    for (const [n, owner] of Object.entries(m.slotSessions ?? {})) {
-      if (!/^\d+$/.test(n) || !owner) continue
-      if (!existsSync(join(dir, `${prefix}.${n}`))) continue
-      const pid = parseInt(String(owner).split("-")[0])
-      if (pid && aliveFn(pid)) active.add(Number(n))
-    }
-  } catch { /* manifest 不可读 → 无活跃槽 */ }
-  return active
-}
-
-/**
- * 残留 GC（§12.2.3——单 cwd 前缀，不跨 cwd 扫描）：返回 { candidates, deleted }
- * （dryRun 时 candidates 照列、deleted 为空——只列不删，N2 可预览）。
- * 扫描先按后缀预过滤（N4——只 stat 残留候选），再对候选做活跃槽/孤儿/保留期判定。
- */
-export function gcResidue({ dir = sessionsDir(), prefix, now = Date.now(), dryRun = false, aliveFn = isProcessAlive } = {}) {
-  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 = liveSlots(dir, prefix, aliveFn)
-  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 才删，等于保留期保留（§12.4）
-    result.candidates.push(c.name)
-    if (!dryRun) {
-      try { unlinkSync(p); result.deleted.push(c.name) } catch { /* 占用/竞态——跳过 */ }
-    }
-  }
-  return result
-}
-
-const scheduledPrefixes = new Set()
-
-/** 启动钩子（§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(() => {
-    try { gcResidue({ dir: dirname(base), prefix: basename(base) }) } catch { /* 清理失败静默——不影响主流程 */ }
-  })
-}
-
-/**
- * 冷 cwd 枚举（§12.2.4 步骤 1/2——跨 cwd 报告面，仅手动命令调用）：候选 =
- * manifest mtime 距今 > 90 天 且 无活跃数据文件（.json.N 主文件不存在或全部属死主进程）。
- * 返回 [{ hash, prefix, manifestMtime, dataFiles, files }]（files = 整前缀全部文件——
- * 含裸 v1 `{hash}.json`，§12.7 D-V1——dataFiles 仅 .json.N，v1 不参与冷态判定）。
- */
-export function listColdCwds({ dir = sessionsDir(), now = Date.now(), aliveFn = isProcessAlive } = {}) {
-  let entries
-  try { entries = readdirSync(dir) } catch { return [] }
-  const cold = []
-  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 hasLive = dataFiles.some((e) => {
-      const owner = m.slotSessions?.[e.slice(prefix.length + 1)]
-      const pid = parseInt(String(owner ?? "").split("-")[0])
-      return !!(pid && aliveFn(pid))
-    })
-    if (hasLive) continue // 有活跃数据文件 → 非冷（T12）
-    cold.push({
-      hash: prefix.slice(0, -".json".length),
-      prefix,
-      manifestMtime: st.mtimeMs,
-      dataFiles: dataFiles.length,
-      files: entries.filter((e) => e.startsWith(prefix + ".") || e === prefix), // 整前缀清空含裸 v1 {hash}.json（§12.7 D-V1）
-    })
-  }
-  return cold
-}
-
-/**
- * 删除指定冷 cwd 的整个前缀（§12.2.4 步骤 3——manifest+end marker+.json.N 死主数据+
- * 裸 v1 {hash}.json（§12.7 D-V1）+残留；只删 manifest 留数据文件会制造孤儿数据，整前缀清空才真正释放）。
- * 删除前重跑冷 cwd 判定（TOCTOU 防护，T12——期间变活跃则拒绝）。
- */
-export function deleteColdCwd(hash, { dir = sessionsDir(), now = Date.now(), aliveFn = isProcessAlive } = {}) {
-  const target = listColdCwds({ dir, now, aliveFn }).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 {
-      // §14.3.8（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 }
-}
-
-/**
- * `thincoder session gc` 子命令分发（§12.2.3/12.2.4 手动面——F2 执行入口仅 CLI，
- *  VS Code 端无 shell 子命令通道，review #7）：
- *   --dry-run          报告当前 cwd 残留候选 + 跨 cwd 冷候选（只列不删，N2 预览）
- *   --confirm <hash>   删除指定冷 cwd 整前缀（警告 + 文件清单 + TOCTOU 重校验）
- *   --confirm --all    逐冷 cwd 同型警告删除
- * 返回进程退出码（0/1）。dir/prefix/now/out/err/aliveFn 为测试注入缝（默认生产行为）。
- */
-export function runSessionGc(args, { dir = sessionsDir(), prefix = null, cwd = process.cwd(), now = Date.now(), out = console.log, err = console.error, aliveFn = isProcessAlive } = {}) {
-  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 残留（§12.2.3 删除面——自动 GC 的预览）
-    let p = prefix
-    if (!p) { try { p = basename(sessionPath(cwd)) } catch { p = null } }
-    const residue = p ? gcResidue({ dir, prefix: p, now, dryRun: true, aliveFn }) : { candidates: [] }
-    out(`Residue candidates for current project (${p ?? "unknown"}): ${residue.candidates.length}`)
-    for (const name of residue.candidates) out(`  ${name}`)
-  }
-
-  const cold = listColdCwds({ dir, now, aliveFn })
-  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 = deleteColdCwd(t.hash, { dir, now, aliveFn })
-    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/src/session-guard.mjs

@@ -1,59 +0,0 @@
-/**
- * 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/src/session-migrate.mjs

@@ -1,48 +0,0 @@
-/**
- * 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
-}

package/src/session-rename.mjs

@@ -1,38 +0,0 @@
-/**
- * session-rename.mjs — 槽位重命名（标题写路径）。2026-09-06 自 session-slots.mjs 拆出：
- * §12.2.5 契约改（boolean → { ok, reason }）使 session-slots.mjs 超 500 行硬限
- *（§12.3 授权——"若 >500 则按 §10.6 先例拆文件，一并拆出 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 §12.2.5：契约 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/src/session-segments.mjs

@@ -1,100 +0,0 @@
-/**
- * session-segments.mjs — 记录存储的段文件原语 + 人读线条目形态（TUI-OOM-ROOTCAUSE 批）。
- *
- * 机制契约全文 = docs/design/SESSION.md §14.3（D2 单一权威源）；本文件 = 「段 IO + 条目
- * 形态」叶子层（`session-store.mjs` 拆分产物——503+ 行越 500 硬限，§14.5 表列模块按职责
- * 拆分；store 继续 re-export 全部公开名，调用面零改）。零项目内依赖（仅 `node:`）。
- */
-
-import { readdirSync, readFileSync } from "node:fs"
-
-/** 常量单源（§14.3.2）：每段消息数 / 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 迁出——§14.5）：机器线（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）。 */
-export function isRealUserMsg(m) {
-  return m?.role === "user" && typeof m.content === "string" && !m.content.startsWith("[System reminder:")
-}
-
-/** 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 }
-}