dsh-sessions-manager 3.5.0 → 3.5.2

package/src/compat/persistence.js

@@ -2,6 +2,30 @@
 // dsh-sessions-manager. Business code consumes normalized headers and complete
 // inspections; it never needs to know whether DSH returned a legacy header or
 // a handle-era SessionPersistenceSnapshot.
+//
+// Handle-era notes (official contract, dsh-v0.1.3-alpha.1):
+//   - `SessionHandle.read(offset?, length?, options?)` returns a bounded slice
+//     of the valid contiguous log; an offset at/past the end returns [].
+//   - Every handle is single-owner state: `close()` MUST run exactly once on
+//     every path, including throws and aborts (the contract exposes
+//     `SessionHandleClosedError` for operations after close).
+//   - `stat(id)` → `SessionPersistenceSnapshot | undefined`; `snapshot.revision`
+//     is an opaque change token valid ONLY within one service instance and one
+//     session id (see src/session-meta-cache.js).
+
+const DEFAULT_CHUNK = 400
+// 防御上限：一次 inspect 的分块循环绝不能无限自旋（后端 read 行为异常时快速失败）。
+const MAX_CHUNKS = 20000
+
+function normalizeReadResult(events) {
+  if (Array.isArray(events)) return events
+  if (events && typeof events[Symbol.iterator] === 'function') return [...events]
+  return []
+}
+
+async function closeQuietly(handle) {
+  try { if (handle && typeof handle.close === 'function') await handle.close() } catch (e) { /* close 是幂等兜底，二次失败忽略 */ }
+}
 
 function asHeader(value) {
   if (!value || typeof value !== 'object') return null
@@ -19,7 +43,7 @@ export function normalizePersistenceEntry(value) {
     id: String(header.id),
     sizeBytes: snapshot && Number.isFinite(snapshot.sizeBytes) ? Number(snapshot.sizeBytes) : null,
     eventCount: snapshot && Number.isSafeInteger(snapshot.eventCount) ? snapshot.eventCount : null,
-    revision: snapshot ? snapshot.revision : null,
+    revision: snapshot && typeof snapshot.revision === 'string' && snapshot.revision ? snapshot.revision : null,
   }
 }
 
