@wrongstack/core 0.275.1 → 0.276.3

package/dist/storage/index.js

@@ -1,3 +1,4 @@
+import * as syncFs from 'fs';
 import { createReadStream, readFileSync, statSync } from 'fs';
 import * as fsp2 from 'fs/promises';
 import * as path2 from 'path';
@@ -8,123 +9,107 @@ import { hostname } from 'os';
 import { fileURLToPath } from 'url';
 
 // src/storage/session-store.ts
-async function atomicWrite(targetPath, content, opts = {}) {
-  const dir = path2.dirname(targetPath);
-  await fsp2.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" });
-    } else {
-      await fsp2.writeFile(tmp, content, { flag: "wx" });
-    }
-    try {
-      const fh = await fsp2.open(tmp, "r+");
-      try {
-        await fh.sync();
-      } finally {
-        await fh.close();
-      }
-    } catch {
-    }
-    let mode;
-    try {
-      const stat10 = await fsp2.stat(targetPath);
-      mode = stat10.mode & 511;
-    } catch {
-      mode = opts.mode;
-    }
-    if (mode !== void 0) {
-      await fsp2.chmod(tmp, mode);
-    }
-    await renameWithRetry(tmp, targetPath);
-    if (mode !== void 0 && process.platform === "win32") {
-      try {
-        await fsp2.chmod(targetPath, mode);
-      } catch {
-      }
-    }
-  } catch (err) {
-    try {
-      await fsp2.unlink(tmp);
-    } catch {
-    }
-    throw err;
-  }
+
+// src/utils/term.ts
+var hasStdout = () => typeof process !== "undefined" && !!process.stdout;
+function isStdoutTTY() {
+  return hasStdout() && Boolean(process.stdout.isTTY);
 }
