tianshu-harness 3.23.0

package/dist/chunk-LH5VCGLB.js

@@ -0,0 +1,1796 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  parseFrozenSnapshotData
+} from "./chunk-6S5FPUS7.js";
+import {
+  normalizeOaiMessage,
+  normalizeOaiMessages
+} from "./chunk-EXXICUIW.js";
+import {
+  stableStringify
+} from "./chunk-QARAGUXX.js";
+import {
+  writeFileAtomicAsync,
+  writeFileAtomicSync
+} from "./chunk-A5MNH4ER.js";
+import {
+  init_paths,
+  sessionsDir
+} from "./chunk-BCQXEZPJ.js";
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/agent/session-persist.ts
+init_esm_shims();
+import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync5, unlinkSync as unlinkSync2, rmSync, readdirSync, statSync as statSync2 } from "fs";
+init_paths();
+import { isAbsolute, join as join5, relative, resolve } from "path";
+
+// src/context/session-memory.ts
+init_esm_shims();
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { createHash } from "crypto";
+
+// src/validation.ts
+init_esm_shims();
+var SESSION_ID_RE = /^[a-zA-Z0-9_-]{1,128}$/;
+function isValidSessionId(id) {
+  return SESSION_ID_RE.test(id);
+}
+function assertValidSessionId(id) {
+  if (!isValidSessionId(id)) throw new Error(`Invalid sessionId: ${id}`);
+}
+
+// src/context/session-memory.ts
+function memoryPath(dir, sessionId) {
+  assertValidSessionId(sessionId);
+  return join(dir, `${sessionId}.memory.json`);
+}
+function idFor(input) {
+  return createHash("sha256").update(`${input.createdAt}:${input.source}:${input.text}`).digest("hex").slice(0, 12);
+}
+function loadSessionMemory(dir, sessionId) {
+  const filePath = memoryPath(dir, sessionId);
+  if (!existsSync(filePath)) return { sessionId, entries: [] };
+  try {
+    return JSON.parse(readFileSync(filePath, "utf-8"));
+  } catch {
+    return { sessionId, entries: [] };
+  }
+}
+function appendSessionMemory(dir, sessionId, input) {
+  const state = loadSessionMemory(dir, sessionId);
+  const duplicate = state.entries.some((entry2) => entry2.text === input.text && entry2.source === input.source);
+  if (duplicate) return state;
+  const entry = { id: idFor(input), ...input };
+  const next = { sessionId, entries: [...state.entries, entry].slice(-50) };
+  writeFileAtomicSync(memoryPath(dir, sessionId), JSON.stringify(next, null, 2) + "\n");
+  return next;
+}
+function escapeXml(text) {
+  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+function buildSessionMemoryBlock(state) {
+  if (state.entries.length === 0) return "";
+  const entries = state.entries.map((entry) => `<entry id="${entry.id}" created_at="${entry.createdAt}" source="${entry.source}">${escapeXml(entry.text)}</entry>`);
+  return `<session-memory session_id="${state.sessionId}">
+${entries.join("\n")}
+</session-memory>`;
+}
+
+// src/context/claim-store.ts
+init_esm_shims();
+import { appendFileSync, existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, statSync, unlinkSync } from "fs";
+import { appendFile, rename, writeFile } from "fs/promises";
+import { join as join3 } from "path";
+
+// src/context/claims.ts
+init_esm_shims();
+import { createHash as createHash2 } from "crypto";
+function normalizeClaimText(text) {
+  return text.trim().replace(/\s+/g, " ").toLowerCase();
+}
+function claimIdFor(proposal) {
+  return createHash2("sha256").update(JSON.stringify({
+    kind: proposal.kind,
+    scope: proposal.scope,
+    text: normalizeClaimText(proposal.text),
+    sessionId: proposal.source.sessionId
+  })).digest("hex").slice(0, 12);
+}
+function kindFromAnchor(anchor) {
+  if (anchor.kind === "user_constraint") return "user_constraint";
+  if (anchor.kind === "user_preference") return "user_preference";
+  if (anchor.kind === "decision") return "decision";
+  if (anchor.kind === "verification") return "verification_fact";
+  if (anchor.kind === "error") return "failure_pattern";
+  return "file_observation";
+}
+function confidenceFromAnchor(anchor) {
+  if (anchor.kind === "user_constraint") return 0.9;
+  if (anchor.kind === "decision") return 0.82;
+  if (anchor.kind === "verification") return 0.88;
+  return 0.7;
+}
+function claimProposalFromAnchor(anchor, meta) {
+  return {
+    kind: kindFromAnchor(anchor),
+    scope: "session",
+    text: anchor.text,
+    confidence: confidenceFromAnchor(anchor),
+    fitness: anchor.salience,
+    source: {
+      actor: meta.actor,
+      sessionId: meta.sessionId,
+      turn: meta.turn,
+      eventId: meta.eventId
+    },
+    evidence: [{
+      id: `${meta.eventId}:anchor`,
+      kind: meta.actor === "user" ? "user_message" : "assistant_message",
+      summary: anchor.text,
+      createdAt: meta.createdAt
+    }],
+    createdAt: meta.createdAt,
+    tags: ["anchor", anchor.kind]
+  };
+}
+function createClaimFromProposal(proposal) {
+  return {
+    id: claimIdFor(proposal),
+    kind: proposal.kind,
+    scope: proposal.scope,
+    status: "active",
+    text: proposal.text,
+    confidence: proposal.confidence,
+    fitness: proposal.fitness,
+    source: proposal.source,
+    evidence: [...proposal.evidence],
+    consumers: [],
+    counterevidence: [],
+    createdAt: proposal.createdAt,
+    lastUsedAt: proposal.createdAt,
+    expiresAt: proposal.expiresAt,
+    tags: [...proposal.tags]
+  };
+}
+function isPromptEligibleClaim(claim, now = Date.now()) {
+  if (claim.expiresAt !== void 0 && claim.expiresAt <= now) return false;
+  return claim.status === "active" || claim.status === "durable_candidate" || claim.status === "durable";
+}
+function checkpointClaims(claims, now = Date.now(), lastEventSeq) {
+  const alive = claims.filter((c) => {
+    if (c.status === "stale" || c.status === "quarantined") return false;
+    if (c.expiresAt !== void 0 && c.expiresAt <= now) return false;
+    return true;
+  });
+  return {
+    version: 1,
+    createdAt: now,
+    ...lastEventSeq !== void 0 ? { lastEventSeq } : {},
+    claims: alive
+  };
+}
+function loadClaimSnapshot(snapshot, now = Date.now()) {
+  if (snapshot.version !== 1) return [];
+  return snapshot.claims.map((claim) => ({
+    ...claim,
+    lastUsedAt: now
+  }));
+}
+
+// src/context/promotion.ts
+init_esm_shims();
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+function canRecallClaim(claim, cwd) {
+  if (!cwd) return true;
+  const filePaths = claim.evidence.filter((e) => e.path !== void 0).map((e) => e.path);
+  if (filePaths.length === 0) return true;
+  return filePaths.some((p) => existsSync2(join2(cwd, p)));
+}
+function evaluatePromotion(claim, now = Date.now()) {
+  if (!isPromptEligibleClaim(claim, now)) return null;
+  if (claim.counterevidence.length > 0) return null;
+  if (claim.status === "active") {
+    if (new Set(claim.consumers.map((c) => c.id)).size < 3) return null;
+    return "durable_candidate";
+  }
+  if (claim.status === "durable_candidate") {
+    const age = now - claim.createdAt;
+    if (age < 10 * 6e4) return null;
+    if (new Set(claim.consumers.map((c) => c.id)).size < 5) return null;
+    return "durable";
+  }
+  return null;
+}
+function claimHasFileEvidence(claim, path) {
+  if (claim.kind !== "file_observation" && claim.kind !== "verification_fact") return false;
+  return claim.evidence.some((evidence) => evidence.path === path);
+}
+function countClaimsByStatus(claims) {
+  return claims.reduce((counts, c) => {
+    if (c.status === "active") return { ...counts, active: counts.active + 1 };
+    if (c.status === "stale") return { ...counts, stale: counts.stale + 1 };
+    if (c.status === "conflicted") return { ...counts, conflicted: counts.conflicted + 1 };
+    if (c.status === "durable") return { ...counts, durable: counts.durable + 1 };
+    if (c.status === "durable_candidate") return { ...counts, durableCandidate: counts.durableCandidate + 1 };
+    if (c.status === "quarantined") return { ...counts, quarantined: counts.quarantined + 1 };
+    return counts;
+  }, { active: 0, stale: 0, conflicted: 0, durable: 0, durableCandidate: 0, quarantined: 0, recallBlocked: 0 });
+}
+
+// src/context/claim-store.ts
+var MAX_CONSUMERS_PER_CLAIM = 50;
+var MAX_ACTIVE_CLAIMS = 50;
+var DEFAULT_CHECKPOINT_EVERY_EVENTS = 500;
+var DEFAULT_MAX_TRANSIENT_WRITE_RETRIES = 8;
+var ContextClaimStore = class _ContextClaimStore {
+  path;
+  sessionId;
+  cachedEvents = null;
+  lastFileSize = -1;
+  cachedClaims = null;
+  lastProcessedLineCount = 0;
+  snapshotPath;
+  // ⚠️ Single-writer assumption: seq is per-instance, not coordinated across processes.
+  // If multiple processes append to the same .claims.jsonl concurrently, seq may collide.
+  // This is acceptable because claim-store is session-scoped and each session has exactly one writer.
+  nextSeq = 1;
+  checkpointing = false;
+  checkpointEveryEvents;
+  maxTransientWriteRetries;
+  constructor(dir, sessionId, options = {}) {
+    assertValidSessionId(sessionId);
+    this.sessionId = sessionId;
+    this.checkpointEveryEvents = options.checkpointEveryEvents ?? DEFAULT_CHECKPOINT_EVERY_EVENTS;
+    this.maxTransientWriteRetries = options.maxTransientWriteRetries ?? DEFAULT_MAX_TRANSIENT_WRITE_RETRIES;
+    mkdirSync(dir, { recursive: true });
+    this.path = join3(dir, `${this.sessionId}.claims.jsonl`);
+    this.snapshotPath = join3(dir, `${this.sessionId}.claims.snapshot.json`);
+  }
+  get eventCount() {
+    return this.readEvents().length;
+  }
+  appendEvent(event) {
+    if (!this.cachedEvents) {
+      if (existsSync3(this.path)) this.readEvents();
+      const checkpointSnapshot = this.loadFromCheckpoint();
+      if (checkpointSnapshot) this.nextSeq = Math.max(this.nextSeq, checkpointSnapshot.lastEventSeq + 1);
+      if (!this.cachedEvents) this.cachedEvents = [];
+      if (this.lastFileSize < 0) this.lastFileSize = 0;
+    }
+    const withSeq = { ...event, seq: event.seq ?? this.nextSeq };
+    const line = JSON.stringify(withSeq) + "\n";
+    const bytes = Buffer.byteLength(line);
+    this.pendingLines.push(line);
+    this.pendingBytes += bytes;
+    this.kickWriteChain();
+    this.nextSeq = Math.max(this.nextSeq, (withSeq.seq ?? 0) + 1);
+    this.cachedEvents.push(withSeq);
+    this.lastFileSize += bytes;
+    if (!this.checkpointing && this.checkpointEveryEvents !== void 0 && this.checkpointEveryEvents > 0 && this.cachedEvents !== null && this.cachedEvents.length >= this.checkpointEveryEvents) {
+      this.checkpointQueued = true;
+      this.kickWriteChain();
+    }
+  }
+  // ── 写链（claims.jsonl 唯一写者）─────────────────────────────────────
+  pendingLines = [];
+  /** 在途未写字节数：readEvents 外部修改检测的「磁盘合法滞后」基线。 */
+  pendingBytes = 0;
+  writeChain = { running: false, again: false };
+  checkpointQueued = false;
+  /** 重试不会改变结果的写入错误码（路径不存在 / 不是目录 / 只读文件系统）。 */
+  static PERMANENT_WRITE_ERROR_CODES = /* @__PURE__ */ new Set([
+    "ENOENT",
+    "ENOTDIR",
+    "EROFS",
+    "EISDIR"
+  ]);
+  /** 撞上永久性错误后置起：停止自动重试。继续重试只会留下永不终止的 250ms
+   *  定时器链，使事件循环永远非空——node --test 因此既不打印汇总也不退出
+   *  （实测：context-injection.test.ts 的 finally 删掉本 store 的目录后整批挂死）。
+   *  新 kick（新数据 / flushWrites）时清位，允许环境恢复后再试。 */
+  permanentWriteFailure = false;
+  /** 最近一次写失败（诊断用，停链时读取输出现场日志）。 */
+  lastWriteError = null;
+  /** 短暂性错误（EACCES/EPERM/EBUSY——AV/EDR 秒级锁会自愈，及未知码）的连续
+   *  失败计数：成功写入即清零；达 maxTransientWriteRetries 才转永久停链。
+   *  一次 EACCES 即停链会让锁释放后滞留行永久留在内存（agent-16）。 */
+  transientWriteRetries = 0;
+  /** 停链诊断「每实例至多一次」的独立闸：不复用 lastWriteError 判定——
+   *  checkpoint 段异常（kickWriteChain 的 catch）也会赋 lastWriteError，
+   *  复用会让「首次真停链」静默无日志。 */
+  stallLogged = false;
+  /** 诊断读取点：最近一次的写失败（写链停链原因 / checkpoint 段异常），
+   *  供排障与测试断言使用（lastWriteError 的真实消费点）。 */
+  getLastWriteError() {
+    return this.lastWriteError;
+  }
+  /** 写链停链的现场记录：置状态 + 首次停链输出一次诊断（写链停了 = 滞留行留
+   *  在内存，值得在日志里可见；后续重试失败不再重复打）。 */
+  stallWriteChain(err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    this.permanentWriteFailure = true;
+    this.lastWriteError = error;
+    if (!this.stallLogged) {
+      this.stallLogged = true;
+      console.error(
+        `[claim-store] \u5199\u94FE\u505C\u94FE\uFF08${error.message}\uFF09\u2014\u2014\u6EDE\u7559\u884C\u4FDD\u7559\u5728\u5185\u5B58\uFF0C\u73AF\u5883\u6062\u590D\u540E\u7531\u65B0\u4E8B\u4EF6 / flushWrites \u91CD\u8BD5`
+      );
+    }
+  }
+  kickWriteChain() {
+    if (this.writeChain.running) {
+      this.writeChain.again = true;
+      return;
+    }
+    this.permanentWriteFailure = false;
+    this.transientWriteRetries = 0;
+    queueMicrotask(() => {
+      if (this.writeChain.running) return;
+      this.writeChain.running = true;
+      void this.runWriteChain().catch((err) => {
+        this.lastWriteError = err instanceof Error ? err : new Error(String(err));
+      });
+    });
+  }
+  async runWriteChain() {
+    try {
+      for (; ; ) {
+        this.writeChain.again = false;
+        const lines = this.pendingLines;
+        const wantCheckpoint = this.checkpointQueued;
+        this.checkpointQueued = false;
+        if (lines.length === 0 && !wantCheckpoint) break;
+        if (lines.length > 0) {
+          this.pendingLines = [];
+          const text = lines.join("");
+          try {
+            await appendFile(this.path, text, "utf-8");
+            this.pendingBytes -= Buffer.byteLength(text);
+            this.transientWriteRetries = 0;
+          } catch (err) {
+            this.pendingLines = [...lines, ...this.pendingLines];
+            const code = err.code ?? "";
+            if (_ContextClaimStore.PERMANENT_WRITE_ERROR_CODES.has(code)) {
+              this.stallWriteChain(err);
+              return;
+            }
+            this.transientWriteRetries++;
+            if (this.transientWriteRetries >= this.maxTransientWriteRetries) {
+              this.stallWriteChain(err);
+              return;
+            }
+            await new Promise((r) => setTimeout(r, 250));
+            continue;
+          }
+        }
+        if (wantCheckpoint) await this.checkpointOnChain();
+        if (!this.writeChain.again && this.pendingLines.length === 0 && !this.checkpointQueued) break;
+      }
+    } finally {
+      this.writeChain.running = false;
+      this.writeChain.again = false;
+      if (!this.permanentWriteFailure && (this.pendingLines.length > 0 || this.checkpointQueued)) {
+        this.kickWriteChain();
+      }
+    }
+  }
+  /** checkpoint 的链内异步版：快照由内存态派生（cachedEvents/cachedClaims 在
+   *  appendEvent 时同步更新），文件写全部异步，截断与后续 append 由链保序。 */
+  async checkpointOnChain(now = Date.now()) {
+    this.checkpointing = true;
+    try {
+      const snapshot = checkpointClaims(this.listClaims(), now, this.maxEventSeq(this.readEvents()));
+      const tmpSnapshot = `${this.snapshotPath}.tmp`;
+      await writeFile(tmpSnapshot, JSON.stringify(snapshot, null, 2) + "\n", "utf-8");
+      await rename(tmpSnapshot, this.snapshotPath);
+      const tmpLog = `${this.path}.tmp`;
+      await writeFile(tmpLog, "", "utf-8");
+      await rename(tmpLog, this.path);
+      this.cachedEvents = [];
+      this.cachedClaims = loadClaimSnapshot(snapshot, now);
+      this.lastProcessedLineCount = 0;
+      this.lastFileSize = 0;
+      this.pendingBytes = 0;
+    } finally {
+      this.checkpointing = false;
+    }
+  }
+  /** 等写链排空（测试/收口用）。 */
+  async flushWrites(timeoutMs = 1e4) {
+    this.kickWriteChain();
+    const deadline = Date.now() + timeoutMs;
+    let requeued = false;
+    for (; ; ) {
+      if (!this.writeChain.running && this.pendingLines.length === 0 && !this.checkpointQueued) return;
+      if (!this.writeChain.running && (this.pendingLines.length > 0 || this.checkpointQueued)) {
+        if (requeued) return;
+        requeued = true;
+        this.kickWriteChain();
+      }
+      if (Date.now() > deadline) return;
+      await new Promise((r) => setTimeout(r, 10));
+    }
+  }
+  propose(proposal) {
+    const claim = createClaimFromProposal(proposal);
+    const existing = this.listClaims().find((current) => current.id === claim.id);
+    if (existing) return existing;
+    this.appendEvent({
+      type: "claim_proposed",
+      eventId: `${proposal.source.eventId}:claim:${claim.id}`,
+      createdAt: proposal.createdAt,
+      claim
+    });
+    this.evictExcessActiveClaims();
+    return claim;
+  }
+  updateClaimStatus(id, status, reason) {
+    const current = this.listClaims().find((claim) => claim.id === id);
+    if (!current) return null;
+    this.appendEvent({
+      type: "claim_status_changed",
+      eventId: `${id}:status:${status}:${Date.now()}`,
+      createdAt: Date.now(),
+      claimId: id,
+      status,
+      reason
+    });
+    return this.listClaims().find((claim) => claim.id === id) ?? null;
+  }
+  recordClaimUsed(id, input) {
+    const current = this.listClaims().find((claim) => claim.id === id);
+    if (!current) return null;
+    this.appendEvent({
+      type: "claim_used",
+      eventId: `${id}:used:${input.consumerId}:${input.usedAt}`,
+      createdAt: input.usedAt,
+      claimId: id,
+      consumerId: input.consumerId,
+      consumerKind: input.consumerKind
+    });
+    return this.listClaims().find((claim) => claim.id === id) ?? null;
+  }
+  boostFitness(id, delta, cap) {
+    const claim = this.listClaims().find((c) => c.id === id);
+    if (!claim) return null;
+    const newFitness = Math.min(claim.fitness + delta, cap);
+    this.appendEvent({
+      type: "claim_boosted",
+      eventId: `${id}:boost:${Date.now()}`,
+      createdAt: Date.now(),
+      claimId: id,
+      fitness: newFitness
+    });
+    return { ...claim, fitness: newFitness };
+  }
+  listClaims(filter = {}) {
+    return this.projectClaims().filter((claim) => {
+      if (filter.status && !filter.status.includes(claim.status)) return false;
+      if (filter.kind && !filter.kind.includes(claim.kind)) return false;
+      if (filter.scope && !filter.scope.includes(claim.scope)) return false;
+      return true;
+    });
+  }
+  listActiveClaims(now = Date.now()) {
+    return this.listClaims().filter((claim) => isPromptEligibleClaim(claim, now));
+  }
+  listClaimsByFileEvidence(path) {
+    return this.listClaims().filter((claim) => claimHasFileEvidence(claim, path));
+  }
+  getStatusCounts() {
+    return countClaimsByStatus(this.listClaims());
+  }
+  markClaimsStaleForFile(path, reason) {
+    const changed = [];
+    for (const claim of this.listClaimsByFileEvidence(path)) {
+      if (claim.status === "stale" || claim.status === "quarantined") continue;
+      const updated = this.updateClaimStatus(claim.id, "stale", reason);
+      if (updated) changed.push(updated);
+    }
+    return changed;
+  }
+  promoteEligibleClaims(now = Date.now(), cwd) {
+    const promoted = [];
+    for (const claim of this.listClaims()) {
+      const next = evaluatePromotion(claim, now);
+      if (!next) continue;
+      if (!canRecallClaim(claim, cwd)) {
+        this.updateClaimStatus(claim.id, "stale", "recall-gate: evidence files no longer exist");
+        continue;
+      }
+      const updated = this.updateClaimStatus(claim.id, next, "promotion threshold met");
+      if (updated) promoted.push(updated);
+    }
+    this.evictExcessActiveClaims();
+    return promoted;
+  }
+  evictExcessActiveClaims() {
+    const evictable = this.listActiveClaims().filter((c) => c.status !== "durable");
+    if (evictable.length <= MAX_ACTIVE_CLAIMS) return;
+    const toEvict = [...evictable].sort((a, b) => a.createdAt - b.createdAt).slice(0, evictable.length - MAX_ACTIVE_CLAIMS);
+    for (const claim of toEvict) {
+      this.updateClaimStatus(claim.id, "stale", "evicted-overflow");
+    }
+  }
+  exportSession() {
+    const disk = existsSync3(this.path) ? readFileSync2(this.path, "utf-8") : "";
+    return disk + this.pendingLines.join("");
+  }
+  /**
+   * Checkpoint: write current claims state as a snapshot, then truncate JSONL.
+   * Follows Redis 7.0 Base+Incr pattern:
+   * - Snapshot = full projected state (base)
+   * - JSONL = incremental events after snapshot (incr)
+   * - Load = read snapshot + replay incr events
+   */
+  checkpoint(now = Date.now()) {
+    if (this.writeChain.running) {
+      this.checkpointQueued = true;
+      this.kickWriteChain();
+      const snapshot = checkpointClaims(this.listClaims(), now, this.maxEventSeq(this.readEvents()));
+      return { snapshotPath: this.snapshotPath, claimCount: snapshot.claims.length, truncatedPath: this.path };
+    }
+    if (this.pendingLines.length > 0) {
+      try {
+        appendFileSync(this.path, this.pendingLines.join(""), "utf-8");
+        this.pendingLines = [];
+        this.pendingBytes = 0;
+      } catch {
+      }
+    }
+    this.checkpointing = true;
+    try {
+      const snapshot = checkpointClaims(this.listClaims(), now, this.maxEventSeq(this.readEvents()));
+      writeFileAtomicSync(this.snapshotPath, JSON.stringify(snapshot, null, 2) + "\n");
+      writeFileAtomicSync(this.path, "");
+      this.cachedEvents = [];
+      this.cachedClaims = loadClaimSnapshot(snapshot, now);
+      this.lastProcessedLineCount = 0;
+      this.lastFileSize = 0;
+      return { snapshotPath: this.snapshotPath, claimCount: snapshot.claims.length, truncatedPath: this.path };
+    } finally {
+      this.checkpointing = false;
+    }
+  }
+  /**
+   * Load claims from checkpoint snapshot. Incremental JSONL events are replayed
+   * by projectClaims() after this base state is loaded.
+   */
+  loadFromCheckpoint(now = Date.now()) {
+    if (!existsSync3(this.snapshotPath)) return null;
+    try {
+      const raw = readFileSync2(this.snapshotPath, "utf-8");
+      const snapshot = JSON.parse(raw);
+      return {
+        claims: loadClaimSnapshot(snapshot, now),
+        // Old snapshots predate watermarks and were always paired with a
+        // truncated JSONL in production. Treat them as base state only.
+        lastEventSeq: snapshot.lastEventSeq ?? 0
+      };
+    } catch {
+      return null;
+    }
+  }
+  /** Delete checkpoint snapshot file (for testing or cleanup). */
+  deleteCheckpoint() {
+    if (existsSync3(this.snapshotPath)) {
+      unlinkSync(this.snapshotPath);
+    }
+  }
+  static loadDurableClaims(dir, sessionId) {
+    if (!existsSync3(join3(dir, `${sessionId}.claims.jsonl`)) && !existsSync3(join3(dir, `${sessionId}.claims.snapshot.json`))) return [];
+    const store = new _ContextClaimStore(dir, sessionId);
+    return store.listClaims().filter((c) => c.status === "durable");
+  }
+  readEvents() {
+    if (this.cachedEvents) {
+      if (!existsSync3(this.path)) {
+        return this.lastFileSize === this.pendingBytes ? this.cachedEvents : [];
+      }
+      const size = statSync(this.path).size;
+      if (size === this.lastFileSize - this.pendingBytes) return this.cachedEvents;
+    } else if (!existsSync3(this.path)) {
+      return [];
+    }
+    const content = readFileSync2(this.path, "utf-8");
+    this.lastFileSize = Buffer.byteLength(content);
+    const events = content.split("\n").filter((line) => line.trim().length > 0).flatMap((line) => {
+      try {
+        return [JSON.parse(line)];
+      } catch {
+        return [];
+      }
+    });
+    this.cachedEvents = events;
+    this.nextSeq = Math.max(1, this.maxEventSeq(events) + 1);
+    return events;
+  }
+  maxEventSeq(events) {
+    return events.reduce((max, event, index) => Math.max(max, event.seq ?? index + 1), 0);
+  }
+  projectClaims() {
+    const events = this.readEvents();
+    if (this.cachedClaims && this.lastProcessedLineCount === events.length) {
+      return this.cachedClaims;
+    }
+    if (this.cachedClaims && this.lastProcessedLineCount < events.length) {
+      const newEvents = events.slice(this.lastProcessedLineCount);
+      const map = new Map(this.cachedClaims.map((c) => [c.id, c]));
+      this.applyEventsToMap(map, newEvents);
+      this.cachedClaims = [...map.values()];
+      this.lastProcessedLineCount = events.length;
+      return this.cachedClaims;
+    }
+    const checkpointSnapshot = this.loadFromCheckpoint();
+    if (checkpointSnapshot) {
+      const claims2 = new Map(checkpointSnapshot.claims.map((c) => [c.id, c]));
+      this.nextSeq = Math.max(this.nextSeq, checkpointSnapshot.lastEventSeq + 1, this.maxEventSeq(events) + 1);
+      const replayEvents = events.filter((event, index) => (event.seq ?? index + 1) > checkpointSnapshot.lastEventSeq);
+      this.applyEventsToMap(claims2, replayEvents);
+      this.cachedClaims = [...claims2.values()];
+      this.lastProcessedLineCount = events.length;
+      return this.cachedClaims;
+    }
+    const claims = /* @__PURE__ */ new Map();
+    this.applyEventsToMap(claims, events);
+    this.cachedClaims = [...claims.values()];
+    this.lastProcessedLineCount = events.length;
+    return this.cachedClaims;
+  }
+  applyEventsToMap(claims, events) {
+    for (const event of events) {
+      if (event.type === "claim_proposed") {
+        if (!claims.has(event.claim.id)) {
+          claims.set(event.claim.id, event.claim);
+        }
+        continue;
+      }
+      if (event.type === "claim_status_changed") {
+        const claim = claims.get(event.claimId);
+        if (!claim) continue;
+        const counterevidence = event.status === "active" ? claim.counterevidence : [...claim.counterevidence, {
+          id: event.eventId,
+          kind: "tool_result",
+          summary: event.reason,
+          createdAt: event.createdAt
+        }];
+        claims.set(event.claimId, { ...claim, status: event.status, counterevidence });
+        continue;
+      }
+      if (event.type === "claim_used") {
+        const claim = claims.get(event.claimId);
+        if (!claim) continue;
+        const newConsumers = [...claim.consumers, {
+          id: event.consumerId,
+          kind: event.consumerKind,
+          usedAt: event.createdAt
+        }];
+        const cappedConsumers = newConsumers.length > MAX_CONSUMERS_PER_CLAIM ? newConsumers.slice(-MAX_CONSUMERS_PER_CLAIM) : newConsumers;
+        claims.set(event.claimId, {
+          ...claim,
+          lastUsedAt: event.createdAt,
+          consumers: cappedConsumers
+        });
+        continue;
+      }
+      if (event.type === "claim_boosted") {
+        const claim = claims.get(event.claimId);
+        if (!claim) continue;
+        claims.set(event.claimId, { ...claim, fitness: event.fitness });
+        continue;
+      }
+    }
+  }
+};
+
+// src/agent/checksum.ts
+init_esm_shims();
+import { createHash as createHash3 } from "crypto";
+function computeLineChecksum(jsonLine) {
+  const hash = createHash3("sha256").update(jsonLine).digest("hex");
+  return hash.slice(0, 16);
+}
+function appendChecksum(jsonLine) {
+  const checksum = computeLineChecksum(jsonLine);
+  return `${jsonLine}|${checksum}`;
+}
+function verifyAndExtract(line) {
+  const trimmed = line.trim();
+  if (!trimmed) {
+    return { valid: false, json: "", isLegacy: false, error: "Empty line" };
+  }
+  const lastPipe = trimmed.lastIndexOf("|");
+  if (lastPipe === -1) {
+    return { valid: true, json: trimmed, isLegacy: true };
+  }
+  const jsonPart = trimmed.slice(0, lastPipe);
+  const storedChecksum = trimmed.slice(lastPipe + 1);
+  if (!/^[0-9a-f]{16}$/.test(storedChecksum)) {
+    return { valid: true, json: trimmed, isLegacy: true };
+  }
+  try {
+    JSON.parse(jsonPart);
+  } catch {
+    return { valid: true, json: trimmed, isLegacy: true };
+  }
+  const computedChecksum = computeLineChecksum(jsonPart);
+  if (computedChecksum !== storedChecksum) {
+    return {
+      valid: false,
+      json: jsonPart,
+      isLegacy: false,
+      error: `Checksum mismatch: expected ${computedChecksum}, got ${storedChecksum}`
+    };
+  }
+  return { valid: true, json: jsonPart, isLegacy: false };
+}
+function verifyLines(lines) {
+  let invalidCount = 0;
+  let legacyCount = 0;
+  const validLines = [];
+  for (const line of lines) {
+    const result = verifyAndExtract(line);
+    if (result.valid) {
+      validLines.push(result.json);
+      if (result.isLegacy) legacyCount++;
+    } else {
+      invalidCount++;
+    }
+  }
+  return { validLines, invalidCount, legacyCount };
+}
+
+// src/agent/session-transcript-codec.ts
+init_esm_shims();
+import { constants, zstdCompressSync, zstdDecompressSync } from "zlib";
+var ZSTD_MAGIC_LE = 4247762216;
+var CHECKSUM_OPTIONS = {
+  params: { [constants.ZSTD_c_checksumFlag]: 1 }
+};
+function scanZstdFrames(buffer) {
+  const frames = [];
+  let offset = 0;
+  while (offset < buffer.length) {
+    const start = offset;
+    if (buffer.length - offset < 4) return { frames, tornStart: start };
+    if (buffer.readUInt32LE(offset) !== ZSTD_MAGIC_LE) {
+      throw new Error(`corrupt session transcript: invalid frame magic at byte ${offset}`);
+    }
+    offset += 4;
+    if (offset === buffer.length) return { frames, tornStart: start };
+    const descriptor = buffer.readUInt8(offset);
+    offset += 1;
+    if ((descriptor & 24) !== 0) {
+      throw new Error(`corrupt session transcript: reserved frame-header bit at byte ${offset - 1}`);
+    }
+    const contentSizeFlag = descriptor >>> 6;
+    const singleSegment = (descriptor & 32) !== 0;
+    const checksum = (descriptor & 4) !== 0;
+    const dictionaryFlag = descriptor & 3;
+    const dictionaryBytes = dictionaryFlag === 3 ? 4 : dictionaryFlag;
+    const contentSizeBytes = contentSizeFlag === 0 ? singleSegment ? 1 : 0 : 1 << contentSizeFlag;
+    const remainingHeaderBytes = (singleSegment ? 0 : 1) + dictionaryBytes + contentSizeBytes;
+    if (buffer.length - offset < remainingHeaderBytes) return { frames, tornStart: start };
+    offset += remainingHeaderBytes;
+    for (; ; ) {
+      if (buffer.length - offset < 3) return { frames, tornStart: start };
+      const blockHeader = buffer.readUIntLE(offset, 3);
+      offset += 3;
+      const lastBlock = (blockHeader & 1) !== 0;
+      const blockType = blockHeader >>> 1 & 3;
+      const blockSize = blockHeader >>> 3;
+      if (blockType === 3) {
+        throw new Error(`corrupt session transcript: reserved block type at byte ${offset - 3}`);
+      }
+      const payloadBytes = blockType === 1 ? 1 : blockSize;
+      if (buffer.length - offset < payloadBytes) return { frames, tornStart: start };
+      offset += payloadBytes;
+      if (lastBlock) break;
+    }
+    if (checksum) {
+      if (buffer.length - offset < 4) return { frames, tornStart: start };
+      offset += 4;
+    }
+    frames.push({ start, end: offset });
+  }
+  return { frames };
+}
+function isZstdFrameStream(buffer) {
+  return buffer.length >= 4 && buffer.readUInt32LE(0) === ZSTD_MAGIC_LE;
+}
+function encodeBatch(text) {
+  if (text.length === 0) return Buffer.alloc(0);
+  return zstdCompressSync(Buffer.from(text, "utf-8"), CHECKSUM_OPTIONS);
+}
+function decodeTranscriptText(buffer) {
+  if (buffer.length === 0) return "";
+  if (!isZstdFrameStream(buffer)) return buffer.toString("utf-8");
+  const { frames } = scanZstdFrames(buffer);
+  if (frames.length === 0) return "";
+  const parts = [];
+  for (const frame of frames) {
+    const plain = zstdDecompressSync(buffer.subarray(frame.start, frame.end));
+    parts.push(plain.toString("utf-8"));
+  }
+  return parts.join("");
+}
+
+// src/agent/session-batch-writer.ts
+init_esm_shims();
+import { appendFileSync as appendFileSync2, copyFileSync, existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { appendFile as appendFile2, open } from "fs/promises";
+import { join as join4 } from "path";
+var SessionBatchWriter = class {
+  constructor(filePath, backupDirProvider) {
+    this.filePath = filePath;
+    this.backupDirProvider = backupDirProvider;
+  }
+  filePath;
+  backupDirProvider;
+  /** Write-behind batch: JSONL text waiting for the next flush. */
+  pendingBuffer = "";
+  flushTimer = null;
+  flushPromise = null;
+  /** Set once the transcript file is known to be zstd-frame format. */
+  codecReady = false;
+  /**
+   * Queue a JSONL line into the batch. The batch is flushed by a 200ms timer,
+   * an explicit flush barrier, or compaction — whichever comes first.
+   *
+   * Exception: the first line of a brand-new session flushes synchronously so
+   * the session file exists immediately, and a crash within the first 200ms
+   * cannot lose the entire session.
+   */
+  enqueueLine(line) {
+    this.pendingBuffer += line;
+    if (this.flushTimer === null) {
+      if (!this.codecReady && !existsSync4(this.filePath)) {
+        this.flushSync();
+        return;
+      }
+      this.flushTimer = setTimeout(() => {
+        this.flushTimer = null;
+        void this.flush().catch((err) => {
+          console.error("[session-persist] batch flush failed:", err);
+        });
+      }, 200);
+      this.flushTimer.unref?.();
+    }
+  }
+  /**
+   * Flush barrier: cancel the timer, drain the pending batch into one
+   * checksummed zstd frame append + datasync. Concurrent callers share the
+   * in-flight drain promise; a drain that arrives while one is already in
+   * flight still drains whatever queued in the meantime (the awaited promise
+   * only covers the batch it started with).
+   *
+   * On write failure the batch is put back at the head of the buffer so the
+   * next flush / shutdown drain retries it — a failed append must not
+   * permanently drop queued lines (ENOSPC etc.).
+   */
+  async flush() {
+    if (this.flushTimer !== null) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.flushPromise !== null) return this.flushPromise;
+    this.flushPromise = this.drainPending().finally(() => {
+      this.flushPromise = null;
+    });
+    return this.flushPromise;
+  }
+  async drainPending() {
+    while (this.pendingBuffer.length > 0) {
+      const text = this.pendingBuffer;
+      this.pendingBuffer = "";
+      try {
+        await this.writeBatch(text);
+      } catch (err) {
+        this.pendingBuffer = text + this.pendingBuffer;
+        throw err;
+      }
+    }
+  }
+  /** Synchronous flush variant for the sync compaction paths. */
+  flushSync() {
+    if (this.flushTimer !== null) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    const text = this.pendingBuffer;
+    this.pendingBuffer = "";
+    if (text.length > 0) {
+      this.ensureCodecFormat();
+      const frame = encodeBatch(text);
+      if (frame.length > 0) appendFileSync2(this.filePath, frame, { mode: 384 });
+    }
+  }
+  /**
+   * Merge the on-disk transcript text with lines still queued in the batch —
+   * in-process readers must see un-flushed lines (append followed by load
+   * without a flush is valid).
+   */
+  mergePending(onDiskText) {
+    return this.pendingBuffer.length > 0 ? onDiskText + this.pendingBuffer : onDiskText;
+  }
+  async writeBatch(text) {
+    this.ensureCodecFormat();
+    const frame = encodeBatch(text);
+    if (frame.length === 0) return;
+    await appendFile2(this.filePath, frame, { mode: 384 });
+    await this.fdatasyncQuiet();
+  }
+  /**
+   * One-time migration: on the first write, a legacy plain-text transcript is
+   * backed up and transcoded to a single zstd frame so subsequent appends can
+   * stay frame-aligned. New files and already-compressed files are untouched.
+   */
+  ensureCodecFormat() {
+    if (this.codecReady) return;
+    this.codecReady = true;
+    if (!existsSync4(this.filePath)) return;
+    const head = readFileSync3(this.filePath);
+    if (isZstdFrameStream(head)) return;
+    try {
+      copyFileSync(this.filePath, join4(this.backupDirProvider(), this.filePath.split("/").pop() + ".pre-zstd"));
+    } catch {
+    }
+    const frame = encodeBatch(head.toString("utf-8"));
+    writeFileAtomicSync(this.filePath, frame.length > 0 ? frame : Buffer.alloc(0));
+  }
+  /** Force appended data to disk without blocking the event loop. */
+  async fdatasyncQuiet() {
+    try {
+      const fh = await open(this.filePath, "a");
+      try {
+        await fh.datasync();
+      } finally {
+        await fh.close();
+      }
+    } catch {
+    }
+  }
+};
+
+// src/agent/session-metadata.ts
+init_esm_shims();
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+var SessionMetadataStore = class {
+  constructor(metadataPath) {
+    this.metadataPath = metadataPath;
+  }
+  metadataPath;
+  /** In-memory cache: null = not loaded, undefined = no file on disk. */
+  cached = null;
+  /** Set when in-memory metadata diverges from disk. */
+  dirty = false;
+  load() {
+    if (this.cached !== null) return this.cached;
+    if (!existsSync5(this.metadataPath)) {
+      this.cached = void 0;
+      return void 0;
+    }
+    try {
+      this.cached = JSON.parse(readFileSync4(this.metadataPath, "utf-8"));
+    } catch {
+      this.cached = void 0;
+    }
+    return this.cached;
+  }
+  /** Synchronously durable write (initMetadata / external writers). */
+  write(metadata) {
+    this.cached = metadata;
+    this.dirty = false;
+    writeFileAtomicSync(this.metadataPath, JSON.stringify(metadata, null, 2) + "\n");
+  }
+  /**
+   * Upsert fields in memory only. Merge semantics: sessionId/createdAt win
+   * from explicit arguments, updatedAt always advances, tokenUsage merges
+   * nested instead of replacing. Disk write rides the batch flush cadence.
+   */
+  update(patch, sessionId) {
+    const existing = this.load();
+    const merged = {
+      compactEvents: existing?.compactEvents ?? [],
+      ...existing,
+      ...patch,
+      // These must win over ...existing/...patch — place them last:
+      // - sessionId is authoritative from the caller
+      // - createdAt is set once at creation and preserved thereafter
+      // - updatedAt always advances to now (the whole point of the field;
+      //   spreading ...existing after it would freeze it at creation time)
+      sessionId,
+      createdAt: existing?.createdAt ?? Date.now(),
+      updatedAt: Date.now(),
+      // Preserve nested objects by merging, not replacing
+      tokenUsage: existing?.tokenUsage || patch.tokenUsage ? { prompt: 0, completion: 0, total: 0, ...existing?.tokenUsage, ...patch.tokenUsage } : void 0
+    };
+    this.cached = merged;
+    this.dirty = true;
+  }
+  /** Persist in-memory metadata when dirty (batch-flush cadence). */
+  flush() {
+    if (!this.dirty) return;
+    try {
+      writeFileAtomicSync(this.metadataPath, JSON.stringify(this.cached ?? {}, null, 2) + "\n");
+    } catch (err) {
+      this.dirty = true;
+      throw err;
+    }
+    this.dirty = false;
+  }
+};
+
+// src/agent/session-persist.ts
+init_paths();
+function legacyMessageToOaiMessages(message) {
+  if (typeof message.content === "string") {
+    return [{ role: message.role, content: message.content }];
+  }
+  if (message.role === "user") {
+    const text2 = message.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+    const toolMessages = message.content.filter((block) => block.type === "tool_result").map((block) => ({ role: "tool", tool_call_id: block.tool_use_id, content: block.content }));
+    return [
+      ...text2 ? [{ role: "user", content: text2 }] : [],
+      ...toolMessages
+    ];
+  }
+  const text = message.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+  const reasoning = message.content.filter((block) => block.type === "thinking").map((block) => block.thinking).join("");
+  const toolCalls = message.content.filter((block) => block.type === "tool_use").map((block) => ({
+    id: block.id,
+    type: "function",
+    function: { name: block.name, arguments: stableStringify(block.input) }
+  }));
+  const assistant = {
+    role: "assistant",
+    content: text || (toolCalls.length === 0 ? "" : null),
+    ...reasoning ? { reasoning_content: reasoning } : {},
+    ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+  };
+  return [assistant];
+}
+function getSessionDir(cwd) {
+  return sessionsDir(cwd);
+}
+function ensureDir(dir) {
+  if (!existsSync6(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+}
+var MAX_SESSION_MESSAGE_JSON_CHARS = 1e5;
+function truncateString(value, maxChars) {
+  if (value.length <= maxChars) return value;
+  const marker = `
+<session-message-truncated original_chars="${value.length}" kept_chars="${maxChars}" />`;
+  const keep = Math.max(0, maxChars - marker.length);
+  return value.slice(0, keep) + marker;
+}
+function capJsonValue(value, maxChars) {
+  if (typeof value === "string") return truncateString(value, maxChars);
+  if (Array.isArray(value)) return value.map((item) => capJsonValue(item, maxChars));
+  if (value && typeof value === "object") {
+    const capped = {};
+    for (const [key, child] of Object.entries(value)) {
+      capped[key] = capJsonValue(child, maxChars);
+    }
+    return capped;
+  }
+  return value;
+}
+function serializeSessionMessage(message, maxChars = MAX_SESSION_MESSAGE_JSON_CHARS) {
+  return serializeSessionJsonValue(message, maxChars, () => ({
+    role: message.role,
+    content: truncateString(JSON.stringify(message), maxChars)
+  }));
+}
+function serializeOaiSessionMessage(message, maxChars = MAX_SESSION_MESSAGE_JSON_CHARS) {
+  const normalized = normalizeOaiMessage(message);
+  return serializeSessionJsonValue(normalized, maxChars, () => ({
+    role: normalized.role,
+    content: truncateString(JSON.stringify(normalized), maxChars),
+    ...normalized.role === "tool" ? { tool_call_id: normalized.tool_call_id } : {}
+  }));
+}
+function serializeSessionJsonValue(message, maxChars, fallback) {
+  let json = JSON.stringify(message);
+  if (json.length <= maxChars) return json;
+  const capped = capJsonValue(message, Math.max(1e3, Math.floor(maxChars * 0.8)));
+  json = JSON.stringify(capped);
+  if (json.length <= maxChars) return json;
+  return JSON.stringify(fallback());
+}
+function isOaiMessage(value) {
+  if (!value || typeof value !== "object") return false;
+  const msg = value;
+  if (msg.role === "system") return typeof msg.content === "string";
+  if (msg.role === "user") return typeof msg.content === "string";
+  if (msg.role === "assistant") return typeof msg.content === "string" || msg.content === null;
+  if (msg.role === "tool") return typeof msg.tool_call_id === "string" && typeof msg.content === "string";
+  return false;
+}
+function parseSessionLine(line) {
+  const parsed = JSON.parse(line);
+  if (parsed.type === "compact_start" || parsed.type === "compact_end" || parsed.type === "model_switch") {
+    return null;
+  }
+  return parsed;
+}
+function readHistoricalTranscript(filePath) {
+  if (!existsSync6(filePath)) return [];
+  let lines;
+  try {
+    lines = decodeTranscriptText(readFileSync5(filePath)).trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+  const messages = [];
+  for (const line of verifyLines(lines).validLines) {
+    try {
+      const parsed = parseSessionLine(line);
+      if (parsed && (parsed.role === "user" || parsed.role === "assistant") && typeof parsed.content === "string") {
+        messages.push({ role: parsed.role, content: parsed.content });
+      }
+    } catch {
+    }
+  }
+  return messages;
+}
+var SessionPersist = class _SessionPersist {
+  filePath;
+  metadataPath;
+  frozenPath;
+  sessionId;
+  cwd;
+  /** Write-behind batch writer (zstd frames + 200ms batching + torn recovery). */
+  batchWriter;
+  /** Metadata store (in-memory cache + batch-flush cadence). */
+  metaStore;
+  /** Public getter for testing file-path-dependent integrations. */
+  getFilePath() {
+    return this.filePath;
+  }
+  constructor(sessionId, cwd) {
+    assertValidSessionId(sessionId);
+    this.cwd = cwd;
+    ensureDir(getSessionDir(cwd));
+    this.sessionId = sessionId;
+    this.filePath = join5(getSessionDir(cwd), `${sessionId}.jsonl`);
+    this.metadataPath = join5(getSessionDir(cwd), `${sessionId}.meta.json`);
+    this.frozenPath = join5(getSessionDir(cwd), `${sessionId}.frozen.json`);
+    this.batchWriter = new SessionBatchWriter(this.filePath, () => this.getBackupDir());
+    this.metaStore = new SessionMetadataStore(this.metadataPath);
+  }
+  getBackupDir() {
+    const dir = join5(getSessionDir(this.cwd), this.sessionId, "backups");
+    ensureDir(dir);
+    return dir;
+  }
+  /** Append a single message to the session file (checksummed batch path). */
+  async append(message) {
+    const line = serializeSessionMessage(message) + "\n";
+    this.batchWriter.enqueueLine(line);
+  }
+  /** Flush barrier: drain the write-behind batch into a zstd frame on disk. */
+  async flushSessionBuffer() {
+    await this.batchWriter.flush();
+    this.metaStore.flush();
+  }
+  /** Read the transcript file as JSONL text (zstd frames or legacy passthrough). */
+  readTranscriptText() {
+    const onDisk = existsSync6(this.filePath) ? decodeTranscriptText(readFileSync5(this.filePath)) : "";
+    return this.batchWriter.mergePending(onDisk);
+  }
+  /** Load all messages from the session file (with checksum validation) */
+  load() {
+    return this.loadWithChecksum();
+  }
+  /** Append an OpenAI-native message with checksum (queued into the batch).
+   *
+   * `flush: true` drains the batch after enqueue — used for durability-critical
+   * records (assistant tool_calls / tool results / user turns) so a hard crash
+   * cannot lose a completed tool result while its disk side effect survives.
+   */
+  async appendOaiWithChecksum(message, options) {
+    const json = serializeOaiSessionMessage(message);
+    const line = appendChecksum(json) + "\n";
+    this.batchWriter.enqueueLine(line);
+    if (options?.flush) await this.batchWriter.flush();
+  }
+  /**
+   * Append a model-switch event to the session transcript.
+   *
+   * Written as a checksummed `type: 'model_switch'` line so it survives
+   * checksum verification, but parseSessionLine skips it on replay (same
+   * pattern as compact_start/compact_end) — it's an audit breadcrumb, not
+   * part of the conversation history. Lets a session JSONL show exactly
+   * when/what the model changed mid-session.
+   */
+  appendModelSwitch(event) {
+    const line = appendChecksum(JSON.stringify({
+      type: "model_switch",
+      t: Date.now(),
+      from: event.from,
+      to: event.to,
+      provider: event.provider
+    })) + "\n";
+    this.batchWriter.enqueueLine(line);
+  }
+  /** Load messages in OpenAI-native format, migrating legacy rows on read. */
+  loadOai() {
+    const content = this.readTranscriptText();
+    const lines = content.trim().split("\n").filter(Boolean);
+    const { validLines } = verifyLines(lines);
+    const messages = [];
+    for (const line of validLines) {
+      try {
+        const parsed = parseSessionLine(line);
+        if (!parsed) continue;
+        if (isOaiMessage(parsed)) {
+          messages.push(parsed);
+        } else {
+          messages.push(...legacyMessageToOaiMessages(parsed).map((message) => JSON.parse(JSON.stringify(message))));
+        }
+      } catch {
+      }
+    }
+    const normalized = normalizeOaiMessages(messages);
+    const { messages: repaired, hadOrphans, strippedWriteTool } = this.repairOrphanToolCalls(normalized);
+    if (hadOrphans) {
+      repaired.unshift({
+        role: "system",
+        content: strippedWriteTool ? "<system-reminder>The previous session was interrupted mid-turn. A write/edit tool call from the last assistant message was stripped because its result was not recorded \u2014 but the interruption may have happened either before OR after the file was actually written, so the file may or may not already contain the intended changes. Do NOT blindly re-run the write. First verify the file's current state with read_file or grep, then only write what is still missing. This is host-process interruption recovery, NOT a tool malfunction \u2014 the write tools remain fully functional; keep using them normally instead of bash workarounds.</system-reminder>" : "<system-reminder>The previous session was interrupted mid-turn. Some tool calls from the last assistant message were stripped because their results were not recorded. Re-run any read-only/search steps you still need; verify state before assuming any side effects took hold.</system-reminder>"
+      });
+    }
+    return repaired.map(normalizeOaiMessage);
+  }
+  /** Tools whose orphan recovery must be non-destructive: the file may already
+   *  hold the intended changes, so the model must verify before re-writing. */
+  static WRITE_TOOL_NAMES = /* @__PURE__ */ new Set([
+    "write_file",
+    "edit_file",
+    "hash_edit",
+    "ast_edit",
+    "apply_patch"
+  ]);
+  /** 压#7: Remove orphan tool_use/tool_result pairs left by corrupted/missing lines.
+   *
+   * Orphan tool_use entries occur when the stream delivered a complete
+   * tool_calls block but the process was killed before the tool executed
+   * (force-kill, power loss, or stream error after tool_use commit). The tool
+   * was NEVER run — any files it would have created/modified do NOT exist.
+   * Returns whether any orphans were stripped so the caller can warn the model
+   * not to assume side effects from the removed tools, plus whether any stripped
+   * orphan was a write/edit tool (so the warning can be non-destructive: the
+   * file may already hold the change, verify before re-running). */
+  repairOrphanToolCalls(messages) {
+    const toolCallIds = /* @__PURE__ */ new Set();
+    const toolResultIndices = /* @__PURE__ */ new Map();
+    for (let i = 0; i < messages.length; i++) {
+      const msg = messages[i];
+      if (msg.role === "assistant" && msg.tool_calls) {
+        for (const tc of msg.tool_calls) {
+          if (tc.id) toolCallIds.add(tc.id);
+        }
+      }
+      if (msg.role === "tool" && msg.tool_call_id) {
+        toolResultIndices.set(msg.tool_call_id, i);
+      }
+    }
+    const orphanResultIdx = /* @__PURE__ */ new Set();
+    for (const [id, idx] of toolResultIndices) {
+      if (!toolCallIds.has(id)) orphanResultIdx.add(idx);
+    }
+    const result = [];
+    let hadOrphans = false;
+    let strippedWriteTool = false;
+    const noteStripped = (tc) => {
+      if (_SessionPersist.WRITE_TOOL_NAMES.has(tc.function?.name ?? "")) strippedWriteTool = true;
+    };
+    for (let i = 0; i < messages.length; i++) {
+      const msg = messages[i];
+      if (orphanResultIdx.has(i)) {
+        hadOrphans = true;
+        continue;
+      }
+      if (msg.role === "assistant" && msg.tool_calls) {
+        const valid = msg.tool_calls.filter((tc) => tc.id && toolResultIndices.has(tc.id));
+        const orphaned = msg.tool_calls.filter((tc) => !(tc.id && toolResultIndices.has(tc.id)));
+        if (valid.length === 0 && !msg.content) {
+          hadOrphans = true;
+          orphaned.forEach(noteStripped);
+          continue;
+        }
+        if (valid.length !== msg.tool_calls.length) {
+          hadOrphans = true;
+          orphaned.forEach(noteStripped);
+          result.push({ ...msg, tool_calls: valid });
+          continue;
+        }
+      }
+      result.push(msg);
+    }
+    return { messages: result, hadOrphans, strippedWriteTool };
+  }
+  /** Audit breadcrumb types: skipped on replay (parseSessionLine), preserved across rewrites. */
+  static AUDIT_LINE_TYPES = /* @__PURE__ */ new Set(["compact_start", "compact_end", "model_switch"]);
+  /**
+   * Collect audit breadcrumb lines from the current file, re-checksummed for a
+   * full rewrite. Rewrites (compact / compactOai / compactOaiAsync) regenerate
+   * the file from in-memory messages only, and audit lines never enter memory
+   * (parseSessionLine skips them on replay) — without this, the first rewrite
+   * after appendModelSwitch silently destroys the audit trail.
+   */
+  collectAuditLines() {
+    if (!existsSync6(this.filePath)) return [];
+    try {
+      const lines = this.readTranscriptText().trim().split("\n").filter(Boolean);
+      const { validLines } = verifyLines(lines);
+      const audit = [];
+      for (const json of validLines) {
+        try {
+          const parsed = JSON.parse(json);
+          if (typeof parsed.type === "string" && _SessionPersist.AUDIT_LINE_TYPES.has(parsed.type)) {
+            audit.push(appendChecksum(json));
+          }
+        } catch {
+        }
+      }
+      return audit;
+    } catch {
+      return [];
+    }
+  }
+  /** Compact the session file with the given messages (with checksums) */
+  compact(messages) {
+    this.batchWriter.flushSync();
+    const audit = this.collectAuditLines();
+    const content = [...audit, ...messages.map((m) => appendChecksum(serializeSessionMessage(m)))].join("\n") + "\n";
+    writeFileAtomicSync(this.filePath, encodeBatch(content));
+  }
+  /** Compact the session file with OAI-format messages */
+  compactOai(messages) {
+    this.batchWriter.flushSync();
+    const audit = this.collectAuditLines();
+    const content = [...audit, ...messages.map((m) => appendChecksum(serializeOaiSessionMessage(m)))].join("\n") + "\n";
+    writeFileAtomicSync(this.filePath, encodeBatch(content));
+  }
+  /** Async atomic compaction — avoids blocking the agent loop on full rewrites (S13). */
+  async compactOaiAsync(messages) {
+    await this.flushSessionBuffer();
+    const audit = this.collectAuditLines();
+    const content = [...audit, ...messages.map((m) => appendChecksum(serializeOaiSessionMessage(m)))].join("\n") + "\n";
+    await writeFileAtomicAsync(this.filePath, encodeBatch(content));
+  }
+  /** Delete the session file */
+  delete() {
+    try {
+      unlinkSync2(this.filePath);
+    } catch {
+    }
+  }
+  /**
+   * 带校验和的 append（入队批处理）
+   */
+  async appendWithChecksum(message) {
+    const json = serializeSessionMessage(message);
+    const line = appendChecksum(json) + "\n";
+    this.batchWriter.enqueueLine(line);
+  }
+  /**
+   * 带校验和的 load（向后兼容）
+   */
+  loadWithChecksum() {
+    const content = this.readTranscriptText();
+    const lines = content.trim().split("\n").filter(Boolean);
+    const { validLines, invalidCount } = verifyLines(lines);
+    if (invalidCount > 0) {
+    }
+    return validLines.map((line) => {
+      try {
+        const parsed = parseSessionLine(line);
+        if (!parsed) return null;
+        return parsed;
+      } catch {
+        return null;
+      }
+    }).filter(Boolean);
+  }
+  /**
+   * 写入 compact 开始标记
+   */
+  /**
+   * 写入 compact 结束标记
+   */
+  /**
+   * 检测 incomplete compact
+   * @returns 是否检测到 incomplete compact
+   */
+  /** Get the session file path */
+  getPath() {
+    return this.filePath;
+  }
+  writeMetadata(metadata) {
+    this.metaStore.write(metadata);
+    this.refreshListCacheEntry();
+  }
+  /** Upsert specific metadata fields without overwriting others */
+  updateMetadata(patch) {
+    this.metaStore.update(patch, this.sessionId);
+    this.refreshListCacheEntry();
+  }
+  /**
+   * 把本会话的最新 metadata 增量并入会话列表缓存（纯内存，无磁盘 I/O），
+   * 而不是整表失效。此前每次 append 都 invalidateListCache——append 监听器
+   * 每条消息都会走 updateMetadata，而 loadPrevHandoff 在每个 LLM round 都读
+   * 列表，活跃会话期间缓存命中率恒为 0，每轮全量 readdirSync + 逐会话重读。
+   * 增量 upsert 保持同样的新鲜度语义：新建/更新立即可见、updatedAt 排序即时
+   * 重排；TTL 不动，外部进程的文件变化仍按原 60s 窗口被吸收。
+   */
+  refreshListCacheEntry() {
+    const meta = this.metaStore.load();
+    if (meta === void 0) return;
+    _SessionPersist.upsertListCacheEntry(this.cwd, _SessionPersist.buildListEntry(this.sessionId, meta));
+  }
+  /** Initialize metadata for a new session if not already present */
+  initMetadata(init) {
+    if (existsSync6(this.metadataPath)) return;
+    this.writeMetadata({
+      sessionId: this.sessionId,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      compactEvents: [],
+      status: "active",
+      turnCount: 0,
+      toolCallCount: 0,
+      tokenUsage: { prompt: 0, completion: 0, total: 0 },
+      ...init
+    });
+  }
+  loadMetadata() {
+    return this.metaStore.load();
+  }
+  /**
+   * 冻结前缀快照落盘（`<id>.frozen.json`）——resume 缓存继承的写侧。
+   * 由 PromptEngine 的 onFrozenSnapshotCommit 钩子在每个 user 边界触发（低频）。
+   */
+  writeFrozenSnapshot(data) {
+    writeFileAtomicSync(this.frozenPath, JSON.stringify(data));
+  }
+  /**
+   * 读回冻结前缀快照（resume 缓存继承的读侧）。
+   * 不存在 / 坏 JSON / 形状校验失败一律 undefined——调用方降级为全量重建。
+   */
+  readFrozenSnapshot() {
+    if (!existsSync6(this.frozenPath)) return void 0;
+    try {
+      return parseFrozenSnapshotData(JSON.parse(readFileSync5(this.frozenPath, "utf-8")));
+    } catch {
+      return void 0;
+    }
+  }
+  loadMemory() {
+    return loadSessionMemory(getSessionDir(this.cwd), this.sessionId);
+  }
+  appendMemory(input) {
+    return appendSessionMemory(getSessionDir(this.cwd), this.sessionId, input);
+  }
+  buildMemoryBlock() {
+    return buildSessionMemoryBlock(this.loadMemory());
+  }
+  getSessionMemoryState() {
+    const memory = this.loadMemory();
+    if (memory.entries.length === 0) return void 0;
+    const block = buildSessionMemoryBlock(memory);
+    return {
+      path: join5(getSessionDir(this.cwd), `${this.sessionId}.memory.json`),
+      lastSummarizedRoundIndex: -1,
+      lastUpdatedAt: memory.entries[memory.entries.length - 1]?.createdAt ?? Date.now(),
+      digest: block.length > 200 ? block.slice(0, 197) + "..." : block,
+      stale: false,
+      tokenEstimate: block.length
+    };
+  }
+  /** Create a claim store for the current session. */
+  createClaimStore() {
+    return new ContextClaimStore(getSessionDir(this.cwd), this.sessionId);
+  }
+  /** Load durable claims from the most recent previous main session.
+   *  listMainSessions 排除 worker-/带点伪 id（`<id>.claims`）并按 updatedAt 降序——
+   *  listSessions + sort().pop() 会选中伪条目（恒返回 []）或非最近会话。 */
+  loadPreviousDurableClaims() {
+    const previous = _SessionPersist.listMainSessions(this.cwd).find((s) => s.id !== this.sessionId);
+    return previous ? ContextClaimStore.loadDurableClaims(getSessionDir(this.cwd), previous.id) : [];
+  }
+  /** Inject durable claims from previous session into a claim store with confidence decay.
+   *  A4: cross-session pollution gate — only inject claims that intersect with current
+   *  project files AND were created within 7 days. */
+  injectDurableClaims(store, cwd) {
+    const now = Date.now();
+    const TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+    const durableClaims = this.loadPreviousDurableClaims();
+    for (const claim of durableClaims) {
+      if (now - claim.createdAt > TTL_MS) continue;
+      if (cwd) {
+        const fileEvidence = claim.evidence.filter((e) => e.path);
+        if (fileEvidence.length > 0) {
+          const hasRelevantFile = fileEvidence.some((e) => {
+            const abs = resolve(cwd, e.path);
+            const rel = relative(cwd, abs);
+            return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+          });
+          if (!hasRelevantFile) continue;
+        }
+      }
+      store.propose({
+        kind: claim.kind,
+        scope: claim.scope,
+        text: claim.text,
+        confidence: claim.confidence * 0.9,
+        fitness: claim.fitness,
+        source: { ...claim.source, eventId: `resume:${claim.id}` },
+        evidence: claim.evidence,
+        createdAt: Date.now(),
+        tags: [...claim.tags, "resumed"]
+      });
+    }
+  }
+  /** Write structured handoff text for this session. */
+  writeHandoff(text) {
+    writeFileAtomicSync(this.getHandoffPath(), text);
+  }
+  /** 会话归档交接文档路径（`<id>.handoff.md`）——loadPrevHandoff 注入管线认的位置。 */
+  getHandoffPath() {
+    return join5(getSessionDir(this.cwd), `${this.sessionId}.handoff.md`);
+  }
+  /**
+   * Load the most relevant previous session's handoff text.
+   * Routes by domain if both sessions have a domain tag; otherwise falls back
+   * to the most recently updated session. Returns null if none found.
+   */
+  static loadPrevHandoff(cwd, currentSessionId, currentDomain) {
+    const sessions = _SessionPersist.listSessionsWithMetadata(cwd).filter((s) => s.id !== currentSessionId);
+    if (sessions.length === 0) return null;
+    let candidates = sessions;
+    if (currentDomain) {
+      const sameDomain = sessions.filter((s) => s.domain === currentDomain);
+      if (sameDomain.length > 0) candidates = sameDomain;
+    }
+    const prev = candidates[0];
+    if (!prev) return null;
+    const handoffPath = join5(getSessionDir(cwd), `${prev.id}.handoff.md`);
+    if (!existsSync6(handoffPath)) return null;
+    try {
+      return readFileSync5(handoffPath, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  /** List all session files */
+  static listSessions(cwd) {
+    const dir = getSessionDir(cwd);
+    ensureDir(dir);
+    try {
+      return readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => f.replace(".jsonl", ""));
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Cache for listSessionsWithMetadata — avoids re-reading hundreds of session
+   * meta files on every user boundary when cross-session handoff is requested.
+   * TTL: 60s. Writes upsert the session's own entry incrementally
+   * (refreshListCacheEntry) so the hot append path never cold-rows the cache.
+   * Keyed by cwd since sessions are per-project.
+   */
+  static _listCache = /* @__PURE__ */ new Map();
+  static LIST_CACHE_TTL_MS = 6e4;
+  static invalidateListCache() {
+    _SessionPersist._listCache.clear();
+  }
+  /** 移除单会话的缓存条目（硬删链——文件删除后条目不得在重建中复活）。 */
+  static removeListCacheEntry(id) {
+    for (const cached of _SessionPersist._listCache.values()) {
+      const idx = cached.data.findIndex((e) => e.id === id);
+      if (idx >= 0) cached.data.splice(idx, 1);
+    }
+  }
+  /** 统一的列表条目形状——全量构建与增量 upsert 共用，防两处漂移。 */
+  static buildListEntry(id, meta) {
+    return {
+      id,
+      sessionId: id,
+      createdAt: meta?.createdAt ?? 0,
+      updatedAt: meta?.updatedAt ?? 0,
+      compactEvents: meta?.compactEvents ?? [],
+      ...meta
+    };
+  }
+  /**
+   * 缓存命中时把单会话条目原位并入列表。不替换数组、不刷新 ts：
+   * 命中路径的契约本来就是"同一 cwd 的多次 list 返回同一数组"，写入原位生效
+   * 即是该契约下的新鲜度语义；ts 不动则 TTL 仍按首次构建计时，外部进程的
+   * 文件变化照旧在 60s 窗口内被吸收。
+   */
+  static upsertListCacheEntry(cwd, entry) {
+    const cached = _SessionPersist._listCache.get(cwd);
+    if (!cached) return;
+    const idx = cached.data.findIndex((e) => e.id === entry.id);
+    if (idx >= 0) cached.data[idx] = { ...cached.data[idx], ...entry };
+    else cached.data.push(entry);
+    cached.data.sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
+  }
+  /** List sessions with metadata, sorted by updatedAt descending (most recent first) */
+  static listSessionsWithMetadata(cwd) {
+    const now = Date.now();
+    const cached = _SessionPersist._listCache.get(cwd);
+    if (cached && now - cached.ts < _SessionPersist.LIST_CACHE_TTL_MS) {
+      return cached.data;
+    }
+    const ids = _SessionPersist.listSessions(cwd);
+    const results = [];
+    for (const id of ids) {
+      try {
+        const p = new _SessionPersist(id, cwd);
+        results.push(_SessionPersist.buildListEntry(id, p.loadMetadata()));
+      } catch {
+      }
+    }
+    results.sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
+    _SessionPersist._listCache.set(cwd, { ts: now, data: results });
+    return results;
+  }
+  /**
+   * Main user-facing sessions only: excludes worker sub-sessions (`worker-*`)
+   * and non-transcript artifacts whose id carries a dotted suffix
+   * (`<id>.claims`, `<id>.memory`, `<id>.snapshot`). Sorted by updatedAt desc.
+   */
+  static listMainSessions(cwd) {
+    return _SessionPersist.listSessionsWithMetadata(cwd).filter((s) => !s.id.startsWith("worker-") && !s.id.includes("."));
+  }
+  /**
+   * Resolve a user-supplied session reference (full id or short prefix) to a
+   * single full session id. Exact match wins; otherwise prefix-match across
+   * main sessions. Returns the resolved id, an ambiguous candidate list, or
+   * null when nothing matches. The id = log id = resume id are the same value.
+   */
+  static resolveSessionId(cwd, ref) {
+    const ref0 = ref.trim();
+    if (!ref0) return null;
+    const sessions = _SessionPersist.listMainSessions(cwd);
+    const exact = sessions.find((s) => s.id === ref0);
+    if (exact) return { id: exact.id };
+    const matches = sessions.filter((s) => s.id.startsWith(ref0));
+    if (matches.length === 1) return { id: matches[0].id };
+    if (matches.length > 1) return { ambiguous: matches.map((s) => s.id) };
+    return null;
+  }
+  /**
+   * Render the session list for CLI `--list` and TUI `/sessions`. One row per
+   * main session, numbered to match `listMainSessions` ordering so the index is
+   * stable and aligned with prefix-based resume.
+   */
+  static formatSessionList(cwd, currentId) {
+    const sessions = _SessionPersist.listMainSessions(cwd);
+    if (sessions.length === 0) return "\u6CA1\u6709\u5386\u53F2\u4F1A\u8BDD\u3002";
+    return sessions.map((s, i) => {
+      const marker = s.id === currentId ? "  \u2190 \u5F53\u524D" : "";
+      const when = formatRelativeTime(s.updatedAt ?? 0);
+      const turns = s.turnCount ?? 0;
+      const model = s.model ?? "?";
+      const domain = s.domain ? ` ${s.domain}` : "";
+      const title = (s.title ?? "").replace(/\s+/g, " ").trim().slice(0, 50);
+      return `${String(i + 1).padStart(2)}. ${s.id.slice(0, 8)}  ${when}  ${turns}\u8F6E  ${model}${domain}  ${title}${marker}`;
+    }).join("\n");
+  }
+};
+function formatExitSummary(meta, sessionId) {
+  const turns = meta?.turnCount ?? 0;
+  if (turns <= 0) return null;
+  const short = sessionId.slice(0, 8);
+  const title = (meta?.title ?? "").replace(/\s+/g, " ").trim().slice(0, 60);
+  const head = `\u4F1A\u8BDD\u5DF2\u4FDD\u5B58: ${short} \xB7 ${turns}\u8F6E${title ? ` \xB7 \u201C${title}\u201D` : ""}`;
+  return `\u2726 \u540E\u4F1A\u6709\u671F \u2014 \u661F\u8F68\u5DF2\u5B58\u6863
+${head}
+\u6062\u590D: rivet --continue\uFF08\u6700\u8FD1\u4F1A\u8BDD\uFF09\u6216 rivet --resume ${short}
+\u7F13\u5B58\u6210\u672C\uFF1A\u5C3D\u5FEB\u56DE\u8FDE \u2248 \u7EE7\u627F\u51BB\u7ED3\u951A\u70B9\uFF08\u53EA\u8BFB\u7F13\u5B58\u4EF7\uFF09\uFF1B\u95F4\u9694\u8FC7\u4E45\u7F13\u5B58\u8FC7\u671F \u2192 \u5168\u91CF\u91CD\u5EFA\u4E00\u6B21\u524D\u7F00\uFF08\u957F\u4F1A\u8BDD\u6570\u5143\u7EA7\uFF09\u3002`;
+}
+function shouldAutoWriteHandoff(existingMtimeMs, sessionStartMs) {
+  if (existingMtimeMs === null) return true;
+  return existingMtimeMs <= sessionStartMs;
+}
+function formatRelativeTime(ts) {
+  if (!ts) return "\u672A\u77E5";
+  const diff = Date.now() - ts;
+  if (diff < 0) return "\u521A\u521A";
+  const sec = Math.floor(diff / 1e3);
+  if (sec < 60) return "\u521A\u521A";
+  const min = Math.floor(sec / 60);
+  if (min < 60) return `${min}\u5206\u949F\u524D`;
+  const hr = Math.floor(min / 60);
+  if (hr < 24) return `${hr}\u5C0F\u65F6\u524D`;
+  const day = Math.floor(hr / 24);
+  if (day < 30) return `${day}\u5929\u524D`;
+  const mon = Math.floor(day / 30);
+  if (mon < 12) return `${mon}\u4E2A\u6708\u524D`;
+  return `${Math.floor(mon / 12)}\u5E74\u524D`;
+}
+var MAX_SESSIONS = 50;
+function evictOldSessions(keepSessionId, cwd) {
+  return evictOldSessionsInternal(getSessionDir(cwd), keepSessionId, MAX_SESSIONS);
+}
+function evictOldSessionsInternal(dir, keepSessionId, limit) {
+  ensureDir(dir);
+  let sessions;
+  try {
+    sessions = readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => f.replace(".jsonl", "")).filter((id) => !id.startsWith("worker-") && !id.includes("."));
+  } catch {
+    return [];
+  }
+  if (sessions.length <= limit) return [];
+  const withMtime = sessions.map((id) => {
+    let mtime = 0;
+    try {
+      mtime = statSync2(join5(dir, `${id}.jsonl`)).mtimeMs;
+    } catch {
+    }
+    return { id, mtime };
+  });
+  withMtime.sort((a, b) => a.mtime - b.mtime);
+  const toEvict = withMtime.filter(({ id }) => id !== keepSessionId).slice(0, sessions.length - limit).map(({ id }) => id);
+  for (const id of toEvict) removeSessionFilesIn(dir, id);
+  return toEvict;
+}
+function removeSessionFilesIn(dir, id) {
+  try {
+    unlinkSync2(join5(dir, `${id}.jsonl`));
+  } catch {
+  }
+  try {
+    unlinkSync2(join5(dir, `${id}.meta.json`));
+  } catch {
+  }
+  try {
+    unlinkSync2(join5(dir, `${id}.memory.json`));
+  } catch {
+  }
+  try {
+    unlinkSync2(join5(dir, `${id}.claims.jsonl`));
+  } catch {
+  }
+  try {
+    unlinkSync2(join5(dir, `${id}.frozen.json`));
+  } catch {
+  }
+  try {
+    rmSync(join5(dir, id), { recursive: true, force: true });
+  } catch {
+  }
+}
+function deleteSessionFiles(cwd, id) {
+  removeSessionFilesIn(getSessionDir(cwd), id);
+  SessionPersist.removeListCacheEntry(id);
+}
+
+export {
+  claimProposalFromAnchor,
+  verifyAndExtract,
+  decodeTranscriptText,
+  getSessionDir,
+  MAX_SESSION_MESSAGE_JSON_CHARS,
+  serializeSessionMessage,
+  serializeOaiSessionMessage,
+  readHistoricalTranscript,
+  SessionPersist,
+  formatExitSummary,
+  shouldAutoWriteHandoff,
+  evictOldSessions,
+  evictOldSessionsInternal,
+  deleteSessionFiles
+};