@@ -31,34 +55,116 @@ export function normalizePersistenceList(values) {
 export function createPersistenceAdapter(service) {
   if (!service || typeof service.list !== 'function') throw new TypeError('sessionPersistence.list is required')
 
+  const hasStat = typeof service.stat === 'function'
+  const kind = typeof service.open === 'function' ? 'session-handle' : 'legacy'
+
   async function listEntries(options) {
     return normalizePersistenceList(await service.list(options))
   }
 
-  async function readSession(id, offset = 0) {
-    if (typeof service.readFrom === 'function') {
-      const result = await service.readFrom(id, offset)
-      return {
-        meta: result && result.meta ? result.meta : null,
-        inheritedEventCount: result && Number.isSafeInteger(result.inheritedEventCount) ? result.inheritedEventCount : 0,
-        events: result && Array.isArray(result.events) ? result.events : [],
-      }
+  // Handle-era only: the official lightweight observation. Returns the
+  // normalized snapshot entry, or null when the session does not exist.
+  // Never falls back to reading the log — callers use it for existence
+  // checks and revision-based cache validation only.
+  async function statSession(id) {
+    if (!hasStat) return null
+    const snapshot = await service.stat(id)
+    return snapshot ? normalizePersistenceEntry(snapshot) : null
+  }
+
+  // Read one bounded slice through a SessionHandle. The caller owns the
+  // handle lifecycle; this helper only guarantees close on read failure —
+  // the surrounding try/finally in the chunk drivers below is authoritative.
+  async function readChunk(handle, offset, length, signal) {
+    if (signal && signal.aborted) {
+      const error = new Error('会话读取已取消')
+      error.code = 'DSM_READ_ABORTED'
+      throw error
     }
+    const events = await handle.read(offset, length, signal ? { signal } : undefined)
+    return normalizeReadResult(events)
+  }
+
+  // Sequential chunk driver shared by inspectSession / readSession. Opens the
+  // handle itself so every code path (success, mid-chunk throw, abort) closes
+  // it exactly once in `finally`.
+  async function readChunks(id, { offset = 0, chunkSize = DEFAULT_CHUNK, signal, onEvents }) {
     if (typeof service.open !== 'function') throw new Error('当前 DSH 持久化服务不支持读取会话')
     const handle = await service.open(id, 'read')
     if (!handle || typeof handle.read !== 'function' || typeof handle.close !== 'function') {
-      try { if (handle && typeof handle.close === 'function') await handle.close() } catch {}
+      await closeQuietly(handle)
       throw new Error('DSH 返回了无效的 SessionHandle')
     }
+    let cursor = Number.isSafeInteger(offset) && offset >= 0 ? offset : 0
+    let total = 0
     try {
-      const events = await handle.read(offset)
-      return {
-        meta: handle.header || handle.meta || null,
-        inheritedEventCount: Number.isSafeInteger(handle.inheritedEventCount) ? handle.inheritedEventCount : 0,
-        events: Array.isArray(events) ? events : [...(events || [])],
+      for (let round = 0; round < MAX_CHUNKS; round++) {
+        const events = await readChunk(handle, cursor, chunkSize, signal)
+        if (events.length === 0) break
+        cursor += events.length
+        total += events.length
+        if (onEvents) await onEvents(events, { offset: cursor - events.length, total })
+        if (events.length < chunkSize) break
       }
     } finally {
-      await handle.close()
+      await closeQuietly(handle)
+    }
+    return {
+      meta: handle.header || handle.meta || null,
+      inheritedEventCount: Number.isSafeInteger(handle.inheritedEventCount) ? handle.inheritedEventCount : 0,
+      eventCount: total,
+    }
+  }
+
+  // Streamed full inspection: folds the log chunk-by-chunk through `onEvents`
+  // so 详情 / 导出 never materialize a whole large log in memory. `signal`
+  // (AbortSignal) cancels before the next chunk; the handle closes on every
+  // path. Legacy runtimes have no bounded read — readFrom already returns the
+  // complete log, which becomes a single onEvents batch.
+  async function inspectSession(id, opts = {}) {
+    const chunkSize = Number.isSafeInteger(opts.chunkSize) && opts.chunkSize > 0 ? opts.chunkSize : DEFAULT_CHUNK
+    if (typeof service.open === 'function') {
+      // 取消发生在 open 之前：连 handle 都不去开。
+      if (opts.signal && opts.signal.aborted) {
+        const error = new Error('会话读取已取消')
+        error.code = 'DSM_READ_ABORTED'
+        throw error
+      }
+      return readChunks(id, { offset: opts.offset || 0, chunkSize, signal: opts.signal, onEvents: opts.onEvents })
+    }
+    if (typeof service.readFrom !== 'function') throw new Error('当前 DSH 持久化服务不支持读取会话')
+    if (opts.signal && opts.signal.aborted) {
+      const error = new Error('会话读取已取消')
+      error.code = 'DSM_READ_ABORTED'
+      throw error
+    }
+    const result = await service.readFrom(id, opts.offset || 0)
+    const events = normalizeReadResult(result && result.events)
+    if (opts.onEvents && events.length) await opts.onEvents(events, { offset: opts.offset || 0, total: events.length })
+    return {
+      meta: result && result.meta ? result.meta : null,
+      inheritedEventCount: result && Number.isSafeInteger(result.inheritedEventCount) ? result.inheritedEventCount : 0,
+      eventCount: events.length,
+    }
+  }
+
+  // Complete read (legacy convenience shape). Internally chunked; callers that
+  // stream should prefer inspectSession so large logs never buffer whole.
+  async function readSession(id, offset = 0) {
+    if (typeof service.readFrom === 'function') {
+      const result = await service.readFrom(id, offset)
+      return {
+        meta: result && result.meta ? result.meta : null,
+        inheritedEventCount: result && Number.isSafeInteger(result.inheritedEventCount) ? result.inheritedEventCount : 0,
+        events: result && Array.isArray(result.events) ? result.events : [],
+      }
+    }
+    const events = []
+    const summary = await readChunks(id, { offset, onEvents: (batch) => { events.push(...batch) } })
+    return {
+      meta: summary.meta,
+      inheritedEventCount: summary.inheritedEventCount,
+      events,
     }
   }
 
@@ -67,6 +173,19 @@ export function createPersistenceAdapter(service) {
     return null
   }
 
-  const kind = typeof service.open === 'function' ? 'session-handle' : 'legacy'
-  return { kind, listEntries, readSession, locate }
+  // 落盘校验版定位：legacy 走官方 locate；handle 时代官方收走了 locate，改由
+  // handle-era-paths 的三层守卫推导（root 实例字段 → 目录结构 → id 归属），
+  // 任一层失败返回 null，调用方安全降级。返回 { path, sessionDir|null }。
+  async function locateVerified(header) {
+    if (typeof service.locate === 'function') {
+      try {
+        const loc = service.locate(header)
+        if (loc && typeof loc.path === 'string') return { path: loc.path, sessionDir: null }
+      } catch (e) { /* 落到推导 */ }
+    }
+    const artifacts = await locateSessionArtifacts(service, header)
+    return artifacts ? { path: artifacts.logPath, sessionDir: artifacts.sessionDir } : null
+  }
+
+  return { kind, listEntries, readSession, inspectSession, statSession, locate, locateVerified, hasStat }
 }

package/src/handle-era-ops.js

@@ -0,0 +1,185 @@
+// Handle-era destructive/moving operations (dsh-v0.1.3-alpha.1).
+//
+// 2026-09-06 用户决策：这两类能力在 legacy 时代本就是「官方 locate 查路径 +
+// 直接文件系统操作」的半官方实现；handle 时代官方收走 locate 后，改为由
+// src/handle-era-paths.js 的三层守卫推导路径。本模块实现两个操作核心，主路径
+// 尽量走官方公共 API（create/append/flush/close/stat/open），文件系统操作仅限
+// 于「把旧日志改名备份 / 删除会话目录」这两步，并且全部有备份回滚或前置探测：
+//
+//   - moveSessionToCwd: revision 前后校验（调用方）→ 官方 create+append 重放
+//     为主路径；后端已有同 id 幽灵时回退到 frame0 cwd 改写搬运（复用
+//     zstd-frame.js，与 legacy relocateLog 同一套校验）。任何失败都会把备份
+//     改名回原位并清理目标目录，绝不留下半移动状态。
+//   - purgeSessionArtifacts: 官方 open(id,'write') 探测并短暂接管写所有权
+//     （活跃写者 → 409 拒绝），然后整目录删除会话目录（basename 已由路径
+//     守卫验证），最后以官方 stat 复核该 id 已消失。
+//
+// 活跃写者策略：两个操作都拒绝「正在进行中」的会话，而不是照 legacy 那样
+// 改写活跃对象——handle 时代的写句柄所有权在官方 tracker 内部，与其打补丁
+// 不如如实拒绝，风险面更小。
+
+import { mkdir, readFile, rename, rm, unlink, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { rewriteFrame0CwdInMemory, scanZstdFrames } from './zstd-frame.js'
+import { deriveSessionDir, locateSessionArtifacts } from './handle-era-paths.js'
+
+const MOVE_BATCH = 400
+
+function conflictError(message) {
+  const error = new Error(message)
+  error.status = 409
+  error.code = 'DSM_SESSION_BUSY'
+  return error
+}
+
+function failureText(e) {
+  return `${(e && e.name) || ''} ${(e && e.message) || e}`
+}
+
+function isAlreadyOwned(e) {
+  return /already owned/i.test(failureText(e))
+}
+
+function isAlreadyExists(e) {
+  return /already exists/i.test(failureText(e))
+}
+
+async function closeQuietly(handle) {
+  try { if (handle && typeof handle.close === 'function') await handle.close() } catch (e) { /* 目录可能已被删，lease 释放失败可忽略 */ }
+}
+
+// 官方写所有权探测：能 open(id,'write') 就证明当前没有活跃写者（顺带让官方
+// 路径 flush 一次），拿到后立即释放。真正的并发保护来自随后的 rename-aside
+// （旧日志消失后，迟到的写者会在官方 open 处干净地 NotFound，而不是写坏数据）。
+export async function ensureNoActiveWriter(sp, sid) {
+  let handle = null
+  try {
+    handle = await sp.open(sid, 'write')
+  } catch (e) {
+    if (isAlreadyOwned(e)) throw conflictError('该会话正在进行中（存在活跃写入），请先切换到别的会话再操作。')
+    throw e
+  }
+  await closeQuietly(handle)
+}
+
+// 彻底删除一个会话的全部物理产物。header 必须来自官方 list/stat（携带真实 cwd）。
+// 返回被删除的 artifacts（供上层记录 originalPath 等）。
+export async function purgeSessionArtifacts(sp, sid, header) {
+  const artifacts = await locateSessionArtifacts(sp, header)
+  if (!artifacts) {
+    const error = new Error('无法定位该会话的物理日志目录，已停止永久删除')
+    error.status = 409
+    throw error
+  }
+  let writer = null
+  try {
+    writer = await sp.open(sid, 'write')
+  } catch (e) {
+    if (isAlreadyOwned(e)) throw conflictError('该会话正在进行中（存在活跃写入），无法彻底删除。')
+    throw e
+  }
+  // 句柄从未 append 过，先释放再删目录（Windows 上打开中的文件无法删除）。
+  await closeQuietly(writer)
+  writer = null
+  try {
+    // 整目录移除（含 lease 等会话本地文件）。basename === encodeSegment(id)
+    // 与「规范 generation 在位」都已在 locateSessionArtifacts 验证过。
+    await rm(artifacts.sessionDir, { recursive: true, force: true })
+  } catch (e) {
+    const error = new Error('删除会话日志失败：' + String((e && e.message) || e))
+    error.status = 500
+    throw error
+  }
+  // 官方视角复核：该 id 必须已从后端消失。
+  if (typeof sp.stat === 'function') {
+    const after = await sp.stat(sid).catch(() => undefined)
+    if (after) {
+      const error = new Error('删除后官方 stat 仍能看到该会话，已中止（目录可能被并发重建）')
+      error.status = 500
+      throw error
+    }
+  }
+  return artifacts
+}
+
+// frame0 改写回退：把备份日志的 frame0 cwd 改写为目标工作区后搬入目标会话目录。
+// 校验与 legacy relocateLog 完全一致：帧数不变 + frame0 之外字节逐位相等。
+async function relocateRewrittenBackup({ sid, canonical, backupPath, artifacts }) {
+  const original = await readFile(backupPath)
+  const frames = scanZstdFrames(original).frames
+  if (frames.length === 0) throw new Error('移动前校验失败：会话日志没有完整 zstd 帧')
+  const rewritten = rewriteFrame0CwdInMemory(original, canonical)
+  const rewrittenFrames = scanZstdFrames(rewritten).frames
+  if (rewrittenFrames.length !== frames.length) throw new Error('移动后校验失败：会话日志帧数发生变化')
+  if (!original.subarray(frames[0].end).equals(rewritten.subarray(rewrittenFrames[0].end))) {
+    throw new Error('移动后校验失败：会话事件内容发生变化')
+  }
+  const targetDir = deriveSessionDir(artifacts.root, canonical, sid)
+  await mkdir(targetDir, { recursive: true })
+  const staged = join(targetDir, `.move-stage-${process.pid}-${Date.now()}`)
+  await writeFile(staged, rewritten, { mode: 0o600 })
+  await rename(staged, join(targetDir, artifacts.generationFiles[0]))
+  return targetDir
+}
+
+// 跨工作区移动核心。events 为完整事件数组（官方 read 路径读回，seq 保持原值）。
+// seeded（fork 溯源）日志的物理事件 seq 不从 0 起步时，官方 assertContiguous
+// 会拒绝直录——此时把副本日志的 seq 重排为 0 起步（仅副本的存储序，事件内容
+// 不变），并在 create 时如实携带 inheritedEventCount 溯源。
+export async function moveSessionToCwd({ sp, sid, header, canonical, events = [], inheritedEventCount = 0 }) {
+  const artifacts = await locateSessionArtifacts(sp, header)
+  if (!artifacts) {
+    const error = new Error('无法定位该会话的物理日志，已停止移动')
+    error.status = 409
+    throw error
+  }
+  await ensureNoActiveWriter(sp, sid)
+  const newHeader = Object.assign({}, header, { cwd: canonical })
+  const firstSeq = events.length ? Number(events[0].seq) : 0
+  const replay = firstSeq !== 0 ? events.map((event, index) => ({ ...event, seq: index })) : events
+  const createOptions = header.isSeeded && Number.isSafeInteger(inheritedEventCount) && inheritedEventCount > 0
+    ? { inheritedEventCount }
+    : undefined
+  const backupPath = `${artifacts.logPath}.move-backup-${process.pid}-${Date.now()}`
+  await rename(artifacts.logPath, backupPath)
+  let writer = null
+  try {
+    try {
+      writer = await sp.create(newHeader, createOptions)
+      for (let i = 0; i < replay.length; i += MOVE_BATCH) {
+        await writer.append(replay.slice(i, i + MOVE_BATCH))
+      }
+      await writer.flush()
+      await writer.close()
+      writer = null
+    } catch (e) {
+      if (isAlreadyExists(e)) {
+        // 后端内存里已有同 id 记录（created-but-unmaterialized 幽灵等）：
+        // 回退到 frame0 改写搬运，不再走 create。
+        await relocateRewrittenBackup({ sid, canonical, backupPath, artifacts })
+      } else {
+        throw e
+      }
+    }
+    // 官方视角校验：新 cwd 必须生效；事件数一致（snapshot.eventCount 缺省时跳过）。
+    if (typeof sp.stat !== 'function') throw new Error('移动后无法校验：后端未提供 stat')
+    const after = await sp.stat(sid)
+    if (!after || !after.header || after.header.cwd !== canonical) {
+      throw new Error('移动后校验失败：会话工作目录未正确更新')
+    }
+    if (Number.isSafeInteger(after.eventCount) && events.length > 0 && after.eventCount !== events.length) {
+      throw new Error(`移动后校验失败：事件数不一致（源 ${events.length}，副本 ${after.eventCount}）`)
+    }
+  } catch (e) {
+    // 回滚：清掉目标目录里的半成品，把备份改名回原位。
+    await closeQuietly(writer)
+    try { await rm(deriveSessionDir(artifacts.root, canonical, sid), { recursive: true, force: true }) } catch (_) {}
+    try { await rename(backupPath, artifacts.logPath) } catch (_) {}
+    if (e && e.status) throw e
+    const error = new Error('移动会话日志失败：' + String((e && e.message) || e))
+    error.status = 500
+    throw error
+  }
+  try { await unlink(backupPath) } catch (e) { /* 备份清理失败不阻塞成功结果 */ }
+  return { sessionDir: deriveSessionDir(artifacts.root, canonical, sid) }
+}

package/src/handle-era-paths.js

@@ -0,0 +1,126 @@
+// Private-path derivation for the SessionHandle era (dsh-v0.1.3-alpha.1).
+//
+// 设计裁决（2026-09-06，用户明确决策）：官方公共契约不含 delete/move，而这两类
+// 能力在 legacy 时代本来就是「官方 locate 查路径 + 直接文件系统操作」的半官方
+// 实现。用户据此放弃 v3.5.2 早前「只走公共契约」的自我限制，要求沿用同一思路
+// 在 handle 时代恢复「彻底删除」与「跨工作区移动」。本模块把官方
+// session-persistence-jsonl 后端的确定性目录布局移植为可校验的路径推导，并配
+// 三层守卫，任何一层不满足都视为「推导失败」返回 null（调用方安全降级为禁用）：
+//
+//   1. root 必须直接读自后端实例字段（`sp.root`，构建产物里是普通实例属性），
+//      绝不猜测、绝不扫描磁盘反推。
+//   2. 会话目录 basename 必须等于 encodeSegment(id)，且目录内必须存在至少一个
+//      规范 generation 文件（session.vN.jsonl[.zstd]；临时/非规范名不算）。
+//   3. 最终日志路径还要过 pathOwnsSession 的 id 归属校验（含子串碰撞拒绝）——
+//      因此含异体字符的 id（编码后目录名 ≠ id）会安全降级为不可用。
+//
+// 布局规则移植自官方构建产物（session-persistence-jsonl/lib/index.js）：
+//   projectDir(root, cwd)  = root / projectKey(cwd)          （cwd 缺省 → _no-cwd）
+//   sessionDir(root, cwd, id) = projectDir / encodeSegment(id)
+//   generationLogFilename  = `session.vN.jsonl` + `.zstd`（compression=zstd）
+//   projectKey: 分隔符与 `:` → `-`；[A-Za-z0-9._-] 保留；其余 → `~XXXX`
+//   （charCode 的四位大写十六进制）；去前导 `-`；截断 251；空串回退 `root`。
+//   encodeSegment: 同样的 `~XXXX` 转义（`.`/`..` 例外）。
+
+import { readdir, stat } from 'node:fs/promises'
+import { basename, join } from 'node:path'
+import { pathOwnsSession } from './path-guard.js'
+
+const GENERATION_LOG_RE = /^session\.v\d+\.jsonl(\.zst(d)?)?$/
+
+function isSafeChar(ch) {
+  return ch !== '~' && /^[A-Za-z0-9._-]$/.test(ch)
+}
+
+export function projectKeyFor(cwd) {
+  const s = String(cwd)
+  if (s.length === 0) throw new Error('cannot encode an empty project path')
+  let readable = ''
+  let separatorRun = false
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i]
+    if (ch === '/' || ch === '\\' || ch === ':') {
+      if (!separatorRun) readable += '-'
+      separatorRun = true
+    } else if (isSafeChar(ch)) {
+      readable += ch
+      separatorRun = false
+    } else {
+      readable += '~' + s.charCodeAt(i).toString(16).toUpperCase().padStart(4, '0')
+      separatorRun = false
+    }
+  }
+  return '--' + ((readable.replace(/^-+/, '') || 'root').slice(0, 251)) + '--'
+}
+
+export function encodeSegmentFor(raw) {
+  const s = String(raw)
+  if (s.length === 0) throw new Error('cannot encode an empty path segment')
+  if (s === '.') return '~002E'
+  if (s === '..') return '~002E~002E'
+  let out = ''
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i]
+    out += isSafeChar(ch) ? ch : '~' + s.charCodeAt(i).toString(16).toUpperCase().padStart(4, '0')
+  }
+  return out
+}
+
+// 后端实例的 root 只在「实例字段确实携带非空字符串」时可信；拿不到就整体降级。
+export function resolveSessionRoot(sp) {
+  const root = sp && typeof sp === 'object' ? sp.root : undefined
+  return typeof root === 'string' && root.length > 0 ? root : null
+}
+
+export function deriveSessionDir(root, cwd, id) {
+  const project = cwd === undefined || cwd === null || cwd === ''
+    ? join(root, '_no-cwd')
+    : join(root, projectKeyFor(cwd))
+  return join(project, encodeSegmentFor(id))
+}
+
+// 纯推导（不做磁盘校验）。供测试与上层组合使用。
+export function deriveGenerationLogPath(root, cwd, id, { compression = 'zstd' } = {}) {
+  return join(deriveSessionDir(root, cwd, id), `session.v2.jsonl${compression === 'zstd' ? '.zstd' : ''}`)
+}
+
+// 定位一个已落盘会话的全部物理坐标；三层守卫在此汇合。返回
+//   { root, projectDir, sessionDir, logPath, generationFiles }
+// 或 null（root 不可用 / 目录不存在 / 无规范 generation / id 归属校验拒绝）。
+export async function locateSessionArtifacts(sp, header) {
+  const root = resolveSessionRoot(sp)
+  if (!root || !header || header.id == null) return null
+  const sid = String(header.id)
+  let sessionDir
+  try {
+    sessionDir = deriveSessionDir(root, header.cwd, sid)
+  } catch (e) {
+    return null
+  }
+  if (basename(sessionDir) !== encodeSegmentFor(sid)) return null
+  let entries
+  try {
+    const st = await stat(sessionDir)
+    if (!st.isDirectory()) return null
+    entries = await readdir(sessionDir)
+  } catch (e) {
+    return null
+  }
+  const generationFiles = entries.filter((name) => GENERATION_LOG_RE.test(name))
+  if (generationFiles.length === 0) return null
+  // 优先 current generation（v2 → 最高版本号），保持确定性。
+  generationFiles.sort((a, b) => {
+    const va = Number((a.match(/^session\.v(\d+)\./) || [])[1] || 0)
+    const vb = Number((b.match(/^session\.v(\d+)\./) || [])[1] || 0)
+    return vb - va
+  })
+  const logPath = join(sessionDir, generationFiles[0])
+  if (!pathOwnsSession(logPath, sid)) return null
+  return {
+    root,
+    projectDir: join(root, header.cwd === undefined || header.cwd === null || header.cwd === '' ? '_no-cwd' : projectKeyFor(header.cwd)),
+    sessionDir,
+    logPath,
+    generationFiles,
+  }
+}