@wrongstack/core 0.283.1 → 0.284.0

package/dist/storage/index.js

@@ -1,15 +1,136 @@
+import { randomUUID, createHash, randomBytes } from 'crypto';
 import * as syncFs from 'fs';
-import { createReadStream, readFileSync, statSync } from 'fs';
-import * as fsp2 from 'fs/promises';
+import { createReadStream, openSync, writeSync, fsyncSync, closeSync, readFileSync, statSync } from 'fs';
+import * as fsp4 from 'fs/promises';
 import * as path2 from 'path';
 import { createInterface } from 'readline';
-import { randomBytes, randomUUID, createHash } from 'crypto';
 import * as os from 'os';
 import { hostname } from 'os';
+import { spawn } from 'child_process';
 import { fileURLToPath } from 'url';
 
 // src/storage/session-store.ts
 
+// src/utils/child-env.ts
+var ALLOWED_KEYS = /* @__PURE__ */ new Set([
+  "PATH",
+  "HOME",
+  "USER",
+  "USERNAME",
+  "LOGNAME",
+  "SHELL",
+  "LANG",
+  "LC_ALL",
+  "LC_CTYPE",
+  "TERM",
+  "TZ",
+  "TMPDIR",
+  "TEMP",
+  "TMP",
+  "PWD",
+  "OLDPWD",
+  "COMSPEC",
+  "SYSTEMROOT",
+  "SYSTEMDRIVE",
+  "WINDIR",
+  "PROGRAMFILES",
+  "PROGRAMFILES(X86)",
+  "PROGRAMDATA",
+  "APPDATA",
+  "LOCALAPPDATA",
+  "USERPROFILE",
+  "PUBLIC",
+  "PATHEXT"
+]);
+var SECRET_NAME_PARTS = [
+  "TOKEN",
+  "SECRET",
+  "PASSWORD",
+  "PASSWD",
+  "AUTH",
+  "CRED",
+  "BEARER",
+  "COOKIE",
+  "PRIVATE"
+];
+function looksSecret(name) {
+  const upper = name.toUpperCase();
+  for (const p of SECRET_NAME_PARTS) {
+    if (upper.includes(p)) return true;
+  }
+  if (/(?:^|_)KEY(?:$|_|S$)/i.test(upper)) return true;
+  if (/API[_-]?KEY/i.test(upper)) return true;
+  if (/ACCESS[_-]?KEY/i.test(upper)) return true;
+  if (/SESSION[_-]?ID/i.test(upper) === false && /SESSION/i.test(upper)) {
+    return true;
+  }
+  return false;
+}
+function valueHasEmbeddedCredential(value) {
+  return /\b[a-z][a-z0-9+.-]*:\/\/[^/\s:@]*:[^/\s@]+@/i.test(value);
+}
+var NODE_OPTIONS_INJECTION_FLAG = /^(?:--require|-r|--import|--loader|--experimental-loader)$/;
+var NODE_OPTIONS_INJECTION_FLAG_EQ = /^(?:--require|-r|--import|--loader|--experimental-loader)=/;
+function sanitizeNodeOptions(value) {
+  const tokens = value.split(/\s+/).filter(Boolean);
+  const kept = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const tok = tokens[i];
+    if (NODE_OPTIONS_INJECTION_FLAG_EQ.test(tok)) continue;
+    if (NODE_OPTIONS_INJECTION_FLAG.test(tok)) {
+      i++;
+      continue;
+    }
+    kept.push(tok);
+  }
+  return kept.join(" ");
+}
+function buildChildEnv(optsOrSessionId) {
+  const opts = {};
+  const hasOwn = Object.hasOwn(process.env, "WRONGSTACK_CHILD_ENV_PASSTHROUGH");
+  const legacyHasOwn = Object.hasOwn(process.env, "WRONGSTACK_BASH_ENV_PASSTHROUGH");
+  const passthrough = hasOwn && process.env["WRONGSTACK_CHILD_ENV_PASSTHROUGH"] === "1" || legacyHasOwn && process.env["WRONGSTACK_BASH_ENV_PASSTHROUGH"] === "1";
+  if (passthrough && !process.env["CI"]) {
+    console.warn(
+      "[agent] WARNING: WRONGSTACK_*_ENV_PASSTHROUGH=1 is active \u2014\n  all parent env vars (including API keys) forwarded to child processes.\n  Do not use on shared or multi-tenant systems."
+    );
+  }
+  const out = {};
+  const nodeEnvDefaulted = process.env["WRONGSTACK_NODE_ENV_DEFAULTED"] === "1";
+  for (const [k, v] of Object.entries(process.env)) {
+    if (v === void 0) continue;
+    if (nodeEnvDefaulted && (k === "NODE_ENV" || k === "WRONGSTACK_NODE_ENV_DEFAULTED")) continue;
+    if (passthrough) {
+      out[k] = v;
+      continue;
+    }
+    const upper = k.toUpperCase();
+    if (valueHasEmbeddedCredential(v)) continue;
+    if (ALLOWED_KEYS.has(upper)) {
+      out[k] = v;
+      continue;
+    }
+    if (looksSecret(upper)) continue;
+    if (upper === "NODE_OPTIONS") {
+      const sanitized = sanitizeNodeOptions(v);
+      if (sanitized) out[k] = sanitized;
+      continue;
+    }
+    if (upper.startsWith("NODE_") || upper.startsWith("NPM_") || upper.startsWith("PNPM_") || upper.startsWith("YARN_") || upper.startsWith("GIT_") || upper.startsWith("CI") || upper.startsWith("XDG_") || // Our own non-secret knobs (WRONGSTACK_HOME, WRONGSTACK_SESSION_ID, …).
+    // Secrets never live in WRONGSTACK_* env vars (they're in the encrypted
+    // vault). Forwarding keeps child wstack processes — e.g. ones spawned
+    // by the test suite — inside the same redirected global root.
+    upper.startsWith("WRONGSTACK_") || upper === "EDITOR" || upper === "VISUAL" || upper === "PAGER") {
+      out[k] = v;
+    }
+  }
+  if (opts.extra) {
+    Object.assign(out, opts.extra);
+  }
+  if (opts.sessionId) out["WRONGSTACK_SESSION_ID"] = opts.sessionId;
+  return out;
+}
+
 // src/utils/term.ts
 var hasStdout = () => typeof process !== "undefined" && !!process.stdout;
 function isStdoutTTY() {
@@ -28,7 +149,7 @@ function envFlag(value) {
   return !/^(0|false|no|off)$/i.test(value.trim());
 }
 var COLOR = isColorTty();
-var wrap = (open8, close) => (s) => COLOR ? `\x1B[${open8}m${s}\x1B[${close}m` : s;
+var wrap = (open9, close) => (s) => COLOR ? `\x1B[${open9}m${s}\x1B[${close}m` : s;
 var color = {
   reset: wrap("0", "0"),
   bold: wrap("1", "22"),
@@ -478,16 +599,16 @@ var FsError = class extends WrongStackError {
 // src/utils/atomic-write.ts
 async function atomicWrite(targetPath, content, opts = {}) {
   const dir = path2.dirname(targetPath);
-  await fsp2.mkdir(dir, { recursive: true });
+  await fsp4.mkdir(dir, { recursive: true });
   const tmp = path2.join(dir, `.${path2.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
   try {
     if (typeof content === "string") {
-      await fsp2.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
+      await fsp4.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
     } else {
-      await fsp2.writeFile(tmp, content, { flag: "wx" });
+      await fsp4.writeFile(tmp, content, { flag: "wx" });
     }
     try {
-      const fh = await fsp2.open(tmp, "r+");
+      const fh = await fsp4.open(tmp, "r+");
       try {
         await fh.sync();
       } finally {
@@ -497,35 +618,35 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat11 = await fsp2.stat(targetPath);
-      mode = stat11.mode & 511;
+      const stat13 = await fsp4.stat(targetPath);
+      mode = stat13.mode & 511;
     } catch {
       mode = opts.mode;
     }
     if (mode !== void 0) {
-      await fsp2.chmod(tmp, mode);
+      await fsp4.chmod(tmp, mode);
     }
     await renameWithRetry(tmp, targetPath);
     if (mode !== void 0 && process.platform === "win32") {
       try {
-        await fsp2.chmod(targetPath, mode);
+        await fsp4.chmod(targetPath, mode);
       } catch {
       }
     }
   } catch (err) {
     try {
-      await fsp2.unlink(tmp);
+      await fsp4.unlink(tmp);
     } catch {
     }
     throw err;
   }
 }
 async function ensureDir(dir) {
-  await fsp2.mkdir(dir, { recursive: true });
+  await fsp4.mkdir(dir, { recursive: true });
 }
 async function withFileLock(targetPath, fn, opts = {}) {
   const dir = path2.dirname(targetPath);
-  await fsp2.mkdir(dir, { recursive: true });
+  await fsp4.mkdir(dir, { recursive: true });
   const lockPath = path2.join(dir, `.${path2.basename(targetPath)}.lock`);
   const timeoutMs = opts.timeoutMs ?? 5e3;
   const staleMs = opts.staleMs ?? 3e4;
@@ -533,20 +654,20 @@ async function withFileLock(targetPath, fn, opts = {}) {
   let handle;
   for (; ; ) {
     try {
-      handle = await fsp2.open(lockPath, "wx");
+      handle = await fsp4.open(lockPath, "wx");
       await handle.writeFile(`${process.pid}:${Date.now()}`);
       break;
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") {
-        await fsp2.mkdir(dir, { recursive: true });
+        await fsp4.mkdir(dir, { recursive: true });
         continue;
       }
       if (code !== "EEXIST") throw err;
       try {
-        const stat11 = await fsp2.stat(lockPath);
-        if (Date.now() - stat11.mtimeMs > staleMs) {
-          await fsp2.unlink(lockPath);
+        const stat13 = await fsp4.stat(lockPath);
+        if (Date.now() - stat13.mtimeMs > staleMs) {
+          await fsp4.unlink(lockPath);
           continue;
         }
       } catch {
@@ -560,7 +681,7 @@ async function withFileLock(targetPath, fn, opts = {}) {
           context: { timeoutMs }
         });
       }
-      await new Promise((resolve8) => setTimeout(resolve8, 25));
+      await new Promise((resolve11) => setTimeout(resolve11, 25));
     }
   }
   try {
@@ -571,7 +692,7 @@ async function withFileLock(targetPath, fn, opts = {}) {
     } catch {
     }
     try {
-      await fsp2.unlink(lockPath);
+      await fsp4.unlink(lockPath);
     } catch {
     }
   }
@@ -579,14 +700,14 @@ async function withFileLock(targetPath, fn, opts = {}) {
 var TRANSIENT_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES", "ENOTEMPTY"]);
 async function renameWithRetry(from, to) {
   if (process.platform !== "win32") {
-    await fsp2.rename(from, to);
+    await fsp4.rename(from, to);
     return;
   }
   const delays = [10, 25, 60, 120, 250];
   let lastErr;
   for (let i = 0; i <= delays.length; i++) {
     try {
-      await fsp2.rename(from, to);
+      await fsp4.rename(from, to);
       return;
     } catch (err) {
       lastErr = err;
@@ -594,7 +715,7 @@ async function renameWithRetry(from, to) {
       if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
         throw err;
       }
-      await new Promise((resolve8) => setTimeout(resolve8, delays[i]));
+      await new Promise((resolve11) => setTimeout(resolve11, delays[i]));
     }
   }
   throw lastErr;
@@ -618,6 +739,7 @@ var FileSessionWriter = class _FileSessionWriter {
     this.manifestFile = opts.dir ? path2.join(opts.dir, `${path2.basename(id)}.summary.json`) : "";
     this.filePath = opts.filePath ?? "";
     this.secretScrubber = opts.secretScrubber;
+    this.checkpointCas = opts.checkpointCas;
     this.onCloseCb = opts.onClose;
     this.summary = {
       id,
@@ -659,6 +781,7 @@ var FileSessionWriter = class _FileSessionWriter {
   appendFailCount = 0;
   lastAppendWarnAt = 0;
   secretScrubber;
+  checkpointCas;
   onCloseCb;
   /** Implements SessionWriter.traceId — propagated from ContextInit.traceId. */
   traceId;
@@ -679,9 +802,12 @@ var FileSessionWriter = class _FileSessionWriter {
   // a timer-driven flush racing an explicit flush()/close() issues two
   // concurrent appendFile() calls on the shared O_APPEND handle — the kernel
   // may complete them out of order (chronology breaks) or, for large
-  // batches, interleave partial writes (torn JSONL lines). The chain keeps
-  // exactly one write in flight; failures don't break the chain.
+  // batches, interleave partial writes (torn JSONL lines). The write chain
+  // serializes handle I/O; flushChain additionally serializes the act of
+  // draining/re-queueing the in-memory event buffer so a failed older batch
+  // can never be overtaken by a newer successful one.
   writeChain = Promise.resolve();
+  flushChain = Promise.resolve();
   /** Enqueue a write on the FIFO chain. Resolves/rejects with that write. */
   enqueueWrite(data) {
     const write = this.writeChain.then(() => this.handle.appendFile(data, "utf8"));
@@ -702,13 +828,25 @@ var FileSessionWriter = class _FileSessionWriter {
   /**
    * Scrub secrets out of conversation-turn events before they are observed
    * for the summary, written to the JSONL log, or surfaced on resume. Only
-   * `user_input` / `llm_response` carry free-form user/model text; other event
-   * types either have no secret-bearing content or are already scrubbed
-   * upstream (tool results). Returns the event unchanged when no scrubber is
-   * configured.
+   * `user_input`, `llm_response`, and `context_snapshot` carry free-form
+   * user/model text; other event types either have no secret-bearing content
+   * or are already scrubbed upstream (tool results). Snapshot normalization
+   * also strips transient token-cache fields even when no scrubber is set.
    */
   scrubEvent(event) {
     const s = this.secretScrubber;
+    if (event.type === "context_snapshot") {
+      return {
+        ...event,
+        messages: event.messages.map((message) => {
+          const { _estTokens: _ignored, ...persisted } = message;
+          return {
+            ...persisted,
+            content: typeof persisted.content === "string" ? s?.scrub(persisted.content) ?? persisted.content : s?.scrubObject(persisted.content) ?? persisted.content
+          };
+        })
+      };
+    }
     if (!s) return event;
     if (event.type === "user_input") {
       return {
@@ -722,10 +860,55 @@ var FileSessionWriter = class _FileSessionWriter {
     return event;
   }
   pendingFileSnapshots = [];
+  /** Prompt whose tool work is currently executing. Set by writeCheckpoint. */
+  activePromptIndex = null;
   /** Tracks open tool_use IDs during the current run to serialize on close for resume. */
   openToolUses = /* @__PURE__ */ new Set();
+  /**
+   * Buffer an event from a synchronous Context callback. ensureInit() starts
+   * by pushing the lifecycle preamble synchronously, so session_start always
+   * precedes observations even though these callbacks cannot await append().
+   */
+  bufferSynchronousEvent(event) {
+    if (this.closed) return;
+    void this.ensureInit();
+    this.observeForSummary(event);
+    this.writeBuffer.push(event);
+    if (this.writeBuffer.length >= _FileSessionWriter.FLUSH_SIZE) {
+      if (this.flushTimer) {
+        clearTimeout(this.flushTimer);
+        this.flushTimer = null;
+      }
+      void this.flushBuffer().catch(() => {
+      });
+    } else {
+      this.scheduleFlush();
+    }
+  }
   recordFileChange(input) {
-    this.pendingFileSnapshots.push(input);
+    if (this.closed) return;
+    if (this.activePromptIndex === null) {
+      this.pendingFileSnapshots.push(input);
+      return;
+    }
+    const event = {
+      type: "file_snapshot",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      promptIndex: this.activePromptIndex,
+      files: [input]
+    };
+    this.bufferSynchronousEvent(event);
+  }
+  recordFileObservation(input) {
+    if (!input.path || !/^[a-f\d]{64}$/i.test(input.hash) || !Number.isFinite(input.mtimeMs)) return;
+    this.bufferSynchronousEvent({
+      type: "file_observation",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      path: input.path,
+      hash: input.hash.toLowerCase(),
+      mtimeMs: input.mtimeMs,
+      source: input.source
+    });
   }
   recordSideEffect(input) {
     this.append({
@@ -743,18 +926,13 @@ var FileSessionWriter = class _FileSessionWriter {
     return Array.from(this.openToolUses);
   }
   async writeSessionStartLazy() {
-    const record = `${JSON.stringify({
+    this.writeBuffer.push({
       type: this.resumed ? "session_resumed" : "session_start",
       ts: this.startedAt,
       id: this.id,
       model: this.meta.model ?? "unknown",
       provider: this.meta.provider ?? "unknown"
-    })}
-`;
-    try {
-      await this.enqueueWrite(record);
-    } catch {
-    }
+    });
   }
   async append(event) {
     if (this.closed) return;
@@ -767,7 +945,8 @@ var FileSessionWriter = class _FileSessionWriter {
         clearTimeout(this.flushTimer);
         this.flushTimer = null;
       }
-      await this.flushBuffer();
+      await this.flushBuffer().catch(() => {
+      });
     } else {
       this.scheduleFlush();
     }
@@ -785,7 +964,8 @@ var FileSessionWriter = class _FileSessionWriter {
         clearTimeout(this.flushTimer);
         this.flushTimer = null;
       }
-      await this.flushBuffer();
+      await this.flushBuffer().catch(() => {
+      });
     } else {
       this.scheduleFlush();
     }
@@ -795,16 +975,49 @@ var FileSessionWriter = class _FileSessionWriter {
    * (user_input, llm_response) call this so they survive SIGKILL/crash
    * instead of sitting in the in-memory buffer for up to 500ms.
    *
-   * Idempotent — cancels any pending timer and writes whatever has
-   * accumulated in the buffer. Safe to call even when the buffer
-   * is empty (no-op).
+   * Idempotent — cancels any pending timer, writes whatever has accumulated,
+   * then asks the OS to synchronize the file data before resolving. Even an
+   * empty-buffer flush synchronizes any earlier timer-driven append.
    */
   async flush() {
+    if (this.closed) return;
     if (this.flushTimer) {
       clearTimeout(this.flushTimer);
       this.flushTimer = null;
     }
     await this.flushBuffer();
+    await this.writeChain;
+    await this.handle.datasync();
+  }
+  /**
+   * Last-gasp synchronous drain for hard-exit paths (process.exit after
+   * rapid Ctrl+C). The async write chain cannot be awaited when the process
+   * is about to die, but whatever still sits in the in-memory buffer CAN be
+   * saved with a blocking append. Best-effort: an in-flight async write may
+   * be cut off by the exit regardless; errors here are swallowed.
+   */
+  flushSync() {
+    if (this.writeBuffer.length === 0 || !this.filePath) return;
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    const batch = this.writeBuffer.map((e) => JSON.stringify(e)).join("\n") + "\n";
+    this.writeBuffer = [];
+    let fd;
+    try {
+      fd = openSync(this.filePath, "a");
+      writeSync(fd, batch, null, "utf8");
+      fsyncSync(fd);
+    } catch {
+    } finally {
+      if (fd !== void 0) {
+        try {
+          closeSync(fd);
+        } catch {
+        }
+      }
+    }
   }
   /** Schedule a deferred flush. No-op if a timer is already pending. */
   scheduleFlush() {
@@ -817,15 +1030,24 @@ var FileSessionWriter = class _FileSessionWriter {
   }
   /**
    * Flush all buffered events to disk as a single appendFile call.
-   * Errors use the same throttled-warning pattern the old per-event
-   * append path used — one warning every 5s with a suppressed count.
-   * On failure the buffer is cleared (events are best-effort, same as
-   * the old per-event path where a failed write was silently dropped).
+   * Concurrent callers join a FIFO flush chain. On failure the drained batch
+   * is prepended to the live buffer, preserving chronology and allowing the
+   * next timer/boundary flush to retry it. Warnings retain the existing
+   * throttled behavior.
    */
-  async flushBuffer() {
+  flushBuffer() {
+    const flush = this.flushChain.then(() => this.flushBufferOnce());
+    this.flushChain = flush.then(
+      () => void 0,
+      () => void 0
+    );
+    return flush;
+  }
+  async flushBufferOnce() {
     if (this.writeBuffer.length === 0) return;
-    const eventCount = this.writeBuffer.length;
-    const batch = this.writeBuffer.map((e) => JSON.stringify(e)).join("\n") + "\n";
+    const events = this.writeBuffer;
+    const eventCount = events.length;
+    const batch = events.map((e) => JSON.stringify(e)).join("\n") + "\n";
     this.writeBuffer = [];
     const t0 = Date.now();
     let outcome = "success";
@@ -835,6 +1057,7 @@ var FileSessionWriter = class _FileSessionWriter {
     } catch (err) {
       outcome = "failure";
       errorMsg = toErrorMessage(err);
+      this.writeBuffer = [...events, ...this.writeBuffer];
       this.appendFailCount += eventCount;
       const now = Date.now();
       if (now - this.lastAppendWarnAt > 5e3) {
@@ -848,6 +1071,8 @@ var FileSessionWriter = class _FileSessionWriter {
         this.lastAppendWarnAt = now;
         this.appendFailCount = 0;
       }
+      if (!this.closed) this.scheduleFlush();
+      throw err;
     } finally {
       this.events?.emit("storage.write", {
         sessionId: this.id,
@@ -902,10 +1127,22 @@ var FileSessionWriter = class _FileSessionWriter {
   }
   async close() {
     if (this.closePromise) return this.closePromise;
-    this.closePromise = this.doClose();
+    this.closePromise = this.doClose().catch((err) => {
+      this.closed = false;
+      this.closePromise = null;
+      if (this.writeBuffer.length > 0) this.scheduleFlush();
+      throw err;
+    });
     return this.closePromise;
   }
   async doClose() {
+    if (this.pendingFileSnapshots.length > 0) {
+      await this.writeFileSnapshot(
+        this.activePromptIndex ?? 0,
+        [...this.pendingFileSnapshots]
+      );
+      this.pendingFileSnapshots = [];
+    }
     this.closed = true;
     if (this.flushTimer) {
       clearTimeout(this.flushTimer);
@@ -913,6 +1150,7 @@ var FileSessionWriter = class _FileSessionWriter {
     }
     await this.flushBuffer();
     await this.writeChain;
+    await this.handle.datasync();
     this.summary = {
       ...this.summary,
       endedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -977,12 +1215,29 @@ var FileSessionWriter = class _FileSessionWriter {
       await this.writeFileSnapshot(promptIndex, [...this.pendingFileSnapshots]);
       this.pendingFileSnapshots = [];
     }
+    let workspaceCheckpoint;
+    try {
+      workspaceCheckpoint = await this.checkpointCas?.capture(this.id, promptIndex);
+    } catch (err) {
+      console.warn(
+        JSON.stringify({
+          level: "warn",
+          event: "session.workspace_checkpoint_capture_failed",
+          sessionId: this.id,
+          promptIndex,
+          message: toErrorMessage(err),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+    }
     await this.append({
       type: "checkpoint",
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       promptIndex,
-      promptPreview
+      promptPreview,
+      ...workspaceCheckpoint ? { workspaceCheckpoint } : {}
     });
+    this.activePromptIndex = promptIndex;
     this.events?.emit("checkpoint.written", {
       sessionId: this.id,
       promptIndex,
@@ -1021,7 +1276,7 @@ var FileSessionWriter = class _FileSessionWriter {
     let removedCount = 0;
     let targetCheckpointSeen = false;
     try {
-      fd = await fsp2.open(this.filePath, "r", 384);
+      fd = await fsp4.open(this.filePath, "r", 384);
       while (true) {
         const buf = Buffer.alloc(CHUNK_SIZE);
         const { bytesRead } = await fd.read(buf, 0, CHUNK_SIZE, fileOffset);
@@ -1076,7 +1331,7 @@ var FileSessionWriter = class _FileSessionWriter {
     await this.writeChain;
     await this.handle.close();
     const tmpPath = `${this.filePath}.rewind.tmp`;
-    const src = await fsp2.open(this.filePath, "r", 384);
+    const src = await fsp4.open(this.filePath, "r", 384);
     try {
       const statResult = await src.stat();
       const totalSize = statResult.size;
@@ -1092,7 +1347,7 @@ var FileSessionWriter = class _FileSessionWriter {
       } else {
         newlineAfterCheckpoint = totalSize;
       }
-      const writeFd = await fsp2.open(tmpPath, "w", 384);
+      const writeFd = await fsp4.open(tmpPath, "w", 384);
       try {
         let readOffset = 0;
         while (readOffset < newlineAfterCheckpoint) {
@@ -1140,11 +1395,11 @@ var FileSessionWriter = class _FileSessionWriter {
         await writeFd.close();
       }
       await src.close();
-      await fsp2.rename(tmpPath, this.filePath);
-      this.handle = await fsp2.open(this.filePath, "a", 384);
+      await fsp4.rename(tmpPath, this.filePath);
+      this.handle = await fsp4.open(this.filePath, "a", 384);
     } catch (err) {
-      await fsp2.unlink(tmpPath).catch(() => void 0);
-      this.handle = await fsp2.open(this.filePath, "a", 384).catch(() => this.handle);
+      await fsp4.unlink(tmpPath).catch(() => void 0);
+      this.handle = await fsp4.open(this.filePath, "a", 384).catch(() => this.handle);
       throw err;
     }
     await this.append({
@@ -1153,6 +1408,7 @@ var FileSessionWriter = class _FileSessionWriter {
       toPromptIndex: targetPromptIndex,
       revertedFiles: []
     });
+    this.activePromptIndex = targetPromptIndex;
     this.events?.emit("session.rewound", {
       sessionId: this.id,
       toPromptIndex: targetPromptIndex,
@@ -1167,6 +1423,7 @@ var FileSessionWriter = class _FileSessionWriter {
       clearTimeout(this.flushTimer);
       this.flushTimer = null;
     }
+    await this.flushChain;
     this.writeBuffer = [];
     await this.writeChain;
     const record = `${JSON.stringify({
@@ -1177,7 +1434,9 @@ var FileSessionWriter = class _FileSessionWriter {
       provider: this.meta.provider ?? "unknown"
     })}
 `;
-    await fsp2.writeFile(this.filePath, record, "utf8");
+    await fsp4.writeFile(this.filePath, record, "utf8");
+    this.activePromptIndex = null;
+    this.pendingFileSnapshots = [];
   }
   /**
    * Write an in-flight marker. The agent loop should call
@@ -1204,6 +1463,13 @@ var FileSessionWriter = class _FileSessionWriter {
    * cleanly X times, then died without finishing Y".
    */
   async clearInFlightMarker(reason) {
+    if (this.pendingFileSnapshots.length > 0) {
+      await this.writeFileSnapshot(
+        this.activePromptIndex ?? 0,
+        [...this.pendingFileSnapshots]
+      );
+      this.pendingFileSnapshots = [];
+    }
     await this.append({
       type: "in_flight_end",
       ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1213,6 +1479,492 @@ var FileSessionWriter = class _FileSessionWriter {
   }
 };
 
+// src/storage/storage-concurrency.ts
+async function mapWithConcurrency(items, concurrency, mapper) {
+  if (items.length === 0) return [];
+  const limit = Math.max(1, Math.floor(concurrency));
+  const results = new Array(items.length);
+  let next = 0;
+  async function worker() {
+    while (true) {
+      const index = next;
+      next++;
+      if (index >= items.length) return;
+      results[index] = await mapper(items[index], index);
+    }
+  }
+  const workers = Array.from({ length: Math.min(limit, items.length) }, () => worker());
+  await Promise.all(workers);
+  return results;
+}
+
+// src/storage/session-checkpoint-cas.ts
+var HASH_RE = /^[a-f\d]{64}$/;
+var CAPTURE_CONCURRENCY = 8;
+var MAX_GIT_OUTPUT = 16 * 1024 * 1024;
+var MAX_BLOB_BYTES = 64 * 1024 * 1024;
+var MAX_CHECKPOINT_BYTES = 512 * 1024 * 1024;
+function sha256(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function isInside(root, target) {
+  const relative6 = path2.relative(root, target);
+  return relative6 === "" || !relative6.startsWith("..") && !path2.isAbsolute(relative6);
+}
+function normalizeRelative(input) {
+  if (!input || path2.isAbsolute(input)) return null;
+  const normalized = input.replace(/\\/g, "/").replace(/^\.\//, "");
+  const resolved = path2.posix.normalize(normalized);
+  if (!resolved || resolved === "." || resolved === ".." || resolved.startsWith("../")) return null;
+  return resolved;
+}
+function parseNulPaths(output) {
+  return output.split("\0").map(normalizeRelative).filter((value) => value !== null);
+}
+function isWrongStackWorktreePath(relative6) {
+  return relative6 === ".wrongstack/worktrees" || relative6.startsWith(".wrongstack/worktrees/");
+}
+var SessionCheckpointCas = class {
+  rootDir;
+  projectRoot;
+  runGit;
+  constructor(opts) {
+    this.rootDir = path2.resolve(opts.rootDir);
+    this.projectRoot = path2.resolve(opts.projectRoot);
+    this.runGit = opts.runGit ?? defaultRunGit;
+  }
+  async capture(_sessionId, _promptIndex) {
+    const head = await this.runGit(["rev-parse", "--verify", "HEAD"], this.projectRoot);
+    const baseHead = head.stdout.trim();
+    if (head.code !== 0 || head.stdoutTruncated || !/^[a-f\d]{40,64}$/i.test(baseHead)) {
+      return void 0;
+    }
+    const [tracked, untracked] = await Promise.all([
+      this.runGit(["diff", "HEAD", "--name-only", "-z", "--"], this.projectRoot),
+      this.runGit(["ls-files", "--others", "--exclude-standard", "-z"], this.projectRoot)
+    ]);
+    if (tracked.code !== 0 || untracked.code !== 0 || tracked.stdoutTruncated || untracked.stdoutTruncated) {
+      return void 0;
+    }
+    const relativePaths = [
+      .../* @__PURE__ */ new Set([...parseNulPaths(tracked.stdout), ...parseNulPaths(untracked.stdout)])
+    ].filter((relative6) => !isWrongStackWorktreePath(relative6)).sort();
+    const unresolved = [];
+    let scheduledBytes = 0;
+    const captured = await mapWithConcurrency(
+      relativePaths,
+      CAPTURE_CONCURRENCY,
+      async (relative6) => {
+        const absolute = path2.resolve(this.projectRoot, ...relative6.split("/"));
+        if (!isInside(this.projectRoot, absolute)) {
+          unresolved.push({ path: relative6, reason: "path escapes project root" });
+          return null;
+        }
+        try {
+          const stat13 = await fsp4.lstat(absolute);
+          if (stat13.isSymbolicLink()) {
+            const linkTarget = await fsp4.readlink(absolute);
+            const resolvedLink = path2.resolve(path2.dirname(absolute), linkTarget);
+            if (path2.isAbsolute(linkTarget) || !isInside(this.projectRoot, resolvedLink)) {
+              unresolved.push({
+                path: relative6,
+                reason: "symlink target escapes project root"
+              });
+              return null;
+            }
+            return { path: relative6, state: "symlink", linkTarget };
+          }
+          if (!stat13.isFile()) {
+            unresolved.push({ path: relative6, reason: "changed path is not a regular file" });
+            return null;
+          }
+          if (stat13.size > MAX_BLOB_BYTES) {
+            unresolved.push({
+              path: relative6,
+              reason: `file exceeds ${MAX_BLOB_BYTES}-byte checkpoint blob limit`
+            });
+            return null;
+          }
+          if (scheduledBytes + stat13.size > MAX_CHECKPOINT_BYTES) {
+            unresolved.push({
+              path: relative6,
+              reason: `checkpoint exceeds ${MAX_CHECKPOINT_BYTES}-byte aggregate blob limit`
+            });
+            return null;
+          }
+          scheduledBytes += stat13.size;
+          const content = await fsp4.readFile(absolute);
+          const blobHash = sha256(content);
+          await this.putBlob(blobHash, content);
+          return { path: relative6, state: "file", blobHash, mode: stat13.mode & 511 };
+        } catch (err) {
+          if (err.code === "ENOENT") {
+            return { path: relative6, state: "absent" };
+          }
+          unresolved.push({ path: relative6, reason: toErrorMessage(err) });
+          return null;
+        }
+      }
+    );
+    const capturedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const manifest = {
+      version: 1,
+      baseHead: baseHead.toLowerCase(),
+      coverage: "git-head-plus-dirty",
+      entries: captured.filter((entry) => entry !== null),
+      unresolved: [...unresolved].sort((a, b) => a.path.localeCompare(b.path))
+    };
+    const encoded = JSON.stringify(manifest);
+    const manifestHash = sha256(encoded);
+    await this.putManifest(manifestHash, encoded);
+    return {
+      manifestHash,
+      baseHead: manifest.baseHead,
+      entryCount: manifest.entries.length,
+      unresolvedCount: manifest.unresolved.length,
+      capturedAt,
+      coverage: manifest.coverage
+    };
+  }
+  async materialize(checkpoint, targetRoot) {
+    const target = path2.resolve(targetRoot);
+    if (target === this.projectRoot) {
+      throw new Error("Refusing to materialize a workspace checkpoint over the parent project root");
+    }
+    const targetStat = await fsp4.stat(target);
+    if (!targetStat.isDirectory()) throw new Error(`Checkpoint target is not a directory: ${target}`);
+    const manifest = await this.loadManifest(checkpoint.manifestHash);
+    if (manifest.baseHead !== checkpoint.baseHead.toLowerCase() || manifest.coverage !== checkpoint.coverage || manifest.entries.length !== checkpoint.entryCount || manifest.unresolved.length !== checkpoint.unresolvedCount) {
+      throw new Error("Workspace checkpoint reference does not match its CAS manifest");
+    }
+    if (manifest.unresolved.length > 0) {
+      throw new Error(
+        `Workspace checkpoint has ${manifest.unresolved.length} unresolved path(s); exact materialization refused`
+      );
+    }
+    const targetHead = await this.runGit(["rev-parse", "--verify", "HEAD"], target);
+    if (targetHead.code !== 0 || targetHead.stdoutTruncated || targetHead.stdout.trim().toLowerCase() !== manifest.baseHead) {
+      throw new Error(
+        `Checkpoint target HEAD must equal ${manifest.baseHead}; got ${targetHead.stdout.trim() || "unknown"}`
+      );
+    }
+    const targetStatus = await this.runGit(
+      ["status", "--porcelain=v1", "-z", "--untracked-files=all", "--ignored=matching"],
+      target
+    );
+    if (targetStatus.code !== 0 || targetStatus.stdoutTruncated) {
+      throw new Error("Unable to verify that the checkpoint target is clean");
+    }
+    if (targetStatus.stdout.length > 0) {
+      throw new Error("Checkpoint target must be a clean checkout before materialization");
+    }
+    const realTarget = await fsp4.realpath(target);
+    const writtenFiles = [];
+    const deletedFiles = [];
+    const errors = [];
+    const prepared = [];
+    for (const entry of manifest.entries) {
+      try {
+        const output = await this.safeOutputPath(target, realTarget, entry.path);
+        if (entry.state === "symlink") {
+          if (path2.isAbsolute(entry.linkTarget)) {
+            throw new Error("absolute symlink target refused");
+          }
+          const resolvedLink = path2.resolve(path2.dirname(output), entry.linkTarget);
+          if (!isInside(target, resolvedLink)) throw new Error("symlink target escapes checkpoint root");
+        }
+        prepared.push({
+          entry,
+          output,
+          ...entry.state === "file" ? { content: await this.readBlob(entry.blobHash) } : {}
+        });
+      } catch (err) {
+        errors.push(`${entry.path}: ${toErrorMessage(err)}`);
+      }
+    }
+    if (errors.length > 0) {
+      return { targetRoot: target, writtenFiles, deletedFiles, errors };
+    }
+    for (const { entry, output, content } of prepared) {
+      try {
+        if (entry.state === "absent") {
+          await fsp4.unlink(output).catch((err) => {
+            if (err.code !== "ENOENT") throw err;
+          });
+          deletedFiles.push(entry.path);
+          continue;
+        }
+        if (entry.state === "symlink") {
+          await fsp4.unlink(output).catch((err) => {
+            if (err.code !== "ENOENT") throw err;
+          });
+          await fsp4.mkdir(path2.dirname(output), { recursive: true });
+          await fsp4.symlink(entry.linkTarget, output);
+          writtenFiles.push(entry.path);
+          continue;
+        }
+        if (!content) throw new Error("CAS blob was not prepared");
+        await atomicWrite(output, content, { mode: entry.mode });
+        await fsp4.chmod(output, entry.mode).catch(() => void 0);
+        writtenFiles.push(entry.path);
+      } catch (err) {
+        errors.push(`${entry.path}: ${toErrorMessage(err)}`);
+      }
+    }
+    return { targetRoot: target, writtenFiles, deletedFiles, errors };
+  }
+  objectPath(hash) {
+    if (!HASH_RE.test(hash)) throw new Error(`Invalid CAS object hash: ${hash}`);
+    return path2.join(this.rootDir, "objects", hash.slice(0, 2), hash.slice(2));
+  }
+  manifestPath(hash) {
+    if (!HASH_RE.test(hash)) throw new Error(`Invalid checkpoint manifest hash: ${hash}`);
+    return path2.join(this.rootDir, "manifests", `${hash}.json`);
+  }
+  async putBlob(hash, content) {
+    const target = this.objectPath(hash);
+    await fsp4.mkdir(path2.dirname(target), { recursive: true });
+    try {
+      const existing = await fsp4.readFile(target);
+      if (sha256(existing) !== hash) throw new Error(`Corrupt CAS object collision: ${hash}`);
+      return;
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+    const temp = path2.join(
+      path2.dirname(target),
+      `.${path2.basename(target)}.${process.pid}.${randomUUID()}.tmp`
+    );
+    let handle;
+    try {
+      handle = await fsp4.open(temp, "wx", 384);
+      await handle.writeFile(content);
+      await handle.sync();
+      await handle.close();
+      handle = void 0;
+      try {
+        await fsp4.link(temp, target);
+      } catch (err) {
+        if (err.code !== "EEXIST") throw err;
+        const existing = await fsp4.readFile(target);
+        if (sha256(existing) !== hash) throw new Error(`Corrupt CAS object collision: ${hash}`);
+      }
+    } finally {
+      await handle?.close().catch(() => void 0);
+      await fsp4.unlink(temp).catch(() => void 0);
+    }
+  }
+  async putManifest(hash, encoded) {
+    const target = this.manifestPath(hash);
+    const existing = await fsp4.readFile(target).catch(() => null);
+    if (existing) {
+      if (sha256(existing) !== hash) throw new Error(`Corrupt checkpoint manifest collision: ${hash}`);
+      return;
+    }
+    await atomicWrite(target, encoded, { mode: 384 });
+  }
+  async readBlob(hash) {
+    const content = await fsp4.readFile(this.objectPath(hash));
+    if (sha256(content) !== hash) throw new Error(`CAS blob integrity check failed: ${hash}`);
+    return content;
+  }
+  async loadManifest(hash) {
+    const raw = await fsp4.readFile(this.manifestPath(hash));
+    if (sha256(raw) !== hash) throw new Error(`Checkpoint manifest integrity check failed: ${hash}`);
+    const parsed = JSON.parse(raw.toString("utf8"));
+    if (parsed.version !== 1 || typeof parsed.baseHead !== "string" || parsed.coverage !== "git-head-plus-dirty" || !Array.isArray(parsed.entries) || !Array.isArray(parsed.unresolved)) {
+      throw new Error(`Invalid workspace checkpoint manifest: ${hash}`);
+    }
+    const entriesValid = parsed.entries.every((entry) => {
+      if (!entry || typeof entry !== "object") return false;
+      const candidate = entry;
+      if (typeof candidate.path !== "string" || !normalizeRelative(candidate.path)) return false;
+      if (candidate.state === "absent") return true;
+      if (candidate.state === "symlink") return typeof candidate.linkTarget === "string";
+      return candidate.state === "file" && typeof candidate.blobHash === "string" && HASH_RE.test(candidate.blobHash) && typeof candidate.mode === "number" && Number.isInteger(candidate.mode) && candidate.mode >= 0 && candidate.mode <= 511;
+    });
+    const unresolvedValid = parsed.unresolved.every(
+      (entry) => entry !== null && typeof entry === "object" && typeof entry.path === "string" && typeof entry.reason === "string"
+    );
+    if (!entriesValid || !unresolvedValid) {
+      throw new Error(`Invalid workspace checkpoint manifest entries: ${hash}`);
+    }
+    return parsed;
+  }
+  async safeOutputPath(target, realTarget, relative6) {
+    const normalized = normalizeRelative(relative6);
+    if (!normalized) throw new Error("invalid relative path");
+    const output = path2.resolve(target, ...normalized.split("/"));
+    if (!isInside(target, output)) throw new Error("path escapes checkpoint target");
+    let probe = output;
+    for (; ; ) {
+      try {
+        const real = await fsp4.realpath(probe);
+        if (!isInside(realTarget, real)) throw new Error("path resolves through a symlink outside checkpoint target");
+        return output;
+      } catch (err) {
+        if (err.code !== "ENOENT") throw err;
+        const parent = path2.dirname(probe);
+        if (parent === probe) throw err;
+        probe = parent;
+      }
+    }
+  }
+};
+function defaultRunGit(args, cwd) {
+  return new Promise((resolve11) => {
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let stdoutTruncated = false;
+    let stderrTruncated = false;
+    const child = spawn("git", args, {
+      cwd,
+      env: buildChildEnv(),
+      stdio: ["ignore", "pipe", "pipe"],
+      signal: AbortSignal.timeout(3e4),
+      windowsHide: true
+    });
+    child.stdout?.on("data", (chunk) => {
+      const remaining = MAX_GIT_OUTPUT - stdoutBytes;
+      if (remaining <= 0) {
+        stdoutTruncated = true;
+        return;
+      }
+      const kept = chunk.subarray(0, remaining);
+      stdoutChunks.push(kept);
+      stdoutBytes += kept.length;
+      if (kept.length < chunk.length) stdoutTruncated = true;
+    });
+    child.stderr?.on("data", (chunk) => {
+      const remaining = MAX_GIT_OUTPUT - stderrBytes;
+      if (remaining <= 0) {
+        stderrTruncated = true;
+        return;
+      }
+      const kept = chunk.subarray(0, remaining);
+      stderrChunks.push(kept);
+      stderrBytes += kept.length;
+      if (kept.length < chunk.length) stderrTruncated = true;
+    });
+    const result = (code, extraStderr) => ({
+      code,
+      stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+      stderr: `${Buffer.concat(stderrChunks).toString("utf8")}${extraStderr ?? ""}`,
+      stdoutTruncated,
+      stderrTruncated
+    });
+    child.on("error", (err) => resolve11(result(1, err.message)));
+    child.on("close", (code) => resolve11(result(code ?? 1)));
+  });
+}
+var MAX_REVALIDATE_BYTES = 5 * 1024 * 1024;
+var VALIDATION_CONCURRENCY = 8;
+var NOTICE_PATH_LIMIT = 20;
+function isInside2(root, target) {
+  const relative6 = path2.relative(root, target);
+  return relative6 === "" || !relative6.startsWith("..") && !path2.isAbsolute(relative6);
+}
+function errno(err) {
+  return err && typeof err === "object" && "code" in err ? String(err.code) : void 0;
+}
+function latestObservations(events, projectRoot) {
+  const latest = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.type !== "file_observation" || typeof event.path !== "string" || event.path.length === 0 || typeof event.hash !== "string" || !/^[a-f\d]{64}$/i.test(event.hash)) {
+      continue;
+    }
+    const normalized = path2.resolve(projectRoot, event.path);
+    latest.set(normalized, {
+      path: normalized,
+      hash: event.hash.toLowerCase(),
+      ts: event.ts
+    });
+  }
+  return [...latest.values()];
+}
+async function validateOne(observation, lexicalRoot, realRoot) {
+  const base = {
+    path: observation.path,
+    observedAt: observation.ts,
+    expectedHash: observation.hash
+  };
+  if (!isInside2(lexicalRoot, observation.path)) {
+    return {
+      ...base,
+      status: "outside_project",
+      detail: "Recorded path is outside the active project root."
+    };
+  }
+  let realFile;
+  try {
+    realFile = await fsp4.realpath(observation.path);
+  } catch (err) {
+    if (errno(err) === "ENOENT") return { ...base, status: "deleted" };
+    return { ...base, status: "unreadable", detail: toErrorMessage(err) };
+  }
+  if (!isInside2(realRoot, realFile)) {
+    return {
+      ...base,
+      status: "outside_project",
+      detail: "Recorded path resolves through a symlink outside the active project root."
+    };
+  }
+  try {
+    const stat13 = await fsp4.stat(realFile);
+    if (!stat13.isFile()) {
+      return { ...base, status: "unreadable", detail: "Path is no longer a regular file." };
+    }
+    if (stat13.size > MAX_REVALIDATE_BYTES) {
+      return {
+        ...base,
+        status: "unreadable",
+        detail: `File now exceeds the ${MAX_REVALIDATE_BYTES}-byte validation limit.`
+      };
+    }
+    const content = await fsp4.readFile(realFile, "utf8");
+    const actualHash = createHash("sha256").update(content, "utf8").digest("hex");
+    if (actualHash === observation.hash) return null;
+    return { ...base, status: "modified", actualHash };
+  } catch (err) {
+    if (errno(err) === "ENOENT") return { ...base, status: "deleted" };
+    return { ...base, status: "unreadable", detail: toErrorMessage(err) };
+  }
+}
+async function validateResumeFileObservations(events, projectRoot) {
+  const lexicalRoot = path2.resolve(projectRoot);
+  const realRoot = await fsp4.realpath(lexicalRoot).catch(() => lexicalRoot);
+  const observations = latestObservations(events, lexicalRoot);
+  const results = await mapWithConcurrency(
+    observations,
+    VALIDATION_CONCURRENCY,
+    (observation) => validateOne(observation, lexicalRoot, realRoot)
+  );
+  return {
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    checkedFileCount: observations.length,
+    staleFiles: results.filter((entry) => entry !== null)
+  };
+}
+function formatResumeValidationNotice(validation, projectRoot) {
+  if (validation.staleFiles.length === 0) return null;
+  const root = path2.resolve(projectRoot);
+  const shown = validation.staleFiles.slice(0, NOTICE_PATH_LIMIT).map((entry) => {
+    const relative6 = path2.relative(root, entry.path);
+    const display = isInside2(root, entry.path) ? relative6 || "." : entry.path;
+    return `- ${JSON.stringify(display)} [${entry.status}]`;
+  });
+  const omitted = validation.staleFiles.length - shown.length;
+  if (omitted > 0) shown.push(`- ... and ${omitted} more stale path(s)`);
+  return [
+    "[SESSION RESUME FILE VALIDATION]",
+    `Journal hash validation found ${validation.staleFiles.length} previously observed file(s) whose current state cannot be trusted.`,
+    "Prior tool results and reasoning based on these paths are stale. Re-read each relevant file before relying on it or editing it.",
+    ...shown
+  ].join("\n");
+}
+
 // src/storage/session-id.ts
 function sanitizeModel(model) {
   return model.replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
@@ -1260,30 +2012,52 @@ function extractToolCallEnds(events) {
   return out;
 }
 
-// src/storage/storage-concurrency.ts
-async function mapWithConcurrency(items, concurrency, mapper) {
-  if (items.length === 0) return [];
-  const limit = Math.max(1, Math.floor(concurrency));
-  const results = new Array(items.length);
-  let next = 0;
-  async function worker() {
-    while (true) {
-      const index = next;
-      next++;
-      if (index >= items.length) return;
-      results[index] = await mapper(items[index], index);
+// src/storage/session-store.ts
+function isReplayableMessage(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return (candidate.role === "user" || candidate.role === "assistant" || candidate.role === "system") && (typeof candidate.content === "string" || Array.isArray(candidate.content));
+}
+function applyContextSnapshot(target, openToolUses, snapshot) {
+  if (!Array.isArray(snapshot) || !snapshot.every(isReplayableMessage)) return false;
+  target.length = 0;
+  openToolUses.clear();
+  for (const raw of snapshot) {
+    const { _estTokens: _ignored, ...message } = raw;
+    target.push(message);
+    if (!Array.isArray(message.content)) continue;
+    for (const block of message.content) {
+      if (block.type === "tool_use") openToolUses.add(block.id);
+      else if (block.type === "tool_result") openToolUses.delete(block.tool_use_id);
     }
   }
-  const workers = Array.from({ length: Math.min(limit, items.length) }, () => worker());
-  await Promise.all(workers);
-  return results;
+  return true;
+}
+function inheritsIntoFork(event) {
+  switch (event.type) {
+    case "session_start":
+    case "session_resumed":
+    case "session_forked":
+    case "session_end":
+    case "in_flight_start":
+    case "in_flight_end":
+    case "rewound":
+      return false;
+    // Parent snapshots describe mutations owned by the parent journal. A
+    // child that shares the current workspace must not inherit authority to
+    // rewind those historical side effects.
+    case "file_snapshot":
+      return false;
+    default:
+      return true;
+  }
 }
-
-// src/storage/session-store.ts
 var DefaultSessionStore = class _DefaultSessionStore {
   dir;
   events;
   secretScrubber;
+  projectRoot;
+  checkpointCas;
   isSessionInUse;
   /**
    * In-memory cache for load() results, keyed by session ID. The cache is
@@ -1302,6 +2076,11 @@ var DefaultSessionStore = class _DefaultSessionStore {
   static LIST_SCAN_CONCURRENCY = 32;
   constructor(opts) {
     this.dir = opts.dir;
+    this.projectRoot = opts.projectRoot ? path2.resolve(opts.projectRoot) : void 0;
+    this.checkpointCas = this.projectRoot ? new SessionCheckpointCas({
+      rootDir: path2.join(this.dir, "_cas"),
+      projectRoot: this.projectRoot
+    }) : void 0;
     this.events = opts.events;
     this.secretScrubber = opts.secretScrubber;
     this.isSessionInUse = opts.isSessionInUse;
@@ -1387,7 +2166,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const t0 = Date.now();
     let handle;
     try {
-      handle = await fsp2.open(file, "a", 384);
+      handle = await fsp4.open(file, "a", 384);
     } catch (err) {
       this.emitError(id, file, "create", toErrorMessage(err), false);
       throw new Error(
@@ -1400,6 +2179,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
         dir: shardDir,
         filePath: file,
         secretScrubber: this.secretScrubber,
+        checkpointCas: this.checkpointCas,
         onClose: (s) => this.appendToIndex(s)
       });
       this.emitWrite(id, file, "create", "success", Date.now() - t0);
@@ -1415,13 +2195,99 @@ var DefaultSessionStore = class _DefaultSessionStore {
       throw err;
     }
   }
+  async fork(id, opts = {}) {
+    const parent = await this.load(id);
+    let boundary = parent.events.length - 1;
+    let targetCheckpoint;
+    if (opts.checkpointPromptIndex !== void 0) {
+      boundary = -1;
+      for (let i = 0; i < parent.events.length; i++) {
+        const event = parent.events[i];
+        if (event?.type === "checkpoint" && event.promptIndex === opts.checkpointPromptIndex) {
+          boundary = i;
+          targetCheckpoint = event;
+        }
+      }
+      if (boundary === -1) {
+        throw new Error(
+          `Checkpoint ${opts.checkpointPromptIndex} not found in session "${id}"`
+        );
+      }
+    }
+    const parentPrefix = parent.events.slice(0, boundary + 1);
+    const workspaceCheckpoint = targetCheckpoint?.workspaceCheckpoint;
+    const checkpointHash = createHash("sha256").update(parentPrefix.map((event) => JSON.stringify(event)).join("\n") + "\n", "utf8").digest("hex");
+    const inherited = parentPrefix.filter(inheritsIntoFork);
+    const writer = await this.create({
+      id: "",
+      title: parent.metadata.title,
+      model: parent.metadata.model,
+      provider: parent.metadata.provider
+    });
+    try {
+      await writer.append({
+        type: "session_forked",
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        parentSessionId: id,
+        parentCheckpointPromptIndex: opts.checkpointPromptIndex,
+        parentCheckpointHash: checkpointHash,
+        workspace: "shared-current",
+        workspaceCheckpointHash: workspaceCheckpoint?.manifestHash
+      });
+      const batchSize = 250;
+      for (let offset = 0; offset < inherited.length; offset += batchSize) {
+        await writer.appendBatch(inherited.slice(offset, offset + batchSize));
+      }
+      await writer.flush();
+      await writer.close();
+      const data = await this.load(writer.id);
+      return {
+        id: writer.id,
+        data,
+        parentSessionId: id,
+        checkpointPromptIndex: opts.checkpointPromptIndex,
+        checkpointHash,
+        workspace: "shared-current",
+        workspaceCheckpoint
+      };
+    } catch (err) {
+      await writer.close().catch(() => void 0);
+      await this.delete(writer.id).catch(() => void 0);
+      throw err;
+    }
+  }
+  async materializeWorkspaceCheckpoint(checkpoint, targetRoot) {
+    if (!this.checkpointCas) {
+      throw new Error("Workspace checkpoint materialization requires a projectRoot-aware session store");
+    }
+    return this.checkpointCas.materialize(checkpoint, targetRoot);
+  }
   async resume(id) {
     const file = this.sessionPath(id, ".jsonl");
     const t0 = Date.now();
     const data = await this.load(id);
+    let resumedData = data;
+    if (this.projectRoot) {
+      try {
+        const resumeValidation = await validateResumeFileObservations(data.events, this.projectRoot);
+        const notice = formatResumeValidationNotice(resumeValidation, this.projectRoot);
+        resumedData = {
+          ...data,
+          resumeValidation,
+          ...notice ? {
+            messages: [
+              ...data.messages,
+              { role: "system", content: notice, ts: resumeValidation.checkedAt }
+            ]
+          } : {}
+        };
+      } catch (err) {
+        this.emitError(id, file, "resume_validation", toErrorMessage(err), true);
+      }
+    }
     let handle;
     try {
-      handle = await fsp2.open(file, "a", 384);
+      handle = await fsp4.open(file, "a", 384);
     } catch (err) {
       this.emitError(id, file, "resume", toErrorMessage(err), false);
       throw new Error(
@@ -1448,11 +2314,12 @@ var DefaultSessionStore = class _DefaultSessionStore {
           dir: path2.dirname(file),
           filePath: file,
           secretScrubber: this.secretScrubber,
+          checkpointCas: this.checkpointCas,
           onClose: (s) => this.appendToIndex(s)
         }
       );
       this.emitWrite(id, file, "resume", "success", Date.now() - t0);
-      return { writer, data };
+      return { writer, data: resumedData };
     } catch (err) {
       await handle.close().catch((e) => console.warn(JSON.stringify({
         level: "warn",
@@ -1491,10 +2358,10 @@ var DefaultSessionStore = class _DefaultSessionStore {
     let errorMsg;
     let cacheHit = false;
     try {
-      const s = await fsp2.stat(file);
-      const stat11 = { mtimeMs: s.mtimeMs, size: s.size };
+      const s = await fsp4.stat(file);
+      const stat13 = { mtimeMs: s.mtimeMs, size: s.size };
       const cached = this._loadCache.get(id);
-      if (cached && cached.mtimeMs === stat11.mtimeMs && cached.size === stat11.size) {
+      if (cached && cached.mtimeMs === stat13.mtimeMs && cached.size === stat13.size) {
         cacheHit = true;
         this._loadCache.delete(id);
         this._loadCache.set(id, cached);
@@ -1507,6 +2374,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       let sessionModel;
       let sessionProvider;
       let sessionPendingToolUses;
+      let sessionForkedEvent;
       const messages = mode.full ? [] : void 0;
       const openToolUses = mode.full ? /* @__PURE__ */ new Set() : void 0;
       let usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
@@ -1529,8 +2397,18 @@ var DefaultSessionStore = class _DefaultSessionStore {
                 sessionEndEvent = ev;
                 sessionPendingToolUses = ev.pendingToolUses;
               }
+              if (ev.type === "session_forked" && !sessionForkedEvent) {
+                sessionForkedEvent = ev;
+              }
               if (mode.full && messages !== void 0 && openToolUses !== void 0) {
-                if (ev.type === "user_input") {
+                if (ev.type === "context_snapshot") {
+                  if (!applyContextSnapshot(messages, openToolUses, ev.messages)) {
+                    this.events?.emit("session.damaged", {
+                      sessionId: id,
+                      detail: "Ignored malformed context_snapshot event"
+                    });
+                  }
+                } else if (ev.type === "user_input") {
                   openToolUses.clear();
                   messages.push({ role: "user", content: ev.content, ts: ev.ts });
                 } else if (ev.type === "llm_response") {
@@ -1606,7 +2484,14 @@ var DefaultSessionStore = class _DefaultSessionStore {
         endedAt: sessionEndEvent?.ts,
         model: sessionModel,
         provider: sessionProvider,
-        pendingToolUses: sessionPendingToolUses
+        pendingToolUses: sessionPendingToolUses,
+        forkedFrom: sessionForkedEvent ? {
+          sessionId: sessionForkedEvent.parentSessionId,
+          checkpointPromptIndex: sessionForkedEvent.parentCheckpointPromptIndex,
+          checkpointHash: sessionForkedEvent.parentCheckpointHash,
+          workspace: sessionForkedEvent.workspace,
+          workspaceCheckpointHash: sessionForkedEvent.workspaceCheckpointHash
+        } : void 0
       };
       const toolCallEnds = extractToolCallEnds(events);
       const data = { metadata: meta, events, messages: finalMessages, usage, toolCallEnds };
@@ -1617,7 +2502,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
             this._loadCache.delete(oldest);
           }
         }
-        this._loadCache.set(id, { mtimeMs: stat11.mtimeMs, size: stat11.size, data });
+        this._loadCache.set(id, { mtimeMs: stat13.mtimeMs, size: stat13.size, data });
       }
       return data;
     } catch (err) {
@@ -1659,17 +2544,17 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const limit = opts?.limit;
     const signal = opts?.signal;
     const out = [];
-    let stat11;
+    let stat13;
     try {
-      stat11 = await fsp2.stat(file);
+      stat13 = await fsp4.stat(file);
     } catch (err) {
       if (err.code === "ENOENT") return [];
       throw err;
     }
-    if (stat11.size === 0) return [];
+    if (stat13.size === 0) return [];
     let fh;
     try {
-      fh = await fsp2.open(file, "r");
+      fh = await fsp4.open(file, "r");
       const CHUNK = 64 * 1024;
       const buf = Buffer.alloc(CHUNK);
       let leftover = "";
@@ -1782,7 +2667,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       let shouldCompact = false;
       await withFileLock(this.indexFile, async () => {
         const line = JSON.stringify(summary) + "\n";
-        await fsp2.appendFile(this.indexFile, line, "utf8");
+        await fsp4.appendFile(this.indexFile, line, "utf8");
         this._indexCache = null;
         this.invalidateShardManifestBySessionId(summary.id);
         this.indexAppendCount++;
@@ -1803,7 +2688,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       await ensureDir(this.dir);
       await withFileLock(this.indexFile, async () => {
         const line = JSON.stringify({ action: "delete", id }) + "\n";
-        await fsp2.appendFile(this.indexFile, line, "utf8");
+        await fsp4.appendFile(this.indexFile, line, "utf8");
         this._indexCache = null;
         this.invalidateShardManifestBySessionId(id);
         this.indexAppendCount++;
@@ -1849,20 +2734,20 @@ var DefaultSessionStore = class _DefaultSessionStore {
    * Returns empty array when the index doesn't exist or is corrupt.
    */
   async readIndex() {
-    let stat11;
+    let stat13;
     try {
-      const s = await fsp2.stat(this.indexFile);
-      stat11 = { mtimeMs: s.mtimeMs, size: s.size };
+      const s = await fsp4.stat(this.indexFile);
+      stat13 = { mtimeMs: s.mtimeMs, size: s.size };
     } catch {
       this._indexCache = null;
       return [];
     }
-    if (this._indexCache !== null && this._indexCache.mtimeMs === stat11.mtimeMs && this._indexCache.size === stat11.size) {
+    if (this._indexCache !== null && this._indexCache.mtimeMs === stat13.mtimeMs && this._indexCache.size === stat13.size) {
       return [...this._indexCache.summaries];
     }
     let raw;
     try {
-      raw = await fsp2.readFile(this.indexFile, "utf8");
+      raw = await fsp4.readFile(this.indexFile, "utf8");
     } catch {
       this._indexCache = null;
       return [];
@@ -1890,7 +2775,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       if (a.startedAt > b.startedAt) return -1;
       return a.id.localeCompare(b.id);
     });
-    this._indexCache = { ...stat11, summaries };
+    this._indexCache = { ...stat13, summaries };
     return [...summaries];
   }
   /**
@@ -1933,7 +2818,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
   async collectShardKeys() {
     let entries;
     try {
-      entries = await fsp2.readdir(this.dir, { withFileTypes: true });
+      entries = await fsp4.readdir(this.dir, { withFileTypes: true });
     } catch {
       return [""];
     }
@@ -1950,7 +2835,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     if (cached) return cached;
     const manifestPath = this.shardManifestPath(shardKey);
     try {
-      const raw = await fsp2.readFile(manifestPath, "utf8");
+      const raw = await fsp4.readFile(manifestPath, "utf8");
       const parsed = JSON.parse(raw);
       const entry2 = {
         summaries: Array.isArray(parsed.summaries) ? parsed.summaries : [],
@@ -1988,7 +2873,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
   async collectSessionFiles(dir, prefix = "", depth = 0) {
     let entries;
     try {
-      entries = await fsp2.readdir(dir, { withFileTypes: true });
+      entries = await fsp4.readdir(dir, { withFileTypes: true });
     } catch {
       return [];
     }
@@ -2022,7 +2907,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
   async collectSessionIds(dir, prefix = "", depth = 0) {
     let entries;
     try {
-      entries = await fsp2.readdir(dir, { withFileTypes: true });
+      entries = await fsp4.readdir(dir, { withFileTypes: true });
     } catch {
       return [];
     }
@@ -2057,8 +2942,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
     if (fromManifest) return fromManifest;
     try {
       const full = this.sessionPath(id, ".jsonl");
-      const stat11 = await fsp2.stat(full);
-      const summary = await this.summarize(id, stat11.mtime.toISOString());
+      const stat13 = await fsp4.stat(full);
+      const summary = await this.summarize(id, stat13.mtime.toISOString());
       await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
         const msg = toErrorMessage(err);
         this.emitError(id, manifest, "summary_fallback", msg, true);
@@ -2091,7 +2976,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
   async readSummaryManifest(id, startTime = Date.now()) {
     const manifest = this.sessionPath(id, ".summary.json");
     try {
-      const raw = await fsp2.readFile(manifest, "utf8");
+      const raw = await fsp4.readFile(manifest, "utf8");
       this.emitRead(id, manifest, "summary", "success", Date.now() - startTime);
       return JSON.parse(raw);
     } catch {
@@ -2101,18 +2986,18 @@ var DefaultSessionStore = class _DefaultSessionStore {
   async summaryHeaderFor(ref) {
     let mtime = (/* @__PURE__ */ new Date(0)).toISOString();
     try {
-      const stat11 = await fsp2.stat(ref.filePath);
-      if (!stat11.isFile()) {
+      const stat13 = await fsp4.stat(ref.filePath);
+      if (!stat13.isFile()) {
         return {
           id: ref.id,
           title: "(damaged)",
-          startedAt: stat11.mtime.toISOString(),
+          startedAt: stat13.mtime.toISOString(),
           model: "unknown",
           provider: "unknown",
           tokenTotal: 0
         };
       }
-      mtime = stat11.mtime.toISOString();
+      mtime = stat13.mtime.toISOString();
     } catch {
       return null;
     }
@@ -2164,11 +3049,11 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const base = path2.basename(id);
     const sessDir = path2.join(shardDir, base);
     const deletions = [
-      fsp2.unlink(jsonlPath),
-      fsp2.unlink(summaryPath),
-      fsp2.unlink(sessionScopedPath(this.dir, id, ".plan.json")),
-      fsp2.unlink(sessionScopedPath(this.dir, id, ".tasks.json")),
-      fsp2.unlink(sessionScopedPath(this.dir, id, ".todos.json"))
+      fsp4.unlink(jsonlPath),
+      fsp4.unlink(summaryPath),
+      fsp4.unlink(sessionScopedPath(this.dir, id, ".plan.json")),
+      fsp4.unlink(sessionScopedPath(this.dir, id, ".tasks.json")),
+      fsp4.unlink(sessionScopedPath(this.dir, id, ".todos.json"))
     ];
     const results = await Promise.allSettled(deletions);
     for (const r of results) {
@@ -2185,7 +3070,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
         }
       }
     }
-    await fsp2.rm(sessDir, { recursive: true, force: true }).catch((err) => {
+    await fsp4.rm(sessDir, { recursive: true, force: true }).catch((err) => {
       console.warn(JSON.stringify({
         level: "warn",
         event: "session_store.rmdir_failed",
@@ -2203,7 +3088,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
    */
   async readActiveSessionId() {
     try {
-      const raw = await fsp2.readFile(path2.join(this.dir, "active.json"), "utf8");
+      const raw = await fsp4.readFile(path2.join(this.dir, "active.json"), "utf8");
       const active = JSON.parse(raw);
       return active.sessionId ?? null;
     } catch {
@@ -2230,7 +3115,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const manifest = this.sessionPath(id, ".summary.json");
     const jsonlPath = this.sessionPath(id, ".jsonl");
     try {
-      await fsp2.stat(jsonlPath);
+      await fsp4.stat(jsonlPath);
     } catch (err) {
       const code = err?.code;
       if (code === "ENOENT") {
@@ -2268,8 +3153,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const pruneFile = async (dir, name, prefix) => {
       const jsonlPath = path2.join(dir, name);
       try {
-        const stat11 = await fsp2.stat(jsonlPath);
-        if (stat11.mtimeMs >= cutoff) return;
+        const stat13 = await fsp4.stat(jsonlPath);
+        if (stat13.mtimeMs >= cutoff) return;
       } catch {
         return;
       }
@@ -2279,7 +3164,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       await this.deleteSession(id);
       deleted++;
     };
-    const entries = await fsp2.readdir(this.dir, { withFileTypes: true }).catch(() => []);
+    const entries = await fsp4.readdir(this.dir, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
       if (entry.isFile()) {
         if (isPrunableJsonl(entry.name)) await pruneFile(this.dir, entry.name, "");
@@ -2287,7 +3172,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       }
       if (!entry.isDirectory()) continue;
       const dateDir = path2.join(this.dir, entry.name);
-      const files = await fsp2.readdir(dateDir, { withFileTypes: true }).catch(() => []);
+      const files = await fsp4.readdir(dateDir, { withFileTypes: true }).catch(() => []);
       for (const file of files) {
         if (!file.isFile() || !isPrunableJsonl(file.name)) continue;
         await pruneFile(dateDir, file.name, entry.name);
@@ -2300,9 +3185,9 @@ var DefaultSessionStore = class _DefaultSessionStore {
       if (!entry.isDirectory()) continue;
       const dateDir = path2.join(this.dir, entry.name);
       try {
-        const remaining = await fsp2.readdir(dateDir);
+        const remaining = await fsp4.readdir(dateDir);
         if (remaining.length === 0) {
-          await fsp2.rmdir(dateDir).catch(() => void 0);
+          await fsp4.rmdir(dateDir).catch(() => void 0);
         }
       } catch {
       }
@@ -2321,8 +3206,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
       provider: "unknown"
     })}
 `;
-    await fsp2.writeFile(file, record, "utf8");
-    await fsp2.unlink(meta).catch(() => void 0);
+    await fsp4.writeFile(file, record, "utf8");
+    await fsp4.unlink(meta).catch(() => void 0);
   }
   async summarize(id, mtime) {
     try {
@@ -2472,7 +3357,7 @@ var QueueStore = class {
     const t0 = Date.now();
     let raw;
     try {
-      raw = await fsp2.readFile(this.file, "utf8");
+      raw = await fsp4.readFile(this.file, "utf8");
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") {
@@ -2553,7 +3438,7 @@ var QueueStore = class {
   async clear() {
     const t0 = Date.now();
     try {
-      await fsp2.unlink(this.file);
+      await fsp4.unlink(this.file);
       this.events?.emit("storage.write", {
         sessionId: this.traceId ?? "~boot~",
         store: "queue",
@@ -2610,7 +3495,7 @@ var DefaultAttachmentStore = class {
     let spooledPath;
     let data = input.data;
     if (this.spoolDir && bytes >= this.spoolThreshold) {
-      await fsp2.mkdir(this.spoolDir, { recursive: true });
+      await fsp4.mkdir(this.spoolDir, { recursive: true });
       spooledPath = path2.join(this.spoolDir, `${id}.bin`);
       await atomicWrite(spooledPath, input.data, {
         encoding: input.kind === "image" ? "base64" : "utf8"
@@ -2673,7 +3558,7 @@ var DefaultAttachmentStore = class {
       for (const att of this.items.values()) {
         if (att.path) toDelete.push(att.path);
       }
-      await Promise.all(toDelete.map((p) => fsp2.unlink(p).catch(() => void 0)));
+      await Promise.all(toDelete.map((p) => fsp4.unlink(p).catch(() => void 0)));
     }
     this.items.clear();
     this.refs.length = 0;
@@ -2681,7 +3566,7 @@ var DefaultAttachmentStore = class {
   }
   async toBlock(att) {
     if (att.kind === "image") {
-      const data = att.data ?? (att.path ? await fsp2.readFile(att.path, { encoding: "base64" }) : "");
+      const data = att.data ?? (att.path ? await fsp4.readFile(att.path, { encoding: "base64" }) : "");
       return {
         type: "image",
         source: {
@@ -2691,7 +3576,7 @@ var DefaultAttachmentStore = class {
         }
       };
     }
-    const raw = att.data ?? (att.path ? await fsp2.readFile(att.path, "utf8") : "");
+    const raw = att.data ?? (att.path ? await fsp4.readFile(att.path, "utf8") : "");
     const label = att.meta.filename ? `<file path="${att.meta.filename}">` : "<pasted>";
     const close = att.meta.filename ? "</file>" : "</pasted>";
     return { type: "text", text: `${label}
@@ -2894,8 +3779,8 @@ var FileMemoryBackend = class {
   }
   async getMtime(file) {
     try {
-      const stat11 = await fsp2.stat(file);
-      return stat11.mtimeMs;
+      const stat13 = await fsp4.stat(file);
+      return stat13.mtimeMs;
     } catch {
       return 0;
     }
@@ -2944,7 +3829,7 @@ var FileMemoryBackend = class {
     await ensureDir(path2.dirname(file));
     let existing = "";
     try {
-      existing = await fsp2.readFile(file, "utf8");
+      existing = await fsp4.readFile(file, "utf8");
     } catch {
     }
     const id = `mem_${Date.now()}_${randomUUID().slice(0, 8)}`;
@@ -2962,7 +3847,7 @@ ${line}`;
     return withFileLock(file, async () => {
       let existing;
       try {
-        existing = await fsp2.readFile(file, "utf8");
+        existing = await fsp4.readFile(file, "utf8");
       } catch {
         return 0;
       }
@@ -2999,7 +3884,7 @@ ${line}`;
   async readAll(scope, filePath) {
     const file = this.resolveFile(filePath, scope);
     try {
-      return await fsp2.readFile(file, "utf8");
+      return await fsp4.readFile(file, "utf8");
     } catch {
       return "";
     }
@@ -3023,7 +3908,7 @@ ${line}`;
     const file = this.resolveFile(filePath, scope);
     let existing;
     try {
-      existing = await fsp2.readFile(file, "utf8");
+      existing = await fsp4.readFile(file, "utf8");
     } catch {
       return 0;
     }
@@ -3043,7 +3928,7 @@ ${line}`;
     const next = lines.join("\n");
     const backup = `${file}.bak.${Date.now()}`;
     try {
-      await fsp2.copyFile(file, backup);
+      await fsp4.copyFile(file, backup);
       await pruneConsolidateBackups(file);
     } catch {
     }
@@ -3060,11 +3945,11 @@ async function pruneConsolidateBackups(file) {
   const dir = path2.dirname(file);
   const base = path2.basename(file);
   const prefix = `${base}.bak.`;
-  const backups = (await fsp2.readdir(dir)).filter((name) => name.startsWith(prefix)).sort().reverse();
+  const backups = (await fsp4.readdir(dir)).filter((name) => name.startsWith(prefix)).sort().reverse();
   await Promise.all(
     backups.slice(MAX_MEMORY_CONSOLIDATE_BACKUPS).map(async (name) => {
       try {
-        await fsp2.unlink(path2.join(dir, name));
+        await fsp4.unlink(path2.join(dir, name));
       } catch {
       }
     })
@@ -3631,8 +4516,8 @@ ${body.trim()}`);
     if (!this.persistBackup || scope === "project-agents") return;
     try {
       const content = await this.backend.readAll(scope, this.files[scope]);
-      const { writeFile: writeFile8, mkdir: mkdir7 } = await import('fs/promises');
-      await mkdir7(this.backupDir, { recursive: true });
+      const { writeFile: writeFile8, mkdir: mkdir8 } = await import('fs/promises');
+      await mkdir8(this.backupDir, { recursive: true });
       await writeFile8(`${this.backupDir}/${scope}.md`, content, "utf8");
     } catch {
     }
@@ -3814,7 +4699,7 @@ var GraphMemoryBackend = class _GraphMemoryBackend {
     this.loadedScope = scope;
     this.loaded = true;
     try {
-      await fsp2.unlink(this.graphFile);
+      await fsp4.unlink(this.graphFile);
     } catch {
     }
   }
@@ -3854,7 +4739,7 @@ var GraphMemoryBackend = class _GraphMemoryBackend {
   async loadGraph(scope) {
     if (this.loaded && this.loadedScope === scope) return;
     try {
-      const raw = await fsp2.readFile(this.graphFile, "utf8");
+      const raw = await fsp4.readFile(this.graphFile, "utf8");
       const data = JSON.parse(raw);
       this.nodes = new Map(data.nodes);
       this.edges = data.edges;
@@ -3876,10 +4761,10 @@ var GraphMemoryBackend = class _GraphMemoryBackend {
         edges: this.edges
       };
       const dir = this.graphFile.substring(0, this.graphFile.lastIndexOf("/"));
-      await fsp2.mkdir(dir, { recursive: true });
+      await fsp4.mkdir(dir, { recursive: true });
       const tmp = `${this.graphFile}.tmp`;
-      await fsp2.writeFile(tmp, JSON.stringify(data));
-      await fsp2.rename(tmp, this.graphFile);
+      await fsp4.writeFile(tmp, JSON.stringify(data));
+      await fsp4.rename(tmp, this.graphFile);
     } catch {
     }
   }
@@ -4270,7 +5155,7 @@ function isSecretField(name) {
 async function readProviderSnapshot(configPath, vault, warn) {
   let raw;
   try {
-    raw = await fsp2.readFile(configPath, "utf8");
+    raw = await fsp4.readFile(configPath, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") {
       warn?.(`Could not read ${configPath}: ${err.message}`);
@@ -4423,7 +5308,14 @@ var DEFAULT_TOOLS_CONFIG = Object.freeze({
   descriptionMode: Object.freeze({}),
   disabledTools: Object.freeze([]),
   autoExtendLimit: true,
-  restrictToProjectRoot: false
+  restrictToProjectRoot: false,
+  loopDetection: Object.freeze({
+    mode: "steer-then-cut",
+    steerThreshold: 3,
+    cutThreshold: 5,
+    windowSize: 12,
+    callRepeatThreshold: 4
+  })
 });
 var DEFAULT_CONTEXT_CONFIG = Object.freeze({
   preserveK: 10,
@@ -4475,7 +5367,8 @@ var BEHAVIOR_DEFAULTS = {
     descriptionMode: DEFAULT_TOOLS_CONFIG.descriptionMode,
     disabledTools: DEFAULT_TOOLS_CONFIG.disabledTools,
     autoExtendLimit: DEFAULT_TOOLS_CONFIG.autoExtendLimit,
-    restrictToProjectRoot: DEFAULT_TOOLS_CONFIG.restrictToProjectRoot
+    restrictToProjectRoot: DEFAULT_TOOLS_CONFIG.restrictToProjectRoot,
+    loopDetection: DEFAULT_TOOLS_CONFIG.loopDetection
   },
   log: { level: "info" },
   features: {
@@ -4933,7 +5826,7 @@ var DefaultConfigLoader = class {
       await withFileLock(fp, async () => {
         let parsed;
         try {
-          const raw = await fsp2.readFile(fp, "utf8");
+          const raw = await fsp4.readFile(fp, "utf8");
           const result = safeParse(raw);
           if (!result.ok || !isPlainRecord(result.value)) {
             return;
@@ -5052,7 +5945,7 @@ var DefaultConfigLoader = class {
     const fp = this.paths.syncConfig;
     const t0 = Date.now();
     try {
-      const raw = await fsp2.readFile(fp, "utf8");
+      const raw = await fsp4.readFile(fp, "utf8");
       const parsed = safeParse(raw);
       if (!parsed.ok || !parsed.value) {
         this.events?.emit("storage.read", {
@@ -5118,8 +6011,8 @@ var DefaultConfigLoader = class {
     const t0 = Date.now();
     let mtimeMs = null;
     try {
-      const stat11 = await fsp2.stat(file);
-      mtimeMs = stat11.mtimeMs;
+      const stat13 = await fsp4.stat(file);
+      mtimeMs = stat13.mtimeMs;
       const cached = this.jsonCache.get(file);
       if (cached && cached.mtimeMs === mtimeMs) {
         return structuredClone(cached.value);
@@ -5152,7 +6045,7 @@ var DefaultConfigLoader = class {
     }
     let raw;
     try {
-      raw = await fsp2.readFile(file, "utf8");
+      raw = await fsp4.readFile(file, "utf8");
     } catch (err) {
       if (err.code !== "ENOENT") {
         this.events?.emit("storage.read", {
@@ -5399,7 +6292,7 @@ var RecoveryLock = class {
       startedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     try {
-      await fsp2.writeFile(this.file, JSON.stringify(lock), { flag: "wx", mode: 384 });
+      await fsp4.writeFile(this.file, JSON.stringify(lock), { flag: "wx", mode: 384 });
     } catch (err) {
       const code = err.code;
       if (code === "EEXIST") {
@@ -5415,7 +6308,7 @@ var RecoveryLock = class {
    */
   async clear() {
     try {
-      await fsp2.unlink(this.file);
+      await fsp4.unlink(this.file);
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") return;
@@ -5425,7 +6318,7 @@ var RecoveryLock = class {
   async readLock() {
     let raw;
     try {
-      raw = await fsp2.readFile(this.file, "utf8");
+      raw = await fsp4.readFile(this.file, "utf8");
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") return null;
@@ -5473,8 +6366,8 @@ var DefaultSessionReader = class _DefaultSessionReader {
     const sessionPath = sessionScopedPath(rootDir, sessionId, ".jsonl");
     let mtimeMs = null;
     try {
-      const stat11 = await fsp2.stat(sessionPath);
-      mtimeMs = stat11.mtimeMs;
+      const stat13 = await fsp4.stat(sessionPath);
+      mtimeMs = stat13.mtimeMs;
     } catch {
       this.eventCache.delete(sessionId);
       this.eventCacheMtimes.delete(sessionId);
@@ -6054,7 +6947,7 @@ var AnnotationsStore = class {
     const fp = this.filePath(sessionId);
     let raw;
     try {
-      raw = await fsp2.readFile(fp, "utf8");
+      raw = await fsp4.readFile(fp, "utf8");
     } catch (err) {
       if (err.code === "ENOENT") return null;
       throw err;
@@ -6173,12 +7066,12 @@ var ReplayLogStore = class {
             const line = JSON.stringify(entry) + "\n";
             let offset2 = 0;
             try {
-              const stat11 = await fsp2.stat(fp);
-              offset2 = stat11.size;
+              const stat13 = await fsp4.stat(fp);
+              offset2 = stat13.size;
             } catch (err) {
               if (err.code !== "ENOENT") throw err;
             }
-            await fsp2.appendFile(fp, line, "utf8");
+            await fsp4.appendFile(fp, line, "utf8");
             cache.set(hash, { entry, offset: offset2, length: Buffer.byteLength(line, "utf8") });
             this.diskCount.set(input.sessionId, currentCount + 1);
             this.events?.emit("storage.write", {
@@ -6306,7 +7199,7 @@ var ReplayLogStore = class {
     const scan = async (dir, prefix, depth) => {
       let entries;
       try {
-        entries = await fsp2.readdir(dir, { withFileTypes: true });
+        entries = await fsp4.readdir(dir, { withFileTypes: true });
       } catch (err) {
         if (depth === 0 && err.code !== "ENOENT") {
           console.warn(JSON.stringify({
@@ -6344,10 +7237,10 @@ var ReplayLogStore = class {
     return sessionScopedPath(this.dir, sessionId, ".replay.jsonl");
   }
   async countEntries(filePath) {
-    const handle = await fsp2.open(filePath, "r");
+    const handle = await fsp4.open(filePath, "r");
     const buffer = Buffer.allocUnsafe(64 * 1024);
     let count = 0;
-    let hasNonWhitespace = false;
+    let hasNonWhitespace2 = false;
     try {
       while (true) {
         const { bytesRead } = await handle.read(buffer, 0, buffer.length, null);
@@ -6355,19 +7248,19 @@ var ReplayLogStore = class {
         for (let i = 0; i < bytesRead; i++) {
           const ch = buffer[i];
           if (ch === 10) {
-            if (hasNonWhitespace) count++;
-            hasNonWhitespace = false;
+            if (hasNonWhitespace2) count++;
+            hasNonWhitespace2 = false;
             continue;
           }
           if (ch !== 13 && ch !== 32 && ch !== 9) {
-            hasNonWhitespace = true;
+            hasNonWhitespace2 = true;
           }
         }
       }
     } finally {
       await handle.close();
     }
-    if (hasNonWhitespace) count++;
+    if (hasNonWhitespace2) count++;
     return count;
   }
   parseReplayLine(line) {
@@ -6385,7 +7278,7 @@ var ReplayLogStore = class {
   async readAll(sessionId) {
     const fp = this.filePath(sessionId);
     try {
-      const raw = await fsp2.readFile(fp, "utf8");
+      const raw = await fsp4.readFile(fp, "utf8");
       const out = [];
       for (const line of raw.split("\n")) {
         if (!line.trim()) continue;
@@ -6420,7 +7313,7 @@ var ReplayLogStore = class {
     const fp = this.filePath(sessionId);
     cache = /* @__PURE__ */ new Map();
     try {
-      const handle = await fsp2.open(fp, "r");
+      const handle = await fsp4.open(fp, "r");
       const CHUNK = 64 * 1024;
       const buffer = Buffer.alloc(CHUNK);
       let leftover = "";
@@ -6471,7 +7364,7 @@ var ReplayLogStore = class {
   async hydrateEntry(sessionId, hash, location) {
     if (location.entry) return location.entry;
     const fp = this.filePath(sessionId);
-    const handle = await fsp2.open(fp, "r");
+    const handle = await fsp4.open(fp, "r");
     try {
       const buffer = Buffer.alloc(location.length);
       const { bytesRead } = await handle.read(buffer, 0, location.length, location.offset);
@@ -6502,66 +7395,50 @@ var SessionRecovery = class {
   }
   dir;
   /**
-   * Scan a session log and return a `StaleSession` if and only
-   * if the last event is an `in_flight_start` without a matching
-   * `in_flight_end`. Returns `null` when:
+   * Scan a session log and return a `StaleSession` if and only if the newest
+   * lifecycle boundary is an `in_flight_start` without a later
+   * `in_flight_end`/`session_end`. Ordinary provider/tool events after the
+   * marker do not make the session clean. Returns `null` when:
    *   - the log does not exist;
    *   - the log is empty;
-   *   - the last event is `in_flight_end` (clean shutdown);
-   *   - the last event is something else (e.g. an unannotated
-   *     legacy log without in-flight markers).
+   *   - the latest lifecycle boundary is `in_flight_end` or `session_end`;
+   *   - there is no lifecycle boundary (legacy/pre-marker log).
+   *
+   * The reverse scanner is chunked and line-aware. It can cross arbitrarily
+   * large JSONL records (for example a large tool result) without imposing a
+   * fixed tail-size correctness limit. Clean logs normally return after the
+   * first chunk; stale logs continue counting lines so `eventCount` remains
+   * the documented total rather than a tail-only approximation.
    */
   async detectStale(sessionId) {
     const fp = this.filePath(sessionId);
-    const TAIL_SIZE = 8192;
-    let stat11;
+    let stat13;
     try {
-      stat11 = await fsp2.stat(fp);
+      stat13 = await fsp4.stat(fp);
     } catch (err) {
       if (err.code === "ENOENT") return null;
       return null;
     }
-    if (stat11.size === 0) return null;
-    const position = Math.max(0, stat11.size - TAIL_SIZE);
-    const buf = Buffer.alloc(TAIL_SIZE);
-    let fh;
+    if (stat13.size === 0) return null;
     try {
-      fh = await fsp2.open(fp, "r");
-      const { bytesRead } = await fh.read(buf, 0, TAIL_SIZE, position);
-      let eventCount = 0;
-      const raw = buf.subarray(0, bytesRead).toString("utf8");
-      for (const line of raw.split("\n")) {
-        if (line.trim()) eventCount++;
-      }
-      const lines = raw.split("\n").filter((l) => l.trim());
-      for (let i = lines.length - 1; i >= 0; i--) {
-        try {
-          const ev = JSON.parse(expectDefined(lines[i]));
-          if (ev.type === "in_flight_start") {
-            return {
-              sessionId,
-              path: fp,
-              lastEventTs: ev.ts,
-              context: ev.context,
-              eventCount
-            };
-          }
-          return null;
-        } catch {
-        }
-      }
-      return null;
+      const scan = await scanLatestLifecycleBoundary(fp, stat13.size);
+      if (scan?.boundary.type !== "in_flight_start") return null;
+      return {
+        sessionId,
+        path: fp,
+        lastEventTs: scan.boundary.ts,
+        context: scan.boundary.context,
+        eventCount: scan.eventCount
+      };
     } catch {
       return null;
-    } finally {
-      if (fh) await fh.close();
     }
   }
   /**
    * Generate a recovery plan for a session. The plan describes
-   * "what would be re-executed" if the user chose to resume —
-   * everything after the last `checkpoint` event, plus the
-   * dangling in-flight marker if present.
+   * the persisted tail after the last checkpoint, plus the dangling in-flight
+   * marker if present. SessionStore.resume() independently reconstructs state
+   * from the journal and does not re-run these events as commands.
    *
    * Returns a non-null plan for ANY session that has at least
    * one event after a checkpoint (or, for legacy sessions, at
@@ -6571,7 +7448,7 @@ var SessionRecovery = class {
     const fp = this.filePath(sessionId);
     let raw;
     try {
-      raw = await fsp2.readFile(fp, "utf8");
+      raw = await fsp4.readFile(fp, "utf8");
     } catch (err) {
       if (err.code === "ENOENT") return null;
       return null;
@@ -6594,8 +7471,8 @@ var SessionRecovery = class {
       }
     }
     const pendingEvents = lastCheckpointIdx >= 0 ? events.slice(lastCheckpointIdx + 1) : events;
-    const lastEv = expectDefined(events[events.length - 1]);
-    const inFlightStart = lastEv.type === "in_flight_start" ? lastEv : null;
+    const latestBoundary = events.findLast(isLifecycleBoundary);
+    const inFlightStart = latestBoundary?.type === "in_flight_start" ? latestBoundary : null;
     const context = inFlightStart && inFlightStart.type === "in_flight_start" ? inFlightStart.context : null;
     return {
       sessionId,
@@ -6616,7 +7493,7 @@ var SessionRecovery = class {
     const collect = async (dir, prefix, depth) => {
       let entries;
       try {
-        entries = await fsp2.readdir(dir, { withFileTypes: true });
+        entries = await fsp4.readdir(dir, { withFileTypes: true });
       } catch {
         return;
       }
@@ -6648,6 +7525,61 @@ var SessionRecovery = class {
     return sessionScopedPath(this.dir, sessionId, ".jsonl");
   }
 };
+function isLifecycleBoundary(event) {
+  return event.type === "in_flight_start" || event.type === "in_flight_end" || event.type === "session_end";
+}
+function parseLifecycleBoundary(line) {
+  try {
+    const parsed = JSON.parse(line.toString("utf8"));
+    return isLifecycleBoundary(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function hasNonWhitespace(line) {
+  for (const byte of line) {
+    if (byte !== 9 && byte !== 10 && byte !== 13 && byte !== 32) return true;
+  }
+  return false;
+}
+async function scanLatestLifecycleBoundary(filePath, size) {
+  const CHUNK_SIZE = 64 * 1024;
+  const handle = await fsp4.open(filePath, "r");
+  let position = size;
+  let laterLineFragment = Buffer.alloc(0);
+  let latestBoundary = null;
+  let eventCount = 0;
+  const observeLine = (line) => {
+    if (!hasNonWhitespace(line)) return null;
+    eventCount++;
+    return parseLifecycleBoundary(line);
+  };
+  try {
+    while (position > 0) {
+      const length = Math.min(CHUNK_SIZE, position);
+      position -= length;
+      const chunk = Buffer.allocUnsafe(length);
+      const { bytesRead } = await handle.read(chunk, 0, length, position);
+      const data = Buffer.concat([chunk.subarray(0, bytesRead), laterLineFragment]);
+      let lineEnd = data.length;
+      for (let i = data.length - 1; i >= 0; i--) {
+        if (data[i] !== 10) continue;
+        const boundary2 = observeLine(data.subarray(i + 1, lineEnd));
+        if (!latestBoundary && boundary2) latestBoundary = boundary2;
+        lineEnd = i;
+      }
+      laterLineFragment = data.subarray(0, lineEnd);
+      if (latestBoundary && latestBoundary.type !== "in_flight_start") {
+        return { boundary: latestBoundary, eventCount };
+      }
+    }
+    const boundary = observeLine(laterLineFragment);
+    if (!latestBoundary && boundary) latestBoundary = boundary;
+    return latestBoundary ? { boundary: latestBoundary, eventCount } : null;
+  } finally {
+    await handle.close();
+  }
+}
 var GENESIS_PREV = "0".repeat(64);
 var DEFAULT_FSYNC_EVERY = 100;
 var ToolAuditLog = class {
@@ -6717,9 +7649,9 @@ var ToolAuditLog = class {
             isError: input.isError,
             index
           };
-          await fsp2.appendFile(fp, JSON.stringify(entry) + "\n", "utf8");
+          await fsp4.appendFile(fp, JSON.stringify(entry) + "\n", "utf8");
           try {
-            const st = await fsp2.stat(fp);
+            const st = await fsp4.stat(fp);
             this.tailStat.set(input.sessionId, { mtimeMs: st.mtimeMs, size: st.size });
           } catch {
           }
@@ -6766,7 +7698,7 @@ var ToolAuditLog = class {
     const cachedStat = this.tailStat.get(sessionId);
     if (cachedHash !== void 0 && cachedIndex !== void 0 && cachedStat) {
       try {
-        const st = await fsp2.stat(fp);
+        const st = await fsp4.stat(fp);
         if (st.mtimeMs === cachedStat.mtimeMs && st.size === cachedStat.size) {
           return { prevHash: cachedHash, nextIndex: cachedIndex };
         }
@@ -6787,7 +7719,7 @@ var ToolAuditLog = class {
     this.tailHash.set(sessionId, prevHash);
     this.tailIndex.set(sessionId, nextIndex);
     try {
-      const st = await fsp2.stat(fp);
+      const st = await fsp4.stat(fp);
       this.tailStat.set(sessionId, { mtimeMs: st.mtimeMs, size: st.size });
     } catch {
     }
@@ -6908,7 +7840,7 @@ var ToolAuditLog = class {
   async readAll(sessionId) {
     const fp = this.filePath(sessionId);
     try {
-      const raw = await fsp2.readFile(fp, "utf8");
+      const raw = await fsp4.readFile(fp, "utf8");
       const out = [];
       for (const line of raw.split("\n")) {
         if (!line.trim()) continue;
@@ -6946,7 +7878,7 @@ var ToolAuditLog = class {
   }
   async sync(sessionId, fp) {
     try {
-      const fh = await fsp2.open(fp, "r+");
+      const fh = await fsp4.open(fp, "r+");
       try {
         await fh.sync();
       } finally {
@@ -7264,7 +8196,7 @@ var SessionRegistry = class {
   }
   async readAndPrune() {
     try {
-      const raw = await fsp2.readFile(this.filePath, "utf8");
+      const raw = await fsp4.readFile(this.filePath, "utf8");
       const registry = JSON.parse(raw);
       const now = Date.now();
       let pruned = false;
@@ -7298,11 +8230,11 @@ var SessionRegistry = class {
     const retryDelayMs = 20;
     for (let attempt = 0; attempt < maxRetries; attempt++) {
       try {
-        await fsp2.mkdir(path2.dirname(this.filePath), { recursive: true });
-        let lockHandle = await fsp2.open(lockPath, "wx").catch(() => null);
+        await fsp4.mkdir(path2.dirname(this.filePath), { recursive: true });
+        let lockHandle = await fsp4.open(lockPath, "wx").catch(() => null);
         if (!lockHandle) {
           if (await this.breakStaleLock(lockPath)) {
-            lockHandle = await fsp2.open(lockPath, "wx").catch(() => null);
+            lockHandle = await fsp4.open(lockPath, "wx").catch(() => null);
           }
           if (!lockHandle) {
             await new Promise((r) => setTimeout(r, retryDelayMs * (attempt + 1)));
@@ -7311,14 +8243,14 @@ var SessionRegistry = class {
         }
         try {
           await lockHandle.writeFile(String(process.pid)).catch(() => void 0);
-          const raw = await fsp2.readFile(this.filePath, "utf8").catch(() => "{}");
+          const raw = await fsp4.readFile(this.filePath, "utf8").catch(() => "{}");
           const registry = JSON.parse(raw);
           fn(registry);
           await this.writeAtomicLocked(registry);
           return;
         } finally {
           await lockHandle.close();
-          await fsp2.unlink(lockPath).catch(() => void 0);
+          await fsp4.unlink(lockPath).catch(() => void 0);
         }
       } catch {
         return;
@@ -7334,17 +8266,17 @@ var SessionRegistry = class {
    */
   async breakStaleLock(lockPath) {
     try {
-      const [stat11, content] = await Promise.all([
-        fsp2.stat(lockPath),
+      const [stat13, content] = await Promise.all([
+        fsp4.stat(lockPath),
         /* v8 ignore start -- best-effort lock-content read; .catch only fires if the lock vanished */
-        fsp2.readFile(lockPath, "utf8").catch(() => "")
+        fsp4.readFile(lockPath, "utf8").catch(() => "")
         /* v8 ignore stop */
       ]);
-      const ageMs = Date.now() - stat11.mtimeMs;
+      const ageMs = Date.now() - stat13.mtimeMs;
       const ownerPid = Number.parseInt(content.trim(), 10);
       const ownerDead = Number.isInteger(ownerPid) && ownerPid > 0 && ownerPid !== process.pid && !pidAlive(ownerPid);
       if (ownerDead || ageMs > STALE_LOCK_MS) {
-        await fsp2.unlink(lockPath).catch(() => void 0);
+        await fsp4.unlink(lockPath).catch(() => void 0);
         return true;
       }
       return false;
@@ -7367,10 +8299,10 @@ var SessionRegistry = class {
       `.${path2.basename(this.filePath)}.${randomUUID().slice(0, 8)}.tmp`
     );
     try {
-      await fsp2.writeFile(tmp, JSON.stringify(registry, null, 2), "utf8");
-      await fsp2.rename(tmp, this.filePath);
+      await fsp4.writeFile(tmp, JSON.stringify(registry, null, 2), "utf8");
+      await fsp4.rename(tmp, this.filePath);
     } catch (err) {
-      await fsp2.unlink(tmp).catch(() => void 0);
+      await fsp4.unlink(tmp).catch(() => void 0);
       throw err;
     }
   }
@@ -7380,17 +8312,17 @@ var SessionRegistry = class {
       const base = path2.basename(this.filePath);
       const now = Date.now();
       const stale = [];
-      for (const name of await fsp2.readdir(dir)) {
+      for (const name of await fsp4.readdir(dir)) {
         const isTemp = (name.startsWith(`${base}.`) || name.startsWith(`.${base}.`)) && name.endsWith(".tmp");
         if (!isTemp) continue;
-        const stat11 = await fsp2.stat(path2.join(dir, name)).catch(() => null);
-        if (!stat11) continue;
-        if (now - stat11.mtimeMs > STALE_TMP_MS) stale.push({ name, mtimeMs: stat11.mtimeMs });
+        const stat13 = await fsp4.stat(path2.join(dir, name)).catch(() => null);
+        if (!stat13) continue;
+        if (now - stat13.mtimeMs > STALE_TMP_MS) stale.push({ name, mtimeMs: stat13.mtimeMs });
       }
       stale.sort((a, b) => b.mtimeMs - a.mtimeMs);
       await Promise.all(
         stale.slice(MAX_STALE_TMP_FILES).map(async ({ name }) => {
-          await fsp2.unlink(path2.join(dir, name)).catch(() => void 0);
+          await fsp4.unlink(path2.join(dir, name)).catch(() => void 0);
         })
       );
     } catch {
@@ -7858,7 +8790,7 @@ var FleetNotifier = class {
   }
   async discover() {
     try {
-      const raw = await fsp2.readFile(path2.join(this.baseDir, INSTANCES_FILE), "utf8");
+      const raw = await fsp4.readFile(path2.join(this.baseDir, INSTANCES_FILE), "utf8");
       const data = JSON.parse(raw);
       const list = Array.isArray(data?.instances) ? data.instances : [];
       return list.filter((i) => i && typeof i.httpPort === "number").filter((i) => i.pid !== this.selfPid).filter((i) => normRoot(i.projectRoot) === this.projectRoot).filter((i) => pidAlive2(i.pid)).map((i) => {
@@ -7888,7 +8820,7 @@ var DefaultSessionRewinder = class {
   }
   async listCheckpoints(sessionId) {
     const file = this.sessionFile(sessionId);
-    const raw = await fsp2.readFile(file, "utf8");
+    const raw = await fsp4.readFile(file, "utf8");
     const events = parseEvents(raw);
     const fileCountMap = /* @__PURE__ */ new Map();
     for (const event of events) {
@@ -7913,7 +8845,7 @@ var DefaultSessionRewinder = class {
   }
   async rewindToCheckpoint(sessionId, checkpointIndex) {
     const file = this.sessionFile(sessionId);
-    const raw = await fsp2.readFile(file, "utf8");
+    const raw = await fsp4.readFile(file, "utf8");
     const events = parseEvents(raw);
     let targetIdx = -1;
     for (let i = 0; i < events.length; i++) {
@@ -7952,7 +8884,7 @@ var DefaultSessionRewinder = class {
   }
   async rewindLastN(sessionId, n) {
     const file = this.sessionFile(sessionId);
-    const raw = await fsp2.readFile(file, "utf8");
+    const raw = await fsp4.readFile(file, "utf8");
     const events = parseEvents(raw);
     const checkpoints = [];
     for (const event of events) {
@@ -7976,12 +8908,12 @@ var DefaultSessionRewinder = class {
         snapshotsToRevert.push({ promptIndex: event.promptIndex, files: event.files });
       }
     }
-    const result = await revertSnapshots(snapshotsToRevert.reverse(), this.projectRoot);
+    const result = await revertSnapshots(snapshotsToRevert, this.projectRoot);
     return { ...result, toPromptIndex: targetIndex, removedEvents: snapshotsToRevert.length };
   }
   async rewindToStart(sessionId) {
     const file = this.sessionFile(sessionId);
-    const raw = await fsp2.readFile(file, "utf8");
+    const raw = await fsp4.readFile(file, "utf8");
     const events = parseEvents(raw);
     const allSnapshots = [];
     for (const event of events) {
@@ -7992,7 +8924,7 @@ var DefaultSessionRewinder = class {
     if (allSnapshots.length === 0) {
       return { revertedFiles: [], errors: [], toPromptIndex: 0, removedEvents: 0 };
     }
-    const result = await revertSnapshots(allSnapshots.reverse(), this.projectRoot);
+    const result = await revertSnapshots(allSnapshots, this.projectRoot);
     return { ...result, toPromptIndex: 0, removedEvents: allSnapshots.length };
   }
 };
@@ -8013,8 +8945,8 @@ function parseEvents(raw) {
 async function revertSnapshots(snapshots, projectRoot) {
   const revertedFiles = [];
   const errors = [];
-  for (const snapshot of snapshots) {
-    for (const file of snapshot.files) {
+  for (const snapshot of [...snapshots].reverse()) {
+    for (const file of [...snapshot.files].reverse()) {
       try {
         const absPath = path2.resolve(file.path);
         const root = path2.resolve(projectRoot);
@@ -8029,7 +8961,7 @@ async function revertSnapshots(snapshots, projectRoot) {
             revertedFiles.push(file.path);
           }
         } else if (file.action === "created") {
-          await fsp2.unlink(file.path);
+          await fsp4.unlink(file.path);
           revertedFiles.push(file.path);
         } else if (file.action === "modified") {
           if (file.before !== null) {
@@ -8048,7 +8980,7 @@ async function loadTodosCheckpoint(filePath, events, traceId) {
   const t0 = Date.now();
   let raw;
   try {
-    raw = await fsp2.readFile(filePath, "utf8");
+    raw = await fsp4.readFile(filePath, "utf8");
   } catch (err) {
     events?.emit("storage.error", {
       sessionId: traceId ?? "~boot~",
@@ -8187,7 +9119,7 @@ async function loadCompletedWorkCheckpoint(filePath, events, traceId) {
   const t0 = Date.now();
   let raw;
   try {
-    raw = await fsp2.readFile(filePath, "utf8");
+    raw = await fsp4.readFile(filePath, "utf8");
   } catch (err) {
     events?.emit("storage.error", {
       sessionId: traceId ?? "~boot~",
@@ -8285,7 +9217,7 @@ async function loadPlan(filePath, events) {
   const t0 = Date.now();
   let raw;
   try {
-    raw = await fsp2.readFile(filePath, "utf8");
+    raw = await fsp4.readFile(filePath, "utf8");
   } catch (err) {
     events?.emit("storage.error", {
       sessionId: "~boot~",
@@ -8601,7 +9533,7 @@ async function loadTasks(filePath, events, traceId) {
   const t0 = Date.now();
   let raw;
   try {
-    raw = await fsp2.readFile(filePath, "utf8");
+    raw = await fsp4.readFile(filePath, "utf8");
   } catch (err) {
     events?.emit("storage.error", {
       sessionId: traceId ?? "~boot~",
@@ -8705,7 +9637,7 @@ async function mutateTasks(filePath, sessionId, fn, events, traceId) {
 async function loadDirectorState(filePath) {
   let raw;
   try {
-    raw = await fsp2.readFile(filePath, "utf8");
+    raw = await fsp4.readFile(filePath, "utf8");
   } catch {
     return null;
   }
@@ -8720,7 +9652,7 @@ async function loadDirectorState(filePath) {
 async function acquireDirectorStateLock(lockPath, processId = process.pid) {
   let existing;
   try {
-    existing = await fsp2.readFile(lockPath, "utf8");
+    existing = await fsp4.readFile(lockPath, "utf8");
   } catch {
   }
   if (existing) {
@@ -8744,7 +9676,7 @@ async function acquireDirectorStateLock(lockPath, processId = process.pid) {
 }
 async function releaseDirectorStateLock(lockPath) {
   try {
-    await fsp2.unlink(lockPath);
+    await fsp4.unlink(lockPath);
   } catch {
   }
 }
@@ -8907,7 +9839,7 @@ async function loadGoal(filePath, events) {
   const t0 = Date.now();
   let raw;
   try {
-    raw = await fsp2.readFile(filePath, "utf8");
+    raw = await fsp4.readFile(filePath, "utf8");
   } catch (err) {
     const code = err.code;
     if (code === "ENOENT") {
@@ -9214,12 +10146,12 @@ var DefaultPromptStore = class {
     await ensureDir(this.dir);
     const entries = [];
     try {
-      const files = await fsp2.readdir(this.dir);
+      const files = await fsp4.readdir(this.dir);
       for (const file of files) {
         if (!file.endsWith(".json")) continue;
         try {
           const raw = JSON.parse(
-            await fsp2.readFile(path2.join(this.dir, file), "utf8")
+            await fsp4.readFile(path2.join(this.dir, file), "utf8")
           );
           const migrated = migratePromptEntry(raw.entry);
           if (migrated) entries.push(migrated);
@@ -9235,7 +10167,7 @@ var DefaultPromptStore = class {
   async get(id) {
     const file = path2.join(this.dir, `${id}.json`);
     try {
-      const raw = JSON.parse(await fsp2.readFile(file, "utf8"));
+      const raw = JSON.parse(await fsp4.readFile(file, "utf8"));
       return migratePromptEntry(raw.entry);
     } catch {
       return null;
@@ -9250,7 +10182,7 @@ var DefaultPromptStore = class {
   async delete(id) {
     const file = path2.join(this.dir, `${id}.json`);
     try {
-      await fsp2.unlink(file);
+      await fsp4.unlink(file);
       return true;
     } catch {
       return false;
@@ -9294,7 +10226,7 @@ var PromptUsageStore = class {
   file;
   async load() {
     try {
-      const raw = JSON.parse(await fsp2.readFile(this.file, "utf8"));
+      const raw = JSON.parse(await fsp4.readFile(this.file, "utf8"));
       if (raw && typeof raw === "object" && raw.usage && typeof raw.usage === "object") {
         return raw.usage;
       }
@@ -9350,7 +10282,7 @@ var InputHistoryStore = class {
    */
   async load() {
     try {
-      const raw = JSON.parse(await fsp2.readFile(this.file, "utf8"));
+      const raw = JSON.parse(await fsp4.readFile(this.file, "utf8"));
       if (raw && typeof raw === "object" && Array.isArray(raw.entries) && raw.entries.every((e) => typeof e === "string")) {
         return raw.entries.slice(0, this.maxEntries);
       }
@@ -9486,7 +10418,7 @@ var CloudSync = class {
       lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString(),
       localRev: rev
     };
-    await fsp2.writeFile(this.statePath, JSON.stringify(syncState, null, 2), "utf8");
+    await fsp4.writeFile(this.statePath, JSON.stringify(syncState, null, 2), "utf8");
     this.state = syncState;
     return {
       ok: true,
@@ -9518,8 +10450,8 @@ var CloudSync = class {
       const rel = segments.slice(2).join("/");
       const destPath = resolvePulledCategoryPath(cat, localPath, rel, entry.path);
       const blobData = await this.getBlob(token, owner, repoName, entry.sha);
-      await fsp2.mkdir(path2.dirname(destPath), { recursive: true });
-      await fsp2.writeFile(destPath, Buffer.from(blobData, "base64"));
+      await fsp4.mkdir(path2.dirname(destPath), { recursive: true });
+      await fsp4.writeFile(destPath, Buffer.from(blobData, "base64"));
     }
     const localRev = await this.hashLocalCategories(cfg.categories);
     const syncState = {
@@ -9528,7 +10460,7 @@ var CloudSync = class {
       lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString(),
       localRev
     };
-    await fsp2.writeFile(this.statePath, JSON.stringify(syncState, null, 2), "utf8");
+    await fsp4.writeFile(this.statePath, JSON.stringify(syncState, null, 2), "utf8");
     this.state = syncState;
     return {
       ok: true,
@@ -9547,7 +10479,7 @@ var CloudSync = class {
   }
   async loadState() {
     try {
-      const raw = await fsp2.readFile(this.statePath, "utf8");
+      const raw = await fsp4.readFile(this.statePath, "utf8");
       this.state = JSON.parse(raw);
     } catch {
       this.state = null;
@@ -9625,17 +10557,17 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat11 = await fsp2.stat(localPath);
-        if (stat11.isDirectory()) {
+        const stat13 = await fsp4.stat(localPath);
+        if (stat13.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
-            const content = await fsp2.readFile(file, "utf8");
+            const content = await fsp4.readFile(file, "utf8");
             const rel = path2.relative(localPath, file).replace(/\\/g, "/");
             entries.push({ path: `data/${cat}/${rel}`, content, mode: "100644" });
             hashes.push(content);
           }
         } else {
-          const content = await fsp2.readFile(localPath, "utf8");
+          const content = await fsp4.readFile(localPath, "utf8");
           entries.push({ path: `data/${cat}`, content, mode: "100644" });
           hashes.push(content);
         }
@@ -9651,15 +10583,15 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat11 = await fsp2.stat(localPath);
-        if (stat11.isDirectory()) {
+        const stat13 = await fsp4.stat(localPath);
+        if (stat13.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
-            const content = await fsp2.readFile(file);
+            const content = await fsp4.readFile(file);
             hashes.push(content.toString("base64") + file);
           }
         } else {
-          const content = await fsp2.readFile(localPath);
+          const content = await fsp4.readFile(localPath);
           hashes.push(content.toString("base64") + localPath);
         }
       } catch {
@@ -9686,7 +10618,7 @@ var CloudSync = class {
   }
   async walkDir(dir, base) {
     const results = [];
-    const entries = await fsp2.readdir(dir, { withFileTypes: true });
+    const entries = await fsp4.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       const full = path2.join(dir, entry.name);
       if (entry.isDirectory()) {
@@ -9722,8 +10654,8 @@ function resolvePulledCategoryPath(cat, localPath, rel, remotePath) {
   }
   const dest = path2.resolve(localPath, normalizedRel);
   const root = path2.resolve(localPath);
-  const relative4 = path2.relative(root, dest);
-  if (relative4.startsWith("..") || path2.isAbsolute(relative4)) {
+  const relative6 = path2.relative(root, dest);
+  if (relative6.startsWith("..") || path2.isAbsolute(relative6)) {
     throw new FsError({
       message: `Refusing CloudSync path outside category root: ${remotePath}`,
       code: ERROR_CODES.FS_DELETE_FAILED,
@@ -9748,11 +10680,14 @@ function timeAgo(iso) {
 var CORE_RECONSTRUCT_EVENTS = /* @__PURE__ */ new Set([
   "session_start",
   "session_resumed",
+  "session_forked",
   "user_input",
   "llm_response",
   "tool_result",
+  "context_snapshot",
   "checkpoint",
   "file_snapshot",
+  "file_observation",
   "rewound",
   "in_flight_start",
   "in_flight_end",
@@ -9860,6 +10795,6 @@ function resolveSessionLoggingConfig(cfg) {
   };
 }
 
-export { ALL_SYNC_CATEGORIES, AgentStatusTracker, AnnotationsStore, CORE_RECONSTRUCT_EVENTS, CloudSync, ConfigMigrationError, DEFAULT_CONFIG_MIGRATIONS, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultMemoryStore, DefaultPromptStore, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DirectorStateCheckpoint, FileMemoryBackend, FleetNotifier, GraphMemoryBackend, INPUT_HISTORY_DEFAULT_MAX, InputHistoryStore, MAX_JOURNAL_ENTRIES, MAX_PROGRESS_HISTORY, PromptUsageStore, QueueStore, RecoveryLock, ReplayLogStore, STANDARD_AUDIT_EVENTS, SessionAnalyzer, SessionMemoryConsolidator, SessionRecovery, SessionRegistry, ToolAuditLog, addPlanItem, appendJournal, attachPlanCheckpoint, attachTodosCheckpoint, clearPlan, createSessionEventBridge, deriveTodosFromPlanItem, emptyGoal, emptyPlan, emptyTaskFile, formatGoal, formatPlan, formatPlanTemplates, generateSessionId, getPlanTemplate, getSessionRegistry, goalFilePath, hasSessionRegistry, listPlanTemplates, loadCompletedWorkCheckpoint, loadDirectorState, loadGoal, loadPlan, loadTasks, loadTodosCheckpoint, migratePromptEntry, mutatePlan, mutateTasks, parseEntries, parseProgressFromText, promptChecksum, recordProgress, removePlanItem, resolveAuditLevel, resolveSessionLoggingConfig, runConfigMigrations, sanitizeModel, saveCompletedWorkCheckpoint, saveGoal, savePlan, saveTasks, saveTodosCheckpoint, setPlanItemStatus, setProgress, summarizeUsage, watchProviderConfig };
+export { ALL_SYNC_CATEGORIES, AgentStatusTracker, AnnotationsStore, CORE_RECONSTRUCT_EVENTS, CloudSync, ConfigMigrationError, DEFAULT_CONFIG_MIGRATIONS, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultMemoryStore, DefaultPromptStore, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DirectorStateCheckpoint, FileMemoryBackend, FleetNotifier, GraphMemoryBackend, INPUT_HISTORY_DEFAULT_MAX, InputHistoryStore, MAX_JOURNAL_ENTRIES, MAX_PROGRESS_HISTORY, PromptUsageStore, QueueStore, RecoveryLock, ReplayLogStore, STANDARD_AUDIT_EVENTS, SessionAnalyzer, SessionCheckpointCas, SessionMemoryConsolidator, SessionRecovery, SessionRegistry, ToolAuditLog, addPlanItem, appendJournal, attachPlanCheckpoint, attachTodosCheckpoint, clearPlan, createSessionEventBridge, deriveTodosFromPlanItem, emptyGoal, emptyPlan, emptyTaskFile, formatGoal, formatPlan, formatPlanTemplates, generateSessionId, getPlanTemplate, getSessionRegistry, goalFilePath, hasSessionRegistry, listPlanTemplates, loadCompletedWorkCheckpoint, loadDirectorState, loadGoal, loadPlan, loadTasks, loadTodosCheckpoint, migratePromptEntry, mutatePlan, mutateTasks, parseEntries, parseProgressFromText, promptChecksum, recordProgress, removePlanItem, resolveAuditLevel, resolveSessionLoggingConfig, runConfigMigrations, sanitizeModel, saveCompletedWorkCheckpoint, saveGoal, savePlan, saveTasks, saveTodosCheckpoint, setPlanItemStatus, setProgress, summarizeUsage, watchProviderConfig };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map