-async function ensureDir(dir) {
-  await fsp2.mkdir(dir, { recursive: true });
+
+// src/utils/color.ts
+var isColorTty = () => {
+  if (envFlag(process.env.NO_COLOR)) return false;
+  if (envFlag(process.env.FORCE_COLOR)) return true;
+  return isStdoutTTY();
+};
+function envFlag(value) {
+  if (value === void 0) return false;
+  if (value.trim() === "") return false;
+  return !/^(0|false|no|off)$/i.test(value.trim());
 }
-async function withFileLock(targetPath, fn, opts = {}) {
-  const dir = path2.dirname(targetPath);
-  await fsp2.mkdir(dir, { recursive: true });
-  const lockPath = path2.join(dir, `.${path2.basename(targetPath)}.lock`);
-  const timeoutMs = opts.timeoutMs ?? 5e3;
-  const staleMs = opts.staleMs ?? 3e4;
-  const started = Date.now();
-  let handle;
-  for (; ; ) {
-    try {
-      handle = await fsp2.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 });
-        continue;
-      }
-      if (code !== "EEXIST") throw err;
-      try {
-        const stat10 = await fsp2.stat(lockPath);
-        if (Date.now() - stat10.mtimeMs > staleMs) {
-          await fsp2.unlink(lockPath);
-          continue;
-        }
-      } catch {
-        continue;
-      }
-      if (Date.now() - started >= timeoutMs) {
-        throw new Error(`Timed out waiting for file lock: ${targetPath}`);
-      }
-      await new Promise((resolve8) => setTimeout(resolve8, 25));
-    }
+var COLOR = isColorTty();
+var wrap = (open8, close) => (s) => COLOR ? `\x1B[${open8}m${s}\x1B[${close}m` : s;
+var color = {
+  reset: wrap("0", "0"),
+  bold: wrap("1", "22"),
+  dim: wrap("2", "22"),
+  italic: wrap("3", "23"),
+  underline: wrap("4", "24"),
+  red: wrap("31", "39"),
+  green: wrap("32", "39"),
+  yellow: wrap("33", "39"),
+  blue: wrap("34", "39"),
+  magenta: wrap("35", "39"),
+  cyan: wrap("36", "39"),
+  gray: wrap("90", "39"),
+  amber: wrap("38;5;214", "39"),
+  pink: wrap("38;5;205", "39"),
+  bgRed: wrap("41", "49"),
+  bgGreen: wrap("42", "49")
+};
+
+// src/utils/deep-merge.ts
+var FORBIDDEN_PROTO_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype",
+  "__defineGetter__",
+  "__defineSetter__",
+  "__lookupGetter__",
+  "__lookupSetter__"
+]);
+function isPrimitiveArray(a) {
+  return a.every((v) => v === null || typeof v !== "object" && typeof v !== "function");
+}
+function deepMerge(base, patch, options = {}) {
+  const {
+    conflictResolution = "prefer-patch",
+    arrayMode = "replace",
+    protectProto = true,
+    onNonPrimitiveArrayReplace
+  } = options;
+  if (typeof base !== "object" || base === null) {
+    return conflictResolution === "prefer-patch" ? patch : base;
   }
-  try {
-    return await fn();
-  } finally {
-    try {
-      await handle?.close();
-    } catch {
-    }
-    try {
-      await fsp2.unlink(lockPath);
-    } catch {
+  if (typeof patch !== "object" || patch === null) {
+    return conflictResolution === "prefer-patch" ? patch : base;
+  }
+  if (Array.isArray(base) && Array.isArray(patch)) {
+    if (arrayMode === "concat-primitives" && isPrimitiveArray(base) && isPrimitiveArray(patch)) {
+      return [.../* @__PURE__ */ new Set([...base, ...patch])];
     }
+    return conflictResolution === "prefer-patch" ? patch : base;
   }
-}
-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);
-    return;
+  if (Array.isArray(base) || Array.isArray(patch)) {
+    return conflictResolution === "prefer-patch" ? patch : base;
   }
-  const delays = [10, 25, 60, 120, 250];
-  let lastErr;
-  for (let i = 0; i <= delays.length; i++) {
-    try {
-      await fsp2.rename(from, to);
-      return;
-    } catch (err) {
-      lastErr = err;
-      const code = err?.code;
-      if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
-        throw err;
+  const baseObj = base;
+  const patchObj = patch;
+  const out = { ...baseObj };
+  for (const [k, v] of Object.entries(patchObj)) {
+    if (protectProto && FORBIDDEN_PROTO_KEYS.has(k)) continue;
+    const existing = out[k];
+    if (v !== null && typeof v === "object" && !Array.isArray(v) && existing !== null && typeof existing === "object" && !Array.isArray(existing)) {
+      out[k] = deepMerge(existing, v, options);
+    } else if (Array.isArray(v) && Array.isArray(existing)) {
+      if (onNonPrimitiveArrayReplace && !isPrimitiveArray(v)) {
+        onNonPrimitiveArrayReplace(k, existing.length, v.length);
       }
-      await new Promise((resolve8) => setTimeout(resolve8, delays[i]));
+      out[k] = deepMerge(existing, v, options);
+    } else if (v !== void 0) {
+      if (onNonPrimitiveArrayReplace && Array.isArray(v) && !isPrimitiveArray(v)) {
+        const existingLen = Array.isArray(existing) ? existing.length : 0;
+        onNonPrimitiveArrayReplace(k, existingLen, v.length);
+      }
+      out[k] = v;
     }
   }
-  throw lastErr;
+  return out;
+}
+
+// src/utils/error.ts
+function toErrorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
 }
 
 // src/utils/expect-defined.ts
@@ -229,108 +214,6 @@ function isEmptyMessage(msg) {
   return msg.content.length === 0;
 }
 
-// src/utils/term.ts
-var hasStdout = () => typeof process !== "undefined" && !!process.stdout;
-function isStdoutTTY() {
-  return hasStdout() && Boolean(process.stdout.isTTY);
-}
-
-// src/utils/color.ts
-var isColorTty = () => {
-  if (envFlag(process.env.NO_COLOR)) return false;
-  if (envFlag(process.env.FORCE_COLOR)) return true;
-  return isStdoutTTY();
-};
-function envFlag(value) {
-  if (value === void 0) return false;
-  if (value.trim() === "") return false;
-  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 color = {
-  reset: wrap("0", "0"),
-  bold: wrap("1", "22"),
-  dim: wrap("2", "22"),
-  italic: wrap("3", "23"),
-  underline: wrap("4", "24"),
-  red: wrap("31", "39"),
-  green: wrap("32", "39"),
-  yellow: wrap("33", "39"),
-  blue: wrap("34", "39"),
-  magenta: wrap("35", "39"),
-  cyan: wrap("36", "39"),
-  gray: wrap("90", "39"),
-  amber: wrap("38;5;214", "39"),
-  pink: wrap("38;5;205", "39"),
-  bgRed: wrap("41", "49"),
-  bgGreen: wrap("42", "49")
-};
-
-// src/utils/deep-merge.ts
-var FORBIDDEN_PROTO_KEYS = /* @__PURE__ */ new Set([
-  "__proto__",
-  "constructor",
-  "prototype",
-  "__defineGetter__",
-  "__defineSetter__",
-  "__lookupGetter__",
-  "__lookupSetter__"
-]);
-function isPrimitiveArray(a) {
-  return a.every((v) => v === null || typeof v !== "object" && typeof v !== "function");
-}
-function deepMerge(base, patch, options = {}) {
-  const {
-    conflictResolution = "prefer-patch",
-    arrayMode = "replace",
-    protectProto = true,
-    onNonPrimitiveArrayReplace
-  } = options;
-  if (typeof base !== "object" || base === null) {
-    return conflictResolution === "prefer-patch" ? patch : base;
-  }
-  if (typeof patch !== "object" || patch === null) {
-    return conflictResolution === "prefer-patch" ? patch : base;
-  }
-  if (Array.isArray(base) && Array.isArray(patch)) {
-    if (arrayMode === "concat-primitives" && isPrimitiveArray(base) && isPrimitiveArray(patch)) {
-      return [.../* @__PURE__ */ new Set([...base, ...patch])];
-    }
-    return conflictResolution === "prefer-patch" ? patch : base;
-  }
-  if (Array.isArray(base) || Array.isArray(patch)) {
-    return conflictResolution === "prefer-patch" ? patch : base;
-  }
-  const baseObj = base;
-  const patchObj = patch;
-  const out = { ...baseObj };
-  for (const [k, v] of Object.entries(patchObj)) {
-    if (protectProto && FORBIDDEN_PROTO_KEYS.has(k)) continue;
-    const existing = out[k];
-    if (v !== null && typeof v === "object" && !Array.isArray(v) && existing !== null && typeof existing === "object" && !Array.isArray(existing)) {
-      out[k] = deepMerge(existing, v, options);
-    } else if (Array.isArray(v) && Array.isArray(existing)) {
-      if (onNonPrimitiveArrayReplace && !isPrimitiveArray(v)) {
-        onNonPrimitiveArrayReplace(k, existing.length, v.length);
-      }
-      out[k] = deepMerge(existing, v, options);
-    } else if (v !== void 0) {
-      if (onNonPrimitiveArrayReplace && Array.isArray(v) && !isPrimitiveArray(v)) {
-        const existingLen = Array.isArray(existing) ? existing.length : 0;
-        onNonPrimitiveArrayReplace(k, existingLen, v.length);
-      }
-      out[k] = v;
-    }
-  }
-  return out;
-}
-
-// src/utils/error.ts
-function toErrorMessage(err) {
-  return err instanceof Error ? err.message : String(err);
-}
-
 // src/utils/regex-guard.ts
 var MAX_PATTERN_LEN = 512;
 var DANGEROUS_PATTERNS = [
@@ -381,6 +264,25 @@ function safeParse(input, maxBytes = 5e6) {
     };
   }
 }
+function sessionScopedPath(dir, sessionId, suffix) {
+  if (!sessionId || sessionId.includes("\\") || sessionId.includes("..")) {
+    throw invalid(sessionId);
+  }
+  const resolved = path2.resolve(dir, `${sessionId}${suffix}`);
+  const rel = path2.relative(path2.resolve(dir), resolved);
+  if (rel.startsWith("..") || path2.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/utils/slug.ts
 function slugify(name, fallback = "prompt", maxLen = 64) {
@@ -476,6 +378,222 @@ function resolveWstackPaths(opts) {
   };
 }
 
+// src/types/errors.ts
+var ERROR_CODES = {
+  // Config
+  CONFIG_INVALID: "CONFIG_INVALID",
+  // Session
+  SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
+  SESSION_CORRUPTED: "SESSION_CORRUPTED",
+  SESSION_WRITE_FAILED: "SESSION_WRITE_FAILED",
+  // File system
+  FS_READ_FAILED: "FS_READ_FAILED",
+  FS_DELETE_FAILED: "FS_DELETE_FAILED",
+  FS_ATOMIC_WRITE_FAILED: "FS_ATOMIC_WRITE_FAILED",
+  // General
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  UNKNOWN: "UNKNOWN"
+};
+var WrongStackError = class extends Error {
+  code;
+  subsystem;
+  severity;
+  recoverable;
+  context;
+  constructor(opts) {
+    super(opts.message, { cause: opts.cause });
+    this.name = "WrongStackError";
+    this.code = opts.code;
+    this.subsystem = opts.subsystem;
+    this.severity = opts.severity ?? "error";
+    this.recoverable = opts.recoverable ?? false;
+    this.context = opts.context;
+  }
+  /**
+   * Render a one-line user-facing description.
+   * Subclasses should override for domain-specific formatting.
+   */
+  describe() {
+    const ctx = this.context ? ` ${formatContext(this.context)}` : "";
+    return `${this.code}: ${this.message}${ctx}`;
+  }
+};
+function formatContext(ctx) {
+  const parts = Object.entries(ctx).filter(([, v]) => v !== void 0).slice(0, 3).map(([k, v]) => `${k}=${String(v)}`);
+  return parts.length > 0 ? `[${parts.join(" ")}]` : "";
+}
+var ConfigError = class extends WrongStackError {
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "config",
+      severity: "fatal",
+      recoverable: false,
+      context: opts.context,
+      cause: opts.cause
+    });
+    this.name = "ConfigError";
+  }
+};
+var SessionError = class extends WrongStackError {
+  sessionId;
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "session",
+      severity: opts.code === ERROR_CODES.SESSION_WRITE_FAILED ? "error" : "warning",
+      recoverable: opts.code !== ERROR_CODES.SESSION_CORRUPTED,
+      context: { sessionId: opts.sessionId, ...opts.context },
+      cause: opts.cause
+    });
+    this.name = "SessionError";
+    this.sessionId = opts.sessionId;
+  }
+};
+var FsError = class extends WrongStackError {
+  path;
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "fs",
+      severity: "error",
+      recoverable: opts.code !== ERROR_CODES.FS_READ_FAILED,
+      context: { path: opts.path, ...opts.context },
+      cause: opts.cause
+    });
+    this.name = "FsError";
+    this.path = opts.path;
+  }
+};
+
+// src/utils/atomic-write.ts
+async function atomicWrite(targetPath, content, opts = {}) {
+  const dir = path2.dirname(targetPath);
+  await fsp2.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" });
+    } else {
+      await fsp2.writeFile(tmp, content, { flag: "wx" });
+    }
+    try {
+      const fh = await fsp2.open(tmp, "r+");
+      try {
+        await fh.sync();
+      } finally {
+        await fh.close();
+      }
+    } catch {
+    }
+    let mode;
+    try {
+      const stat11 = await fsp2.stat(targetPath);
+      mode = stat11.mode & 511;
+    } catch {
+      mode = opts.mode;
+    }
+    if (mode !== void 0) {
+      await fsp2.chmod(tmp, mode);
+    }
+    await renameWithRetry(tmp, targetPath);
+    if (mode !== void 0 && process.platform === "win32") {
+      try {
+        await fsp2.chmod(targetPath, mode);
+      } catch {
+      }
+    }
+  } catch (err) {
+    try {
+      await fsp2.unlink(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
+async function ensureDir(dir) {
+  await fsp2.mkdir(dir, { recursive: true });
+}
+async function withFileLock(targetPath, fn, opts = {}) {
+  const dir = path2.dirname(targetPath);
+  await fsp2.mkdir(dir, { recursive: true });
+  const lockPath = path2.join(dir, `.${path2.basename(targetPath)}.lock`);
+  const timeoutMs = opts.timeoutMs ?? 5e3;
+  const staleMs = opts.staleMs ?? 3e4;
+  const started = Date.now();
+  let handle;
+  for (; ; ) {
+    try {
+      handle = await fsp2.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 });
+        continue;
+      }
+      if (code !== "EEXIST") throw err;
+      try {
+        const stat11 = await fsp2.stat(lockPath);
+        if (Date.now() - stat11.mtimeMs > staleMs) {
+          await fsp2.unlink(lockPath);
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      if (Date.now() - started >= timeoutMs) {
+        throw new FsError({
+          message: `Timed out waiting for file lock: ${targetPath}`,
+          code: "FS_ATOMIC_WRITE_FAILED",
+          path: targetPath,
+          context: { timeoutMs }
+        });
+      }
+      await new Promise((resolve8) => setTimeout(resolve8, 25));
+    }
+  }
+  try {
+    return await fn();
+  } finally {
+    try {
+      await handle?.close();
+    } catch {
+    }
+    try {
+      await fsp2.unlink(lockPath);
+    } catch {
+    }
+  }
+}
+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);
+    return;
+  }
+  const delays = [10, 25, 60, 120, 250];
+  let lastErr;
+  for (let i = 0; i <= delays.length; i++) {
+    try {
+      await fsp2.rename(from, to);
+      return;
+    } catch (err) {
+      lastErr = err;
+      const code = err?.code;
+      if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
+        throw err;
+      }
+      await new Promise((resolve8) => setTimeout(resolve8, delays[i]));
+    }
+  }
+  throw lastErr;
+}
+
 // src/storage/session-helpers.ts
 function userInputTitle(content) {
   const text = typeof content === "string" ? content : content.filter((b) => b.type === "text").map((b) => b.text).join(" ");
@@ -860,6 +978,7 @@ var FileSessionWriter = class _FileSessionWriter {
       promptPreview
     });
     this.events?.emit("checkpoint.written", {
+      sessionId: this.id,
       promptIndex,
       promptPreview,
       ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1029,6 +1148,7 @@ var FileSessionWriter = class _FileSessionWriter {
       revertedFiles: []
     });
     this.events?.emit("session.rewound", {
+      sessionId: this.id,
       toPromptIndex: targetPromptIndex,
       revertedFiles: [],
       removedEvents: removedCount
@@ -1068,7 +1188,7 @@ var FileSessionWriter = class _FileSessionWriter {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       context
     });
-    this.events?.emit("in_flight.started", { context, ts: (/* @__PURE__ */ new Date()).toISOString() });
+    this.events?.emit("in_flight.started", { sessionId: this.id, context, ts: (/* @__PURE__ */ new Date()).toISOString() });
   }
   /**
    * Close the in-flight marker. Idempotent in spirit
@@ -1083,18 +1203,18 @@ var FileSessionWriter = class _FileSessionWriter {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       reason
     });
-    this.events?.emit("in_flight.ended", { reason, ts: (/* @__PURE__ */ new Date()).toISOString() });
+    this.events?.emit("in_flight.ended", { sessionId: this.id, reason, ts: (/* @__PURE__ */ new Date()).toISOString() });
   }
 };
