@wrongstack/core 0.257.2 → 0.260.0

package/dist/index.js

@@ -4279,6 +4279,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;
@@ -5052,6 +5059,12 @@ var Context = class {
   agentId;
   /** Human-readable agent name. */
   agentName;
+  /**
+   * Session-level trace ID for correlating storage events with agent
+   * iterations. Stored here and also propagated to `session.traceId`
+   * so storage operations can include it in `storage.*` events.
+   */
+  traceId;
   /** Callbacks fired when `setWorkingDir()` changes the working directory. */
   _onWorkingDirChanged = [];
   /**
@@ -5087,6 +5100,8 @@ var Context = class {
     this.tools = init.tools ?? [];
     this.agentId = init.agentId ?? "unknown";
     this.agentName = init.agentName ?? "Unknown Agent";
+    this.traceId = init.traceId;
+    this.session.traceId = init.traceId;
   }
   /**
    * Observable wrapper over the mutable conversation state. Lazy so
@@ -6487,6 +6502,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 path7.join(this.dir, "_index.jsonl");
@@ -6510,22 +6559,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 = path7.join(shardDir, `${path7.basename(id)}.jsonl`);
+    const t0 = Date.now();
     let handle;
     try {
       handle = await fsp3.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",
@@ -6533,16 +6586,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 fsp3.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 }
@@ -6570,6 +6626,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({
@@ -6578,27 +6635,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 fsp3.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 fsp3.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 {
@@ -6665,12 +6734,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 fsp3.writeFile(tmp, lines, "utf8");
-    await fsp3.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 fsp3.writeFile(tmp, lines, "utf8");
+      await fsp3.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.
@@ -6746,22 +6825,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 fsp3.readFile(manifest, "utf8");
+      this.emitRead(id, manifest, "summary", "success", Date.now() - t0);
       return JSON.parse(raw);
     } catch {
       const full = this.sessionPath(id, ".jsonl");
       const stat11 = await fsp3.stat(full);
       const summary = await this.summarize(id, stat11.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;
     }
   }
@@ -7027,7 +7115,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;
@@ -7046,6 +7134,7 @@ var FileSessionWriter = class _FileSessionWriter {
       provider: meta.provider ?? "unknown",
       tokenTotal: 0
     };
+    this.traceId = traceId;
   }
   id;
   handle;
@@ -7078,6 +7167,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
@@ -7231,9 +7322,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) {
@@ -7247,6 +7343,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) {
@@ -7312,14 +7420,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();
@@ -7481,23 +7621,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 = path7.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 fsp3.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",
@@ -7511,9 +7709,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)) {
+      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 [];
     }
-    if (!Array.isArray(parsed)) 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);
@@ -7521,11 +7750,31 @@ var QueueStore = class {
     return out;
   }
   async clear() {
+    const t0 = Date.now();
     try {
       await fsp3.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",
@@ -7900,6 +8149,7 @@ var MAX_BYTES_TOTAL = 32e3;
 var DefaultMemoryStore = class {
   files;
   events;
+  traceId;
   backend;
   /**
    * Per-scope serialization queue. `remember` / `forget` / `consolidate` /
@@ -7965,15 +8215,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
@@ -7999,7 +8304,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]);
@@ -8127,7 +8459,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,
@@ -8141,7 +8501,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,
@@ -8154,7 +8542,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);
       });
@@ -8162,15 +8577,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 {
@@ -8264,6 +8718,13 @@ function deepFreeze(obj) {
   return Object.freeze(obj);
 }
 init_atomic_write();
+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: {
@@ -8366,11 +8827,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 };
@@ -8447,7 +8912,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
@@ -8456,17 +8947,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 fsp3.readFile(this.paths.syncConfig, "utf8");
+      const raw = await fsp3.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",
@@ -8478,10 +9012,21 @@ var DefaultConfigLoader = class {
   }
   async readJson(file) {
     let raw;
+    const t0 = Date.now();
     try {
       raw = await fsp3.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",
@@ -8494,6 +9039,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",
@@ -8969,24 +9524,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 fsp3.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(
       (t2) => !!t2 && typeof t2.id === "string" && typeof t2.content === "string" && typeof t2.status === "string" && (t2.activeForm === void 0 || typeof t2.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,
@@ -8995,7 +9592,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",
@@ -9004,12 +9619,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",
@@ -9051,25 +9666,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 fsp3.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)
@@ -9753,7 +10422,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;
@@ -9772,7 +10450,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;
@@ -11441,13 +12139,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 fsp3.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 {
@@ -11460,8 +12177,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({
@@ -11471,13 +12205,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,
@@ -11923,7 +12683,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;
@@ -12027,7 +12787,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 {
     }
@@ -12347,12 +13107,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
@@ -12361,11 +13121,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
@@ -12375,7 +13135,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" };
@@ -12385,7 +13145,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?.();
   }
   /**
@@ -12394,10 +13154,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: unlink16 } = await import('fs/promises');
@@ -12473,16 +13233,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);
   }
 };
 
@@ -12831,6 +13591,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) => {
@@ -16997,7 +17771,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) {
@@ -17032,7 +17807,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" });
@@ -17050,7 +17825,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" });
@@ -17159,13 +17935,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);
@@ -17311,10 +18091,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,
@@ -17326,10 +18106,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);
   }
 };
 
@@ -18109,7 +18889,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.`;
@@ -18126,6 +18911,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
@@ -18140,7 +18932,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;
@@ -20549,6 +21346,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) {
@@ -20564,12 +21362,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;
     }
   };
 }
@@ -23288,7 +24090,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() {
@@ -23330,7 +24134,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);
@@ -25417,20 +26223,53 @@ var MAX_TEXT_LENGTH = 2e3;
 var MAX_ANNOTATIONS = 1e3;
 var AnnotationsStore = class {
   dir;
+  events;
+  traceId;
   /** Per-session write queue. Created lazily on first add. */
   writeChains = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.dir = opts.dir;
+    this.events = opts.events;
+    this.traceId = opts.traceId;
   }
   // ── Reads ──────────────────────────────────────────────────────────────
   /**
    * Return all annotations for `sessionId` in insertion order
    * (oldest first). Returns an empty array when no file exists
-   * yet (the normal case for a fresh session).
+   * yet (the normal case for a fresh session) and also degrades
+   * gracefully to `[]` on a read error (permissions, corruption) —
+   * the failure is still surfaced via a `storage.read` event so it
+   * never silently hides I/O problems from observers.
    */
   async list(sessionId) {
-    const file = await this.readFile(sessionId);
-    return file ? file.annotations : [];
+    const t0 = Date.now();
+    const fp = this.filePath(sessionId);
+    try {
+      const file = await this.readFile(sessionId);
+      const durationMs = Date.now() - t0;
+      this.events?.emit("storage.read", {
+        sessionId,
+        store: "annotations",
+        filePath: fp,
+        operation: "list",
+        outcome: "success",
+        durationMs,
+        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+      });
+      return file ? file.annotations : [];
+    } catch (err) {
+      this.events?.emit("storage.read", {
+        sessionId,
+        store: "annotations",
+        filePath: fp,
+        operation: "list",
+        outcome: "failure",
+        durationMs: Date.now() - t0,
+        error: err instanceof Error ? err.message : String(err),
+        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+      });
+      return [];
+    }
   }
   /**
    * Convenience: only unresolved annotations, newest first — the
@@ -25482,25 +26321,62 @@ var AnnotationsStore = class {
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       resolved: false
     };
-    await this.enqueue(input.sessionId, async () => {
-      await withFileLock(this.filePath(input.sessionId), async () => {
-        const all = await this.list(input.sessionId);
-        all.push(annotation);
-        if (all.length > MAX_ANNOTATIONS) {
-          const sorted = all.map((a, i) => ({ a, i })).sort((x, y) => {
-            if (x.a.resolved !== y.a.resolved) return x.a.resolved ? 1 : -1;
-            return x.a.createdAt.localeCompare(y.a.createdAt);
-          });
-          const evictCount = all.length - MAX_ANNOTATIONS;
-          const toEvict = new Set(sorted.slice(0, evictCount).map((s) => s.a.id));
-          const kept = all.filter((a) => !toEvict.has(a.id));
-          await this.writeFile(input.sessionId, { version: FILE_VERSION, annotations: kept });
-        } else {
-          await this.writeFile(input.sessionId, { version: FILE_VERSION, annotations: all });
-        }
+    const fp = this.filePath(input.sessionId);
+    const t0 = Date.now();
+    try {
+      await this.enqueue(input.sessionId, async () => {
+        await withFileLock(fp, async () => {
+          const all = await this.list(input.sessionId);
+          all.push(annotation);
+          if (all.length > MAX_ANNOTATIONS) {
+            const sorted = all.map((a, i) => ({ a, i })).sort((x, y) => {
+              if (x.a.resolved !== y.a.resolved) return x.a.resolved ? 1 : -1;
+              return x.a.createdAt.localeCompare(y.a.createdAt);
+            });
+            const evictCount = all.length - MAX_ANNOTATIONS;
+            const toEvict = new Set(sorted.slice(0, evictCount).map((s) => s.a.id));
+            const kept = all.filter((a) => !toEvict.has(a.id));
+            await this.writeFile(input.sessionId, { version: FILE_VERSION, annotations: kept });
+            const durationMs = Date.now() - t0;
+            this.events?.emit("storage.write", {
+              sessionId: input.sessionId,
+              store: "annotations",
+              filePath: fp,
+              operation: "evict",
+              outcome: "success",
+              durationMs,
+              ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+            });
+          } else {
+            await this.writeFile(input.sessionId, { version: FILE_VERSION, annotations: all });
+            const durationMs = Date.now() - t0;
+            this.events?.emit("storage.write", {
+              sessionId: input.sessionId,
+              store: "annotations",
+              filePath: fp,
+              operation: "add",
+              outcome: "success",
+              durationMs,
+              ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+            });
+          }
+        });
       });
-    });
-    return annotation;
+      return annotation;
+    } catch (err) {
+      this.events?.emit("storage.error", {
+        sessionId: input.sessionId,
+        store: "annotations",
+        filePath: fp,
+        operation: "add",
+        outcome: "failure",
+        error: err instanceof Error ? err.message : String(err),
+        recoverable: false,
+        durationMs: Date.now() - t0,
+        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+      });
+      throw err;
+    }
   }
   /**
    * Mark an annotation as resolved. Returns the updated record, or
@@ -25510,26 +26386,53 @@ var AnnotationsStore = class {
    */
   async resolve(input) {
     let updated = null;
-    await this.enqueue(input.sessionId, async () => {
-      await withFileLock(this.filePath(input.sessionId), async () => {
-        const all = await this.list(input.sessionId);
-        const idx = all.findIndex((a) => a.id === input.annotationId);
-        if (idx === -1) {
-          updated = null;
-          return;
-        }
-        const next = {
-          ...expectDefined(all[idx]),
-          resolved: true,
-          resolvedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          resolvedBy: input.resolvedBy
-        };
-        all[idx] = next;
-        await this.writeFile(input.sessionId, { version: FILE_VERSION, annotations: all });
-        updated = next;
+    const fp = this.filePath(input.sessionId);
+    const t0 = Date.now();
+    try {
+      await this.enqueue(input.sessionId, async () => {
+        await withFileLock(fp, async () => {
+          const all = await this.list(input.sessionId);
+          const idx = all.findIndex((a) => a.id === input.annotationId);
+          if (idx === -1) {
+            updated = null;
+            return;
+          }
+          const next = {
+            ...expectDefined(all[idx]),
+            resolved: true,
+            resolvedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            resolvedBy: input.resolvedBy
+          };
+          all[idx] = next;
+          await this.writeFile(input.sessionId, { version: FILE_VERSION, annotations: all });
+          updated = next;
+          const durationMs = Date.now() - t0;
+          this.events?.emit("storage.write", {
+            sessionId: input.sessionId,
+            store: "annotations",
+            filePath: fp,
+            operation: "resolve",
+            outcome: "success",
+            durationMs,
+            ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+          });
+        });
       });
-    });
-    return updated;
+      return updated;
+    } catch (err) {
+      this.events?.emit("storage.error", {
+        sessionId: input.sessionId,
+        store: "annotations",
+        filePath: fp,
+        operation: "resolve",
+        outcome: "failure",
+        error: err instanceof Error ? err.message : String(err),
+        recoverable: false,
+        durationMs: Date.now() - t0,
+        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+      });
+      throw err;
+    }
   }
   // ── Internals ──────────────────────────────────────────────────────────
   filePath(sessionId) {
@@ -25537,16 +26440,21 @@ var AnnotationsStore = class {
   }
   async readFile(sessionId) {
     const fp = this.filePath(sessionId);
+    let raw;
+    try {
+      raw = await fsp3.readFile(fp, "utf8");
+    } catch (err) {
+      if (err.code === "ENOENT") return null;
+      throw err;
+    }
     try {
-      const raw = await fsp3.readFile(fp, "utf8");
       const parsed = JSON.parse(raw);
       if (parsed.version !== FILE_VERSION) {
         return { version: FILE_VERSION, annotations: [] };
       }
       return parsed;
-    } catch (err) {
-      if (err.code === "ENOENT") return null;
-      return { version: FILE_VERSION, annotations: [] };
+    } catch {
+      return null;
     }
   }
   async writeFile(sessionId, file) {
@@ -25603,9 +26511,20 @@ function hashRequest(request) {
   const digest = createHash("sha256").update(json, "utf8").digest("hex");
   return `sha256:${digest}`;
 }
+
+// src/storage/replay-log-store.ts
+function storageErrorString2(err) {
+  if (err instanceof Error) {
+    const code = err.code;
+    return code ? `${code}: ${err.message}` : err.message;
+  }
+  return String(err);
+}
 var DEFAULT_MAX_ENTRIES = 1e3;
 var ReplayLogStore = class {
   dir;
+  events;
+  traceId;
   writeChains = /* @__PURE__ */ new Map();
   /** Per-session hash → entry index, kept in memory after the first load. */
   cache = /* @__PURE__ */ new Map();
@@ -25614,6 +26533,8 @@ var ReplayLogStore = class {
   maxEntries;
   constructor(opts) {
     this.dir = opts.dir;
+    this.events = opts.events;
+    this.traceId = opts.traceId;
     this.maxEntries = opts.maxEntries ?? DEFAULT_MAX_ENTRIES;
   }
   // ── Writes ──────────────────────────────────────────────────────────────
@@ -25624,38 +26545,43 @@ var ReplayLogStore = class {
    */
   async record(input) {
     const hash = hashRequest(input.request);
-    await this.enqueue(input.sessionId, async () => {
-      await withFileLock(this.filePath(input.sessionId), async () => {
-        const entries = await this.readAll(input.sessionId);
-        if (entries.some((entry2) => entry2.hash === hash)) return;
-        const entry = {
-          hash,
-          ts: (/* @__PURE__ */ new Date()).toISOString(),
-          request: input.request,
-          response: input.response
-        };
-        entries.push(entry);
-        const keep = entries.slice(-this.maxEntries);
-        const cache = /* @__PURE__ */ new Map();
-        for (const e of keep) cache.set(e.hash, e);
-        this.cache.set(input.sessionId, cache);
-        await this.rewriteCache(input.sessionId, cache);
+    const fp = this.filePath(input.sessionId);
+    const t0 = Date.now();
+    try {
+      await this.enqueue(input.sessionId, async () => {
+        await withFileLock(this.filePath(input.sessionId), async () => {
+          const entries = await this.readAll(input.sessionId);
+          if (entries.some((entry2) => entry2.hash === hash)) return;
+          const entry = {
+            hash,
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            request: input.request,
+            response: input.response
+          };
+          entries.push(entry);
+          const keep = entries.slice(-this.maxEntries);
+          const didEvict = keep.length < entries.length;
+          const cache = /* @__PURE__ */ new Map();
+          for (const e of keep) cache.set(e.hash, e);
+          this.cache.set(input.sessionId, cache);
+          await this.writeAll(input.sessionId, keep, didEvict ? "compact" : "record");
+        });
       });
-    });
-    return hash;
-  }
-  /**
-   * Compact the replay log to keep only the most recent maxEntries.
-   * Called when entry count exceeds the cap. Rewrites the entire file
-   * but only happens O(n / maxEntries) times per session.
-   */
-  async rewriteCache(sessionId, cache) {
-    const all = [...cache.values()];
-    const keep = all.slice(-this.maxEntries);
-    await this.writeAll(sessionId, keep);
-    cache.clear();
-    for (const e of keep) cache.set(e.hash, e);
-    this.diskCount.set(sessionId, keep.length);
+      return hash;
+    } catch (err) {
+      this.events?.emit("storage.error", {
+        sessionId: input.sessionId,
+        store: "replay",
+        filePath: fp,
+        operation: "record",
+        outcome: "failure",
+        error: storageErrorString2(err),
+        recoverable: false,
+        durationMs: Date.now() - t0,
+        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+      });
+      throw err;
+    }
   }
   // ── Reads ───────────────────────────────────────────────────────────────
   /**
@@ -25664,13 +26590,65 @@ var ReplayLogStore = class {
    * per session (in-memory cache).
    */
   async lookup(sessionId, hash) {
-    const cache = await this.ensureCache(sessionId);
-    return cache.get(hash) ?? null;
+    const fp = this.filePath(sessionId);
+    const t0 = Date.now();
+    try {
+      const cache = await this.ensureCache(sessionId);
+      this.events?.emit("storage.read", {
+        sessionId,
+        store: "replay",
+        filePath: fp,
+        operation: "lookup",
+        outcome: "success",
+        durationMs: Date.now() - t0,
+        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+      });
+      return cache.get(hash) ?? null;
+    } catch (err) {
+      this.events?.emit("storage.read", {
+        sessionId,
+        store: "replay",
+        filePath: fp,
+        operation: "lookup",
+        outcome: "failure",
+        durationMs: Date.now() - t0,
+        error: storageErrorString2(err),
+        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+      });
+      throw err;
+    }
   }
   /** All recorded entries for a session, in insertion order. */
   async load(sessionId) {
-    const cache = await this.ensureCache(sessionId);
-    return [...cache.values()];
+    const fp = this.filePath(sessionId);
+    const t0 = Date.now();
+    try {
+      const cache = await this.ensureCache(sessionId);
+      const durationMs = Date.now() - t0;
+      this.events?.emit("storage.read", {
+        sessionId,
+        store: "replay",
+        filePath: fp,
+        operation: "load",
+        outcome: "success",
+        durationMs,
+        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+      });
+      return [...cache.values()];
+    } catch (err) {
+      const durationMs = Date.now() - t0;
+      this.events?.emit("storage.read", {
+        sessionId,
+        store: "replay",
+        filePath: fp,
+        operation: "load",
+        outcome: "failure",
+        durationMs,
+        error: storageErrorString2(err),
+        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+      });
+      throw err;
+    }
   }
   /**
    * List every session id that has a replay log in the store dir.
@@ -25740,13 +26718,24 @@ var ReplayLogStore = class {
       return out;
     } catch (err) {
       if (err.code === "ENOENT") return [];
-      return [];
+      throw err;
     }
   }
-  async writeAll(sessionId, entries) {
+  async writeAll(sessionId, entries, operation = "record") {
     const fp = this.filePath(sessionId);
+    const t0 = Date.now();
     const body = entries.map((e) => JSON.stringify(e)).join("\n") + (entries.length ? "\n" : "");
     await atomicWrite(fp, body);
+    const durationMs = Date.now() - t0;
+    this.events?.emit("storage.write", {
+      sessionId,
+      store: "replay",
+      filePath: fp,
+      operation,
+      outcome: "success",
+      durationMs,
+      ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+    });
   }
   async ensureCache(sessionId) {
     let cache = this.cache.get(sessionId);
@@ -25927,6 +26916,8 @@ var GENESIS_PREV = "0".repeat(64);
 var DEFAULT_FSYNC_EVERY = 100;
 var ToolAuditLog = class {
   dir;
+  events;
+  traceId;
   /** In-memory cache of the last entry's hash (per session), to compute chains efficiently. */
   tailHash = /* @__PURE__ */ new Map();
   /** In-memory counter for entry indices — avoids re-reading the file on every write. */
@@ -25937,6 +26928,8 @@ var ToolAuditLog = class {
   fsyncEvery;
   constructor(opts) {
     this.dir = opts.dir;
+    this.events = opts.events;
+    this.traceId = opts.traceId;
     this.fsyncEvery = opts.fsyncEvery ?? DEFAULT_FSYNC_EVERY;
   }
   /**
@@ -25947,96 +26940,180 @@ var ToolAuditLog = class {
    */
   async record(input) {
     let entry;
-    await this.enqueue(input.sessionId, async () => {
-      await withFileLock(this.filePath(input.sessionId), async () => {
-        const entries = await this.readAll(input.sessionId);
-        const prev = entries.at(-1);
-        const prevHash = prev?.hash ?? GENESIS_PREV;
-        const index = prev ? prev.index + 1 : 0;
-        const id = randomUUID();
-        const ts = (/* @__PURE__ */ new Date()).toISOString();
-        const content = {
-          id,
-          ts,
-          prevHash,
-          toolName: input.toolName,
-          toolUseId: input.toolUseId,
-          input: input.input,
-          output: input.output,
-          isError: input.isError,
-          index
-        };
-        const hash = createHash("sha256").update(stableStringify2(content), "utf8").digest("hex");
-        entry = {
-          id,
-          ts,
-          prevHash,
-          hash,
-          toolName: input.toolName,
-          toolUseId: input.toolUseId,
-          input: input.input,
-          output: input.output,
-          isError: input.isError,
-          index
-        };
-        entries.push(entry);
-        await this.writeAll(input.sessionId, entries);
-        this.tailHash.set(input.sessionId, hash);
-        this.tailIndex.set(input.sessionId, index + 1);
+    const fp = this.filePath(input.sessionId);
+    const t0 = Date.now();
+    try {
+      await this.enqueue(input.sessionId, async () => {
+        await withFileLock(fp, async () => {
+          const entries = await this.readAll(input.sessionId);
+          const prev = entries.at(-1);
+          const prevHash = prev?.hash ?? GENESIS_PREV;
+          const index = prev ? prev.index + 1 : 0;
+          const id = randomUUID();
+          const ts = (/* @__PURE__ */ new Date()).toISOString();
+          const content = {
+            id,
+            ts,
+            prevHash,
+            toolName: input.toolName,
+            toolUseId: input.toolUseId,
+            input: input.input,
+            output: input.output,
+            isError: input.isError,
+            index
+          };
+          const hash = createHash("sha256").update(stableStringify2(content), "utf8").digest("hex");
+          entry = {
+            id,
+            ts,
+            prevHash,
+            hash,
+            toolName: input.toolName,
+            toolUseId: input.toolUseId,
+            input: input.input,
+            output: input.output,
+            isError: input.isError,
+            index
+          };
+          entries.push(entry);
+          await this.writeAll(input.sessionId, entries);
+          this.tailHash.set(input.sessionId, hash);
+          this.tailIndex.set(input.sessionId, index + 1);
+          const durationMs = Date.now() - t0;
+          this.events?.emit("storage.write", {
+            sessionId: input.sessionId,
+            store: "audit",
+            filePath: fp,
+            operation: "record",
+            outcome: "success",
+            durationMs,
+            ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+          });
+        });
       });
-    });
-    return entry;
+      return entry;
+    } catch (err) {
+      this.events?.emit("storage.error", {
+        sessionId: input.sessionId,
+        store: "audit",
+        filePath: fp,
+        operation: "record",
+        outcome: "failure",
+        error: err instanceof Error ? err.message : String(err),
+        recoverable: false,
+        durationMs: Date.now() - t0,
+        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+      });
+      throw err;
+    }
   }
   /**
    * Walk the chain and verify every entry's hash and prevHash.
    * Returns a structured verdict — never throws.
    */
   async verify(sessionId) {
-    const entries = await this.readAll(sessionId);
-    if (entries.length === 0) return { ok: true, entries: 0 };
-    if (entries[0]?.prevHash !== GENESIS_PREV) {
-      return {
-        ok: false,
-        brokenAt: 0,
-        reason: "first entry is not the genesis (prevHash != 0\u20260)"
-      };
+    const fp = this.filePath(sessionId);
+    const t0 = Date.now();
+    let entries;
+    try {
+      entries = await this.readAll(sessionId);
+    } catch (err) {
+      this.events?.emit("storage.read", {
+        sessionId,
+        store: "audit",
+        filePath: fp,
+        operation: "verify",
+        outcome: "failure",
+        durationMs: Date.now() - t0,
+        error: err instanceof Error ? err.message : String(err),
+        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+      });
+      return { ok: true, entries: 0 };
     }
-    let prevHash = GENESIS_PREV;
-    for (let i = 0; i < entries.length; i++) {
-      const e = expectDefined(entries[i]);
-      if (e.prevHash !== prevHash) {
+    const verdict = (() => {
+      if (entries.length === 0) return { ok: true, entries: 0 };
+      if (entries[0]?.prevHash !== GENESIS_PREV) {
         return {
           ok: false,
-          brokenAt: i,
-          reason: `prevHash mismatch at entry ${i} (expected ${prevHash.slice(0, 8)}\u2026, got ${e.prevHash.slice(0, 8)}\u2026)`
+          brokenAt: 0,
+          reason: "first entry is not the genesis (prevHash != 0\u20260)"
         };
       }
-      const content = {
-        id: e.id,
-        ts: e.ts,
-        prevHash: e.prevHash,
-        toolName: e.toolName,
-        toolUseId: e.toolUseId,
-        input: e.input,
-        output: e.output,
-        isError: e.isError,
-        index: e.index
-      };
-      const expectedHash = createHash("sha256").update(stableStringify2(content), "utf8").digest("hex");
-      if (expectedHash !== e.hash) {
-        return {
-          ok: false,
-          brokenAt: i,
-          reason: `hash mismatch at entry ${i} (entry content was modified)`
+      let prevHash = GENESIS_PREV;
+      for (let i = 0; i < entries.length; i++) {
+        const e = expectDefined(entries[i]);
+        if (e.prevHash !== prevHash) {
+          return {
+            ok: false,
+            brokenAt: i,
+            reason: `prevHash mismatch at entry ${i} (expected ${prevHash.slice(0, 8)}\u2026, got ${e.prevHash.slice(0, 8)}\u2026)`
+          };
+        }
+        const content = {
+          id: e.id,
+          ts: e.ts,
+          prevHash: e.prevHash,
+          toolName: e.toolName,
+          toolUseId: e.toolUseId,
+          input: e.input,
+          output: e.output,
+          isError: e.isError,
+          index: e.index
         };
+        const expectedHash = createHash("sha256").update(stableStringify2(content), "utf8").digest("hex");
+        if (expectedHash !== e.hash) {
+          return {
+            ok: false,
+            brokenAt: i,
+            reason: `hash mismatch at entry ${i} (entry content was modified)`
+          };
+        }
+        prevHash = e.hash;
       }
-      prevHash = e.hash;
-    }
-    return { ok: true, entries: entries.length };
+      return { ok: true, entries: entries.length };
+    })();
+    this.events?.emit("storage.read", {
+      sessionId,
+      store: "audit",
+      filePath: fp,
+      operation: "verify",
+      outcome: verdict.ok ? "success" : "failure",
+      durationMs: Date.now() - t0,
+      ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+    });
+    return verdict;
   }
   /** All entries for a session, in insertion order. */
   async load(sessionId) {
-    return this.readAll(sessionId);
+    const fp = this.filePath(sessionId);
+    const t0 = Date.now();
+    try {
+      const entries = await this.readAll(sessionId);
+      const durationMs = Date.now() - t0;
+      this.events?.emit("storage.read", {
+        sessionId,
+        store: "audit",
+        filePath: fp,
+        operation: "load",
+        outcome: "success",
+        durationMs,
+        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+      });
+      return entries;
+    } catch (err) {
+      const durationMs = Date.now() - t0;
+      this.events?.emit("storage.read", {
+        sessionId,
+        store: "audit",
+        filePath: fp,
+        operation: "load",
+        outcome: "failure",
+        durationMs,
+        error: err instanceof Error ? err.message : String(err),
+        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+      });
+      throw err;
+    }
   }
   // ── Internals ────────────────────────────────────────────────────────────
   filePath(sessionId) {
@@ -26058,7 +27135,7 @@ var ToolAuditLog = class {
       return out;
     } catch (err) {
       if (err.code === "ENOENT") return [];
-      return [];
+      throw err;
     }
   }
   async writeAll(sessionId, entries) {
@@ -26458,37 +27535,98 @@ function emptyTaskFile(sessionId) {
     tasks: []
   };
 }
-async function loadTasks(filePath) {
+async function loadTasks(filePath, events, traceId) {
+  const t0 = Date.now();
   let raw;
   try {
     raw = await fsp3.readFile(filePath, "utf8");
-  } catch {
+  } catch (err) {
+    events?.emit("storage.error", {
+      sessionId: traceId ?? "~boot~",
+      store: "tasks",
+      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.tasks)) return null;
+    if (parsed?.version !== 1 || !Array.isArray(parsed.tasks)) {
+      events?.emit("storage.read", {
+        sessionId: traceId ?? "~boot~",
+        store: "tasks",
+        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: "tasks",
+      filePath,
+      operation: "load",
+      outcome: "success",
+      durationMs: Date.now() - t0,
+      ...traceId !== void 0 && { traceId }
+    });
     return parsed;
   } catch {
+    events?.emit("storage.read", {
+      sessionId: traceId ?? "~boot~",
+      store: "tasks",
+      filePath,
+      operation: "load",
+      outcome: "failure",
+      durationMs: Date.now() - t0,
+      error: "parse_failed",
+      ...traceId !== void 0 && { traceId }
+    });
     return null;
   }
 }
-async function saveTasks(filePath, tasks) {
+async function saveTasks(filePath, tasks, events, traceId) {
+  const t0 = Date.now();
   try {
     tasks.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     await atomicWrite(filePath, JSON.stringify(tasks, null, 2), { mode: 384 });
+    events?.emit("storage.write", {
+      sessionId: traceId ?? "~boot~",
+      store: "tasks",
+      filePath,
+      operation: "save",
+      outcome: "success",
+      durationMs: Date.now() - t0,
+      ...traceId !== void 0 && { traceId }
+    });
   } catch (err) {
+    events?.emit("storage.error", {
+      sessionId: traceId ?? "~boot~",
+      store: "tasks",
+      filePath,
+      operation: "save",
+      outcome: "failure",
+      error: err instanceof Error ? err.message : String(err),
+      recoverable: false,
+      ...traceId !== void 0 && { traceId }
+    });
     console.warn(
       "[task-store] save failed:",
       err instanceof Error ? err.message : String(err)
     );
   }
 }
-async function mutateTasks(filePath, sessionId, fn) {
+async function mutateTasks(filePath, sessionId, fn, events, traceId) {
   return withFileLock(filePath, async () => {
-    const file = await loadTasks(filePath) ?? emptyTaskFile(sessionId);
+    const file = await loadTasks(filePath, events, traceId) ?? emptyTaskFile(sessionId);
     const updated = await fn(file);
-    await saveTasks(filePath, updated);
+    await saveTasks(filePath, updated, events, traceId);
     return updated;
   });
 }
@@ -30795,8 +31933,9 @@ function buildMailboxBlock(messages) {
   const parts = [];
   parts.push("[MAILBOX] New message(s) from other agents:");
   parts.push("");
+  const hasActionable = messages.some((m) => m.type === "ask" || m.type === "assign" || m.type === "result");
   for (const m of messages) {
-    const typeLabel = m.type === "steer" ? "\u{1F504} STEER" : m.type === "btw" ? "\u{1F4AC} BTW" : `\u{1F4E8} ${m.type.toUpperCase()}`;
+    const typeLabel = m.type === "steer" ? "\u{1F504} STEER" : m.type === "btw" ? "\u{1F4AC} BTW" : m.type === "ask" ? "\u2753 ASK" : m.type === "assign" ? "\u{1F4CB} ASSIGN" : m.type === "result" ? "\u2705 RESULT" : `\u{1F4E8} ${m.type.toUpperCase()}`;
     parts.push(`--- ${typeLabel} from ${m.from} ---`);
     parts.push(`Subject: ${m.subject}`);
     parts.push("");
@@ -30806,6 +31945,22 @@ function buildMailboxBlock(messages) {
       parts.push("After your current operation reaches a stopping point, adjust your approach per the instruction above.");
       parts.push("");
     }
+    if (m.type === "ask") {
+      parts.push("\u21B3 This agent is waiting for your answer. Reply directly or use mailbox action=send to respond.");
+      parts.push("");
+    }
+    if (m.type === "assign") {
+      parts.push("\u21B3 This is a task assignment. Act on it when your current operation allows.");
+      parts.push("");
+    }
+    if (m.type === "result") {
+      parts.push("\u21B3 A subagent has completed its work. Factor this result into your next decision.");
+      parts.push("");
+    }
+  }
+  if (hasActionable) {
+    parts.push("Action required: address the items above. When done, use `mailbox action=ack messageId=<id> completed=true` to mark them complete.");
+    parts.push("");
   }
   parts.push("[END MAILBOX]");
   return { type: "text", text: parts.join("\n") };
@@ -30826,26 +31981,12 @@ async function injectPendingMailboxMessages(checkMailbox, foldFn, a) {
     });
   }
   if (messages.length === 0) return;
-  const injectable = messages.filter((m) => m.type === "steer" || m.type === "btw");
-  const others = messages.filter((m) => m.type !== "steer" && m.type !== "btw");
-  if (injectable.length > 0) {
-    try {
-      foldFn(buildMailboxBlock(injectable));
-    } catch (err) {
-      (a.logger.debug ?? console.debug)?.(
-        `mailbox: failed to fold messages: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-  }
-  if (others.length > 0) {
-    const otherSubjects = others.map((m) => `  - [${m.type}] ${m.from}: ${m.subject}`).join("\n");
-    const note = `[MAILBOX] You have ${others.length} other unread message(s). Use \`mailbox action=check\` to read them:
-${otherSubjects}
-[END MAILBOX]`;
-    try {
-      foldFn({ type: "text", text: note });
-    } catch {
-    }
+  try {
+    foldFn(buildMailboxBlock(messages));
+  } catch (err) {
+    (a.logger.debug ?? console.debug)?.(
+      `mailbox: failed to fold messages: ${err instanceof Error ? err.message : String(err)}`
+    );
   }
 }
 
@@ -31860,9 +33001,26 @@ async function writeProjectMeta(paths, projectRoot) {
   } catch {
   }
 }
-async function registerProjectInManifest(paths, projectRoot) {
+async function registerProjectInManifest(paths, projectRoot, events) {
+  const manifestPath = path7.join(paths.globalRoot, "projects.json");
+  try {
+    const t0 = Date.now();
+    const raw = await fsp3.readFile(manifestPath, "utf8");
+    events?.emit("storage.read", {
+      sessionId: "~boot~",
+      store: "project",
+      filePath: manifestPath,
+      operation: "manifest_read",
+      outcome: "success",
+      durationMs: Date.now() - t0
+    });
+    try {
+      JSON.parse(raw);
+    } catch {
+    }
+  } catch (err) {
+  }
   try {
-    const manifestPath = path7.join(paths.globalRoot, "projects.json");
     let manifest;
     try {
       const raw = await fsp3.readFile(manifestPath, "utf8");
@@ -31879,8 +33037,17 @@ async function registerProjectInManifest(paths, projectRoot) {
       const name = path7.basename(projectRoot);
       manifest.projects.push({ name, root: projectRoot, slug, lastSeen: now, createdAt: now });
     }
+    const writeT0 = Date.now();
     await fsp3.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf8");
-  } catch {
+    events?.emit("storage.write", {
+      sessionId: "~boot~",
+      store: "project",
+      filePath: manifestPath,
+      operation: "manifest_write",
+      outcome: "success",
+      durationMs: Date.now() - writeT0
+    });
+  } catch (err) {
   }
 }
 var GITIGNORE_ENTRY = ".wrongstack/\n";
@@ -32145,9 +33312,10 @@ Never silently skip a failure \u2014 always report it, even when you choose not
 
 ## After-task suggestions
 
-After completing a significant task, end your response with 2\u20134 suggested next
-actions in a \`<next_steps>\` block. Use this exact format so the user can
-select them with \`/next 1\`, \`/next 2\`, or \`/next 1 2 3\`:
+**You are the leader agent.** After completing a significant task, end your
+response with 2\u20134 suggested next actions in a \`<next_steps>\` block. Use this
+exact format so the user can select them with \`/next 1\`, \`/next 2\`, or
+\`/next 1 2 3\`:
 
 \`\`\`
 <next_steps>
@@ -32160,6 +33328,7 @@ select them with \`/next 1\`, \`/next 2\`, or \`/next 1 2 3\`:
 Rules:
 - Each line is a single imperative sentence the user can act on immediately.
 - Be specific: mention file names, tool names, or commands.
+- **Concrete actions only** \u2014 never write declarations of intent ("we should fix X", "consider refactoring Y") or manual suggestions ("manually check Z"). Write exactly what should be done: "Fix null deref in auth/session.ts:42", "Run pnpm typecheck".
 - Order by priority. Keep each suggestion to one line.
 - Skip during multi-step operations \u2014 only show after completion.
 - If nothing is pending, say "No pending actions."
@@ -32489,8 +33658,17 @@ sender's exact \`from\` id.
 ### Receiving
 
 Unread mail (direct, base-name, and \`*\` broadcasts) is injected into
-your conversation automatically before each step \u2014 urgent steer/btw
-inline, the rest as a summary. To catch up explicitly:
+your conversation automatically before each step \u2014 ALL message types
+(steer, btw, ask, assign, result, note) appear inline with a call to
+action. You do NOT need to manually check the mailbox; subagent results
+and questions reach you even while you are mid-task.
+
+When a message includes a call to action:
+- **ask**: reply to the agent directly or use \`mail_send\` to respond
+- **assign**: act on the task when your current operation allows
+- **result**: factor the outcome into your next decision
+
+To catch up explicitly:
 
 - \`mail_inbox\` \u2014 read your unread mail and mark it read
 - \`mailbox action=query from=<agent> type=result\` \u2014 find specific results