@wrongstack/core 0.303.0 → 0.305.1

package/dist/storage/index.js

@@ -2152,15 +2152,51 @@ var atomicReplaceWithWriter = primitives.atomicReplaceWithWriter;
 var ensureDir = primitives.ensureDir;
 var withFileLock = primitives.withFileLock;
 
+// src/utils/session-scoped-path.ts
+import * as path6 from "node:path";
+function sessionScopedPath(dir, sessionId, suffix) {
+  if (!sessionId || sessionId.includes("\\") || sessionId.includes("..")) {
+    throw invalid(sessionId);
+  }
+  const resolved = path6.resolve(dir, `${sessionId}${suffix}`);
+  const rel = path6.relative(path6.resolve(dir), resolved);
+  if (rel.startsWith("..") || path6.isAbsolute(rel)) {
+    throw invalid(sessionId);
+  }
+  return resolved;
+}
+var SESSION_SIDECAR_JSONL_SUFFIXES = [
+  ".replay.jsonl",
+  ".audit.jsonl",
+  ".annotations.jsonl"
+];
+var RESERVED_SESSION_JSONL_NAMES = /* @__PURE__ */ new Set([
+  "_index.jsonl",
+  "_mailbox.jsonl"
+]);
+function isSessionTranscriptFileName(name) {
+  if (!name.endsWith(".jsonl")) return false;
+  if (RESERVED_SESSION_JSONL_NAMES.has(name)) return false;
+  return !SESSION_SIDECAR_JSONL_SUFFIXES.some((suffix) => name.endsWith(suffix));
+}
+function invalid(sessionId) {
+  return new FsError({
+    message: `Invalid sessionId: ${sessionId}`,
+    code: ERROR_CODES.FS_DELETE_FAILED,
+    path: sessionId,
+    context: { reason: "path_traversal" }
+  });
+}
+
 // src/session-registry.ts
 import * as fs6 from "node:fs/promises";
-import * as path7 from "node:path";
+import * as path8 from "node:path";
 
 // src/session-registry-atomic-file.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import * as fs5 from "node:fs/promises";
 import { hostname } from "node:os";
-import * as path6 from "node:path";
+import * as path7 from "node:path";
 var STALE_LOCK_MS = 1e4;
 var SAME_HOST_STALE_MS = 2 * STALE_LOCK_MS;
 var STALE_TMP_MS = 6e4;