+
+// src/storage/session-id.ts
 function sanitizeModel(model) {
   return model.replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
 }
-function generateSessionId(startedAt, model) {
+function generateSessionId(startedAt, _model) {
   const date = startedAt.slice(0, 10);
-  const time = startedAt.slice(11, 19).replace(/:/g, "-");
-  const suffix = randomBytes(2).toString("hex");
-  const modelPart = model ? `_${sanitizeModel(model)}` : "";
-  return `${date}/${time}Z${modelPart}_${suffix}`;
+  const seedTime = Number.isNaN(Date.parse(startedAt)) ? Date.now() : Date.parse(startedAt);
+  return `${date}/sess_${ulid(seedTime)}`;
 }
 
 // src/storage/session-summary.ts
@@ -1229,7 +1349,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
   }
   /** Join session ID to its absolute path within the store directory. */
   sessionPath(id, ext) {
-    return path2.join(this.dir, `${id}${ext}`);
+    return sessionScopedPath(this.dir, id, ext);
   }
   shardManifestPath(shardKey) {
     return shardKey ? path2.join(this.dir, shardKey, "_manifest.json") : path2.join(this.dir, "_manifest.json");
@@ -1247,15 +1367,15 @@ var DefaultSessionStore = class _DefaultSessionStore {
    * subdirectory so sessions group naturally by day.
    */
   async ensureShardDir(id) {
-    const dirPath = path2.dirname(path2.join(this.dir, id));
+    const dirPath = path2.dirname(sessionScopedPath(this.dir, id, ""));
     await ensureDir(dirPath);
     return dirPath;
   }
   async create(meta) {
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const id = meta.id && meta.id.length > 0 ? meta.id : generateSessionId(startedAt, meta.model ?? meta.provider);
+    const id = meta.id && meta.id.length > 0 ? meta.id : generateSessionId(startedAt);
     const shardDir = await this.ensureShardDir(id);
-    const file = path2.join(shardDir, `${path2.basename(id)}.jsonl`);
+    const file = this.sessionPath(id, ".jsonl");
     const t0 = Date.now();
     let handle;
     try {
@@ -1337,6 +1457,26 @@ var DefaultSessionStore = class _DefaultSessionStore {
     }
   }
   async load(id) {
+    return this.loadInternal(id, { full: true });
+  }
+  /**
+   * Fast-path loader that skips message reconstruction and adjacency repair.
+   *
+   * Use this for callers that only need the raw event stream + session
+   * metadata — e.g. session listers, analytics, audit, and the TUI's
+   * "events only" views. It avoids the message array build and
+   * repairToolUseAdjacency cost on large session files (a long agent
+   * run can have 50k+ events; rebuilding messages is O(events) and
+   * allocates per-block, so skipping it is a meaningful win).
+   *
+   * The returned data.messages is an empty array; data.toolCallEnds
+   * is computed from the raw events. usage is the sum across all
+   * llm_response events — same as full load().
+   */
+  async loadEventsOnly(id) {
+    return this.loadInternal(id, { full: false });
+  }
+  async loadInternal(id, mode) {
     const file = this.sessionPath(id, ".jsonl");
     const t0 = Date.now();
     let outcome = "success";
@@ -1344,93 +1484,113 @@ var DefaultSessionStore = class _DefaultSessionStore {
     let cacheHit = false;
     try {
       const s = await fsp2.stat(file);
-      const stat10 = { mtimeMs: s.mtimeMs, size: s.size };
+      const stat11 = { mtimeMs: s.mtimeMs, size: s.size };
       const cached = this._loadCache.get(id);
-      if (cached && cached.mtimeMs === stat10.mtimeMs && cached.size === stat10.size) {
+      if (cached && cached.mtimeMs === stat11.mtimeMs && cached.size === stat11.size) {
         cacheHit = true;
         this._loadCache.delete(id);
         this._loadCache.set(id, cached);
-        return cached.data;
+        if (mode.full) return cached.data;
+        return { ...cached.data, messages: [] };
       }
-      const raw = await fsp2.readFile(file, "utf8");
-      const lines = raw.split("\n").filter((l) => l.trim());
       const events = [];
       let sessionStartEvent;
       let sessionEndEvent;
       let sessionModel;
       let sessionProvider;
       let sessionPendingToolUses;
-      const messages = [];
-      const openToolUses = /* @__PURE__ */ new Set();
+      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 };
-      for (const line of lines) {
-        try {
-          const parsed = JSON.parse(line);
-          if (parsed !== null && typeof parsed === "object" && typeof parsed.type === "string" && typeof parsed.ts === "string") {
-            const ev = parsed;
-            events.push(ev);
-            if (ev.type === "session_start" && !sessionStartEvent) {
-              sessionStartEvent = ev;
-              sessionModel = ev.model;
-              sessionProvider = ev.provider;
-            }
-            if (ev.type === "session_end") {
-              sessionEndEvent = ev;
-              sessionPendingToolUses = ev.pendingToolUses;
-            }
-            if (ev.type === "user_input") {
-              openToolUses.clear();
-              messages.push({ role: "user", content: ev.content, ts: ev.ts });
-            } else if (ev.type === "llm_response") {
-              messages.push({ role: "assistant", content: ev.content, ts: ev.ts });
-              for (const b of ev.content) {
-                if (b.type === "tool_use") openToolUses.add(b.id);
+      const stream = createReadStream(file, { encoding: "utf8" });
+      const rl = createInterface({ input: stream, crlfDelay: Infinity });
+      try {
+        for await (const line of rl) {
+          if (!line.trim()) continue;
+          try {
+            const parsed = JSON.parse(line);
+            if (parsed !== null && typeof parsed === "object" && typeof parsed.type === "string" && typeof parsed.ts === "string") {
+              const ev = parsed;
+              events.push(ev);
+              if (ev.type === "session_start" && !sessionStartEvent) {
+                sessionStartEvent = ev;
+                sessionModel = ev.model;
+                sessionProvider = ev.provider;
               }
-              usage = {
-                input: usage.input + (ev.usage.input ?? 0),
-                output: usage.output + (ev.usage.output ?? 0),
-                cacheRead: (usage.cacheRead ?? 0) + (ev.usage.cacheRead ?? 0),
-                cacheWrite: (usage.cacheWrite ?? 0) + (ev.usage.cacheWrite ?? 0)
-              };
-            } else if (ev.type === "tool_result") {
-              if (!openToolUses.has(ev.id)) {
-                this.events?.emit("session.damaged", {
-                  sessionId: id,
-                  detail: `Orphan tool_result "${ev.id}" has no matching tool_use`
-                });
-                continue;
+              if (ev.type === "session_end") {
+                sessionEndEvent = ev;
+                sessionPendingToolUses = ev.pendingToolUses;
               }
-              openToolUses.delete(ev.id);
-              const resultBlock = {
-                type: "tool_result",
-                tool_use_id: ev.id,
-                content: typeof ev.content === "string" ? ev.content : JSON.stringify(ev.content),
-                is_error: ev.isError
-              };
-              const last = messages[messages.length - 1];
-              const lastIsToolResultUser = last?.role === "user" && Array.isArray(last.content) && last.content.every((b) => b.type === "tool_result");
-              if (lastIsToolResultUser && Array.isArray(last.content)) {
-                last.content.push(resultBlock);
-              } else {
-                messages.push({ role: "user", content: [resultBlock], ts: ev.ts });
+              if (mode.full && messages !== void 0 && openToolUses !== void 0) {
+                if (ev.type === "user_input") {
+                  openToolUses.clear();
+                  messages.push({ role: "user", content: ev.content, ts: ev.ts });
+                } else if (ev.type === "llm_response") {
+                  messages.push({ role: "assistant", content: ev.content, ts: ev.ts });
+                  for (const b of ev.content) {
+                    if (b.type === "tool_use") openToolUses.add(b.id);
+                  }
+                  usage = {
+                    input: usage.input + (ev.usage.input ?? 0),
+                    output: usage.output + (ev.usage.output ?? 0),
+                    cacheRead: (usage.cacheRead ?? 0) + (ev.usage.cacheRead ?? 0),
+                    cacheWrite: (usage.cacheWrite ?? 0) + (ev.usage.cacheWrite ?? 0)
+                  };
+                } else if (ev.type === "tool_result") {
+                  if (!openToolUses.has(ev.id)) {
+                    this.events?.emit("session.damaged", {
+                      sessionId: id,
+                      detail: `Orphan tool_result "${ev.id}" has no matching tool_use`
+                    });
+                    continue;
+                  }
+                  openToolUses.delete(ev.id);
+                  const resultBlock = {
+                    type: "tool_result",
+                    tool_use_id: ev.id,
+                    content: typeof ev.content === "string" ? ev.content : JSON.stringify(ev.content),
+                    is_error: ev.isError
+                  };
+                  const last = messages[messages.length - 1];
+                  const lastIsToolResultUser = last?.role === "user" && Array.isArray(last.content) && last.content.every((b) => b.type === "tool_result");
+                  if (lastIsToolResultUser && Array.isArray(last.content)) {
+                    last.content.push(resultBlock);
+                  } else {
+                    messages.push({ role: "user", content: [resultBlock], ts: ev.ts });
+                  }
+                }
+              } else if (ev.type === "llm_response") {
+                usage = {
+                  input: usage.input + (ev.usage.input ?? 0),
+                  output: usage.output + (ev.usage.output ?? 0),
+                  cacheRead: (usage.cacheRead ?? 0) + (ev.usage.cacheRead ?? 0),
+                  cacheWrite: (usage.cacheWrite ?? 0) + (ev.usage.cacheWrite ?? 0)
+                };
               }
             }
+          } catch {
           }
-        } catch {
         }
+      } finally {
+        rl.close();
+        stream.close();
       }
-      if (openToolUses.size > 0) {
-        this.events?.emit("session.damaged", {
-          sessionId: id,
-          detail: `${openToolUses.size} tool_use blocks without matching results - replay repaired`
-        });
-      }
-      const repaired = repairToolUseAdjacency(messages);
-      if (repaired.report.changed) {
-        this.events?.emit("session.damaged", {
-          sessionId: id,
-          detail: `Repaired replay adjacency: removed ${repaired.report.removedToolUses.length} tool_use, ${repaired.report.removedToolResults.length} tool_result, ${repaired.report.removedMessages} empty messages`
-        });
+      let finalMessages = [];
+      if (mode.full && messages !== void 0 && openToolUses !== void 0) {
+        if (openToolUses.size > 0) {
+          this.events?.emit("session.damaged", {
+            sessionId: id,
+            detail: `${openToolUses.size} tool_use blocks without matching results - replay repaired`
+          });
+        }
+        const repaired = repairToolUseAdjacency(messages);
+        if (repaired.report.changed) {
+          this.events?.emit("session.damaged", {
+            sessionId: id,
+            detail: `Repaired replay adjacency: removed ${repaired.report.removedToolUses.length} tool_use, ${repaired.report.removedToolResults.length} tool_result, ${repaired.report.removedMessages} empty messages`
+          });
+        }
+        finalMessages = repaired.messages;
       }
       const meta = {
         id,
@@ -1441,27 +1601,29 @@ var DefaultSessionStore = class _DefaultSessionStore {
         pendingToolUses: sessionPendingToolUses
       };
       const toolCallEnds = extractToolCallEnds(events);
-      const data = { metadata: meta, events, messages: repaired.messages, usage, toolCallEnds };
-      if (this._loadCache.size >= _DefaultSessionStore.LOAD_CACHE_MAX_ENTRIES) {
-        const oldest = this._loadCache.keys().next().value;
-        if (oldest !== void 0) {
-          this._loadCache.delete(oldest);
+      const data = { metadata: meta, events, messages: finalMessages, usage, toolCallEnds };
+      if (mode.full) {
+        if (this._loadCache.size >= _DefaultSessionStore.LOAD_CACHE_MAX_ENTRIES) {
+          const oldest = this._loadCache.keys().next().value;
+          if (oldest !== void 0) {
+            this._loadCache.delete(oldest);
+          }
         }
+        this._loadCache.set(id, { mtimeMs: stat11.mtimeMs, size: stat11.size, data });
       }
-      this._loadCache.set(id, { mtimeMs: stat10.mtimeMs, size: stat10.size, data });
       return data;
     } catch (err) {
       outcome = "failure";
       errorMsg = toErrorMessage(err);
       throw err;
     } finally {
-      this.emitRead(id, file, "load", outcome, Date.now() - t0, errorMsg);
+      this.emitRead(id, file, mode.full ? "load" : "load_events_only", outcome, Date.now() - t0, errorMsg);
       if (cacheHit) {
         this.events?.emit("storage.cache_hit", {
           sessionId: id,
           store: "session",
           filePath: file,
-          operation: "load",
+          operation: mode.full ? "load" : "load_events_only",
           durationMs: Date.now() - t0
         });
       }
@@ -1489,14 +1651,14 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const limit = opts?.limit;
     const signal = opts?.signal;
     const out = [];
-    let stat10;
+    let stat11;
     try {
-      stat10 = await fsp2.stat(file);
+      stat11 = await fsp2.stat(file);
     } catch (err) {
       if (err.code === "ENOENT") return [];
       throw err;
     }
-    if (stat10.size === 0) return [];
+    if (stat11.size === 0) return [];
     let fh;
     try {
       fh = await fsp2.open(file, "r");
@@ -1609,14 +1771,20 @@ var DefaultSessionStore = class _DefaultSessionStore {
   async appendToIndex(summary) {
     try {
       await ensureDir(this.dir);
-      const line = JSON.stringify(summary) + "\n";
-      await fsp2.appendFile(this.indexFile, line, "utf8");
-      this._indexCache = null;
-      this.invalidateShardManifestBySessionId(summary.id);
-      this.indexAppendCount++;
-      if (this.indexAppendCount >= _DefaultSessionStore.COMPACT_EVERY) {
-        await this.compactIndex();
-        this.indexAppendCount = 0;
+      let shouldCompact = false;
+      await withFileLock(this.indexFile, async () => {
+        const line = JSON.stringify(summary) + "\n";
+        await fsp2.appendFile(this.indexFile, line, "utf8");
+        this._indexCache = null;
+        this.invalidateShardManifestBySessionId(summary.id);
+        this.indexAppendCount++;
+        if (this.indexAppendCount >= _DefaultSessionStore.COMPACT_EVERY) {
+          shouldCompact = true;
+          this.indexAppendCount = 0;
+        }
+      });
+      if (shouldCompact) {
+        await withFileLock(this.indexFile, () => this.compactIndexInner());
       }
     } catch {
     }
@@ -1625,30 +1793,28 @@ var DefaultSessionStore = class _DefaultSessionStore {
   async writeTombstone(id) {
     try {
       await ensureDir(this.dir);
-      const line = JSON.stringify({ action: "delete", id }) + "\n";
-      await fsp2.appendFile(this.indexFile, line, "utf8");
-      this._indexCache = null;
-      this.invalidateShardManifestBySessionId(id);
-      this.indexAppendCount++;
+      await withFileLock(this.indexFile, async () => {
+        const line = JSON.stringify({ action: "delete", id }) + "\n";
+        await fsp2.appendFile(this.indexFile, line, "utf8");
+        this._indexCache = null;
+        this.invalidateShardManifestBySessionId(id);
+        this.indexAppendCount++;
+      });
     } catch {
     }
   }
   /**
    * Compact the index: read all entries, drop tombstones, deduplicate
-   * (keep latest per session), and rewrite. Atomic via temp+rename.
+   * (keep latest per session), and rewrite atomically. Acquires the index
+   * file lock so a concurrent append (this process or another wstack in the
+   * same project) can't be overwritten by the rewrite.
    */
   async compactIndex() {
     const t0 = Date.now();
     let outcome = "success";
     let errorMsg;
     try {
-      const entries = await this.readIndex();
-      if (entries.length === 0) return;
-      const tmp = `${this.indexFile}.compact.tmp`;
-      const lines = entries.map((s) => JSON.stringify(s)).join("\n") + "\n";
-      await fsp2.writeFile(tmp, lines, "utf8");
-      await fsp2.rename(tmp, this.indexFile);
-      this._indexCache = null;
+      await withFileLock(this.indexFile, () => this.compactIndexInner());
     } catch (err) {
       outcome = "failure";
       errorMsg = toErrorMessage(err);
@@ -1656,21 +1822,34 @@ var DefaultSessionStore = class _DefaultSessionStore {
       this.emitWrite("~compact~", this.indexFile, "compact", outcome, Date.now() - t0, void 0, errorMsg);
     }
   }
+  /**
+   * Lock-free compaction body. The caller MUST already hold the index file
+   * lock (via withFileLock(this.indexFile, ...)). Uses atomicWrite for the
+   * rewrite so the temp file gets a random suffix (no collision between two
+   * compactions) and the Windows transient-EPERM rename retry.
+   */
+  async compactIndexInner() {
+    const entries = await this.readIndex();
+    if (entries.length === 0) return;
+    const lines = entries.map((s) => JSON.stringify(s)).join("\n") + "\n";
+    await atomicWrite(this.indexFile, lines, { mode: 384 });
+    this._indexCache = null;
+  }
   /**
    * Read the index file and return deduplicated session summaries.
    * Entries with a matching tombstone are filtered out.
    * Returns empty array when the index doesn't exist or is corrupt.
    */
   async readIndex() {
-    let stat10;
+    let stat11;
     try {
       const s = await fsp2.stat(this.indexFile);
-      stat10 = { mtimeMs: s.mtimeMs, size: s.size };
+      stat11 = { mtimeMs: s.mtimeMs, size: s.size };
     } catch {
       this._indexCache = null;
       return [];
     }
-    if (this._indexCache !== null && this._indexCache.mtimeMs === stat10.mtimeMs && this._indexCache.size === stat10.size) {
+    if (this._indexCache !== null && this._indexCache.mtimeMs === stat11.mtimeMs && this._indexCache.size === stat11.size) {
       return [...this._indexCache.summaries];
     }
     let raw;
@@ -1703,7 +1882,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       if (a.startedAt > b.startedAt) return -1;
       return a.id.localeCompare(b.id);
     });
-    this._indexCache = { ...stat10, summaries };
+    this._indexCache = { ...stat11, summaries };
     return [...summaries];
   }
   /**
@@ -1714,11 +1893,11 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const ids = await this.collectSessionIds(this.dir);
     const summaries = await Promise.all(ids.map((id) => this.summaryFor(id).catch(() => null)));
     const valid = summaries.filter((s) => s !== null);
-    const tmp = `${this.indexFile}.tmp`;
     const lines = valid.map((s) => JSON.stringify(s)).join("\n") + "\n";
-    await fsp2.writeFile(tmp, lines, "utf8");
-    await fsp2.rename(tmp, this.indexFile);
-    this._indexCache = null;
+    await withFileLock(this.indexFile, async () => {
+      await atomicWrite(this.indexFile, lines, { mode: 384 });
+      this._indexCache = null;
+    });
     return valid.length;
   }
   async listFromDirectoryScan(limit) {
@@ -1870,8 +2049,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
     if (fromManifest) return fromManifest;
     try {
       const full = this.sessionPath(id, ".jsonl");
-      const stat10 = await fsp2.stat(full);
-      const summary = await this.summarize(id, stat10.mtime.toISOString());
+      const stat11 = await fsp2.stat(full);
+      const summary = await this.summarize(id, stat11.mtime.toISOString());
       await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
         const msg = toErrorMessage(err);
         this.emitError(id, manifest, "summary_fallback", msg, true);
@@ -1914,18 +2093,18 @@ var DefaultSessionStore = class _DefaultSessionStore {
   async summaryHeaderFor(ref) {
     let mtime = (/* @__PURE__ */ new Date(0)).toISOString();
     try {
-      const stat10 = await fsp2.stat(ref.filePath);
-      if (!stat10.isFile()) {
+      const stat11 = await fsp2.stat(ref.filePath);
+      if (!stat11.isFile()) {
         return {
           id: ref.id,
           title: "(damaged)",
-          startedAt: stat10.mtime.toISOString(),
+          startedAt: stat11.mtime.toISOString(),
           model: "unknown",
           provider: "unknown",
           tokenTotal: 0
         };
       }
-      mtime = stat10.mtime.toISOString();
+      mtime = stat11.mtime.toISOString();
     } catch {
       return null;
     }
@@ -1973,14 +2152,15 @@ var DefaultSessionStore = class _DefaultSessionStore {
   async deleteSession(id) {
     const jsonlPath = this.sessionPath(id, ".jsonl");
     const summaryPath = this.sessionPath(id, ".summary.json");
-    const shardDir = path2.dirname(path2.join(this.dir, id));
+    const shardDir = path2.dirname(jsonlPath);
     const base = path2.basename(id);
     const sessDir = path2.join(shardDir, base);
     const deletions = [
       fsp2.unlink(jsonlPath),
       fsp2.unlink(summaryPath),
-      fsp2.unlink(path2.join(shardDir, `${base}.plan.json`)),
-      fsp2.unlink(path2.join(shardDir, `${base}.todos.json`))
+      fsp2.unlink(sessionScopedPath(this.dir, id, ".plan.json")),
+      fsp2.unlink(sessionScopedPath(this.dir, id, ".tasks.json")),
+      fsp2.unlink(sessionScopedPath(this.dir, id, ".todos.json"))
     ];
     const results = await Promise.allSettled(deletions);
     for (const r of results) {
@@ -2025,8 +2205,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const pruneFile = async (dir, name, prefix) => {
       const jsonlPath = path2.join(dir, name);
       try {
-        const stat10 = await fsp2.stat(jsonlPath);
-        if (stat10.mtimeMs >= cutoff) return;
+        const stat11 = await fsp2.stat(jsonlPath);
+        if (stat11.mtimeMs >= cutoff) return;
       } catch {
         return;
       }
@@ -2565,9 +2745,80 @@ function isMemoryType(s) {
 function isPriority(s) {
   return s === "critical" || s === "high" || s === "medium" || s === "low";
 }
+function buildInvertedIndex(entries) {
+  const wordMap = /* @__PURE__ */ new Map();
+  const tagMap = /* @__PURE__ */ new Map();
+  const indexed = new Array(entries.length);
+  for (let i = 0; i < entries.length; i++) {
+    const e = entries[i];
+    const words = e.text.toLowerCase().split(/\s+/).filter((w) => w.length > 0);
+    const tags = (e.tags ?? []).map((t) => t.toLowerCase());
+    indexed[i] = { entry: e, words, tags };
+    for (const w of words) {
+      const arr = wordMap.get(w);
+      if (arr) arr.push(i);
+      else wordMap.set(w, [i]);
+    }
+    for (const t of tags) {
+      const arr = tagMap.get(t);
+      if (arr) arr.push(i);
+      else tagMap.set(t, [i]);
+    }
+  }
+  return { wordMap, tagMap, entries: indexed, mtimeMs: 0 };
+}
+var MIN_SUBSTRING_NEEDLE_LEN = 3;
+function searchIndex(index, query, limit) {
+  const needles = query.toLowerCase().split(/\s+/).filter((n) => n.length > 0);
+  if (needles.length === 0) return [];
+  const scores = /* @__PURE__ */ new Map();
+  for (const n of needles) {
+    let matched = false;
+    const wordExact = index.wordMap.get(n);
+    if (wordExact) {
+      for (const idx of wordExact) scores.set(idx, (scores.get(idx) ?? 0) + 1);
+      matched = true;
+    }
+    const tagExact = index.tagMap.get(n);
+    if (tagExact) {
+      for (const idx of tagExact) scores.set(idx, (scores.get(idx) ?? 0) + 2);
+      matched = true;
+    }
+    if (matched || n.length < MIN_SUBSTRING_NEEDLE_LEN) continue;
+    for (const [word, indices] of index.wordMap) {
+      if (word.includes(n) || n.includes(word)) {
+        for (const idx of indices) {
+          scores.set(idx, (scores.get(idx) ?? 0) + 1);
+        }
+      }
+    }
+    for (const [tag, indices] of index.tagMap) {
+      if (tag.includes(n) || n.includes(tag)) {
+        for (const idx of indices) {
+          scores.set(idx, (scores.get(idx) ?? 0) + 2);
+        }
+      }
+    }
+  }
+  if (scores.size === 0) return [];
+  const scored = Array.from(scores.entries());
+  scored.sort((a, b) => b[1] - a[1]);
+  const result = [];
+  const max = limit ? Math.min(limit, scored.length) : scored.length;
+  for (let i = 0; i < max; i++) {
+    result.push(index.entries[scored[i][0]].entry);
+  }
+  return result;
+}
 var FileMemoryBackend = class {
   kind = "file";
   files;
+  /** Cache of parsed entries per file path. */
+  entryCache = /* @__PURE__ */ new Map();
+  /** Inverted index per file path. */
+  indexCache = /* @__PURE__ */ new Map();
+  /** File mtime cache for invalidation. */
+  mtimeCache = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.files = {
       "project-agents": opts.paths.inProjectAgentsFile,
@@ -2578,6 +2829,53 @@ var FileMemoryBackend = class {
   resolveFile(filePath, scope) {
     return filePath || this.files[scope];
   }
+  async getMtime(file) {
+    try {
+      const stat11 = await fsp2.stat(file);
+      return stat11.mtimeMs;
+    } catch {
+      return 0;
+    }
+  }
+  invalidateCache(file) {
+    this.entryCache.delete(file);
+    this.indexCache.delete(file);
+    this.mtimeCache.delete(file);
+  }
+  /**
+   * Load (and cache) the parsed entries for a file. Callers that have already
+   * stat'd the file this tick (e.g. `getIndex`) can pass the known `mtime` to
+   * avoid a redundant `fs.stat` — otherwise it's fetched here.
+   */
+  async loadEntries(file, scope, mtime) {
+    const resolvedMtime = mtime ?? await this.getMtime(file);
+    const cachedMtime = this.mtimeCache.get(file);
+    if (cachedMtime === resolvedMtime && this.entryCache.has(file)) {
+      return this.entryCache.get(file);
+    }
+    const raw = await this.readAll(scope, file);
+    if (!raw.trim()) {
+      this.entryCache.set(file, []);
+      this.mtimeCache.set(file, resolvedMtime);
+      return [];
+    }
+    const entries = parseEntries(raw, scope);
+    this.entryCache.set(file, entries);
+    this.mtimeCache.set(file, resolvedMtime);
+    return entries;
+  }
+  async getIndex(file, scope) {
+    const mtime = await this.getMtime(file);
+    const cached = this.indexCache.get(file);
+    if (cached && cached.mtimeMs === mtime) {
+      return cached;
+    }
+    const entries = await this.loadEntries(file, scope, mtime);
+    const index = buildInvertedIndex(entries);
+    index.mtimeMs = mtime;
+    this.indexCache.set(file, index);
+    return index;
+  }
   async remember(scope, entry, filePath) {
     const file = this.resolveFile(filePath, scope);
     await ensureDir(path2.dirname(file));
@@ -2594,6 +2892,7 @@ var FileMemoryBackend = class {
     const next = existing.trim() ? existing.replace(/\n+$/, "") + line : `# Agent Memory
 ${line}`;
     await atomicWrite(file, next);
+    this.invalidateCache(file);
   }
   async forget(scope, query, filePath) {
     const file = this.resolveFile(filePath, scope);
@@ -2630,6 +2929,7 @@ ${line}`;
           await atomicWrite(file, lines.join("\n"));
         }
       }
+      this.invalidateCache(file);
       return removed;
     });
   }
@@ -2642,30 +2942,19 @@ ${line}`;
     }
   }
   async list(scope, filePath, limit) {
-    const raw = await this.readAll(scope, filePath);
-    if (!raw.trim()) return [];
-    const entries = parseEntries(raw, scope);
+    const file = this.resolveFile(filePath, scope);
+    const entries = await this.loadEntries(file, scope);
     return limit ? entries.slice(0, limit) : entries;
   }
   async search(scope, query, filePath, limit) {
-    const entries = await this.list(scope, filePath);
-    const needle = query.toLowerCase().split(/\s+/);
-    const scored = entries.map((e) => {
-      const words = e.text.toLowerCase().split(/\s+/);
-      let score = 0;
-      for (const n of needle) {
-        if (words.some((w) => w.includes(n))) score += 1;
-        if (e.tags?.some((t) => t.toLowerCase().includes(n))) score += 2;
-      }
-      return { entry: e, score };
-    });
-    scored.sort((a, b) => b.score - a.score);
-    const matched = scored.filter((s) => s.score > 0).map((s) => s.entry);
-    return limit ? matched.slice(0, limit) : matched;
+    const file = this.resolveFile(filePath, scope);
+    const index = await this.getIndex(file, scope);
+    return searchIndex(index, query, limit);
   }
   async clear(scope, filePath) {
     const file = this.resolveFile(filePath, scope);
     await atomicWrite(file, "");
+    this.invalidateCache(file);
   }
   async consolidate(scope, filePath) {
     const file = this.resolveFile(filePath, scope);
@@ -2700,6 +2989,7 @@ ${line}`;
     } catch {
       return 0;
     }
+    this.invalidateCache(file);
     return removed;
   }
 };
@@ -2766,9 +3056,10 @@ var DefaultMemoryStore = class {
   /** Result cache for scoreRelevant() — keyed by scope + context hash, TTL 30s. */
   _scoreCache = /* @__PURE__ */ new Map();
   /**
-   * Per-entry cached lowercase strings — computed once per scoreRelevant() call,
-   * stored here so repeated scoring of the same entries avoids re-computation.
-   * Cleared on every mutation (remember/forget/consolidate/clear).
+   * Per-entry cached lowercase strings — lazily allocated once and reused
+   * across scoreRelevant() calls so repeated scoring of the same entries skips
+   * re-lowercasing. Keyed by entry object identity; cleared (set to null) on
+   * every mutation (remember/forget/consolidate/clear) via invalidateScoreCaches().
    */
   _cachedLower = null;
   constructor(opts) {
@@ -2918,7 +3209,7 @@ ${body.trim()}`);
       const t0 = Date.now();
       try {
         await this.backend.remember(scope, entry, filePath);
-        this._scoreCache.clear();
+        this.invalidateScoreCaches();
         const dur = Date.now() - t0;
         this.events?.emit("storage.write", {
           sessionId: "~memory~",
@@ -2969,6 +3260,15 @@ ${body.trim()}`);
       });
     });
   }
+  /**
+   * Drop the relevance caches after a mutation. Both the per-context score
+   * cache and the per-entry lowercase cache are keyed on entry objects that a
+   * mutation invalidates, so they must be cleared together when entries change.
+   */
+  invalidateScoreCaches() {
+    this._scoreCache.clear();
+    this._cachedLower = null;
+  }
   /**
    * Score and rank memories by relevance to the current context.
    * Returns entries with score >= MIN_RELEVANCE_SCORE, sorted highest first.
@@ -2986,18 +3286,19 @@ ${body.trim()}`);
     const taskWords = ctx.currentTask.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
     const skillWords = (ctx.activeSkills ?? []).flatMap((s) => s.split("-"));
     const toolWords = (ctx.toolNames ?? []).flatMap((t) => t.toLowerCase().split("_"));
-    this._cachedLower = /* @__PURE__ */ new WeakMap();
+    this._cachedLower ??= /* @__PURE__ */ new WeakMap();
+    const lowerCache = this._cachedLower;
     const scored = [];
     for (const entry of all) {
       let score = 0;
       const reasons = [];
-      let cachedLower = this._cachedLower.get(entry);
+      let cachedLower = lowerCache.get(entry);
       if (!cachedLower) {
         cachedLower = {
           textLower: entry.text.toLowerCase(),
           tagsLower: (entry.tags ?? []).map((t) => t.toLowerCase())
         };
-        this._cachedLower.set(entry, cachedLower);
+        lowerCache.set(entry, cachedLower);
       }
       const { textLower, tagsLower } = cachedLower;
       let taskHits = 0;
@@ -3095,7 +3396,7 @@ ${body.trim()}`);
       let removed = 0;
       try {
         removed = await this.backend.forget(scope, query, filePath);
-        this._scoreCache.clear();
+        this.invalidateScoreCaches();
         const dur = Date.now() - t0;
         this.events?.emit("storage.write", {
           sessionId: "~memory~",
@@ -3139,7 +3440,7 @@ ${body.trim()}`);
       let removed = 0;
       try {
         removed = await this.backend.consolidate(scope, filePath);
-        this._scoreCache.clear();
+        this.invalidateScoreCaches();
         const dur = Date.now() - t0;
         this.events?.emit("storage.write", {
           sessionId: "~memory~",
@@ -3181,7 +3482,7 @@ ${body.trim()}`);
         const t0 = Date.now();
         try {
           await this.backend.clear(scope, filePath);
-          this._scoreCache.clear();
+          this.invalidateScoreCaches();
           const dur = Date.now() - t0;
           this.events?.emit("storage.write", {
             sessionId: "~memory~",
@@ -3248,6 +3549,7 @@ ${body.trim()}`);
         })
       )
     );
+    this.invalidateScoreCaches();
   }
   /**
    * Return a new MemoryStore proxy that carries `traceId` on every storage
@@ -3775,97 +4077,6 @@ var SessionMemoryConsolidator = class {
   };
 };
 
-// src/types/errors.ts
-var ERROR_CODES = {
-  // Config
-  CONFIG_INVALID: "CONFIG_INVALID",
-  // Session
-  SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
-  SESSION_CORRUPTED: "SESSION_CORRUPTED",
-  SESSION_WRITE_FAILED: "SESSION_WRITE_FAILED",
-  // File system
-  FS_READ_FAILED: "FS_READ_FAILED",
-  FS_DELETE_FAILED: "FS_DELETE_FAILED",
-  FS_ATOMIC_WRITE_FAILED: "FS_ATOMIC_WRITE_FAILED",
-  // General
-  VALIDATION_ERROR: "VALIDATION_ERROR",
-  UNKNOWN: "UNKNOWN"
-};
-var WrongStackError = class extends Error {
-  code;
-  subsystem;
-  severity;
-  recoverable;
-  context;
-  constructor(opts) {
-    super(opts.message, { cause: opts.cause });
-    this.name = "WrongStackError";
-    this.code = opts.code;
-    this.subsystem = opts.subsystem;
-    this.severity = opts.severity ?? "error";
-    this.recoverable = opts.recoverable ?? false;
-    this.context = opts.context;
-  }
-  /**
-   * Render a one-line user-facing description.
-   * Subclasses should override for domain-specific formatting.
-   */
-  describe() {
-    const ctx = this.context ? ` ${formatContext(this.context)}` : "";
-    return `${this.code}: ${this.message}${ctx}`;
-  }
-};
-function formatContext(ctx) {
-  const parts = Object.entries(ctx).filter(([, v]) => v !== void 0).slice(0, 3).map(([k, v]) => `${k}=${String(v)}`);
-  return parts.length > 0 ? `[${parts.join(" ")}]` : "";
-}
-var ConfigError = class extends WrongStackError {
-  constructor(opts) {
-    super({
-      message: opts.message,
-      code: opts.code,
-      subsystem: "config",
-      severity: "fatal",
-      recoverable: false,
-      context: opts.context,
-      cause: opts.cause
-    });
-    this.name = "ConfigError";
-  }
-};
-var SessionError = class extends WrongStackError {
-  sessionId;
-  constructor(opts) {
-    super({
-      message: opts.message,
-      code: opts.code,
-      subsystem: "session",
-      severity: opts.code === ERROR_CODES.SESSION_WRITE_FAILED ? "error" : "warning",
-      recoverable: opts.code !== ERROR_CODES.SESSION_CORRUPTED,
-      context: { sessionId: opts.sessionId, ...opts.context },
-      cause: opts.cause
-    });
-    this.name = "SessionError";
-    this.sessionId = opts.sessionId;
-  }
-};
-var FsError = class extends WrongStackError {
-  path;
-  constructor(opts) {
-    super({
-      message: opts.message,
-      code: opts.code,
-      subsystem: "fs",
-      severity: "error",
-      recoverable: opts.code !== ERROR_CODES.FS_READ_FAILED,
-      context: { path: opts.path, ...opts.context },
-      cause: opts.cause
-    });
-    this.name = "FsError";
-    this.path = opts.path;
-  }
-};
-
 // src/storage/config-store.ts
 function stripEphemeralFields(cfg) {
   const env = cfg._envSource;
@@ -3945,7 +4156,7 @@ var KEK_MAGIC = Buffer.from("WSKW", "ascii");
 var KEK_SALT_BYTES = 16;
 KEK_MAGIC.length + 1 + KEK_SALT_BYTES + IV_BYTES + TAG_BYTES + KEY_BYTES;
 function decryptConfigSecrets(cfg, vault, opts) {
-  const warn = ((msg) => console.warn(msg));
+  const warn = opts?.warn ?? ((msg) => console.warn(msg));
   return walk(cfg, vault, (v, key) => {
     try {
       return vault.decrypt(v);
@@ -3983,6 +4194,95 @@ function isSecretField(name) {
   return SECRET_KEY_PATTERN.test(lc);
 }
 
+// src/storage/provider-config-watcher.ts
+async function readProviderSnapshot(configPath, vault, warn) {
+  let raw;
+  try {
+    raw = await fsp2.readFile(configPath, "utf8");
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      warn?.(`Could not read ${configPath}: ${err.message}`);
+    }
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    warn?.(`Config at ${configPath} is not valid JSON: ${err.message}`);
+    return void 0;
+  }
+  const decrypted = decryptConfigSecrets(parsed, vault, warn ? { warn } : {});
+  const snapshot = {
+    providers: decrypted.providers ?? {}
+  };
+  if (typeof decrypted.apiKey === "string") snapshot.apiKey = decrypted.apiKey;
+  if (typeof decrypted.baseUrl === "string") snapshot.baseUrl = decrypted.baseUrl;
+  return snapshot;
+}
+function serializeSnapshot(s) {
+  return JSON.stringify({
+    providers: s.providers,
+    apiKey: s.apiKey ?? null,
+    baseUrl: s.baseUrl ?? null
+  });
+}
+function watchProviderConfig(configPath, vault, onChange, opts = {}) {
+  const debounceMs = opts.debounceMs ?? 200;
+  const warn = opts.warn;
+  const base = path2.basename(configPath);
+  let timer;
+  let closed = false;
+  let lastSerialized;
+  void readProviderSnapshot(configPath, vault, warn).then((seed) => {
+    if (!closed && seed && lastSerialized === void 0) {
+      lastSerialized = serializeSnapshot(seed);
+    }
+  });
+  let watcher;
+  try {
+    watcher = syncFs.watch(path2.dirname(configPath), { recursive: false });
+  } catch (err) {
+    warn?.(`Provider config watcher could not start: ${err.message}`);
+    return { close: () => {
+    } };
+  }
+  const trigger = () => {
+    if (closed) return;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = void 0;
+      void readProviderSnapshot(configPath, vault, warn).then(
+        (next) => {
+          if (closed || !next) return;
+          const serialized = serializeSnapshot(next);
+          if (serialized === lastSerialized) return;
+          lastSerialized = serialized;
+          onChange(next);
+        },
+        () => {
+        }
+      );
+    }, debounceMs);
+  };
+  watcher.on("change", (eventType, filename) => {
+    const name = typeof filename === "string" ? filename : "";
+    if (eventType === "rename" || eventType === "change") {
+      if (!name || name === base) trigger();
+    }
+  });
+  watcher.on("error", (err) => {
+    warn?.(`Provider config watcher error: ${err.message}`);
+  });
+  return {
+    close: () => {
+      closed = true;
+      if (timer) clearTimeout(timer);
+      watcher.close();
+    }
+  };
+}
+
 // src/types/context-window.ts
 var DEFAULT_CONTEXT_WINDOW_MODE_ID = "balanced";
 var CONTEXT_WINDOW_MODES = Object.freeze([
@@ -4676,8 +4976,8 @@ var DefaultConfigLoader = class {
     const t0 = Date.now();
     let mtimeMs = null;
     try {
-      const stat10 = await fsp2.stat(file);
-      mtimeMs = stat10.mtimeMs;
+      const stat11 = await fsp2.stat(file);
+      mtimeMs = stat11.mtimeMs;
       const cached = this.jsonCache.get(file);
       if (cached && cached.mtimeMs === mtimeMs) {
         return structuredClone(cached.value);
@@ -5019,11 +5319,11 @@ var DefaultSessionReader = class _DefaultSessionReader {
     if (!rootDir) {
       return await this.store.load(sessionId);
     }
-    const sessionPath = path2.join(rootDir, `${sessionId}.jsonl`);
+    const sessionPath = sessionScopedPath(rootDir, sessionId, ".jsonl");
     let mtimeMs = null;
     try {
-      const stat10 = await fsp2.stat(sessionPath);
-      mtimeMs = stat10.mtimeMs;
+      const stat11 = await fsp2.stat(sessionPath);
+      mtimeMs = stat11.mtimeMs;
     } catch {
       this.eventCache.delete(sessionId);
       this.eventCacheMtimes.delete(sessionId);
@@ -5379,27 +5679,6 @@ function renderPlainText(meta, events) {
   }
   return lines.join("\n");
 }
-function sessionScopedPath(dir, sessionId, suffix) {
-  if (!sessionId || sessionId.includes("\\") || sessionId.includes("..")) {
-    throw invalid(sessionId);
-  }
-  const resolved = path2.resolve(dir, `${sessionId}${suffix}`);
-  const rel = path2.relative(path2.resolve(dir), resolved);
-  if (rel.startsWith("..") || path2.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;
 var MAX_ANNOTATIONS = 1e3;
@@ -5743,8 +6022,8 @@ var ReplayLogStore = class {
             const line = JSON.stringify(entry) + "\n";
             let offset2 = 0;
             try {
-              const stat10 = await fsp2.stat(fp);
-              offset2 = stat10.size;
+              const stat11 = await fsp2.stat(fp);
+              offset2 = stat11.size;
             } catch (err) {
               if (err.code !== "ENOENT") throw err;
             }
@@ -6084,15 +6363,15 @@ var SessionRecovery = class {
   async detectStale(sessionId) {
     const fp = this.filePath(sessionId);
     const TAIL_SIZE = 8192;
-    let stat10;
+    let stat11;
     try {
-      stat10 = await fsp2.stat(fp);
+      stat11 = await fsp2.stat(fp);
     } catch (err) {
       if (err.code === "ENOENT") return null;
       return null;
     }
-    if (stat10.size === 0) return null;
-    const position = Math.max(0, stat10.size - TAIL_SIZE);
+    if (stat11.size === 0) return null;
+    const position = Math.max(0, stat11.size - TAIL_SIZE);
     const buf = Buffer.alloc(TAIL_SIZE);
     let fh;
     try {
@@ -6904,11 +7183,11 @@ var SessionRegistry = class {
    */
   async breakStaleLock(lockPath) {
     try {
-      const [stat10, content] = await Promise.all([
+      const [stat11, content] = await Promise.all([
         fsp2.stat(lockPath),
         fsp2.readFile(lockPath, "utf8").catch(() => "")
       ]);
-      const ageMs = Date.now() - stat10.mtimeMs;
+      const ageMs = Date.now() - stat11.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) {
@@ -6951,9 +7230,9 @@ var SessionRegistry = class {
       for (const name of await fsp2.readdir(dir)) {
         const isTemp = (name.startsWith(`${base}.`) || name.startsWith(`.${base}.`)) && name.endsWith(".tmp");
         if (!isTemp) continue;
-        const stat10 = await fsp2.stat(path2.join(dir, name)).catch(() => null);
-        if (!stat10) continue;
-        if (now - stat10.mtimeMs > STALE_TMP_MS) stale.push({ name, mtimeMs: stat10.mtimeMs });
+        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 });
       }
       stale.sort((a, b) => b.mtimeMs - a.mtimeMs);
       await Promise.all(
@@ -6991,6 +7270,7 @@ function clampPct(pct) {
 var AgentStatusTracker = class {
   events;
   registry;
+  sessionId;
   leaderName;
   // Live agent map: agentId → AgentEntry
   agents = /* @__PURE__ */ new Map();
@@ -7016,6 +7296,7 @@ var AgentStatusTracker = class {
   constructor(opts) {
     this.events = opts.events;
     this.registry = opts.registry;
+    this.sessionId = opts.sessionId;
     this.leaderName = opts.leaderName ?? "leader";
     this.onUpdate = opts.onUpdate;
   }
@@ -7024,8 +7305,12 @@ var AgentStatusTracker = class {
     return this.lastAgents.length > 0 ? [...this.lastAgents] : [];
   }
   start() {
+    const on = (pattern, fn) => this.events.onPattern(pattern, (event, payload) => {
+      if (!this.acceptsSession(payload)) return;
+      fn(event, payload);
+    });
     this.unsubscribers.push(
-      this.events.onPattern("agent.run.started", (_event, payload) => {
+      on("agent.run.started", (_event, payload) => {
         const p = payload;
         this.markLeaderStarted(p?.at);
         this.captureLeaderContext(p?.ctx);
@@ -7036,7 +7321,7 @@ var AgentStatusTracker = class {
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("iteration.started", (_e, payload) => {
+      on("iteration.started", (_e, payload) => {
         const p = payload;
         const ctx = p?.ctx;
         this.markLeaderStarted();
@@ -7053,7 +7338,7 @@ var AgentStatusTracker = class {
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("agent.run.completed", (_event, payload) => {
+      on("agent.run.completed", (_event, payload) => {
         const p = payload;
         this.captureLeaderContext(p?.ctx);
         this.leaderStatus = p?.status === "failed" ? "error" : "idle";
@@ -7064,7 +7349,7 @@ var AgentStatusTracker = class {
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("agent.run.error", (_event, payload) => {
+      on("agent.run.error", (_event, payload) => {
         const p = payload;
         this.captureLeaderContext(p?.ctx);
         this.leaderStatus = "error";
@@ -7074,7 +7359,7 @@ var AgentStatusTracker = class {
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("tool.started", (_event, payload) => {
+      on("tool.started", (_event, payload) => {
         const p = payload;
         if (p?.name) {
           this.markLeaderStarted();
@@ -7086,20 +7371,20 @@ var AgentStatusTracker = class {
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("tool.executed", () => {
+      on("tool.executed", () => {
         this.leaderCurrentTool = void 0;
         this.flush();
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("brain.ask_human", () => {
+      on("brain.ask_human", () => {
         this.markLeaderStarted();
         this.leaderStatus = "waiting_user";
         this.flush();
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("llm.stream_started", () => {
+      on("llm.stream_started", () => {
         this.markLeaderStarted();
         this.leaderStatus = "streaming";
         this.leaderPartialText = "";
@@ -7107,7 +7392,7 @@ var AgentStatusTracker = class {
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("provider.text_delta", (_e, payload) => {
+      on("provider.text_delta", (_e, payload) => {
         const p = payload;
         const text = p?.text;
         if (!text) return;
@@ -7120,14 +7405,14 @@ var AgentStatusTracker = class {
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("provider.response", (_e, payload) => {
+      on("provider.response", (_e, payload) => {
         const p = payload;
         this.captureLeaderContext(p?.ctx);
         this.flush();
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("provider.fallback", (_e, payload) => {
+      on("provider.fallback", (_e, payload) => {
         const p = payload;
         if (p?.to?.model) {
           this.leaderModel = p.to.providerId ? `${p.to.providerId}/${p.to.model}` : p.to.model;
@@ -7136,7 +7421,7 @@ var AgentStatusTracker = class {
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("ctx.pct", (_e, payload) => {
+      on("ctx.pct", (_e, payload) => {
         const p = payload;
         if (typeof p?.load === "number" && Number.isFinite(p.load)) {
           this.leaderCtxPct = clampPct(Math.round(p.load * 100));
@@ -7145,7 +7430,7 @@ var AgentStatusTracker = class {
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("token.accounted", (_e, payload) => {
+      on("token.accounted", (_e, payload) => {
         const p = payload;
         if (!p) return;
         this.leaderTokensIn += p.usage?.input ?? 0;
@@ -7165,7 +7450,7 @@ var AgentStatusTracker = class {
       return entry;
     };
     this.unsubscribers.push(
-      this.events.onPattern("subagent.spawned", (_e, payload) => {
+      on("subagent.spawned", (_e, payload) => {
         const p = payload;
         if (!p?.subagentId) return;
         const entry = touch(p.subagentId);
@@ -7177,7 +7462,7 @@ var AgentStatusTracker = class {
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("subagent.ctx_pct", (_e, payload) => {
+      on("subagent.ctx_pct", (_e, payload) => {
         const p = payload;
         if (!p?.subagentId) return;
         const entry = touch(p.subagentId);
@@ -7186,7 +7471,7 @@ var AgentStatusTracker = class {
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("subagent.task_started", (_e, payload) => {
+      on("subagent.task_started", (_e, payload) => {
         const p = payload;
         if (!p?.subagentId) return;
         const entry = touch(p.subagentId);
@@ -7197,7 +7482,7 @@ var AgentStatusTracker = class {
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("subagent.tool_executed", (_e, payload) => {
+      on("subagent.tool_executed", (_e, payload) => {
         const p = payload;
         if (!p?.subagentId) return;
         const entry = touch(p.subagentId);
@@ -7209,7 +7494,7 @@ var AgentStatusTracker = class {
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("subagent.iteration_summary", (_e, payload) => {
+      on("subagent.iteration_summary", (_e, payload) => {
         const p = payload;
         if (!p?.subagentId) return;
         const entry = touch(p.subagentId);
@@ -7226,7 +7511,7 @@ var AgentStatusTracker = class {
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("subagent.task_completed", (_e, payload) => {
+      on("subagent.task_completed", (_e, payload) => {
         const p = payload;
         if (!p?.subagentId) return;
         const entry = this.agents.get(p.subagentId);
@@ -7241,7 +7526,7 @@ var AgentStatusTracker = class {
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("subagent.stopped", (_e, payload) => {
+      on("subagent.stopped", (_e, payload) => {
         const p = payload;
         if (!p?.subagentId) return;
         if (this.agents.delete(p.subagentId)) this.flush();
@@ -7318,7 +7603,10 @@ var AgentStatusTracker = class {
     const allAgents = [leaderEntry, ...this.agents.values()];
     this.lastAgents = allAgents;
     try {
-      this.events.emit("session.agents_updated", { agents: allAgents });
+      this.events.emit("session.agents_updated", {
+        sessionId: this.currentSessionId(),
+        agents: allAgents
+      });
     } catch {
     }
     this.registry.updateAgents(allAgents).then(() => {
@@ -7328,6 +7616,16 @@ var AgentStatusTracker = class {
       }
     }).catch(() => void 0);
   }
+  currentSessionId() {
+    return typeof this.sessionId === "function" ? this.sessionId() : this.sessionId;
+  }
+  acceptsSession(payload) {
+    const expected = this.currentSessionId();
+    if (!expected) return true;
+    if (typeof payload !== "object" || payload === null) return true;
+    const actual = payload.sessionId;
+    return typeof actual !== "string" || actual.length === 0 || actual === expected;
+  }
   markLeaderStarted(startedAt) {
     if (this.leaderStartedAt && (this.leaderStatus === "running" || this.leaderStatus === "streaming" || this.leaderStatus === "waiting_user")) {
       return;
@@ -7432,8 +7730,11 @@ var DefaultSessionRewinder = class {
   }
   sessionsDir;
   projectRoot;
+  sessionFile(sessionId) {
+    return sessionScopedPath(this.sessionsDir, sessionId, ".jsonl");
+  }
   async listCheckpoints(sessionId) {
-    const file = path2.join(this.sessionsDir, `${sessionId}.jsonl`);
+    const file = this.sessionFile(sessionId);
     const raw = await fsp2.readFile(file, "utf8");
     const events = parseEvents(raw);
     const fileCountMap = /* @__PURE__ */ new Map();
@@ -7458,7 +7759,7 @@ var DefaultSessionRewinder = class {
     return checkpoints;
   }
   async rewindToCheckpoint(sessionId, checkpointIndex) {
-    const file = path2.join(this.sessionsDir, `${sessionId}.jsonl`);
+    const file = this.sessionFile(sessionId);
     const raw = await fsp2.readFile(file, "utf8");
     const events = parseEvents(raw);
     let targetIdx = -1;
@@ -7497,7 +7798,7 @@ var DefaultSessionRewinder = class {
     return { ...result, toPromptIndex: checkpointIndex, removedEvents };
   }
   async rewindLastN(sessionId, n) {
-    const file = path2.join(this.sessionsDir, `${sessionId}.jsonl`);
+    const file = this.sessionFile(sessionId);
     const raw = await fsp2.readFile(file, "utf8");
     const events = parseEvents(raw);
     const checkpoints = [];
@@ -7526,7 +7827,7 @@ var DefaultSessionRewinder = class {
     return { ...result, toPromptIndex: targetIndex, removedEvents: snapshotsToRevert.length };
   }
   async rewindToStart(sessionId) {
-    const file = path2.join(this.sessionsDir, `${sessionId}.jsonl`);
+    const file = this.sessionFile(sessionId);
     const raw = await fsp2.readFile(file, "utf8");
     const events = parseEvents(raw);
     const allSnapshots = [];
@@ -7911,7 +8212,12 @@ async function mutatePlan(filePath, sessionId, fn) {
     const updated = await fn(plan);
     const persisted = await savePlan(filePath, updated);
     if (!persisted) {
-      throw new Error(`Failed to persist plan to ${filePath} \u2014 the change was NOT saved.`);
+      throw new SessionError({
+        message: `Failed to persist plan to ${filePath} \u2014 the change was NOT saved.`,
+        code: "SESSION_WRITE_FAILED",
+        sessionId,
+        context: { filePath, operation: "mutatePlan" }
+      });
     }
     return updated;
   });
@@ -8135,7 +8441,12 @@ async function mutateTasks(filePath, sessionId, fn, events, traceId) {
     const updated = await fn(file);
     const persisted = await saveTasks(filePath, updated, events, traceId);
     if (!persisted) {
-      throw new Error(`Failed to persist tasks to ${filePath} \u2014 the change was NOT saved.`);
+      throw new SessionError({
+        message: `Failed to persist tasks to ${filePath} \u2014 the change was NOT saved.`,
+        code: "SESSION_WRITE_FAILED",
+        sessionId,
+        context: { filePath, operation: "mutateTasks" }
+      });
     }
     return updated;
   });
@@ -8968,8 +9279,8 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat10 = await fsp2.stat(localPath);
-        if (stat10.isDirectory()) {
+        const stat11 = await fsp2.stat(localPath);
+        if (stat11.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
             const content = await fsp2.readFile(file, "utf8");
@@ -8994,8 +9305,8 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat10 = await fsp2.stat(localPath);
-        if (stat10.isDirectory()) {
+        const stat11 = await fsp2.stat(localPath);
+        if (stat11.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
             const content = await fsp2.readFile(file);
@@ -9201,6 +9512,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, 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, loadDirectorState, loadGoal, loadPlan, loadTasks, loadTodosCheckpoint, migratePromptEntry, mutatePlan, mutateTasks, parseEntries, parseProgressFromText, promptChecksum, recordProgress, removePlanItem, resolveAuditLevel, resolveSessionLoggingConfig, runConfigMigrations, sanitizeModel, saveGoal, savePlan, saveTasks, saveTodosCheckpoint, setPlanItemStatus, setProgress, summarizeUsage };
+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, 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, loadDirectorState, loadGoal, loadPlan, loadTasks, loadTodosCheckpoint, migratePromptEntry, mutatePlan, mutateTasks, parseEntries, parseProgressFromText, promptChecksum, recordProgress, removePlanItem, resolveAuditLevel, resolveSessionLoggingConfig, runConfigMigrations, sanitizeModel, saveGoal, savePlan, saveTasks, saveTodosCheckpoint, setPlanItemStatus, setProgress, summarizeUsage, watchProviderConfig };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map