@wrongstack/core 0.257.0 → 0.260.0

package/dist/index.js

@@ -7,6 +7,8 @@ import { join, extname, relative, isAbsolute, resolve, sep } from 'path';
 import * as fs2 from 'fs';
 import * as os6 from 'os';
 import { hostname } from 'os';
+import * as dns from 'dns/promises';
+import * as net from 'net';
 import { execFile, spawn } from 'child_process';
 import { promisify } from 'util';
 import { EventEmitter } from 'events';
@@ -4277,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;
@@ -5050,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 = [];
   /**
@@ -5085,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
@@ -6374,6 +6391,95 @@ function mergeCustomModelDefs(providerCustomModels, configModels) {
   if (Object.keys(out).length === 0) return void 0;
   return out;
 }
+function isPrivateIPv4(addr) {
+  const parts = addr.split(".").map((p) => Number.parseInt(p, 10));
+  if (parts.length !== 4 || parts.some((n) => Number.isNaN(n) || n < 0 || n > 255)) {
+    return true;
+  }
+  const [a, b, c] = parts;
+  if (a === 0) return true;
+  if (a === 10) return true;
+  if (a === 127) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 192 && b === 0 && c === 0) return true;
+  if (a === 100 && b >= 64 && b <= 127) return true;
+  if (a >= 224) return true;
+  return false;
+}
+function isPrivateIPv6(raw) {
+  const lower = raw.toLowerCase();
+  if (lower === "::" || lower === "::1") return true;
+  const groups = expandIPv6(lower);
+  if (!groups) return true;
+  if (groups[0] === 0 && groups[1] === 0 && groups[2] === 0 && groups[3] === 0 && groups[4] === 0 && groups[5] === 65535) {
+    const a = (groups[6] ?? 0) >> 8;
+    const b = (groups[6] ?? 0) & 255;
+    const c = (groups[7] ?? 0) >> 8;
+    const d = (groups[7] ?? 0) & 255;
+    return isPrivateIPv4(`${a}.${b}.${c}.${d}`);
+  }
+  const high = groups[0] ?? 0;
+  if ((high & 65024) === 64512) return true;
+  if ((high & 65472) === 65152) return true;
+  if ((high & 65280) === 65280) return true;
+  return false;
+}
+function expandIPv6(addr) {
+  const parts = addr.split("::");
+  if (parts.length > 2) return null;
+  const parseGroups = (s) => {
+    if (s === "") return [];
+    const out = [];
+    for (const g of s.split(":")) {
+      if (g.length === 0 || g.length > 4) return null;
+      const n = Number.parseInt(g, 16);
+      if (Number.isNaN(n) || n < 0 || n > 65535) return null;
+      out.push(n);
+    }
+    return out;
+  };
+  if (parts.length === 1) {
+    const groups = parseGroups(parts[0] ?? "");
+    if (!groups || groups.length !== 8) return null;
+    return groups;
+  }
+  const head = parseGroups(parts[0] ?? "");
+  const tail = parseGroups(parts[1] ?? "");
+  if (!head || !tail) return null;
+  const fill = 8 - head.length - tail.length;
+  if (fill < 0) return null;
+  return [...head, ...new Array(fill).fill(0), ...tail];
+}
+async function assertNotPrivateHost(hostname3) {
+  const host = hostname3.startsWith("[") && hostname3.endsWith("]") ? hostname3.slice(1, -1) : hostname3;
+  if (host === "localhost" || host.endsWith(".localhost")) {
+    throw new Error("fetch: blocked localhost target");
+  }
+  const ipVersion = net.isIP(host);
+  if (ipVersion === 4) {
+    if (isPrivateIPv4(host)) {
+      throw new Error(`fetch: blocked private/loopback address "${host}"`);
+    }
+  } else if (ipVersion === 6) {
+    if (isPrivateIPv6(host)) {
+      throw new Error(`fetch: blocked private/loopback address "${host}"`);
+    }
+  } else {
+    try {
+      const records = await dns.lookup(host, { all: true });
+      for (const r of records) {
+        const bad = r.family === 4 ? isPrivateIPv4(r.address) : isPrivateIPv6(r.address);
+        if (bad) {
+          throw new Error(`fetch: resolved to private address ${r.address}`);
+        }
+      }
+    } catch (err) {
+      if (err instanceof Error && err.message.startsWith("fetch:")) throw err;
+    }
+  }
+}
 
 // src/storage/session-store.ts
 init_atomic_write();
@@ -6396,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");
@@ -6419,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",
@@ -6442,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 }
@@ -6479,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({
@@ -6487,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 {
@@ -6574,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.
@@ -6655,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;
     }
   }
@@ -6936,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;
@@ -6955,6 +7134,7 @@ var FileSessionWriter = class _FileSessionWriter {
       provider: meta.provider ?? "unknown",
       tokenTotal: 0
     };
+    this.traceId = traceId;
   }
   id;
   handle;
@@ -6987,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
@@ -7140,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) {
@@ -7156,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) {
@@ -7221,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();
@@ -7390,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",
@@ -7420,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);
@@ -7430,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",
@@ -7809,6 +8149,7 @@ var MAX_BYTES_TOTAL = 32e3;
 var DefaultMemoryStore = class {
   files;
   events;
+  traceId;
   backend;
   /**
    * Per-scope serialization queue. `remember` / `forget` / `consolidate` /
@@ -7874,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
@@ -7908,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]);
@@ -8036,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,
@@ -8050,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,
@@ -8063,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);
       });
@@ -8071,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 {
@@ -8173,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: {
@@ -8275,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 };
@@ -8356,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
@@ -8365,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",
@@ -8387,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",
@@ -8403,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",
@@ -8878,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,
@@ -8904,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",
@@ -8913,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",
@@ -8960,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)
@@ -9662,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;
@@ -9681,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;
@@ -9840,6 +10629,8 @@ function compactSkillBody(body) {
 var DefaultSkillLoader = class {
   dirs;
   cache;
+  entriesCache;
+  bodyCache = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.dirs = [
       { dir: opts.paths.inProjectSkills, source: "project" },
@@ -9898,6 +10689,7 @@ var DefaultSkillLoader = class {
     return lines.join("\n");
   }
   async listEntries() {
+    if (this.entriesCache) return this.entriesCache;
     const skills = await this.list();
     const entries = [];
     for (const s of skills) {
@@ -9908,33 +10700,47 @@ var DefaultSkillLoader = class {
       } catch {
       }
     }
+    this.entriesCache = entries;
     return entries;
   }
   invalidateCache() {
     this.cache = void 0;
+    this.entriesCache = void 0;
+    this.bodyCache.clear();
   }
   async readBody(name) {
+    const cached = this.bodyCache.get(name);
+    if (cached !== void 0) return cached;
     const m = await this.find(name);
     if (!m) throw new Error(`Skill "${name}" not found`);
-    return fsp3.readFile(m.path, "utf8");
+    const body = await fsp3.readFile(m.path, "utf8");
+    this.bodyCache.set(name, body);
+    return body;
   }
   async readSaveBody(name) {
+    const key = `save:${name}`;
+    const cached = this.bodyCache.get(key);
+    if (cached !== void 0) return cached;
     const m = await this.find(name);
     if (!m) throw new Error(`Skill "${name}" not found`);
     const savePath = path7.join(path7.dirname(m.path), "SKILL.save.md");
+    let result;
     try {
-      return await fsp3.readFile(savePath, "utf8");
+      result = await fsp3.readFile(savePath, "utf8");
     } catch {
       const full = await fsp3.readFile(m.path, "utf8");
       const body = stripFrontmatter(full);
       const compact = compactSkillBody(body);
       if (compact) {
-        return `## Overview
+        result = `## Overview
 
 ${compact}`;
+      } else {
+        result = body.trim().slice(0, 300);
       }
-      return body.trim().slice(0, 300);
     }
+    this.bodyCache.set(key, result);
+    return result;
   }
 };
 function parseFrontmatter(raw) {
@@ -11333,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 {
@@ -11352,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({
@@ -11363,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,
@@ -11815,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;
@@ -11919,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 {
     }
@@ -12239,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
@@ -12253,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
@@ -12267,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" };
@@ -12277,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?.();
   }
   /**
@@ -12286,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');
@@ -12365,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);
   }
 };
 
@@ -12723,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) => {
@@ -15546,17 +16428,17 @@ function normalize2(text) {
   return ` ${text.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim()} `;
 }
 function scoreAgents(task, catalog = AGENT_CATALOG) {
-  const hay = normalize2(task);
+  const haySet = new Set(normalize2(task).split(/\s+/).filter(Boolean));
   const out = [];
   for (const def of Object.values(catalog)) {
     if (!def?.config?.role) continue;
     let score = 0;
     const matched = [];
     for (const kw of def.capability.keywords) {
-      const needle = normalize2(kw);
-      if (hay.includes(needle.trimEnd() + " ") || hay.includes(" " + needle.trimStart())) {
-        const words = kw.trim().split(/\s+/).length;
-        score += words;
+      const needleWords = normalize2(kw).split(/\s+/).filter(Boolean);
+      const allPresent = needleWords.every((w) => haySet.has(w));
+      if (allPresent) {
+        score += needleWords.length;
         matched.push(kw);
       }
     }
@@ -16889,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) {
@@ -16924,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" });
@@ -16942,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" });
@@ -17051,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);
@@ -17203,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,
@@ -17218,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);
   }
 };
 
@@ -17967,6 +18855,7 @@ Emit each evaluation immediately. Do not wait until you have read all reports.`;
     }
     for (const dispose of this.disposers) dispose();
     this.disposers.length = 0;
+    this.snapshot.files.length = 0;
   }
 };
 
@@ -18000,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.`;
@@ -18017,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
@@ -18031,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;
@@ -20440,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) {
@@ -20455,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;
     }
   };
 }
@@ -23179,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() {
@@ -23221,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);
@@ -25308,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
@@ -25373,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
@@ -25401,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) {
@@ -25428,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) {
@@ -25494,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();
@@ -25505,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 ──────────────────────────────────────────────────────────────
@@ -25515,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 ───────────────────────────────────────────────────────────────
   /**
@@ -25555,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.
@@ -25631,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);
@@ -25818,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. */
@@ -25828,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;
   }
   /**
@@ -25838,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) {
@@ -25949,7 +27135,7 @@ var ToolAuditLog = class {
       return out;
     } catch (err) {
       if (err.code === "ENOENT") return [];
-      return [];
+      throw err;
     }
   }
   async writeAll(sessionId, entries) {
@@ -26349,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;
   });
 }
@@ -30686,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("");
@@ -30697,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") };
@@ -30717,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)}`
+    );
   }
 }
 
@@ -31751,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");
@@ -31770,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";
@@ -32036,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>
@@ -32051,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."
@@ -32380,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
@@ -38351,6 +39638,6 @@ function createChimeraPlugin() {
   };
 }
 
-export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, ALL_SYNC_CATEGORIES, AUDIT_LOG_AGENT, Agent, AgentError, AgentStatusTracker, AnnotationsStore, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutoPhasePlanner, AutoPhaseRunner, AutonomousRunner, BUG_HUNTER_AGENT, BrainDecisionQueue, BrainMonitor, BudgetExceededError, CHIMERA_REVIEW_PROMPT, CONTEXT_WINDOW_MODES, CORE_RECONSTRUCT_EVENTS, CheckpointManager, CloudSync, CollaborationBus, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SESSION_LOGGING_CONFIG, DEFAULT_SESSION_PRUNE_DAYS, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DEPENDENCY_FILE_PATTERNS, DefaultAttachmentStore, DefaultBrainArbiter, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMailbox, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultPromptStore, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorStateCheckpoint, DoneConditionChecker, ENHANCER_SYSTEM_PROMPT, ERROR_CODES, EternalAutonomyEngine, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, FORBIDDEN_PROTO_KEYS, FileMemoryBackend, FleetBus, FleetCostCapError, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, FsError, GitignoreUpdater, GlobalMailbox, GraphMemoryBackend, HookRegistry, HookRunner, HumanEscalatingBrainArbiter, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, MATRIX_PHASE_KEYS, MAX_JOURNAL_ENTRIES, MAX_PROGRESS_HISTORY, MEMORY_TYPE_LABELS, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, ObservableBrainArbiter, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, PhaseGraphBuilder, PhaseOrchestrator, PhaseStore, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, ReplayLogStore, ReplayProviderRunner, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, STANDARD_AUDIT_EVENTS, ScopedEventBus, SddError, SddParallelRun, SddTaskDecomposer, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SessionMemoryConsolidator, SessionRecovery, SessionRegistry, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, StreamHangError, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolAuditLog, ToolError, ToolExecutor, ToolRegistry, WorktreeManager, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyRosterBudget, asBlocks, asText, assertNever, assertSafePath, atomicWrite, attachAutoExtend, attachDepWatcherBridge, attachMailboxChecker, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, bootConfig, braveSearchServer, buildBtwBlock, buildChildEnv, buildGoalPreamble, buildLosslessDigest, buildMailboxBlock, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildQueuedMessagesBlock, buildRecoveryStrategies, buildSmartDigest, classifyFamily, clearPlan, collabInjectMiddleware, collabPauseMiddleware, color, compactLog, compileGlob, compileUserRegex, completePartialObject, composeDirectorPrompt, composeSubagentPrompt, computeMessageTokens, computeTaskItemProgress, computeTaskProgress, consumeBtwNotes, consumeQueuedMessagesUpdate, context7Server, contextManagerTool, createAutoExecutor, createAutoPhaseFromTaskGraph, createAutonomyBrain, createChimeraPlugin, createContextManagerTool, createDefaultPipelines, createDelegateTool, createGitPlugin, createMailboxChecker, createMcpControlTool, createMcpUseTool, createMessage, createObservabilityPlugin, createPlanPlugin, createPromptsPlugin, createSecurityPlugin, createSecuritySlashCommand, createSessionEventBridge, createSkillsPlugin, createStrategyCompactor, createSyncPlugin, createTieredBrainArbiter, createToolOutputSerializer, decryptConfigSecrets, deepMerge, defaultGitignoreUpdater, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, deriveTodosFromPlanItem, detectNewlineStyle, detectEcosystem as detectPackageEcosystem, dispatchAgent, downloadGitHubTarball, eliseOldToolResults, emptyGoal, emptyPlan, emptyTaskFile, encryptConfigSecrets, enhanceUserPrompt, ensureDir, estimateMessageTokens, estimateMessages, estimateRequestTokens, estimateRequestTokensCalibrated, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, expandGlob, expectDefined, extractRunEnv, extractText, filesystemServer, findCriticalPath, findPreserveStart, flagsToConfigPatch, formatContextWindowModeList, formatDecisionSummary, formatGoal, formatHumanPrompt, formatPlan, formatPlanTemplates, formatTaskList, formatTaskProgress, formatTodosList, getAgentDefinition, getCalibrationState, getContextWindowMode, getFileHistory, getFilesByAgent, getFullLog, getFullPackageLog, getLastAuthor, getManifestPackages, getPackageAuthor, getPackagesByAgent, getPlanTemplate, getSessionRegistry, getTemplate, getTermSize, githubServer, goalFilePath, googleMapsServer, hasSessionRegistry, hasTextContent, hashRequest, hookMatcherMatches, injectPendingMailboxMessages, isAgentError, isConfigError, isContextWindowModeId, isFsError, isImageBlock, isInteractive, isPluginError, isPrimitiveArray, isSddError, isSecretField, isSessionError, isStdinTTY, isStdoutTTY, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isValidMatrixKey, isWrongStackError, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadGoal, loadPlan, loadPlugins, loadProjectModes, loadTasks, loadTodosCheckpoint, loadUserModes, mailboxSessionTag, makeAgentSubagentRunner, makeAskTool, makeAssignTool, makeAutonomyPromptContributor, makeAwaitTasksTool, makeCollabDebugTool, makeContinueToNextIterationTool, makeDependencyWatcherConfig, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetHealthTool, makeFleetSessionTool, makeFleetStatusTool, makeFleetUsageTool, makeLLMClassifier, makeMailInboxTool, makeMailSendTool, makeMailboxTool, makeRollUpTool, makeSpawnTool, makeTerminateTool, matchAny, matchGlob, matrixKeyKind, mergeCustomModelDefs, mergeModelsPayload, migratePlaintextSecrets, miniMaxVisionServer, mutatePlan, mutateTasks, noOpLogger, noOpVault, normalizeRecipient, normalizeToLf, normalizedEqual, onResize, parseContinueDirective, parseEntries, parseProgressFromText, parseSkillRef, peekQueuedMessages, pendingBtwCount, phaseForRole, projectHash, projectSlug, recentTextTurns, recordActualUsage, recordFileAction, recordPackageAction, recordProgress, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resetCalibration, resolveAuditLevel, resolveChimeraConfig, resolveContextWindowPolicy, resolveMailboxIdentity, resolveModelMatrix, resolveProjectDir, resolveSessionLoggingConfig, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, runProviderWithRetry, runShellHook, safeParse, safeStringify, sanitizeJsonString, saveGoal, savePlan, saveTasks, saveTodosCheckpoint, scoreAgents, scoreMessage, securitySlashCommand, sentinelServer, setBtwNote, setOutputLineGuard, setPlanItemStatus, setProgress, setQueuedMessagesSnapshot, setRawMode, shouldEnhance, slackServer, sleep, stableStringify, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, startPackageOutdatedWatcher, startTechStackConsumer, stripAnsi, summarizeUsage, templateToMarkdown, toStyle, toWrongStackError, topologicalSort, truncate, unifiedDiff, unloadPlugins, updatePackageOutdatedStatus, validateAgainstSchema, wireMetricsToEvents, withFileLock, wrapAsState, writeErr, writeOut, wstackGlobalRoot, zaiVisionServer };
+export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, ALL_SYNC_CATEGORIES, AUDIT_LOG_AGENT, Agent, AgentError, AgentStatusTracker, AnnotationsStore, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutoPhasePlanner, AutoPhaseRunner, AutonomousRunner, BUG_HUNTER_AGENT, BrainDecisionQueue, BrainMonitor, BudgetExceededError, CHIMERA_REVIEW_PROMPT, CONTEXT_WINDOW_MODES, CORE_RECONSTRUCT_EVENTS, CheckpointManager, CloudSync, CollaborationBus, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SESSION_LOGGING_CONFIG, DEFAULT_SESSION_PRUNE_DAYS, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DEPENDENCY_FILE_PATTERNS, DefaultAttachmentStore, DefaultBrainArbiter, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMailbox, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultPromptStore, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorStateCheckpoint, DoneConditionChecker, ENHANCER_SYSTEM_PROMPT, ERROR_CODES, EternalAutonomyEngine, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, FORBIDDEN_PROTO_KEYS, FileMemoryBackend, FleetBus, FleetCostCapError, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, FsError, GitignoreUpdater, GlobalMailbox, GraphMemoryBackend, HookRegistry, HookRunner, HumanEscalatingBrainArbiter, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, MATRIX_PHASE_KEYS, MAX_JOURNAL_ENTRIES, MAX_PROGRESS_HISTORY, MEMORY_TYPE_LABELS, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, ObservableBrainArbiter, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, PhaseGraphBuilder, PhaseOrchestrator, PhaseStore, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, ReplayLogStore, ReplayProviderRunner, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, STANDARD_AUDIT_EVENTS, ScopedEventBus, SddError, SddParallelRun, SddTaskDecomposer, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SessionMemoryConsolidator, SessionRecovery, SessionRegistry, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, StreamHangError, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolAuditLog, ToolError, ToolExecutor, ToolRegistry, WorktreeManager, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyRosterBudget, asBlocks, asText, assertNever, assertNotPrivateHost, assertSafePath, atomicWrite, attachAutoExtend, attachDepWatcherBridge, attachMailboxChecker, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, bootConfig, braveSearchServer, buildBtwBlock, buildChildEnv, buildGoalPreamble, buildLosslessDigest, buildMailboxBlock, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildQueuedMessagesBlock, buildRecoveryStrategies, buildSmartDigest, classifyFamily, clearPlan, collabInjectMiddleware, collabPauseMiddleware, color, compactLog, compileGlob, compileUserRegex, completePartialObject, composeDirectorPrompt, composeSubagentPrompt, computeMessageTokens, computeTaskItemProgress, computeTaskProgress, consumeBtwNotes, consumeQueuedMessagesUpdate, context7Server, contextManagerTool, createAutoExecutor, createAutoPhaseFromTaskGraph, createAutonomyBrain, createChimeraPlugin, createContextManagerTool, createDefaultPipelines, createDelegateTool, createGitPlugin, createMailboxChecker, createMcpControlTool, createMcpUseTool, createMessage, createObservabilityPlugin, createPlanPlugin, createPromptsPlugin, createSecurityPlugin, createSecuritySlashCommand, createSessionEventBridge, createSkillsPlugin, createStrategyCompactor, createSyncPlugin, createTieredBrainArbiter, createToolOutputSerializer, decryptConfigSecrets, deepMerge, defaultGitignoreUpdater, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, deriveTodosFromPlanItem, detectNewlineStyle, detectEcosystem as detectPackageEcosystem, dispatchAgent, downloadGitHubTarball, eliseOldToolResults, emptyGoal, emptyPlan, emptyTaskFile, encryptConfigSecrets, enhanceUserPrompt, ensureDir, estimateMessageTokens, estimateMessages, estimateRequestTokens, estimateRequestTokensCalibrated, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, expandGlob, expandIPv6, expectDefined, extractRunEnv, extractText, filesystemServer, findCriticalPath, findPreserveStart, flagsToConfigPatch, formatContextWindowModeList, formatDecisionSummary, formatGoal, formatHumanPrompt, formatPlan, formatPlanTemplates, formatTaskList, formatTaskProgress, formatTodosList, getAgentDefinition, getCalibrationState, getContextWindowMode, getFileHistory, getFilesByAgent, getFullLog, getFullPackageLog, getLastAuthor, getManifestPackages, getPackageAuthor, getPackagesByAgent, getPlanTemplate, getSessionRegistry, getTemplate, getTermSize, githubServer, goalFilePath, googleMapsServer, hasSessionRegistry, hasTextContent, hashRequest, hookMatcherMatches, injectPendingMailboxMessages, isAgentError, isConfigError, isContextWindowModeId, isFsError, isImageBlock, isInteractive, isPluginError, isPrimitiveArray, isPrivateIPv4, isPrivateIPv6, isSddError, isSecretField, isSessionError, isStdinTTY, isStdoutTTY, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isValidMatrixKey, isWrongStackError, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadGoal, loadPlan, loadPlugins, loadProjectModes, loadTasks, loadTodosCheckpoint, loadUserModes, mailboxSessionTag, makeAgentSubagentRunner, makeAskTool, makeAssignTool, makeAutonomyPromptContributor, makeAwaitTasksTool, makeCollabDebugTool, makeContinueToNextIterationTool, makeDependencyWatcherConfig, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetHealthTool, makeFleetSessionTool, makeFleetStatusTool, makeFleetUsageTool, makeLLMClassifier, makeMailInboxTool, makeMailSendTool, makeMailboxTool, makeRollUpTool, makeSpawnTool, makeTerminateTool, matchAny, matchGlob, matrixKeyKind, mergeCustomModelDefs, mergeModelsPayload, migratePlaintextSecrets, miniMaxVisionServer, mutatePlan, mutateTasks, noOpLogger, noOpVault, normalizeRecipient, normalizeToLf, normalizedEqual, onResize, parseContinueDirective, parseEntries, parseProgressFromText, parseSkillRef, peekQueuedMessages, pendingBtwCount, phaseForRole, projectHash, projectSlug, recentTextTurns, recordActualUsage, recordFileAction, recordPackageAction, recordProgress, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resetCalibration, resolveAuditLevel, resolveChimeraConfig, resolveContextWindowPolicy, resolveMailboxIdentity, resolveModelMatrix, resolveProjectDir, resolveSessionLoggingConfig, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, runProviderWithRetry, runShellHook, safeParse, safeStringify, sanitizeJsonString, saveGoal, savePlan, saveTasks, saveTodosCheckpoint, scoreAgents, scoreMessage, securitySlashCommand, sentinelServer, setBtwNote, setOutputLineGuard, setPlanItemStatus, setProgress, setQueuedMessagesSnapshot, setRawMode, shouldEnhance, slackServer, sleep, stableStringify, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, startPackageOutdatedWatcher, startTechStackConsumer, stripAnsi, summarizeUsage, templateToMarkdown, toStyle, toWrongStackError, topologicalSort, truncate, unifiedDiff, unloadPlugins, updatePackageOutdatedStatus, validateAgainstSchema, wireMetricsToEvents, withFileLock, wrapAsState, writeErr, writeOut, wstackGlobalRoot, zaiVisionServer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map