@wrongstack/core 0.257.0 → 0.260.0

package/dist/defaults/index.js

@@ -451,6 +451,40 @@ var DefaultSessionStore = class _DefaultSessionStore {
     this.events = opts.events;
     this.secretScrubber = opts.secretScrubber;
   }
+  // ── Storage event helpers ───────────────────────────────────────────────────
+  emitRead(sessionId, filePath, operation, outcome, durationMs, error) {
+    this.events?.emit("storage.read", {
+      sessionId,
+      store: "session",
+      filePath,
+      operation,
+      outcome,
+      durationMs,
+      ...error !== void 0 ? { error } : {}
+    });
+  }
+  emitWrite(sessionId, filePath, operation, outcome, durationMs, eventCount, error) {
+    this.events?.emit("storage.write", {
+      sessionId,
+      store: "session",
+      filePath,
+      operation,
+      outcome,
+      durationMs,
+      ...eventCount !== void 0 ? { eventCount } : {},
+      ...error !== void 0 ? { error } : {}
+    });
+  }
+  emitError(sessionId, filePath, operation, error, recoverable) {
+    this.events?.emit("storage.error", {
+      sessionId,
+      store: "session",
+      filePath,
+      operation,
+      error,
+      recoverable
+    });
+  }
   /** Absolute path to the session index file. */
   get indexFile() {
     return path11.join(this.dir, "_index.jsonl");
@@ -474,22 +508,26 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const id = meta.id && meta.id.length > 0 ? meta.id : generateSessionId(startedAt, meta.model ?? meta.provider);
     const shardDir = await this.ensureShardDir(id);
     const file = path11.join(shardDir, `${path11.basename(id)}.jsonl`);
+    const t0 = Date.now();
     let handle;
     try {
       handle = await fsp.open(file, "a", 384);
     } catch (err) {
+      this.emitError(id, file, "create", err instanceof Error ? err.message : String(err), false);
       throw new Error(
         `Failed to open session file: ${err instanceof Error ? err.message : String(err)}`,
         { cause: err }
       );
     }
     try {
-      return new FileSessionWriter(id, handle, startedAt, meta, this.events, {
+      const writer = new FileSessionWriter(id, handle, startedAt, meta, this.events, {
         dir: shardDir,
         filePath: file,
         secretScrubber: this.secretScrubber,
         onClose: (s) => this.appendToIndex(s)
       });
+      this.emitWrite(id, file, "create", "success", Date.now() - t0);
+      return writer;
     } catch (err) {
       await handle.close().catch((e) => console.warn(JSON.stringify({
         level: "warn",
@@ -497,16 +535,19 @@ var DefaultSessionStore = class _DefaultSessionStore {
         message: e instanceof Error ? e.message : String(e),
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       })));
+      this.emitError(id, file, "create", err instanceof Error ? err.message : String(err), true);
       throw err;
     }
   }
   async resume(id) {
     const file = this.sessionPath(id, ".jsonl");
+    const t0 = Date.now();
     const data = await this.load(id);
     let handle;
     try {
       handle = await fsp.open(file, "a", 384);
     } catch (err) {
+      this.emitError(id, file, "resume", err instanceof Error ? err.message : String(err), false);
       throw new Error(
         `Failed to open session "${id}" for append: ${err instanceof Error ? err.message : String(err)}`,
         { cause: err }
@@ -534,6 +575,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
           onClose: (s) => this.appendToIndex(s)
         }
       );
+      this.emitWrite(id, file, "resume", "success", Date.now() - t0);
       return { writer, data };
     } catch (err) {
       await handle.close().catch((e) => console.warn(JSON.stringify({
@@ -542,27 +584,39 @@ var DefaultSessionStore = class _DefaultSessionStore {
         message: e instanceof Error ? e.message : String(e),
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       })));
+      this.emitError(id, file, "resume", err instanceof Error ? err.message : String(err), true);
       throw err;
     }
   }
   async load(id) {
     const file = this.sessionPath(id, ".jsonl");
-    const raw = await fsp.readFile(file, "utf8");
-    const lines = raw.split("\n").filter((l) => l.trim());
-    const events = [];
-    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") {
-          events.push(parsed);
+    const t0 = Date.now();
+    let outcome = "success";
+    let errorMsg;
+    try {
+      const raw = await fsp.readFile(file, "utf8");
+      const lines = raw.split("\n").filter((l) => l.trim());
+      const events = [];
+      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") {
+            events.push(parsed);
+          }
+        } catch {
         }
-      } catch {
       }
+      const meta = this.metaFromEvents(id, events);
+      const { messages, usage } = this.replay(events, id);
+      const toolCallEnds = extractToolCallEnds(events);
+      return { metadata: meta, events, messages, usage, toolCallEnds };
+    } catch (err) {
+      outcome = "failure";
+      errorMsg = err instanceof Error ? err.message : String(err);
+      throw err;
+    } finally {
+      this.emitRead(id, file, "load", outcome, Date.now() - t0, errorMsg);
     }
-    const meta = this.metaFromEvents(id, events);
-    const { messages, usage } = this.replay(events, id);
-    const toolCallEnds = extractToolCallEnds(events);
-    return { metadata: meta, events, messages, usage, toolCallEnds };
   }
   async list(limit = 20) {
     try {
@@ -629,12 +683,22 @@ var DefaultSessionStore = class _DefaultSessionStore {
    * (keep latest per session), and rewrite. Atomic via temp+rename.
    */
   async compactIndex() {
-    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 fsp.writeFile(tmp, lines, "utf8");
-    await fsp.rename(tmp, this.indexFile);
+    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 fsp.writeFile(tmp, lines, "utf8");
+      await fsp.rename(tmp, this.indexFile);
+    } catch (err) {
+      outcome = "failure";
+      errorMsg = err instanceof Error ? err.message : String(err);
+    } finally {
+      this.emitWrite("~compact~", this.indexFile, "compact", outcome, Date.now() - t0, void 0, errorMsg);
+    }
   }
   /**
    * Read the index file and return deduplicated session summaries.
@@ -710,22 +774,31 @@ var DefaultSessionStore = class _DefaultSessionStore {
   }
   async summaryFor(id) {
     const manifest = this.sessionPath(id, ".summary.json");
+    const t0 = Date.now();
+    let outcome = "success";
+    let errorMsg;
     try {
       const raw = await fsp.readFile(manifest, "utf8");
+      this.emitRead(id, manifest, "summary", "success", Date.now() - t0);
       return JSON.parse(raw);
     } catch {
       const full = this.sessionPath(id, ".jsonl");
       const stat6 = await fsp.stat(full);
       const summary = await this.summarize(id, stat6.mtime.toISOString());
       await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
+        const msg = err instanceof Error ? err.message : String(err);
+        this.emitError(id, manifest, "summary_fallback", msg, true);
         console.warn(JSON.stringify({
           level: "warn",
           event: "session_store.manifest_write_failed",
           sessionId: id,
-          message: err instanceof Error ? err.message : String(err),
+          message: msg,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         }));
       });
+      outcome = "failure";
+      errorMsg = "summary fallback \u2014 manifest rebuilt";
+      this.emitRead(id, manifest, "summary", outcome, Date.now() - t0, errorMsg);
       return summary;
     }
   }
@@ -991,7 +1064,7 @@ function extractToolCallEnds(events) {
   return result;
 }
 var FileSessionWriter = class _FileSessionWriter {
-  constructor(id, handle, startedAt, meta, events, opts = {}) {
+  constructor(id, handle, startedAt, meta, events, opts = {}, traceId) {
     this.id = id;
     this.handle = handle;
     this.startedAt = startedAt;
@@ -1010,6 +1083,7 @@ var FileSessionWriter = class _FileSessionWriter {
       provider: meta.provider ?? "unknown",
       tokenTotal: 0
     };
+    this.traceId = traceId;
   }
   id;
   handle;
@@ -1042,6 +1116,8 @@ var FileSessionWriter = class _FileSessionWriter {
   lastAppendWarnAt = 0;
   secretScrubber;
   onCloseCb;
+  /** Implements SessionWriter.traceId — propagated from ContextInit.traceId. */
+  traceId;
   // ── Write buffer — batches events to reduce per-event disk I/O ─────────
   //
   // Every append() pushes the scrubbed event into an in-memory buffer instead
@@ -1195,9 +1271,14 @@ var FileSessionWriter = class _FileSessionWriter {
     const eventCount = this.writeBuffer.length;
     const batch = this.writeBuffer.map((e) => JSON.stringify(e)).join("\n") + "\n";
     this.writeBuffer = [];
+    const t0 = Date.now();
+    let outcome = "success";
+    let errorMsg;
     try {
       await this.enqueueWrite(batch);
     } catch (err) {
+      outcome = "failure";
+      errorMsg = err instanceof Error ? err.message : String(err);
       this.appendFailCount += eventCount;
       const now = Date.now();
       if (now - this.lastAppendWarnAt > 5e3) {
@@ -1211,6 +1292,18 @@ var FileSessionWriter = class _FileSessionWriter {
         this.lastAppendWarnAt = now;
         this.appendFailCount = 0;
       }
+    } finally {
+      this.events?.emit("storage.write", {
+        sessionId: this.id,
+        store: "session",
+        filePath: this.filePath,
+        operation: "flush",
+        outcome,
+        durationMs: Date.now() - t0,
+        ...errorMsg !== void 0 ? { error: errorMsg } : {},
+        ...eventCount !== void 0 ? { eventCount } : {},
+        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+      });
     }
   }
   observeForSummary(event) {
@@ -1276,14 +1369,46 @@ var FileSessionWriter = class _FileSessionWriter {
       outcome: this.outcome ?? "completed"
     };
     if (this.manifestFile) {
+      const t0 = Date.now();
+      let outcome = "success";
+      let errorMsg;
       try {
         await atomicWrite(this.manifestFile, JSON.stringify(this.summary), { mode: 384 });
-      } catch {
+      } catch (err) {
+        outcome = "failure";
+        errorMsg = err instanceof Error ? err.message : String(err);
+      } finally {
+        this.events?.emit("storage.write", {
+          sessionId: this.id,
+          store: "session",
+          filePath: this.manifestFile,
+          operation: "close",
+          outcome,
+          durationMs: Date.now() - t0,
+          ...errorMsg !== void 0 ? { error: errorMsg } : {},
+          ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+        });
       }
     }
+    const idxT0 = Date.now();
+    let idxOutcome = "success";
+    let idxError;
     try {
       await this.onCloseCb?.(this.summary);
-    } catch {
+    } catch (err) {
+      idxOutcome = "failure";
+      idxError = err instanceof Error ? err.message : String(err);
+    } finally {
+      this.events?.emit("storage.write", {
+        sessionId: this.summary.id,
+        store: "session",
+        filePath: this.filePath,
+        operation: "index_append",
+        outcome: idxOutcome,
+        durationMs: Date.now() - idxT0,
+        ...idxError !== void 0 ? { error: idxError } : {},
+        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+      });
     }
     try {
       await this.handle.close();
@@ -1445,23 +1570,81 @@ function userInputTitle(content) {
 init_atomic_write();
 var QueueStore = class {
   file;
+  // Use `| undefined` (not `?`) so exactOptionalPropertyTypes doesn't
+  // reject assigning an optional constructor parameter to these fields.
+  events;
+  traceId;
   constructor(opts) {
     this.file = path11.join(opts.dir, "queue.json");
+    this.events = opts.events;
+    this.traceId = opts.traceId;
   }
   async write(items) {
+    const t0 = Date.now();
     if (items.length === 0) {
       await this.clear();
       return;
     }
-    await atomicWrite(this.file, JSON.stringify(items), { mode: 384 });
+    try {
+      await atomicWrite(this.file, JSON.stringify(items), { mode: 384 });
+      this.events?.emit("storage.write", {
+        sessionId: this.traceId ?? "~boot~",
+        store: "queue",
+        filePath: this.file,
+        operation: "write",
+        outcome: "success",
+        durationMs: Date.now() - t0,
+        ...this.traceId !== void 0 && { traceId: this.traceId }
+      });
+    } catch (err) {
+      this.events?.emit("storage.error", {
+        sessionId: this.traceId ?? "~boot~",
+        store: "queue",
+        filePath: this.file,
+        operation: "write",
+        outcome: "failure",
+        error: err instanceof Error ? err.message : String(err),
+        recoverable: false,
+        ...this.traceId !== void 0 && { traceId: this.traceId }
+      });
+      console.warn(JSON.stringify({
+        level: "warn",
+        event: "queue_store.write_failed",
+        path: this.file,
+        message: err instanceof Error ? err.message : String(err),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }));
+    }
   }
   async read() {
+    const t0 = Date.now();
     let raw;
     try {
       raw = await fsp.readFile(this.file, "utf8");
     } catch (err) {
       const code = err.code;
-      if (code === "ENOENT") return [];
+      if (code === "ENOENT") {
+        this.events?.emit("storage.read", {
+          sessionId: this.traceId ?? "~boot~",
+          store: "queue",
+          filePath: this.file,
+          operation: "read",
+          outcome: "success",
+          durationMs: Date.now() - t0,
+          ...this.traceId !== void 0 && { traceId: this.traceId }
+        });
+        return [];
+      }
+      this.events?.emit("storage.error", {
+        sessionId: this.traceId ?? "~boot~",
+        store: "queue",
+        filePath: this.file,
+        operation: "read",
+        outcome: "failure",
+        error: err instanceof Error ? err.message : String(err),
+        recoverable: true,
+        ...this.traceId !== void 0 && { traceId: this.traceId }
+      });
       console.warn(JSON.stringify({
         level: "warn",
         event: "queue_store.read_failed",
@@ -1475,9 +1658,40 @@ var QueueStore = class {
     try {
       parsed = JSON.parse(raw);
     } catch {
+      this.events?.emit("storage.read", {
+        sessionId: this.traceId ?? "~boot~",
+        store: "queue",
+        filePath: this.file,
+        operation: "read",
+        outcome: "failure",
+        durationMs: Date.now() - t0,
+        error: "parse_failed",
+        ...this.traceId !== void 0 && { traceId: this.traceId }
+      });
       return [];
     }
-    if (!Array.isArray(parsed)) return [];
+    if (!Array.isArray(parsed)) {
+      this.events?.emit("storage.read", {
+        sessionId: this.traceId ?? "~boot~",
+        store: "queue",
+        filePath: this.file,
+        operation: "read",
+        outcome: "failure",
+        durationMs: Date.now() - t0,
+        error: "invalid_schema",
+        ...this.traceId !== void 0 && { traceId: this.traceId }
+      });
+      return [];
+    }
+    this.events?.emit("storage.read", {
+      sessionId: this.traceId ?? "~boot~",
+      store: "queue",
+      filePath: this.file,
+      operation: "read",
+      outcome: "success",
+      durationMs: Date.now() - t0,
+      ...this.traceId !== void 0 && { traceId: this.traceId }
+    });
     const out = [];
     for (const v of parsed) {
       if (isPersistedQueueItem(v)) out.push(v);
@@ -1485,11 +1699,31 @@ var QueueStore = class {
     return out;
   }
   async clear() {
+    const t0 = Date.now();
     try {
       await fsp.unlink(this.file);
+      this.events?.emit("storage.write", {
+        sessionId: this.traceId ?? "~boot~",
+        store: "queue",
+        filePath: this.file,
+        operation: "clear",
+        outcome: "success",
+        durationMs: Date.now() - t0,
+        ...this.traceId !== void 0 && { traceId: this.traceId }
+      });
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") return;
+      this.events?.emit("storage.error", {
+        sessionId: this.traceId ?? "~boot~",
+        store: "queue",
+        filePath: this.file,
+        operation: "clear",
+        outcome: "failure",
+        error: err instanceof Error ? err.message : String(err),
+        recoverable: true,
+        ...this.traceId !== void 0 && { traceId: this.traceId }
+      });
       console.warn(JSON.stringify({
         level: "warn",
         event: "queue_store.clear_failed",
@@ -1876,6 +2110,7 @@ var MAX_BYTES_TOTAL = 32e3;
 var DefaultMemoryStore = class {
   files;
   events;
+  traceId;
   backend;
   /**
    * Per-scope serialization queue. `remember` / `forget` / `consolidate` /
@@ -1941,15 +2176,70 @@ var DefaultMemoryStore = class {
       if (writeErr2) {
         parts.push(`> \u26A0\uFE0F Memory write error (${labelOf(scope)}): ${writeErr2.message}`);
       }
-      const body = await this.backend.readAll(scope, this.files[scope]);
-      if (body.trim()) parts.push(`## ${labelOf(scope)}
+      const t0 = Date.now();
+      const filePath = this.files[scope];
+      try {
+        const body = await this.backend.readAll(scope, filePath);
+        const dur = Date.now() - t0;
+        this.events?.emit("storage.read", {
+          sessionId: "~memory~",
+          store: "memory",
+          filePath,
+          operation: "readAll",
+          outcome: "success",
+          durationMs: dur,
+          ...this.traceId !== void 0 && { traceId: this.traceId }
+        });
+        if (body.trim()) parts.push(`## ${labelOf(scope)}
 
 ${body.trim()}`);
+      } catch (err) {
+        const dur = Date.now() - t0;
+        this.events?.emit("storage.read", {
+          sessionId: "~memory~",
+          store: "memory",
+          filePath,
+          operation: "readAll",
+          outcome: "failure",
+          durationMs: dur,
+          error: err instanceof Error ? err.message : String(err),
+          ...this.traceId !== void 0 && { traceId: this.traceId }
+        });
+        throw err;
+      }
     }
     return parts.join("\n\n");
   }
   async read(scope) {
-    return this.backend.readAll(scope, this.files[scope]);
+    const t0 = Date.now();
+    const filePath = this.files[scope];
+    try {
+      const body = await this.backend.readAll(scope, filePath);
+      const dur = Date.now() - t0;
+      this.events?.emit("storage.read", {
+        sessionId: "~memory~",
+        store: "memory",
+        filePath,
+        operation: "read",
+        outcome: "success",
+        durationMs: dur,
+        ...this.traceId !== void 0 && { traceId: this.traceId }
+      });
+      return body;
+    } catch (err) {
+      const dur = Date.now() - t0;
+      this.events?.emit("storage.read", {
+        sessionId: "~memory~",
+        store: "memory",
+        filePath,
+        operation: "read",
+        outcome: "failure",
+        durationMs: dur,
+        error: err instanceof Error ? err.message : String(err),
+        ...this.traceId !== void 0 && { traceId: this.traceId }
+      });
+      throw err;
+    }
   }
   /**
    * List entries from a scope, newest first. Delegates to the backend
@@ -1975,7 +2265,34 @@ ${body.trim()}`);
     const ts = (/* @__PURE__ */ new Date()).toISOString();
     return this.runSerialized(scope, async () => {
       const entry = { scope, text, ts, ...metadata };
-      await this.backend.remember(scope, entry, this.files[scope]);
+      const filePath = this.files[scope];
+      const t0 = Date.now();
+      try {
+        await this.backend.remember(scope, entry, filePath);
+        const dur = Date.now() - t0;
+        this.events?.emit("storage.write", {
+          sessionId: "~memory~",
+          store: "memory",
+          filePath,
+          operation: "remember",
+          outcome: "success",
+          durationMs: dur,
+          ...this.traceId !== void 0 && { traceId: this.traceId }
+        });
+      } catch (err) {
+        const dur = Date.now() - t0;
+        this.events?.emit("storage.write", {
+          sessionId: "~memory~",
+          store: "memory",
+          filePath,
+          operation: "remember",
+          outcome: "failure",
+          durationMs: dur,
+          error: err instanceof Error ? err.message : String(err),
+          ...this.traceId !== void 0 && { traceId: this.traceId }
+        });
+        throw err;
+      }
       const raw = await this.backend.readAll(scope, this.files[scope]);
       if (Buffer.byteLength(raw, "utf8") > MAX_BYTES_TOTAL) {
         const removed = await this.backend.consolidate(scope, this.files[scope]);
@@ -2103,7 +2420,35 @@ ${body.trim()}`);
   }
   async forget(query, scope = "project-memory") {
     return this.runSerialized(scope, async () => {
-      const removed = await this.backend.forget(scope, query, this.files[scope]);
+      const filePath = this.files[scope];
+      const t0 = Date.now();
+      let removed = 0;
+      try {
+        removed = await this.backend.forget(scope, query, filePath);
+        const dur = Date.now() - t0;
+        this.events?.emit("storage.write", {
+          sessionId: "~memory~",
+          store: "memory",
+          filePath,
+          operation: "forget",
+          outcome: "success",
+          durationMs: dur,
+          ...this.traceId !== void 0 && { traceId: this.traceId }
+        });
+      } catch (err) {
+        const dur = Date.now() - t0;
+        this.events?.emit("storage.write", {
+          sessionId: "~memory~",
+          store: "memory",
+          filePath,
+          operation: "forget",
+          outcome: "failure",
+          durationMs: dur,
+          error: err instanceof Error ? err.message : String(err),
+          ...this.traceId !== void 0 && { traceId: this.traceId }
+        });
+        throw err;
+      }
       if (removed > 0) {
         this.events?.emit("memory.forgotten", {
           scope,
@@ -2117,7 +2462,35 @@ ${body.trim()}`);
   }
   async consolidate(scope) {
     return this.runSerialized(scope, async () => {
-      const removed = await this.backend.consolidate(scope, this.files[scope]);
+      const filePath = this.files[scope];
+      const t0 = Date.now();
+      let removed = 0;
+      try {
+        removed = await this.backend.consolidate(scope, filePath);
+        const dur = Date.now() - t0;
+        this.events?.emit("storage.write", {
+          sessionId: "~memory~",
+          store: "memory",
+          filePath,
+          operation: "consolidate",
+          outcome: "success",
+          durationMs: dur,
+          ...this.traceId !== void 0 && { traceId: this.traceId }
+        });
+      } catch (err) {
+        const dur = Date.now() - t0;
+        this.events?.emit("storage.write", {
+          sessionId: "~memory~",
+          store: "memory",
+          filePath,
+          operation: "consolidate",
+          outcome: "failure",
+          durationMs: dur,
+          error: err instanceof Error ? err.message : String(err),
+          ...this.traceId !== void 0 && { traceId: this.traceId }
+        });
+        throw err;
+      }
       if (removed > 0) {
         this.events?.emit("memory.consolidated", {
           scope,
@@ -2130,7 +2503,34 @@ ${body.trim()}`);
   async clear(scope) {
     if (scope) {
       await this.runSerialized(scope, async () => {
-        await this.backend.clear(scope, this.files[scope]);
+        const filePath = this.files[scope];
+        const t0 = Date.now();
+        try {
+          await this.backend.clear(scope, filePath);
+          const dur = Date.now() - t0;
+          this.events?.emit("storage.write", {
+            sessionId: "~memory~",
+            store: "memory",
+            filePath,
+            operation: "clear",
+            outcome: "success",
+            durationMs: dur,
+            ...this.traceId !== void 0 && { traceId: this.traceId }
+          });
+        } catch (err) {
+          const dur = Date.now() - t0;
+          this.events?.emit("storage.write", {
+            sessionId: "~memory~",
+            store: "memory",
+            filePath,
+            operation: "clear",
+            outcome: "failure",
+            durationMs: dur,
+            error: err instanceof Error ? err.message : String(err),
+            ...this.traceId !== void 0 && { traceId: this.traceId }
+          });
+          throw err;
+        }
         this.events?.emit("memory.cleared", { scope });
         await this.mirrorBackup(scope);
       });
@@ -2138,15 +2538,54 @@ ${body.trim()}`);
     }
     await Promise.all(
       ["project-agents", "project-memory", "user-memory"].map(
-        (s) => this.runSerialized(s, async () => {
-          await this.backend.clear(s, this.files[s]);
+        async (s) => this.runSerialized(s, async () => {
+          const filePath = this.files[s];
+          const t0 = Date.now();
+          try {
+            await this.backend.clear(s, filePath);
+            const dur = Date.now() - t0;
+            this.events?.emit("storage.write", {
+              sessionId: "~memory~",
+              store: "memory",
+              filePath,
+              operation: "clear",
+              outcome: "success",
+              durationMs: dur,
+              ...this.traceId !== void 0 && { traceId: this.traceId }
+            });
+          } catch (err) {
+            const dur = Date.now() - t0;
+            this.events?.emit("storage.write", {
+              sessionId: "~memory~",
+              store: "memory",
+              filePath,
+              operation: "clear",
+              outcome: "failure",
+              durationMs: dur,
+              error: err instanceof Error ? err.message : String(err),
+              ...this.traceId !== void 0 && { traceId: this.traceId }
+            });
+            throw err;
+          }
           this.events?.emit("memory.cleared", { scope: s });
           await this.mirrorBackup(s);
         })
       )
     );
   }
-  /** Mirror current memory content to the persistent backup directory. */
+  /**
+   * Return a new MemoryStore proxy that carries `traceId` on every storage
+   * event. The original store is left unchanged — callers that need a
+   * trace-decorated view (e.g. session-run tools) receive the proxy while
+   * the singleton remains trace-free for boot-time use.
+   *
+   * The proxy implements the full `MemoryStore` interface; all other
+   * properties (backend, etc.) are delegated to the original store.
+   */
+  withTraceId(traceId) {
+    this.traceId = traceId;
+    return this;
+  }
   async mirrorBackup(scope) {
     if (!this.persistBackup || scope === "project-agents") return;
     try {
@@ -2796,6 +3235,13 @@ var DEFAULT_SESSION_LOGGING_CONFIG = Object.freeze({
 });
 
 // src/storage/config-loader.ts
+function storageErrorString(err) {
+  if (err instanceof Error) {
+    const code = err.code;
+    return code ? `${code}: ${err.message}` : err.message;
+  }
+  return String(err);
+}
 var BEHAVIOR_DEFAULTS = {
   version: 1,
   context: {
@@ -2898,11 +3344,15 @@ var DefaultConfigLoader = class {
   strict;
   vault;
   extraSources;
+  events;
+  traceId;
   constructor(opts) {
     this.paths = opts.paths;
     this.strict = opts.strict ?? false;
     this.vault = opts.vault;
     this.extraSources = opts.sources ?? [];
+    this.events = opts.events;
+    this.traceId = opts.traceId;
   }
   async load(opts = {}) {
     let cfg = { ...BEHAVIOR_DEFAULTS };
@@ -2979,7 +3429,33 @@ var DefaultConfigLoader = class {
     if (this.vault && toWrite.githubToken && !toWrite.githubToken.startsWith("enc:")) {
       toWrite = { ...toWrite, githubToken: this.vault.encrypt(toWrite.githubToken) };
     }
-    await atomicWrite(this.paths.syncConfig, JSON.stringify(toWrite, null, 2), { mode: 384 });
+    const fp = this.paths.syncConfig;
+    const t0 = Date.now();
+    try {
+      await atomicWrite(fp, JSON.stringify(toWrite, null, 2), { mode: 384 });
+      this.events?.emit("storage.write", {
+        sessionId: "~config~",
+        store: "config",
+        filePath: fp,
+        operation: "persist_sync",
+        outcome: "success",
+        durationMs: Date.now() - t0,
+        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+      });
+    } catch (err) {
+      this.events?.emit("storage.error", {
+        sessionId: "~config~",
+        store: "config",
+        filePath: fp,
+        operation: "persist_sync",
+        outcome: "failure",
+        error: storageErrorString(err),
+        recoverable: false,
+        durationMs: Date.now() - t0,
+        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+      });
+      throw err;
+    }
   }
   /**
    * Read ~/.wrongstack/sync.json (encrypted GitHub token storage) and decrypt
@@ -2988,17 +3464,60 @@ var DefaultConfigLoader = class {
    * isolated — it should never be part of project-local or env-driven config.
    */
   async loadSyncConfig() {
+    const fp = this.paths.syncConfig;
+    const t0 = Date.now();
     try {
-      const raw = await fsp.readFile(this.paths.syncConfig, "utf8");
+      const raw = await fsp.readFile(fp, "utf8");
       const parsed = safeParse(raw);
-      if (!parsed.ok || !parsed.value) return null;
+      if (!parsed.ok || !parsed.value) {
+        this.events?.emit("storage.read", {
+          sessionId: "~config~",
+          store: "config",
+          filePath: fp,
+          operation: "load_sync",
+          outcome: "failure",
+          durationMs: Date.now() - t0,
+          error: "parse error or empty file",
+          ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+        });
+        return null;
+      }
       if (this.vault) {
         const decrypted = decryptConfigSecrets({ sync: parsed.value }, this.vault);
-        return decrypted.sync ?? null;
+        const result = decrypted.sync ?? null;
+        this.events?.emit("storage.read", {
+          sessionId: "~config~",
+          store: "config",
+          filePath: fp,
+          operation: "load_sync",
+          outcome: "success",
+          durationMs: Date.now() - t0,
+          ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+        });
+        return result;
       }
+      this.events?.emit("storage.read", {
+        sessionId: "~config~",
+        store: "config",
+        filePath: fp,
+        operation: "load_sync",
+        outcome: "success",
+        durationMs: Date.now() - t0,
+        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+      });
       return parsed.value;
     } catch (err) {
       if (err.code === "ENOENT") return null;
+      this.events?.emit("storage.read", {
+        sessionId: "~config~",
+        store: "config",
+        filePath: fp,
+        operation: "load_sync",
+        outcome: "failure",
+        durationMs: Date.now() - t0,
+        error: storageErrorString(err),
+        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+      });
       console.warn(JSON.stringify({
         level: "warn",
         event: "config.sync_load_failed",
@@ -3010,10 +3529,21 @@ var DefaultConfigLoader = class {
   }
   async readJson(file) {
     let raw;
+    const t0 = Date.now();
     try {
       raw = await fsp.readFile(file, "utf8");
     } catch (err) {
       if (err.code !== "ENOENT") {
+        this.events?.emit("storage.read", {
+          sessionId: "~config~",
+          store: "config",
+          filePath: file,
+          operation: "read_json",
+          outcome: "failure",
+          durationMs: Date.now() - t0,
+          error: storageErrorString(err),
+          ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+        });
         console.warn(JSON.stringify({
           level: "warn",
           event: "config.read_failed",
@@ -3026,6 +3556,16 @@ var DefaultConfigLoader = class {
     }
     const parsed = safeParse(raw);
     if (!parsed.ok || !parsed.value) {
+      this.events?.emit("storage.read", {
+        sessionId: "~config~",
+        store: "config",
+        filePath: file,
+        operation: "read_json",
+        outcome: "failure",
+        durationMs: Date.now() - t0,
+        error: "parse error or empty file",
+        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+      });
       console.warn(JSON.stringify({
         level: "warn",
         event: "config.parse_failed",
@@ -3813,24 +4353,66 @@ function resolveSessionLoggingConfig(cfg) {
 
 // src/storage/todos-checkpoint.ts
 init_atomic_write();
-async function loadTodosCheckpoint(filePath) {
+async function loadTodosCheckpoint(filePath, events, traceId) {
+  const t0 = Date.now();
   let raw;
   try {
     raw = await fsp.readFile(filePath, "utf8");
-  } catch {
+  } catch (err) {
+    events?.emit("storage.error", {
+      sessionId: traceId ?? "~boot~",
+      store: "todos",
+      filePath,
+      operation: "load",
+      outcome: "failure",
+      error: err instanceof Error ? err.message : String(err),
+      recoverable: true
+    });
     return null;
   }
   try {
     const parsed = JSON.parse(raw);
-    if (parsed?.version !== 1 || !Array.isArray(parsed.todos)) return null;
+    if (parsed?.version !== 1 || !Array.isArray(parsed.todos)) {
+      events?.emit("storage.read", {
+        sessionId: traceId ?? "~boot~",
+        store: "todos",
+        filePath,
+        operation: "load",
+        outcome: "failure",
+        durationMs: Date.now() - t0,
+        error: "invalid_schema",
+        ...traceId !== void 0 && { traceId }
+      });
+      return null;
+    }
+    events?.emit("storage.read", {
+      sessionId: traceId ?? "~boot~",
+      store: "todos",
+      filePath,
+      operation: "load",
+      outcome: "success",
+      durationMs: Date.now() - t0,
+      ...traceId !== void 0 && { traceId }
+    });
     return parsed.todos.filter(
       (t) => !!t && typeof t.id === "string" && typeof t.content === "string" && typeof t.status === "string" && (t.activeForm === void 0 || typeof t.activeForm === "string")
     );
   } catch {
+    events?.emit("storage.read", {
+      sessionId: traceId ?? "~boot~",
+      store: "todos",
+      filePath,
+      operation: "load",
+      outcome: "failure",
+      durationMs: Date.now() - t0,
+      error: "parse_failed",
+      ...traceId !== void 0 && { traceId }
+    });
     return null;
   }
 }
-async function saveTodosCheckpoint(filePath, sessionId, todos) {
+async function saveTodosCheckpoint(filePath, sessionId, todos, events, traceId) {
+  const t0 = Date.now();
   const payload = {
     version: 1,
     sessionId,
@@ -3839,7 +4421,25 @@ async function saveTodosCheckpoint(filePath, sessionId, todos) {
   };
   try {
     await atomicWrite(filePath, JSON.stringify(payload, null, 2), { mode: 384 });
+    events?.emit("storage.write", {
+      sessionId: traceId ?? sessionId,
+      store: "todos",
+      filePath,
+      operation: "save",
+      outcome: "success",
+      durationMs: Date.now() - t0,
+      ...traceId !== void 0 && { traceId }
+    });
   } catch (err) {
+    events?.emit("storage.error", {
+      sessionId: traceId ?? sessionId,
+      store: "todos",
+      filePath,
+      operation: "save",
+      outcome: "failure",
+      error: err instanceof Error ? err.message : String(err),
+      recoverable: false
+    });
     console.warn(JSON.stringify({
       level: "warn",
       event: "todos_checkpoint.save_failed",
@@ -3848,12 +4448,12 @@ async function saveTodosCheckpoint(filePath, sessionId, todos) {
     }));
   }
 }
-function attachTodosCheckpoint(state, filePath, sessionId) {
+function attachTodosCheckpoint(state, filePath, sessionId, events, traceId) {
   let timer = null;
   let pending = null;
   let writeChain = Promise.resolve();
   const enqueueWrite = (todos) => {
-    writeChain = writeChain.then(() => saveTodosCheckpoint(filePath, sessionId, todos)).catch((err) => {
+    writeChain = writeChain.then(() => saveTodosCheckpoint(filePath, sessionId, todos, events, traceId)).catch((err) => {
       const msg = err instanceof Error ? err.message : String(err);
       console.error(JSON.stringify({
         level: "error",
@@ -3895,25 +4495,79 @@ function attachTodosCheckpoint(state, filePath, sessionId) {
 
 // src/storage/plan-store.ts
 init_atomic_write();
-async function loadPlan(filePath) {
+async function loadPlan(filePath, events) {
+  const t0 = Date.now();
   let raw;
   try {
     raw = await fsp.readFile(filePath, "utf8");
-  } catch {
+  } catch (err) {
+    events?.emit("storage.error", {
+      sessionId: "~boot~",
+      store: "plan",
+      filePath,
+      operation: "load",
+      error: err instanceof Error ? err.message : String(err),
+      recoverable: true
+    });
     return null;
   }
   try {
     const parsed = JSON.parse(raw);
-    if (parsed?.version !== 1 || !Array.isArray(parsed.items)) return null;
+    if (parsed?.version !== 1 || !Array.isArray(parsed.items)) {
+      events?.emit("storage.read", {
+        sessionId: "~boot~",
+        store: "plan",
+        filePath,
+        operation: "load",
+        outcome: "failure",
+        durationMs: Date.now() - t0,
+        error: "invalid_schema"
+      });
+      return null;
+    }
+    events?.emit("storage.read", {
+      sessionId: "~boot~",
+      store: "plan",
+      filePath,
+      operation: "load",
+      outcome: "success",
+      durationMs: Date.now() - t0
+    });
     return parsed;
   } catch {
+    events?.emit("storage.read", {
+      sessionId: "~boot~",
+      store: "plan",
+      filePath,
+      operation: "load",
+      outcome: "failure",
+      durationMs: Date.now() - t0,
+      error: "parse_failed"
+    });
     return null;
   }
 }
-async function savePlan(filePath, plan) {
+async function savePlan(filePath, plan, events) {
+  const t0 = Date.now();
   try {
     await atomicWrite(filePath, JSON.stringify(plan, null, 2), { mode: 384 });
+    events?.emit("storage.write", {
+      sessionId: "~boot~",
+      store: "plan",
+      filePath,
+      operation: "save",
+      outcome: "success",
+      durationMs: Date.now() - t0
+    });
   } catch (err) {
+    events?.emit("storage.error", {
+      sessionId: "~boot~",
+      store: "plan",
+      filePath,
+      operation: "save",
+      error: err instanceof Error ? err.message : String(err),
+      recoverable: false
+    });
     console.warn(
       "[plan-store] save failed:",
       err instanceof Error ? err.message : String(err)
@@ -4493,6 +5147,13 @@ function hasDangerousCapabilityForSubagents(toolOrCaps) {
   const caps = Array.isArray(toolOrCaps) ? toolOrCaps : input.capabilities ?? [];
   return caps.some((c) => DANGEROUS_FOR_SUBAGENTS.includes(c));
 }
+function hasCapability(toolOrCaps, capability) {
+  if (!toolOrCaps) return false;
+  const input = toolOrCaps;
+  const caps = Array.isArray(toolOrCaps) ? toolOrCaps : input.capabilities ?? [];
+  const toCheck = Array.isArray(capability) ? capability : [capability];
+  return toCheck.some((c) => caps.includes(c));
+}
 function getDangerousCapabilities(toolOrCaps) {
   if (!toolOrCaps) return [];
   const input = toolOrCaps;
@@ -4856,7 +5517,16 @@ var DefaultPermissionPolicy = class {
         };
       }
     }
-    if (tool.permission === "auto" && !tool.mutating) {
+    const hasWriteCap = hasCapability(tool, ToolCapabilities.FS_WRITE);
+    const hasShellCap = hasCapability(tool, [
+      ToolCapabilities.SHELL_ARBITRARY,
+      ToolCapabilities.SHELL_RESTRICTED
+    ]);
+    const hasInstallCap = hasCapability(tool, ToolCapabilities.PACKAGE_INSTALL);
+    const hasConfigCap = hasCapability(tool, ToolCapabilities.CONFIG_MUTATE);
+    const hasSubagentCap = hasCapability(tool, ToolCapabilities.SUBAGENT_SPAWN);
+    const isMutating = tool.mutating || hasWriteCap || hasShellCap || hasInstallCap || hasConfigCap || hasSubagentCap;
+    if (tool.permission === "auto" && !isMutating) {
       const decision = { permission: "auto", source: "default" };
       this._evalCache.set(cacheKey, decision);
       return decision;
@@ -4875,7 +5545,27 @@ var DefaultPermissionPolicy = class {
     }
     return { permission: "confirm", source: "default" };
   }
+  // Capability-based destructive check (preferred over name-based)
+  isDestructiveByCapability(tool) {
+    const caps = tool.capabilities ?? [];
+    if (caps.includes("shell.arbitrary")) return true;
+    if (caps.includes("fs.write")) return true;
+    if (caps.includes("fs.write.outside-project")) return true;
+    return false;
+  }
   isDestructiveYoloCall(tool, input, ctx) {
+    if (this.isDestructiveByCapability(tool)) {
+      if (tool.name === "bash") {
+        const command = getInputString(input, "command");
+        return command ? isClearlyDestructiveBashCommand(command, ctx.projectRoot) : true;
+      }
+      if (tool.name === "write" || tool.name === "edit" || tool.name === "replace" || tool.name === "patch") {
+        const targetPath = getInputString(input, "path") ?? getInputString(input, "file");
+        if (!targetPath || !ctx.projectRoot) return false;
+        return !pathLooksInsideProject(targetPath, ctx.projectRoot);
+      }
+      return true;
+    }
     if (tool.name === "bash") {
       const command = getInputString(input, "command");
       return command ? isClearlyDestructiveBashCommand(command, ctx.projectRoot) : true;
@@ -5227,6 +5917,8 @@ function compactSkillBody(body) {
 var DefaultSkillLoader = class {
   dirs;
   cache;
+  entriesCache;
+  bodyCache = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.dirs = [
       { dir: opts.paths.inProjectSkills, source: "project" },
@@ -5285,6 +5977,7 @@ var DefaultSkillLoader = class {
     return lines.join("\n");
   }
   async listEntries() {
+    if (this.entriesCache) return this.entriesCache;
     const skills = await this.list();
     const entries = [];
     for (const s of skills) {
@@ -5295,33 +5988,47 @@ var DefaultSkillLoader = class {
       } catch {
       }
     }
+    this.entriesCache = entries;
     return entries;
   }
   invalidateCache() {
     this.cache = void 0;
+    this.entriesCache = void 0;
+    this.bodyCache.clear();
   }
   async readBody(name) {
+    const cached = this.bodyCache.get(name);
+    if (cached !== void 0) return cached;
     const m = await this.find(name);
     if (!m) throw new Error(`Skill "${name}" not found`);
-    return fsp.readFile(m.path, "utf8");
+    const body = await fsp.readFile(m.path, "utf8");
+    this.bodyCache.set(name, body);
+    return body;
   }
   async readSaveBody(name) {
+    const key = `save:${name}`;
+    const cached = this.bodyCache.get(key);
+    if (cached !== void 0) return cached;
     const m = await this.find(name);
     if (!m) throw new Error(`Skill "${name}" not found`);
     const savePath = path11.join(path11.dirname(m.path), "SKILL.save.md");
+    let result;
     try {
-      return await fsp.readFile(savePath, "utf8");
+      result = await fsp.readFile(savePath, "utf8");
     } catch {
       const full = await fsp.readFile(m.path, "utf8");
       const body = stripFrontmatter(full);
       const compact = compactSkillBody(body);
       if (compact) {
-        return `## Overview
+        result = `## Overview
 
 ${compact}`;
+      } else {
+        result = body.trim().slice(0, 300);
       }
-      return body.trim().slice(0, 300);
     }
+    this.bodyCache.set(key, result);
+    return result;
   }
 };
 function parseFrontmatter(raw) {
@@ -8069,13 +8776,32 @@ var MAX_JOURNAL_ENTRIES = 500;
 function goalFilePath(projectRoot) {
   return resolveWstackPaths({ projectRoot }).projectGoal;
 }
-async function loadGoal(filePath) {
+async function loadGoal(filePath, events) {
+  const t0 = Date.now();
   let raw;
   try {
     raw = await fsp.readFile(filePath, "utf8");
   } catch (err) {
     const code = err.code;
-    if (code === "ENOENT") return null;
+    if (code === "ENOENT") {
+      events?.emit("storage.read", {
+        sessionId: "~boot~",
+        store: "goal",
+        filePath,
+        operation: "load",
+        outcome: "success",
+        durationMs: Date.now() - t0
+      });
+      return null;
+    }
+    events?.emit("storage.error", {
+      sessionId: "~boot~",
+      store: "goal",
+      filePath,
+      operation: "load",
+      error: err instanceof Error ? err.message : String(err),
+      recoverable: false
+    });
     throw err;
   }
   try {
@@ -8088,8 +8814,25 @@ async function loadGoal(filePath) {
         message: "invalid schema \u2014 consider deleting and re-creating",
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       }));
+      events?.emit("storage.read", {
+        sessionId: "~boot~",
+        store: "goal",
+        filePath,
+        operation: "load",
+        outcome: "failure",
+        durationMs: Date.now() - t0,
+        error: "invalid_schema"
+      });
       return null;
     }
+    events?.emit("storage.read", {
+      sessionId: "~boot~",
+      store: "goal",
+      filePath,
+      operation: "load",
+      outcome: "success",
+      durationMs: Date.now() - t0
+    });
     return parsed;
   } catch {
     console.warn(JSON.stringify({
@@ -8099,13 +8842,39 @@ async function loadGoal(filePath) {
       message: "JSON parse failed \u2014 consider deleting and re-creating",
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     }));
+    events?.emit("storage.read", {
+      sessionId: "~boot~",
+      store: "goal",
+      filePath,
+      operation: "load",
+      outcome: "failure",
+      durationMs: Date.now() - t0,
+      error: "parse_failed"
+    });
     return null;
   }
 }
-async function saveGoal(filePath, goal) {
+async function saveGoal(filePath, goal, events) {
+  const t0 = Date.now();
   try {
     await atomicWrite(filePath, JSON.stringify(goal, null, 2), { mode: 384 });
+    events?.emit("storage.write", {
+      sessionId: "~boot~",
+      store: "goal",
+      filePath,
+      operation: "save",
+      outcome: "success",
+      durationMs: Date.now() - t0
+    });
   } catch (err) {
+    events?.emit("storage.error", {
+      sessionId: "~boot~",
+      store: "goal",
+      filePath,
+      operation: "save",
+      error: err instanceof Error ? err.message : String(err),
+      recoverable: false
+    });
     throw new FsError({
       message: err instanceof Error ? err.message : String(err),
       code: ERROR_CODES.FS_ATOMIC_WRITE_FAILED,
@@ -8275,7 +9044,7 @@ var EternalAutonomyEngine = class {
     const emit = (stage) => {
       this.opts.onStage?.(stage);
     };
-    const goal = await loadGoal(this.goalPath);
+    const goal = await loadGoal(this.goalPath, this.opts.events);
     if (!goal) {
       emit({ phase: "stopped" });
       this.stopRequested = true;
@@ -8379,7 +9148,7 @@ var EternalAutonomyEngine = class {
     emit({ phase: "reflect", status, note });
     let iterationIndex = 0;
     try {
-      const reloaded = await loadGoal(this.goalPath);
+      const reloaded = await loadGoal(this.goalPath, this.opts.events);
       iterationIndex = reloaded?.iterations ?? 0;
     } catch {
     }
@@ -8699,12 +9468,12 @@ ${recentJournal}` : "No prior iterations.",
     }
   }
   async appendIterationEntry(entry) {
-    const current = await loadGoal(this.goalPath);
+    const current = await loadGoal(this.goalPath, this.opts.events);
     if (!current) {
       return;
     }
     const updated = appendJournal(current, entry);
-    await saveGoal(this.goalPath, updated);
+    await saveGoal(this.goalPath, updated, this.opts.events);
   }
   /**
    * Persistent per-todo failure counter. Skipped silently when the goal
@@ -8713,11 +9482,11 @@ ${recentJournal}` : "No prior iterations.",
    * the counter to rotate past stuck todos once they cross `todoMaxAttempts`.
    */
   async bumpTodoAttempt(todoId) {
-    const current = await loadGoal(this.goalPath);
+    const current = await loadGoal(this.goalPath, this.opts.events);
     if (!current) return;
     const attempts = { ...current.todoAttempts ?? {} };
     attempts[todoId] = (attempts[todoId] ?? 0) + 1;
-    await saveGoal(this.goalPath, { ...current, todoAttempts: attempts });
+    await saveGoal(this.goalPath, { ...current, todoAttempts: attempts }, this.opts.events);
   }
   /**
    * Flip the mission to `completed` and journal it. Called from two
@@ -8727,7 +9496,7 @@ ${recentJournal}` : "No prior iterations.",
    * goal is already `completed`.
    */
   async markGoalCompleted(action, note) {
-    const current = await loadGoal(this.goalPath);
+    const current = await loadGoal(this.goalPath, this.opts.events);
     if (!current) return;
     if (current.goalState === "completed") return;
     const withFlag = { ...current, goalState: "completed" };
@@ -8737,7 +9506,7 @@ ${recentJournal}` : "No prior iterations.",
       status: "success",
       note: note.slice(0, 240)
     });
-    await saveGoal(this.goalPath, withEntry);
+    await saveGoal(this.goalPath, withEntry, this.opts.events);
     this.opts.onEternalStop?.();
   }
   /**
@@ -8746,10 +9515,10 @@ ${recentJournal}` : "No prior iterations.",
    * `onEternalStop` so the REPL returns to normal mode.
    */
   async clearGoalManually(note) {
-    const current = await loadGoal(this.goalPath);
+    const current = await loadGoal(this.goalPath, this.opts.events);
     if (current) {
       const abandoned = { ...current, goalState: "abandoned" };
-      await saveGoal(this.goalPath, abandoned);
+      await saveGoal(this.goalPath, abandoned, this.opts.events);
     }
     try {
       const { unlink: unlink10 } = await import('fs/promises');
@@ -8825,16 +9594,16 @@ ${recentJournal}` : ""
    * Persist a progress update from the agent's [PROGRESS: N%] output.
    */
   async updateProgress(progress, note) {
-    const current = await loadGoal(this.goalPath);
+    const current = await loadGoal(this.goalPath, this.opts.events);
     if (!current) return;
     const updated = recordProgress(current, progress, note);
-    await saveGoal(this.goalPath, updated);
+    await saveGoal(this.goalPath, updated, this.opts.events);
   }
   async persistEngineState(state) {
-    const current = await loadGoal(this.goalPath);
+    const current = await loadGoal(this.goalPath, this.opts.events);
     if (!current) return;
     if (current.engineState === state) return;
-    await saveGoal(this.goalPath, { ...current, engineState: state });
+    await saveGoal(this.goalPath, { ...current, engineState: state }, this.opts.events);
   }
 };
 
@@ -9183,6 +9952,20 @@ var SubagentBudget = class _SubagentBudget {
 };
 
 // src/coordination/agent-subagent-runner.ts
+function withDisabledToolFiltering(factory) {
+  return async (config) => {
+    const result = await factory(config);
+    const disabled = config.disabledTools ?? [];
+    if (disabled.length === 0) return result;
+    const registry = result.agent.tools;
+    if (registry && typeof registry.unregister === "function") {
+      for (const toolName of disabled) {
+        registry.unregister(toolName);
+      }
+    }
+    return result;
+  };
+}
 function makeAgentSubagentRunner(opts) {
   const format = opts.formatTaskInput ?? defaultFormatTaskInput;
   return async (task, ctx) => {
@@ -12006,17 +12789,17 @@ function normalize(text) {
   return ` ${text.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim()} `;
 }
 function scoreAgents(task, catalog = AGENT_CATALOG) {
-  const hay = normalize(task);
+  const haySet = new Set(normalize(task).split(/\s+/).filter(Boolean));
   const out = [];
   for (const def of Object.values(catalog)) {
     if (!def?.config?.role) continue;
     let score = 0;
     const matched = [];
     for (const kw of def.capability.keywords) {
-      const needle = normalize(kw);
-      if (hay.includes(needle.trimEnd() + " ") || hay.includes(" " + needle.trimStart())) {
-        const words = kw.trim().split(/\s+/).length;
-        score += words;
+      const needleWords = normalize(kw).split(/\s+/).filter(Boolean);
+      const allPresent = needleWords.every((w) => haySet.has(w));
+      if (allPresent) {
+        score += needleWords.length;
         matched.push(kw);
       }
     }
@@ -13349,7 +14132,8 @@ var ParallelEternalEngine = class {
       doneCondition: { type: "all_tasks_done" }
     };
     this.coordinator = new DefaultMultiAgentCoordinator(config);
-    const runner = makeAgentSubagentRunner({ factory: this.agentFactory });
+    const filteredFactory = withDisabledToolFiltering(this.agentFactory);
+    const runner = makeAgentSubagentRunner({ factory: filteredFactory });
     this.coordinator.setRunner?.(runner);
     try {
       while (!this.stopRequested) {
@@ -13384,7 +14168,7 @@ var ParallelEternalEngine = class {
       this.opts.onStage?.(stage);
     };
     this.iterations++;
-    const goal = await loadGoal(this.goalPath);
+    const goal = await loadGoal(this.goalPath, this.opts.events);
     if (!goal) {
       this.stopRequested = true;
       emit({ phase: "stopped" });
@@ -13402,7 +14186,8 @@ var ParallelEternalEngine = class {
         doneCondition: { type: "all_tasks_done" }
       };
       this.coordinator = new DefaultMultiAgentCoordinator(config);
-      const runner = makeAgentSubagentRunner({ factory: this.agentFactory });
+      const filteredFactory = withDisabledToolFiltering(this.agentFactory);
+      const runner = makeAgentSubagentRunner({ factory: filteredFactory });
       this.coordinator.setRunner?.(runner);
     }
     emit({ phase: "decompose" });
@@ -13511,13 +14296,17 @@ ${personaLine}Task: ${task}
                 role: route.role,
                 tools: route.definition.config.tools,
                 systemPromptOverride: route.definition.config.prompt,
-                timeoutMs: this.timeoutMs
+                timeoutMs: this.timeoutMs,
+                // Disable delegation — subagents are leaf workers, not orchestrators
+                disabledTools: ["delegate"]
               } : {
                 id: subagentId,
                 name: `slot-${subagentId.slice(-6)}`,
                 // Let the coordinator apply its default budget (roster or generic).
                 // Hardcoding low limits here defeats the x10 budget improvement.
-                timeoutMs: this.timeoutMs
+                timeoutMs: this.timeoutMs,
+                // Disable delegation — subagents are leaf workers, not orchestrators
+                disabledTools: ["delegate"]
               }
             );
             subagentIds.push(subagentId);
@@ -13663,10 +14452,10 @@ ${lastFew}` : "No prior iterations.",
   // Helpers
   // -------------------------------------------------------------------------
   async appendIterationEntry(entry) {
-    const current = await loadGoal(this.goalPath);
+    const current = await loadGoal(this.goalPath, this.opts.events);
     if (!current) return;
     const updated = appendJournal(current, entry);
-    await saveGoal(this.goalPath, updated);
+    await saveGoal(this.goalPath, updated, this.opts.events);
     const entryWithMeta = {
       at: (this.opts.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
       iteration: updated.iterations,
@@ -13678,10 +14467,10 @@ ${lastFew}` : "No prior iterations.",
     await this.appendIterationEntry({ source: "manual", task, status: "failure", note });
   }
   async persistState(state) {
-    const current = await loadGoal(this.goalPath);
+    const current = await loadGoal(this.goalPath, this.opts.events);
     if (!current) return;
     if (current.engineState === state) return;
-    await saveGoal(this.goalPath, { ...current, engineState: state });
+    await saveGoal(this.goalPath, { ...current, engineState: state }, this.opts.events);
   }
 };
 
@@ -14707,6 +15496,7 @@ Emit each evaluation immediately. Do not wait until you have read all reports.`;
     }
     for (const dispose of this.disposers) dispose();
     this.disposers.length = 0;
+    this.snapshot.files.length = 0;
   }
 };
 
@@ -14740,7 +15530,12 @@ Working rules:
   6. Never claim a subagent's work as your own without verifying it. If a
      result looks wrong, ask_subagent for clarification before passing it
      to the user.
-  7. Wind down when satisfied. When the results are good enough, call
+  7. **Act on subagent mail immediately**. Subagent messages (result, ask,
+     assign, note) are injected inline before every step \u2014 even mid-task.
+     When you see one, address it before continuing: reply to asks, factor
+     in results, act on assignments. Use \`mailbox action=ack\` to mark
+     completed messages.
+  8. Wind down when satisfied. When the results are good enough, call
      work_complete \u2014 no new subagents will spawn and queued tasks complete
      as aborted. Running subagents finish naturally. Call terminate_subagent
      only for ones you need to stop immediately.`;
@@ -14757,6 +15552,13 @@ Bridge contract:
     structured, and self-contained \u2014 assume the Director will paste your
     output into its own context.
 
+CRITICAL CONSTRAINT \u2014 NO FURTHER DELEGATION:
+  - You MUST NOT call the \`delegate\` tool or attempt to spawn subagents.
+  - You MUST NOT use \`spawn_subagent\`, \`assign_task\`, or any equivalent.
+  - Your role is to execute the assigned task yourself, not to orchestrate.
+  - If a subtask is too complex, report back to the Director with what you
+    found and let the Director decide how to decompose.
+
 Inter-agent mailbox (if you have the \`mail_send\`/\`mail_inbox\`/\`mailbox\` tools):
   - You are part of a project-wide fleet that may span other terminals and
     WebUIs. Your mailbox identity is \`<your-name>@<session-tag>\` (unique
@@ -14771,7 +15573,12 @@ Inter-agent mailbox (if you have the \`mail_send\`/\`mail_inbox\`/\`mailbox\` to
     their exact id instead of doing everything yourself. Discover ids with
     \`mailbox action=online\`.
   - Answer your mail: reply to the sender's exact \`from\` id. When done with
-    an assigned task, post a \`result\` back to whoever assigned it.`;
+    an assigned task, post a \`result\` back to whoever assigned it.
+  - **Mail to the leader is always seen**: when you send \`ask\`, \`result\`,
+    or \`assign\` to the director/leader, the message is injected inline into
+    the leader's conversation before their next step \u2014 even if the leader is
+    mid-task. Use \`mail_send\` to reliably reach the leader instead of
+    waiting for them to check in.`;
 function composeDirectorPrompt(parts = {}) {
   const sections = [];
   const preamble = parts.directorPreamble ?? DEFAULT_DIRECTOR_PREAMBLE;
@@ -17168,6 +17975,7 @@ async function readSubagentPartial(opts, subagentId) {
 }
 function makeDirectorSessionFactory(opts) {
   const runId = opts.directorRunId ?? `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-director`;
+  const { traceId } = opts;
   let store;
   let dir;
   if (opts.store) {
@@ -17183,12 +17991,16 @@ function makeDirectorSessionFactory(opts) {
     dir,
     directorRunId: runId,
     async createSubagentSession({ subagentId, provider, model, title }) {
-      return store.create({
+      const writer = await store.create({
         id: subagentId,
         title: title ?? subagentId,
         provider: provider ?? "unknown",
         model: model ?? "unknown"
       });
+      if (traceId !== void 0) {
+        writer.traceId = traceId;
+      }
+      return writer;
     }
   };
 }
@@ -20632,7 +21444,9 @@ var SddParallelRun = class {
       doneCondition: { type: "all_tasks_done" }
     };
     this.coordinator = new DefaultMultiAgentCoordinator(config);
-    const runner = makeAgentSubagentRunner({ factory: this.opts.subagentFactory ?? this.defaultFactory() });
+    const baseFactory = this.opts.subagentFactory ?? this.defaultFactory();
+    const filteredFactory = withDisabledToolFiltering(baseFactory);
+    const runner = makeAgentSubagentRunner({ factory: filteredFactory });
     this.coordinator.setRunner?.(runner);
   }
   defaultFactory() {
@@ -20674,7 +21488,9 @@ var SddParallelRun = class {
         id: subagentId,
         name: subagentId,
         role: "executor",
-        timeoutMs: this.timeoutMs
+        timeoutMs: this.timeoutMs,
+        // Disable delegation — subagents are leaf workers, not orchestrators
+        disabledTools: ["delegate"]
       })
     );
     const spawnResults = await Promise.all(spawns);