@@ -2240,9 +2276,9 @@ async function breakLockAtomically(lockPath) {
   return true;
 }
 async function writeAtomicFile(filePath, registry) {
-  const tmp = path6.join(
-    path6.dirname(filePath),
-    `.${path6.basename(filePath)}.${randomUUID2().slice(0, 8)}.tmp`
+  const tmp = path7.join(
+    path7.dirname(filePath),
+    `.${path7.basename(filePath)}.${randomUUID2().slice(0, 8)}.tmp`
   );
   let tmpPersisted = false;
   try {
@@ -2283,21 +2319,21 @@ async function writeAtomicFile(filePath, registry) {
 }
 async function pruneStaleTempFiles(filePath) {
   try {
-    const dir = path6.dirname(filePath);
-    const base = path6.basename(filePath);
+    const dir = path7.dirname(filePath);
+    const base = path7.basename(filePath);
     const now = Date.now();
     const stale = [];
     for (const name of await fs5.readdir(dir)) {
       const isTemp = (name.startsWith(`${base}.`) || name.startsWith(`.${base}.`)) && name.endsWith(".tmp");
       if (!isTemp) continue;
-      const stat15 = await fs5.stat(path6.join(dir, name)).catch(() => null);
+      const stat15 = await fs5.stat(path7.join(dir, name)).catch(() => null);
       if (!stat15) continue;
       if (now - stat15.mtimeMs > STALE_TMP_MS) stale.push({ name, mtimeMs: stat15.mtimeMs });
     }
     stale.sort((a, b) => b.mtimeMs - a.mtimeMs);
     await Promise.all(
       stale.slice(MAX_STALE_TMP_FILES).map(async ({ name }) => {
-        await fs5.unlink(path6.join(dir, name)).catch(() => void 0);
+        await fs5.unlink(path7.join(dir, name)).catch(() => void 0);
       })
     );
   } catch {
@@ -2361,7 +2397,7 @@ var SessionRegistry = class {
   lastEntry = null;
   ownershipLockWaitMs;
   constructor(globalRoot, options = {}) {
-    this.filePath = path7.join(globalRoot, REGISTRY_FILE);
+    this.filePath = path8.join(globalRoot, REGISTRY_FILE);
     this.ownershipLockWaitMs = Math.max(0, options.ownershipLockWaitMs ?? OWNERSHIP_LOCK_WAIT_MS);
   }
   // ── Public API ──────────────────────────────────────────────────────────
@@ -2671,7 +2707,7 @@ var SessionRegistry = class {
     const deadline = Date.now() + waitBudgetMs;
     let attempt = 0;
     try {
-      await fs6.mkdir(path7.dirname(this.filePath), { recursive: true });
+      await fs6.mkdir(path8.dirname(this.filePath), { recursive: true });
       await this.maybePruneStaleTempFiles();
     } catch (err) {
       if (required) {
@@ -2815,28 +2851,6 @@ function expectDefined(value, label) {
   return value;
 }
 
-// src/utils/session-scoped-path.ts
-import * as path8 from "node:path";
-function sessionScopedPath(dir, sessionId, suffix) {
-  if (!sessionId || sessionId.includes("\\") || sessionId.includes("..")) {
-    throw invalid(sessionId);
-  }
-  const resolved = path8.resolve(dir, `${sessionId}${suffix}`);
-  const rel = path8.relative(path8.resolve(dir), resolved);
-  if (rel.startsWith("..") || path8.isAbsolute(rel)) {
-    throw invalid(sessionId);
-  }
-  return resolved;
-}
-function invalid(sessionId) {
-  return new FsError({
-    message: `Invalid sessionId: ${sessionId}`,
-    code: ERROR_CODES.FS_DELETE_FAILED,
-    path: sessionId,
-    context: { reason: "path_traversal" }
-  });
-}
-
 // src/storage/annotations-store.ts
 var FILE_VERSION = 1;
 var MAX_TEXT_LENGTH = 2e3;
@@ -4628,6 +4642,9 @@ var DEFAULT_TOOLS_CONFIG = Object.freeze({
   disabledTools: Object.freeze([]),
   autoExtendLimit: true,
   restrictToProjectRoot: true,
+  // Off by default: the board is a record of the work, not a permit for it.
+  // See ToolsConfig.kanbanGovernance for what turning it on costs and gates.
+  kanbanGovernance: false,
   loopDetection: Object.freeze({
     mode: "steer-then-cut",
     steerThreshold: 3,
@@ -4685,6 +4702,7 @@ var CONFIG_BEHAVIOR_DEFAULTS = {
     disabledTools: DEFAULT_TOOLS_CONFIG.disabledTools,
     autoExtendLimit: DEFAULT_TOOLS_CONFIG.autoExtendLimit,
     restrictToProjectRoot: DEFAULT_TOOLS_CONFIG.restrictToProjectRoot,
+    kanbanGovernance: DEFAULT_TOOLS_CONFIG.kanbanGovernance,
     loopDetection: DEFAULT_TOOLS_CONFIG.loopDetection
   },
   log: { level: "info" },
@@ -5109,6 +5127,14 @@ var IN_PROJECT_DENIED_PATHS = [
   {
     path: "tools.restrictToProjectRoot",
     reason: "The other half of the filesystem confinement switch."
+  },
+  {
+    // Denied for the direction that loosens: the flag defaults to false, so a
+    // repo can only ever use it to turn OFF a gate the user deliberately
+    // enabled. Same class as `tools.restrictToProjectRoot` — a control the
+    // operator owns, not the checked-out repository.
+    path: "tools.kanbanGovernance",
+    reason: "Repo-committed config could disable a Kanban governance gate the operator switched on, letting product mutations run outside any managed card."
   }
 ];
 function deleteNestedPath(target, path34) {
@@ -7682,10 +7708,38 @@ var SessionMemoryConsolidator = class {
         process.stderr.write(`[memory] Session consolidation: ${added} added
 `);
       }
+      if (this.Sage?.rememberSage) {
+        try {
+          const digestBody = buildSessionDigestText(_finalText, _iterations, added);
+          if (digestBody) {
+            const expires = new Date(Date.now() + 14 * 24 * 60 * 6e4).toISOString();
+            await this.Sage.rememberSage({
+              text: digestBody,
+              scope: "session",
+              kind: "session_digest",
+              importance: 0.4,
+              confidence: 0.65,
+              persistence: "short_lived",
+              tags: ["session_digest", "auto"],
+              anchors: [],
+              sources: [{ type: "session", sessionId: _sessionId }],
+              ownerSessionId: _sessionId,
+              expiresAt: expires
+            });
+          }
+        } catch {
+        }
+      }
     } catch {
     }
   };
 };
+function buildSessionDigestText(finalText, iterations, factsAdded) {
+  const cleaned = finalText.replace(/\s+/g, " ").trim();
+  if (cleaned.length < 40) return void 0;
+  const summary2 = cleaned.slice(0, 400);
+  return `Session digest (${iterations} iter${factsAdded > 0 ? `, ${factsAdded} facts added` : ""}): ` + summary2 + (cleaned.length > 400 ? "\u2026" : "");
+}
 
 // src/storage/memory-graph-backend.ts
 import * as fs14 from "node:fs/promises";
@@ -9277,11 +9331,15 @@ function sortKeys(value) {
   }
   return value;
 }
+function semanticMessage(message) {
+  const { ts: _ts, _estTokens: _estimate, origin: _origin, ...semantic } = message;
+  return semantic;
+}
 function hashRequest(request) {
   const payload = {
     model: request.model,
     system: request.system,
-    messages: request.messages,
+    messages: request.messages.map(semanticMessage),
     tools: request.tools,
     maxTokens: request.maxTokens,
     temperature: request.temperature,
@@ -11030,9 +11088,6 @@ import * as path25 from "node:path";
 function shouldSkipSessionDirectoryEntry(name) {
   return name.startsWith(".") && name !== ".wrongstack" || name === "shared" || name === "subagents" || name === "attachments";
 }
-function isSessionJsonlFileName(name) {
-  return name.endsWith(".jsonl") && name !== "_index.jsonl";
-}
 
 // src/storage/session-store/directory-session-files.ts
 function sessionIdForFile(prefix, name) {
@@ -11055,7 +11110,7 @@ async function collectSessionFiles(dir, prefix = "", depth = 0) {
     if (shouldSkipSessionDirectoryEntry(entry.name)) continue;
     if (entry.isDirectory()) {
       dirEntries.push(entry);
-    } else if (entry.isFile() && isSessionJsonlFileName(entry.name)) {
+    } else if (entry.isFile() && isSessionTranscriptFileName(entry.name)) {
       files.push({ id: sessionIdForFile(prefix, entry.name), filePath: path25.join(dir, entry.name) });
     }
   }
@@ -11079,7 +11134,7 @@ async function collectSessionIds(dir, prefix = "", depth = 0) {
     if (shouldSkipSessionDirectoryEntry(entry.name)) continue;
     if (entry.isDirectory()) {
       dirEntries.push(entry);
-    } else if (entry.isFile() && isSessionJsonlFileName(entry.name)) {
+    } else if (entry.isFile() && isSessionTranscriptFileName(entry.name)) {
       fileIds.push(sessionIdForFile(prefix, entry.name));
     }
   }
@@ -11243,11 +11298,8 @@ var SessionRecovery = class _SessionRecovery {
           }
           continue;
         }
-        if (!entry.isFile() || !entry.name.endsWith(".jsonl")) continue;
-        if (entry.name === "_index.jsonl" || entry.name === "_mailbox.jsonl") continue;
+        if (!entry.isFile() || !isSessionTranscriptFileName(entry.name)) continue;
         const base = entry.name.slice(0, -".jsonl".length);
-        if (base.includes(".replay") || base.includes(".annotations") || base.includes(".audit"))
-          continue;
         const sessionId = prefix ? `${prefix}/${base}` : base;
         const stale = await this.detectStaleExact(sessionId);
         if (stale) out.push(stale);
@@ -12605,6 +12657,15 @@ async function validateResumeFileObservations(events, projectRoot) {
     staleFiles: results.filter((entry) => entry !== null)
   };
 }
+var RESUME_NOTICE_HEADERS = [
+  "[SESSION RESUME FILE VALIDATION]",
+  "[SESSION RESUME INTERRUPTED WORK]"
+];
+function isResumeNoticeMessage(message) {
+  if (message.role !== "system" || typeof message.content !== "string") return false;
+  return RESUME_NOTICE_HEADERS.some((header) => message.content === header || message.content.startsWith(`${header}
+`));
+}
 function formatResumeValidationNotice(validation, projectRoot) {
   if (validation.staleFiles.length === 0) return null;
   const root = path28.resolve(projectRoot);
@@ -12801,13 +12862,13 @@ function inheritsIntoFork(event) {
 
 // src/storage/session-store/fork-session.ts
 async function forkSession(host, id, opts = {}) {
-  const parent = await host.load(id);
-  let boundary = parent.events.length - 1;
+  const parentEvents = await host.readRawEvents(id);
+  let boundary = parentEvents.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];
+    for (let i = 0; i < parentEvents.length; i++) {
+      const event = parentEvents[i];
       if (event?.type === "checkpoint" && event.promptIndex === opts.checkpointPromptIndex) {
         boundary = i;
         targetCheckpoint = event;
@@ -12817,15 +12878,18 @@ async function forkSession(host, id, opts = {}) {
       throw new Error(`Checkpoint ${opts.checkpointPromptIndex} not found in session "${id}"`);
     }
   }
-  const parentPrefix = parent.events.slice(0, boundary + 1);
+  const parentPrefix = parentEvents.slice(0, boundary + 1);
   const workspaceCheckpoint = targetCheckpoint?.workspaceCheckpoint;
   const checkpointHash = createHash9("sha256").update(parentPrefix.map((event) => JSON.stringify(event)).join("\n") + "\n", "utf8").digest("hex");
   const inherited = parentPrefix.filter(inheritsIntoFork);
+  const start = parentEvents.find(
+    (event) => event.type === "session_start"
+  );
   const writer = await host.create({
     id: "",
-    title: parent.metadata.title,
-    model: parent.metadata.model,
-    provider: parent.metadata.provider
+    title: "",
+    model: start?.model,
+    provider: start?.provider
   });
   try {
     await writer.append({
@@ -12931,6 +12995,17 @@ var SessionLoadCache = class {
     this.entries.clear();
     this.bytes = 0;
   }
+  /**
+   * A hit hands back fresh `messages` / `events` arrays over the cached
+   * contents.
+   *
+   * The entry outlives every caller, and callers treat what they get as their
+   * own: `resume()` passes `messages` straight into a live conversation, and
+   * anything walking `events` may splice it. Returning the cached arrays
+   * themselves let one caller's edit rewrite what the next one loads. The
+   * elements are still shared — copying them would defeat the cache — so
+   * entries remain read-only *contents* behind private containers.
+   */
   getFresh(id, stat15, full) {
     const cached = this.entries.get(id);
     if (!cached || cached.mtimeMs !== stat15.mtimeMs || cached.size !== stat15.size) {
@@ -12938,8 +13013,11 @@ var SessionLoadCache = class {
     }
     this.entries.delete(id);
     this.entries.set(id, cached);
-    if (full) return cached.data;
-    return { ...cached.data, messages: [] };
+    return {
+      ...cached.data,
+      messages: full ? [...cached.data.messages] : [],
+      events: [...cached.data.events]
+    };
   }
   set(id, stat15, data) {
     this.delete(id);
@@ -13128,6 +13206,9 @@ function stripSnapshotPayload(event) {
   event.messagesOmitted = event.messages.length;
   event.messages = [];
 }
+function isStrippedSnapshot(event) {
+  return event.messages.length === 0 && typeof event.messagesOmitted === "number" && event.messagesOmitted > 0;
+}
 function isSessionEventLike(value) {
   return value !== null && typeof value === "object" && typeof value.type === "string" && typeof value.ts === "string";
 }
@@ -13157,7 +13238,12 @@ function replaySessionEvent(params) {
       emitDamaged(params, `Ignored malformed message_updated event at index ${ev.index}`);
     }
   } else if (ev.type === "messages_replaced" && ev.version === 1) {
-    if (applyContextSnapshot(messages, openToolUses, ev.messages)) {
+    if (isStrippedSnapshot(ev)) {
+      emitDamaged(
+        params,
+        `Ignored messages_replaced event whose payload was stripped before persistence (${String(ev.messagesOmitted)} messages)`
+      );
+    } else if (applyContextSnapshot(messages, openToolUses, ev.messages)) {
       exactJournalActive = true;
     } else {
       emitDamaged(params, "Ignored malformed messages_replaced event");
@@ -13173,9 +13259,16 @@ function replaySessionEvent(params) {
       emitDamaged(params, `Ignored malformed messages_dropped event (count ${String(ev.count)})`);
     }
   } else if (ev.type === "context_snapshot") {
-    if (!applyContextSnapshot(messages, openToolUses, ev.messages)) {
+    if (isStrippedSnapshot(ev)) {
+      emitDamaged(
+        params,
+        `Ignored context_snapshot event whose payload was stripped before persistence (${String(ev.messagesOmitted)} messages)`
+      );
+    } else if (!applyContextSnapshot(messages, openToolUses, ev.messages)) {
       emitDamaged(params, "Ignored malformed context_snapshot event");
     }
+  } else if (ev.type === "messages_replaced" || ev.type === "message_appended" || ev.type === "message_updated" || ev.type === "messages_dropped") {
+    emitDamaged(params, `Ignored ${ev.type} event with unsupported version`);
   } else if (!exactJournalActive && ev.type === "user_input") {
     openToolUses.clear();
     messages.push({ role: "user", content: ev.content, ts: ev.ts });
@@ -13228,7 +13321,7 @@ function emitDamaged(params, detail) {
 import * as fsp15 from "node:fs/promises";
 import * as path31 from "node:path";
 function isPrunableSessionJsonl(name) {
-  return name.endsWith(".jsonl") && name !== "_index.jsonl" && name !== "_mailbox.jsonl" && !name.endsWith(".replay.jsonl") && !name.endsWith(".audit.jsonl");
+  return isSessionTranscriptFileName(name);
 }
 async function pruneSessionFiles(storeDir, maxAgeDays, deleteSession) {
   const cutoff = Date.now() - maxAgeDays * 864e5;
@@ -13751,6 +13844,21 @@ var DefaultSessionStore = class _DefaultSessionStore {
   async fork(id, opts = {}) {
     return forkSession(this, id, opts);
   }
+  /**
+   * Implements {@link SessionForkHost.readRawEvents} — the parent stream a fork
+   * inherits, unmodified.
+   *
+   * Deliberately NOT `load()`: that loader empties superseded snapshot payloads
+   * in place and front-drops events past its retention budget, both of which
+   * are correct for reconstructing a conversation and wrong for copying a
+   * journal prefix into a child. Streaming with an accept-everything predicate
+   * keeps the scrubbing contract (`searchEvents` scrubs each line the same way
+   * `load()` does) without either transformation.
+   */
+  async readRawEvents(id) {
+    const hits = await this.searchEvents(id, () => true);
+    return hits.map((hit) => hit.event);
+  }
   /**
    * Capture the deterministic post-tool workspace identity through the store-owned CAS.
    */
@@ -13839,14 +13947,15 @@ var DefaultSessionStore = class _DefaultSessionStore {
         ts: (/* @__PURE__ */ new Date()).toISOString()
       });
     }
+    const carriedMessages = data.messages.filter((message) => !isResumeNoticeMessage(message));
     const resumedData = {
       ...data,
       ...resumeValidation ? { resumeValidation } : {},
-      ...noticeMessages.length > 0 ? { messages: [...data.messages, ...noticeMessages] } : {}
+      messages: [...carriedMessages, ...noticeMessages]
     };
     let handle;
     try {
-      handle = await fsp19.open(file, "a", 384);
+      handle = await openSessionForAppend(file);
     } catch (err) {
       emitSessionStoreError(this.events, canonicalId, file, "resume", toErrorMessage(err), false);
       throw new Error(
@@ -14025,10 +14134,10 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const limit = criteria.limit ?? 100;
     if (this.catalogClient) {
       const records = await this.catalogClient.call("list_catalog", {
-        limit: Math.min(1e3, Math.max(limit, 100)),
-        ...criteria.titleContains ? { search: criteria.titleContains } : {}
+        limit,
+        ...criteria
       });
-      return this.scrubSummaries(records).filter((summary2) => matchesSessionFilter(summary2, criteria)).slice(0, limit);
+      return this.scrubSummaries(records);
     }
     try {
       const indexed = await this.readIndex();
@@ -14253,11 +14362,11 @@ var DefaultSessionStore = class _DefaultSessionStore {
     return shardKeys;
   }
   async readOrBuildShardManifest(shardKey) {
-    const cached = this.shardManifestCache.get(shardKey);
-    if (cached) return cached;
     const manifestPath = this.shardManifestPath(shardKey);
+    const cached = await this.freshShardManifestCacheEntry(shardKey, manifestPath);
+    if (cached) return cached;
     return withFileLock(manifestPath, async () => {
-      const lockedCached = this.shardManifestCache.get(shardKey);
+      const lockedCached = await this.freshShardManifestCacheEntry(shardKey, manifestPath);
       if (lockedCached) return lockedCached;
       const entry = await readOrBuildShardManifestEntry({
         shardKey,
@@ -14268,10 +14377,38 @@ var DefaultSessionStore = class _DefaultSessionStore {
         summaryHeaderFor: (ref) => this.summaryHeaderFor(ref),
         summaryFor: (id) => this.summaryFor(id)
       });
-      this.shardManifestCache.set(shardKey, entry);
+      try {
+        const stat15 = await fsp19.stat(manifestPath);
+        this.shardManifestCache.set(shardKey, {
+          entry,
+          mtimeMs: stat15.mtimeMs,
+          size: stat15.size,
+          ino: stat15.ino
+        });
+      } catch {
+        this.shardManifestCache.delete(shardKey);
+      }
       return entry;
     });
   }
+  /**
+   * Shard manifests are invalidated by other store processes via atomic
+   * delete/rebuild. Validate the in-memory projection against the persisted
+   * file so one long-lived process cannot retain another process's stale view.
+   */
+  async freshShardManifestCacheEntry(shardKey, manifestPath) {
+    const cached = this.shardManifestCache.get(shardKey);
+    if (!cached) return void 0;
+    try {
+      const stat15 = await fsp19.stat(manifestPath);
+      if (stat15.mtimeMs === cached.mtimeMs && stat15.size === cached.size && stat15.ino === cached.ino) {
+        return cached.entry;
+      }
+    } catch {
+    }
+    this.shardManifestCache.delete(shardKey);
+    return void 0;
+  }
   async collectSessionFilesInShard(shardKey) {
     const dir = shardKey ? path32.join(this.dir, shardKey) : this.dir;
     const entries = await this.collectSessionFiles(dir, shardKey);
@@ -14551,6 +14688,23 @@ var DefaultSessionStore = class _DefaultSessionStore {
     });
   }
 };
+async function openSessionForAppend(file) {
+  const handle = await fsp19.open(file, "a+", 384);
+  try {
+    const stat15 = await handle.stat();
+    if (stat15.size > 0) {
+      const tail = Buffer.allocUnsafe(1);
+      const { bytesRead } = await handle.read(tail, 0, 1, stat15.size - 1);
+      if (bytesRead === 1 && tail[0] !== 10) {
+        await handle.appendFile("\n", "utf8");
+      }
+    }
+    return handle;
+  } catch (err) {
+    await handle.close().catch(() => void 0);
+    throw err;
+  }
+}
 
 // src/storage/session-rewind-apply.ts
 async function applyRewindToConversation(opts) {
@@ -14663,17 +14817,20 @@ var DefaultSessionRewinder = class {
     const targetIndex = checkpoints[n - 1]?.promptIndex ?? 0;
     const snapshotsToRevert = [];
     let shouldRevert = false;
+    let removedEvents = 0;
     for await (const event of this.readEvents(file)) {
       if (event.type === "checkpoint" && event.promptIndex === targetIndex) {
         shouldRevert = true;
         continue;
       }
-      if (shouldRevert && event.type === "file_snapshot") {
+      if (!shouldRevert) continue;
+      removedEvents++;
+      if (event.type === "file_snapshot") {
         snapshotsToRevert.push({ promptIndex: event.promptIndex, files: event.files });
       }
     }
     const result = await revertSnapshots(snapshotsToRevert, this.projectRoot);
-    return { ...result, toPromptIndex: targetIndex, removedEvents: snapshotsToRevert.length };
+    return { ...result, toPromptIndex: targetIndex, removedEvents };
   }
   async rewindToStart(sessionId) {
     const file = this.sessionFile(sessionId);

package/dist/storage/memory-consolidator.d.ts

@@ -9,7 +9,7 @@ import type { Provider } from '../types/provider.js';
  * rememberSage rather than the legacy MemoryStore.remember(),
  * making them visible to searchSage/turn-middleware.
  */
-type ConsolidatorSageKind = 'fact' | 'decision' | 'convention' | 'preference' | 'anti_pattern' | 'warning' | 'workflow' | 'bug_root_cause' | 'file_note' | 'symbol_note' | 'command_note';
+type ConsolidatorSageKind = 'fact' | 'decision' | 'convention' | 'preference' | 'anti_pattern' | 'warning' | 'workflow' | 'bug_root_cause' | 'file_note' | 'symbol_note' | 'command_note' | 'session_digest';
 interface ConsolidatorMemoryAnchor {
     type: 'file' | 'directory' | 'symbol' | 'package' | 'command' | 'test' | 'git';
     path?: string | undefined;
@@ -25,12 +25,14 @@ export interface ConsolidatorSage {
         priority?: string | undefined;
         importance?: number | undefined;
         confidence?: number | undefined;
-        persistence?: 'long_lived' | undefined;
+        persistence?: 'long_lived' | 'short_lived' | undefined;
         anchors?: ConsolidatorMemoryAnchor[] | undefined;
         sources?: Array<{
             type: string;
             sessionId?: string | undefined;
         }> | undefined;
+        ownerSessionId?: string | undefined;
+        expiresAt?: string | undefined;
     }): Promise<unknown>;
     listSage?(statuses?: Array<'active'>): Promise<unknown[]>;
     searchSage?(query: string, opts?: {

package/dist/storage/session-resume-validation.d.ts

@@ -1,6 +1,30 @@
 import type { ResumeValidation, SessionEvent } from '../types/session.js';
 /** Revalidate the latest persisted hash for every distinct observed path. */
 export declare function validateResumeFileObservations(events: readonly SessionEvent[], projectRoot: string): Promise<ResumeValidation>;
+/**
+ * Headers of the system messages `resume()` injects.
+ *
+ * They are described as ephemeral, but every consumer hands the resumed
+ * message list to `replaceMessages`, which journals it as a
+ * `messages_replaced` snapshot — so a notice written on one resume is replayed
+ * as ordinary conversation on the next one, and a fresh notice is added on top.
+ * Three resumes with the same modified file left three copies, all but the last
+ * describing a check that had already been superseded. `resume()` therefore
+ * strips previous notices from the replayed conversation before appending the
+ * current ones; these prefixes are how it recognizes them.
+ */
+export declare const RESUME_NOTICE_HEADERS: readonly ['[SESSION RESUME FILE VALIDATION]', '[SESSION RESUME INTERRUPTED WORK]'];
+/**
+ * True for a system message this module produced on an earlier resume.
+ *
+ * Deliberately narrow: only a `system` message whose text *starts* with one of
+ * the headers matches, so a user or model quoting a notice back is never
+ * mistaken for one.
+ */
+export declare function isResumeNoticeMessage(message: {
+    role: string;
+    content: unknown;
+}): boolean;
 /** Build the ephemeral system message injected into the first resumed turn. */
 export declare function formatResumeValidationNotice(validation: ResumeValidation, projectRoot: string): string | null;
 /**

package/dist/storage/session-store/directory-scan.d.ts

@@ -1,3 +1,7 @@
 export declare function shouldSkipSessionDirectoryEntry(name: string): boolean;
-export declare function isSessionJsonlFileName(name: string): boolean;
+/**
+ * Re-exported under the store's own name; the rule itself lives with
+ * `sessionScopedPath`, which is what writes the sidecars this excludes.
+ */
+export { isSessionTranscriptFileName as isSessionJsonlFileName } from '../../utils/session-scoped-path.js';
 //# sourceMappingURL=directory-scan.d.ts.map

package/dist/storage/session-store/fork-session.d.ts

@@ -1,8 +1,20 @@
-import type { ForkedSession, SessionData, SessionForkOptions, SessionMetadata, SessionWriter } from '../../types/session.js';
+import type { ForkedSession, SessionData, SessionEvent, SessionForkOptions, SessionMetadata, SessionWriter } from '../../types/session.js';
 export interface SessionForkHost {
     load(id: string): Promise<SessionData>;
     create(meta: Omit<SessionMetadata, 'startedAt'>): Promise<SessionWriter>;
     delete(id: string): Promise<void>;
+    /**
+     * Every persisted event of `id`, exactly as it sits on disk.
+     *
+     * `load()` is NOT a substitute. Its loader strips the payload out of every
+     * superseded `messages_replaced` / `context_snapshot` to bound heap, in
+     * place, on the array it returns. Forking from that array copies the
+     * emptied snapshots into the child journal, where replay reads them as
+     * "the conversation is now zero messages" and the child loses every turn
+     * that preceded the newest snapshot inside the fork boundary. A fork is a
+     * byte-level inheritance of the parent prefix, so it has to read the bytes.
+     */
+    readRawEvents(id: string): Promise<SessionEvent[]>;
 }
 export declare function forkSession(host: SessionForkHost, id: string, opts?: SessionForkOptions): Promise<ForkedSession>;
 //# sourceMappingURL=fork-session.d.ts.map

package/dist/storage/session-store/load-cache.d.ts

@@ -9,6 +9,17 @@ export declare class SessionLoadCache {
     constructor(entries?: Map<string, LoadCacheEntry>);
     private bytes;
     clear(sessionId?: string): void;
+    /**
+     * A hit hands back fresh `messages` / `events` arrays over the cached
+     * contents.
+     *
+     * The entry outlives every caller, and callers treat what they get as their
+     * own: `resume()` passes `messages` straight into a live conversation, and
+     * anything walking `events` may splice it. Returning the cached arrays
+     * themselves let one caller's edit rewrite what the next one loads. The
+     * elements are still shared — copying them would defeat the cache — so
+     * entries remain read-only *contents* behind private containers.
+     */
     getFresh(id: string, stat: FileStatSnapshot, full: boolean): SessionData | null;
     set(id: string, stat: FileStatSnapshot, data: SessionData): void;
     private delete;

package/dist/storage/session-store/prune-helpers.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Prunable === is a transcript. This module held the only complete sidecar
+ * list in the codebase while the listing scans held shorter ones; sharing the
+ * predicate is what stops them disagreeing again.
+ */
 export declare function isPrunableSessionJsonl(name: string): boolean;
 export declare function pruneSessionFiles(storeDir: string, maxAgeDays: number, deleteSession: (id: string) => Promise<void>): Promise<number>;
 //# sourceMappingURL=prune-helpers.d.ts.map