@wrongstack/core 0.270.0 → 0.272.1

package/dist/storage/index.js

@@ -1,9 +1,10 @@
-import { randomBytes, randomUUID, createHash } from 'crypto';
+import { createReadStream } from 'fs';
 import * as fsp from 'fs/promises';
 import * as path2 from 'path';
+import { createInterface } from 'readline';
+import { randomBytes, randomUUID, createHash } from 'crypto';
 import * as os from 'os';
 import { hostname } from 'os';
-import 'fs';
 
 // src/storage/session-store.ts
 async function atomicWrite(targetPath, content, opts = {}) {
@@ -79,7 +80,7 @@ async function withFileLock(targetPath, fn, opts = {}) {
       if (Date.now() - started >= timeoutMs) {
         throw new Error(`Timed out waiting for file lock: ${targetPath}`);
       }
-      await new Promise((resolve6) => setTimeout(resolve6, 25));
+      await new Promise((resolve7) => setTimeout(resolve7, 25));
     }
   }
   try {
@@ -113,7 +114,7 @@ async function renameWithRetry(from, to) {
       if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
         throw err;
       }
-      await new Promise((resolve6) => setTimeout(resolve6, delays[i]));
+      await new Promise((resolve7) => setTimeout(resolve7, delays[i]));
     }
   }
   throw lastErr;
@@ -430,8 +431,6 @@ function resolveWstackPaths(opts) {
     projectStatus: (projectHash2) => path2.join(globalRoot, "projects", projectHash2, "status.json")
   };
 }
-
-// src/storage/session-store.ts
 function sanitizeModel(model) {
   return model.replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
 }
@@ -442,6 +441,8 @@ function generateSessionId(startedAt, model) {
   const modelPart = model ? `_${sanitizeModel(model)}` : "";
   return `${date}/${time}Z${modelPart}_${suffix}`;
 }
+
+// src/storage/session-store.ts
 var DefaultSessionStore = class _DefaultSessionStore {
   dir;
   events;
@@ -459,6 +460,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
   _loadCache = /* @__PURE__ */ new Map();
   _indexCache = null;
   static LOAD_CACHE_MAX_ENTRIES = 50;
+  static LIST_SCAN_CONCURRENCY = 32;
   constructor(opts) {
     this.dir = opts.dir;
     this.events = opts.events;
@@ -475,7 +477,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       this._loadCache.clear();
     }
   }
-  // ── Storage event helpers ───────────────────────────────────────────────────
+  // ── Storage event helpers ───────────────────────────────────────────────────
   emitRead(sessionId, filePath, operation, outcome, durationMs, error) {
     this.events?.emit("storage.read", {
       sessionId,
@@ -590,7 +592,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
         this.events,
         {
           resumed: true,
-          // Shard directory (sessions/<date>/) — must match create() so the
+          // Shard directory (sessions/<date>/) — must match create() so the
           // .summary.json sidecar lands next to the JSONL instead of the
           // sessions root (where summaryFor() would never find it).
           dir: path2.dirname(file),
@@ -631,19 +633,93 @@ var DefaultSessionStore = class _DefaultSessionStore {
       const raw = await fsp.readFile(file, "utf8");
       const lines = raw.split("\n").filter((l) => l.trim());
       const events = [];
+      let sessionStartEvent;
+      let sessionEndEvent;
+      let sessionModel;
+      let sessionProvider;
+      let sessionPendingToolUses;
+      const messages = [];
+      const openToolUses = /* @__PURE__ */ new Set();
+      let usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
       for (const line of lines) {
         try {
           const parsed = JSON.parse(line);
           if (parsed !== null && typeof parsed === "object" && typeof parsed.type === "string" && typeof parsed.ts === "string") {
-            events.push(parsed);
+            const ev = parsed;
+            events.push(ev);
+            if (ev.type === "session_start" && !sessionStartEvent) {
+              sessionStartEvent = ev;
+              sessionModel = ev.model;
+              sessionProvider = ev.provider;
+            }
+            if (ev.type === "session_end") {
+              sessionEndEvent = ev;
+              sessionPendingToolUses = ev.pendingToolUses;
+            }
+            if (ev.type === "user_input") {
+              openToolUses.clear();
+              messages.push({ role: "user", content: ev.content, ts: ev.ts });
+            } else if (ev.type === "llm_response") {
+              messages.push({ role: "assistant", content: ev.content, ts: ev.ts });
+              for (const b of ev.content) {
+                if (b.type === "tool_use") openToolUses.add(b.id);
+              }
+              usage = {
+                input: usage.input + (ev.usage.input ?? 0),
+                output: usage.output + (ev.usage.output ?? 0),
+                cacheRead: (usage.cacheRead ?? 0) + (ev.usage.cacheRead ?? 0),
+                cacheWrite: (usage.cacheWrite ?? 0) + (ev.usage.cacheWrite ?? 0)
+              };
+            } else if (ev.type === "tool_result") {
+              if (!openToolUses.has(ev.id)) {
+                this.events?.emit("session.damaged", {
+                  sessionId: id,
+                  detail: `Orphan tool_result "${ev.id}" has no matching tool_use`
+                });
+                continue;
+              }
+              openToolUses.delete(ev.id);
+              const resultBlock = {
+                type: "tool_result",
+                tool_use_id: ev.id,
+                content: typeof ev.content === "string" ? ev.content : JSON.stringify(ev.content),
+                is_error: ev.isError
+              };
+              const last = messages[messages.length - 1];
+              const lastIsToolResultUser = last?.role === "user" && Array.isArray(last.content) && last.content.every((b) => b.type === "tool_result");
+              if (lastIsToolResultUser && Array.isArray(last.content)) {
+                last.content.push(resultBlock);
+              } else {
+                messages.push({ role: "user", content: [resultBlock], ts: ev.ts });
+              }
+            }
           }
         } catch {
         }
       }
-      const meta = this.metaFromEvents(id, events);
-      const { messages, usage } = this.replay(events, id);
+      if (openToolUses.size > 0) {
+        this.events?.emit("session.damaged", {
+          sessionId: id,
+          detail: `${openToolUses.size} tool_use blocks without matching results - replay repaired`
+        });
+      }
+      const repaired = repairToolUseAdjacency(messages);
+      if (repaired.report.changed) {
+        this.events?.emit("session.damaged", {
+          sessionId: id,
+          detail: `Repaired replay adjacency: removed ${repaired.report.removedToolUses.length} tool_use, ${repaired.report.removedToolResults.length} tool_result, ${repaired.report.removedMessages} empty messages`
+        });
+      }
+      const meta = {
+        id,
+        startedAt: sessionStartEvent?.ts ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+        endedAt: sessionEndEvent?.ts,
+        model: sessionModel,
+        provider: sessionProvider,
+        pendingToolUses: sessionPendingToolUses
+      };
       const toolCallEnds = extractToolCallEnds(events);
-      const data = { metadata: meta, events, messages, usage, toolCallEnds };
+      const data = { metadata: meta, events, messages: repaired.messages, usage, toolCallEnds };
       if (this._loadCache.size >= _DefaultSessionStore.LOAD_CACHE_MAX_ENTRIES) {
         const oldest = this._loadCache.keys().next().value;
         if (oldest !== void 0) {
@@ -681,20 +757,12 @@ var DefaultSessionStore = class _DefaultSessionStore {
         });
         return indexed.slice(0, limit);
       }
-      const ids = await this.collectSessionIds(this.dir);
-      const sessions = await Promise.all(ids.map((id) => this.summaryFor(id).catch(() => null)));
-      const out = sessions.filter((s) => s !== null);
-      out.sort((a, b) => {
-        if (a.startedAt < b.startedAt) return 1;
-        if (a.startedAt > b.startedAt) return -1;
-        return a.id.localeCompare(b.id);
-      });
-      return out.slice(0, limit);
+      return await this.listFromDirectoryScan(limit);
     } catch {
       return [];
     }
   }
-  // ── Session index (_index.jsonl) ─────────────────────────────────────────
+  // ── Session index (_index.jsonl) ─────────────────────────────────────────
   //
   // One JSON line per closed session, appended atomically on close().
   // When a session is deleted, a tombstone {action:"delete",id:"..."} is
@@ -814,43 +882,102 @@ var DefaultSessionStore = class _DefaultSessionStore {
     this._indexCache = null;
     return valid.length;
   }
+  async listFromDirectoryScan(limit) {
+    const refs = await this.collectSessionFiles(this.dir);
+    const candidates = await mapWithConcurrency(
+      refs,
+      _DefaultSessionStore.LIST_SCAN_CONCURRENCY,
+      async (ref) => {
+        const manifest = await this.readSummaryManifest(ref.id);
+        if (manifest) return { summary: manifest, needsBackfill: false };
+        const summary = await this.summaryHeaderFor(ref);
+        return summary ? { summary, needsBackfill: true } : null;
+      }
+    );
+    const out = candidates.filter((s) => s !== null);
+    out.sort((a, b) => compareSessionSummaries(a.summary, b.summary));
+    const selected = out.slice(0, limit);
+    const summaries = await mapWithConcurrency(
+      selected,
+      Math.min(_DefaultSessionStore.LIST_SCAN_CONCURRENCY, Math.max(1, limit)),
+      async (candidate) => {
+        if (!candidate.needsBackfill) return candidate.summary;
+        return await this.summaryFor(candidate.summary.id).catch(() => candidate.summary);
+      }
+    );
+    return summaries.filter((s) => s !== null);
+  }
+  async collectSessionFiles(dir, prefix = "", depth = 0) {
+    let entries;
+    try {
+      entries = await fsp.readdir(dir, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    const dirEntries = [];
+    const files = [];
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && entry.name !== ".wrongstack") continue;
+      if (entry.name === "shared" || entry.name === "subagents" || entry.name === "attachments")
+        continue;
+      if (entry.isDirectory()) {
+        dirEntries.push(entry);
+      } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        if (entry.name === "_index.jsonl") continue;
+        const base = entry.name.replace(/\.jsonl$/, "");
+        const id = prefix ? `${prefix}/${base}` : base;
+        files.push({ id, filePath: path2.join(dir, entry.name) });
+      }
+    }
+    const childFileArrays = await Promise.all(
+      dirEntries.map((entry) => {
+        const childPrefix = depth === 0 ? entry.name : `${prefix}/${entry.name}`;
+        return this.collectSessionFiles(path2.join(dir, entry.name), childPrefix, depth + 1);
+      })
+    );
+    return [...childFileArrays.flat(), ...files];
+  }
   /** Recursively collect session IDs from date-shard subdirectories.
-   *  IDs include the date-prefix path (e.g. "2026-06-06/17-46-57Z_…").
+   *  IDs include the date-prefix path (e.g. "2026-06-06/17-46-57Z_…").
    *  Skips `.jsonl`/`.summary.json` root files, dot-files, and
    *  sub-directories that belong to fleet/subagent sessions. */
   async collectSessionIds(dir, prefix = "", depth = 0) {
-    const ids = [];
     let entries;
     try {
       entries = await fsp.readdir(dir, { withFileTypes: true });
     } catch {
-      return ids;
+      return [];
     }
+    const dirEntries = [];
+    const fileIds = [];
     for (const entry of entries) {
       if (entry.name.startsWith(".") && entry.name !== ".wrongstack") continue;
       if (entry.name === "shared" || entry.name === "subagents" || entry.name === "attachments")
         continue;
       if (entry.isDirectory()) {
-        const childPrefix = depth === 0 ? entry.name : `${prefix}/${entry.name}`;
-        ids.push(...await this.collectSessionIds(path2.join(dir, entry.name), childPrefix, depth + 1));
+        dirEntries.push(entry);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
         if (entry.name === "_index.jsonl") continue;
         const base = entry.name.replace(/\.jsonl$/, "");
-        ids.push(prefix ? `${prefix}/${base}` : base);
+        fileIds.push(prefix ? `${prefix}/${base}` : base);
       }
     }
-    return ids;
+    const childIdArrays = await Promise.all(
+      dirEntries.map((entry) => {
+        const childPrefix = depth === 0 ? entry.name : `${prefix}/${entry.name}`;
+        return this.collectSessionIds(path2.join(dir, entry.name), childPrefix, depth + 1);
+      })
+    );
+    return [...childIdArrays.flat(), ...fileIds];
   }
   async summaryFor(id) {
     const manifest = this.sessionPath(id, ".summary.json");
     const t0 = Date.now();
     let outcome = "success";
     let errorMsg;
+    const fromManifest = await this.readSummaryManifest(id, t0);
+    if (fromManifest) return fromManifest;
     try {
-      const raw = await fsp.readFile(manifest, "utf8");
-      this.emitRead(id, manifest, "summary", "success", Date.now() - t0);
-      return JSON.parse(raw);
-    } catch {
       const full = this.sessionPath(id, ".jsonl");
       const stat7 = await fsp.stat(full);
       const summary = await this.summarize(id, stat7.mtime.toISOString());
@@ -866,9 +993,81 @@ var DefaultSessionStore = class _DefaultSessionStore {
         }));
       });
       outcome = "failure";
-      errorMsg = "summary fallback \u2014 manifest rebuilt";
+      errorMsg = "summary fallback \xE2\u20AC\u201D manifest rebuilt";
       this.emitRead(id, manifest, "summary", outcome, Date.now() - t0, errorMsg);
       return summary;
+    } catch (err) {
+      outcome = "failure";
+      errorMsg = toErrorMessage(err);
+      this.emitRead(id, manifest, "summary", outcome, Date.now() - t0, errorMsg);
+      return {
+        id,
+        title: "(damaged)",
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        model: "unknown",
+        provider: "unknown",
+        tokenTotal: 0
+      };
+    }
+  }
+  async readSummaryManifest(id, startTime = Date.now()) {
+    const manifest = this.sessionPath(id, ".summary.json");
+    try {
+      const raw = await fsp.readFile(manifest, "utf8");
+      this.emitRead(id, manifest, "summary", "success", Date.now() - startTime);
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  async summaryHeaderFor(ref) {
+    let mtime = (/* @__PURE__ */ new Date(0)).toISOString();
+    try {
+      const stat7 = await fsp.stat(ref.filePath);
+      if (!stat7.isFile()) {
+        return {
+          id: ref.id,
+          title: "(damaged)",
+          startedAt: stat7.mtime.toISOString(),
+          model: "unknown",
+          provider: "unknown",
+          tokenTotal: 0
+        };
+      }
+      mtime = stat7.mtime.toISOString();
+    } catch {
+      return null;
+    }
+    try {
+      for await (const event of this.iterSessionEvents(ref.filePath)) {
+        if (event.type === "session_start") {
+          return {
+            id: ref.id,
+            title: "(empty session)",
+            startedAt: event.ts,
+            model: event.model ?? "unknown",
+            provider: event.provider ?? "unknown",
+            tokenTotal: 0
+          };
+        }
+      }
+      return {
+        id: ref.id,
+        title: "(empty session)",
+        startedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+        model: "unknown",
+        provider: "unknown",
+        tokenTotal: 0
+      };
+    } catch {
+      return {
+        id: ref.id,
+        title: "(damaged)",
+        startedAt: mtime,
+        model: "unknown",
+        provider: "unknown",
+        tokenTotal: 0
+      };
     }
   }
   /**
@@ -993,39 +1192,62 @@ var DefaultSessionStore = class _DefaultSessionStore {
   }
   async summarize(id, mtime) {
     try {
-      const data = await this.load(id);
-      const firstUser = data.events.find((e) => e.type === "user_input");
-      const title = firstUser && firstUser.type === "user_input" ? userInputTitle(firstUser.content) : "(empty session)";
+      const file = this.sessionPath(id, ".jsonl");
+      let title = "(empty session)";
+      let startedAt = (/* @__PURE__ */ new Date(0)).toISOString();
+      let endedAt;
+      let model = "unknown";
+      let provider = "unknown";
+      let tokenIn = 0;
+      let tokenOut = 0;
       let iterationCount = 0;
       let toolCallCount = 0;
       let toolErrorCount = 0;
       let fileChangeCount = 0;
       const toolBreakdown = {};
       let outcome;
-      const lastEvent = data.events[data.events.length - 1];
-      for (const e of data.events) {
-        if (e.type === "in_flight_start") iterationCount++;
+      let lastEventType;
+      let hasError = false;
+      let sawStart = false;
+      for await (const e of this.iterSessionEvents(file)) {
+        lastEventType = e.type;
+        if (e.type === "session_start") {
+          if (!sawStart) {
+            sawStart = true;
+            startedAt = e.ts;
+            model = e.model ?? "unknown";
+            provider = e.provider ?? "unknown";
+          }
+        } else if (e.type === "session_end") {
+          endedAt = e.ts;
+        } else if (e.type === "user_input") {
+          if (title === "(empty session)") title = userInputTitle(e.content);
+        } else if (e.type === "llm_response") {
+          tokenIn += e.usage.input ?? 0;
+          tokenOut += e.usage.output ?? 0;
+        } else if (e.type === "in_flight_start") iterationCount++;
         else if (e.type === "tool_call_start") {
           toolCallCount++;
           toolBreakdown[e.name] = (toolBreakdown[e.name] ?? 0) + 1;
         } else if (e.type === "tool_result" && e.isError) toolErrorCount++;
         else if (e.type === "file_snapshot") fileChangeCount += e.files.length;
+        else if (e.type === "error" || e.type === "provider_error") hasError = true;
       }
-      if (lastEvent?.type === "session_end") {
+      if (lastEventType === "session_end") {
         outcome = "completed";
-      } else if (lastEvent?.type === "in_flight_start") {
+      } else if (lastEventType === "in_flight_start") {
         outcome = "aborted";
-      } else if (data.events.some((e) => e.type === "error")) {
+      } else if (hasError) {
         outcome = "error";
       }
       return {
         id,
         title,
-        startedAt: data.metadata.startedAt,
-        endedAt: data.metadata.endedAt,
-        model: data.metadata.model ?? "unknown",
-        provider: data.metadata.provider ?? "unknown",
-        tokenTotal: data.usage.input + data.usage.output,
+        startedAt,
+        endedAt,
+        model,
+        provider,
+        tokenTotal: tokenIn + tokenOut,
         iterationCount: iterationCount > 0 ? iterationCount : void 0,
         toolCallCount: toolCallCount > 0 ? toolCallCount : void 0,
         toolErrorCount: toolErrorCount > 0 ? toolErrorCount : void 0,
@@ -1044,75 +1266,24 @@ var DefaultSessionStore = class _DefaultSessionStore {
       };
     }
   }
-  metaFromEvents(id, events) {
-    const start = events.find((e) => e.type === "session_start");
-    const end = events.findLast((e) => e.type === "session_end");
-    return {
-      id,
-      startedAt: start?.ts ?? (/* @__PURE__ */ new Date(0)).toISOString(),
-      endedAt: end?.ts,
-      model: start?.model,
-      provider: start?.provider,
-      pendingToolUses: end?.pendingToolUses
-    };
-  }
-  replay(events, sessionId = "unknown") {
-    const messages = [];
-    let usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
-    const openToolUses = /* @__PURE__ */ new Set();
-    for (const e of events) {
-      if (e.type === "user_input") {
-        openToolUses.clear();
-        messages.push({ role: "user", content: e.content, ts: e.ts });
-      } else if (e.type === "llm_response") {
-        messages.push({ role: "assistant", content: e.content, ts: e.ts });
-        for (const b of e.content) {
-          if (b.type === "tool_use") openToolUses.add(b.id);
-        }
-        usage = {
-          input: usage.input + (e.usage.input ?? 0),
-          output: usage.output + (e.usage.output ?? 0),
-          cacheRead: (usage.cacheRead ?? 0) + (e.usage.cacheRead ?? 0),
-          cacheWrite: (usage.cacheWrite ?? 0) + (e.usage.cacheWrite ?? 0)
-        };
-      } else if (e.type === "tool_result") {
-        if (!openToolUses.has(e.id)) {
-          this.events?.emit("session.damaged", {
-            sessionId,
-            detail: `Orphan tool_result "${e.id}" has no matching tool_use`
-          });
-          continue;
-        }
-        openToolUses.delete(e.id);
-        const resultBlock = {
-          type: "tool_result",
-          tool_use_id: e.id,
-          content: typeof e.content === "string" ? e.content : JSON.stringify(e.content),
-          is_error: e.isError
-        };
-        const last = messages[messages.length - 1];
-        const lastIsToolResultUser = last?.role === "user" && Array.isArray(last.content) && last.content.every((b) => b.type === "tool_result");
-        if (lastIsToolResultUser && Array.isArray(last.content)) {
-          last.content.push(resultBlock);
-        } else {
-          messages.push({ role: "user", content: [resultBlock], ts: e.ts });
+  async *iterSessionEvents(file) {
+    const stream = createReadStream(file, { encoding: "utf8" });
+    const lines = createInterface({ input: stream, crlfDelay: Infinity });
+    try {
+      for await (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const parsed = JSON.parse(line);
+          if (parsed !== null && typeof parsed === "object" && typeof parsed.type === "string" && typeof parsed.ts === "string") {
+            yield parsed;
+          }
+        } catch {
         }
       }
+    } finally {
+      lines.close();
+      stream.destroy();
     }
-    if (openToolUses.size > 0) {
-      this.events?.emit("session.damaged", {
-        sessionId,
-        detail: `${openToolUses.size} tool_use blocks without matching results - replay repaired`
-      });
-    }
-    const repaired = repairToolUseAdjacency(messages);
-    if (repaired.report.changed) {
-      this.events?.emit("session.damaged", {
-        sessionId,
-        detail: `Repaired replay adjacency: removed ${repaired.report.removedToolUses.length} tool_use, ${repaired.report.removedToolResults.length} tool_result, ${repaired.report.removedMessages} empty messages`
-      });
-    }
-    return { messages: repaired.messages, usage };
   }
 };
 function extractToolCallEnds(events) {
@@ -1172,7 +1343,7 @@ var FileSessionWriter = class _FileSessionWriter {
   /**
    * Lazy session_start/session_resumed init, shared by all appenders.
    * A single promise (not a boolean) so a second append racing the first
-   * can't push its event into the buffer BEFORE the first append's event —
+   * can't push its event into the buffer BEFORE the first append's event —
    * every appender awaits the same init and resumes in FIFO call order.
    */
   initPromise = null;
@@ -1185,24 +1356,24 @@ var FileSessionWriter = class _FileSessionWriter {
   lastAppendWarnAt = 0;
   secretScrubber;
   onCloseCb;
-  /** Implements SessionWriter.traceId — propagated from ContextInit.traceId. */
+  /** Implements SessionWriter.traceId — propagated from ContextInit.traceId. */
   traceId;
-  // ── Write buffer — batches events to reduce per-event disk I/O ─────────
+  // ── Write buffer — batches events to reduce per-event disk I/O ─────────
   //
   // Every append() pushes the scrubbed event into an in-memory buffer instead
   // of calling handle.appendFile() synchronously. The buffer flushes to disk
   // when it reaches FLUSH_SIZE events OR after FLUSH_INTERVAL_MS of inactivity.
   // This cuts the number of disk writes by ~95% without changing the on-disk
-  // format — the JSONL is still one JSON object per line.
+  // format — the JSONL is still one JSON object per line.
   writeBuffer = [];
   flushTimer = null;
   static FLUSH_INTERVAL_MS = 500;
   static FLUSH_SIZE = 50;
-  // ── Write serialization ─────────────────────────────────────────────────
+  // ── Write serialization ─────────────────────────────────────────────────
   //
   // All disk writes are funneled through a FIFO promise chain. Without it,
   // a timer-driven flush racing an explicit flush()/close() issues two
-  // concurrent appendFile() calls on the shared O_APPEND handle — the kernel
+  // concurrent appendFile() calls on the shared O_APPEND handle — the kernel
   // may complete them out of order (chronology breaks) or, for large
   // batches, interleave partial writes (torn JSONL lines). The chain keeps
   // exactly one write in flight; failures don't break the chain.
@@ -1216,7 +1387,7 @@ var FileSessionWriter = class _FileSessionWriter {
     );
     return write;
   }
-  // ── Enriched summary tracking ──────────────────────────────────────────
+  // ── Enriched summary tracking ──────────────────────────────────────────
   iterationCount = 0;
   toolCallCount = 0;
   toolErrorCount = 0;
@@ -1308,7 +1479,7 @@ var FileSessionWriter = class _FileSessionWriter {
    * (user_input, llm_response) call this so they survive SIGKILL/crash
    * instead of sitting in the in-memory buffer for up to 500ms.
    *
-   * Idempotent — cancels any pending timer and writes whatever has
+   * Idempotent — cancels any pending timer and writes whatever has
    * accumulated in the buffer. Safe to call even when the buffer
    * is empty (no-op).
    */
@@ -1331,7 +1502,7 @@ var FileSessionWriter = class _FileSessionWriter {
   /**
    * Flush all buffered events to disk as a single appendFile call.
    * Errors use the same throttled-warning pattern the old per-event
-   * append path used — one warning every 5s with a suppressed count.
+   * append path used — one warning every 5s with a suppressed count.
    * On failure the buffer is cleared (events are best-effort, same as
    * the old per-event path where a failed write was silently dropped).
    */
@@ -1514,7 +1685,7 @@ var FileSessionWriter = class _FileSessionWriter {
   /**
    * Truncate the session file to the checkpoint with the given promptIndex,
    * removing all events that follow it. Uses a single-pass byte-offset scan
-   * so post-checkpoint content is never read or parsed — O(1) memory instead
+   * so post-checkpoint content is never read or parsed — O(1) memory instead
    * of O(N) JSON.parse calls over the full file.
    */
   async truncateToCheckpoint(targetPromptIndex) {
@@ -1671,7 +1842,7 @@ var FileSessionWriter = class _FileSessionWriter {
     await fsp.writeFile(this.filePath, record, "utf8");
   }
   /**
-   * Idea #1 — write an in-flight marker. The agent loop should call
+   * Idea #1 — write an in-flight marker. The agent loop should call
    * this at the start of each long-running operation; a matching
    * `clearInFlightMarker` follows on clean exit. A stale marker
    * (no end) is what `SessionRecovery.detectStale` looks for.
@@ -1688,9 +1859,9 @@ var FileSessionWriter = class _FileSessionWriter {
     this.events?.emit("in_flight.started", { context, ts: (/* @__PURE__ */ new Date()).toISOString() });
   }
   /**
-   * Idea #1 — close the in-flight marker. Idempotent in spirit
+   * Idea #1 — close the in-flight marker. Idempotent in spirit
    * (you can call it after a successful iteration even if you
-   * didn't open one this round) — but the session log records
+   * didn't open one this round) — but the session log records
    * every call so postmortem tooling can see "the agent finished
    * cleanly X times, then died without finishing Y".
    */
@@ -1707,6 +1878,27 @@ function userInputTitle(content) {
   const text = typeof content === "string" ? content : content.filter((b) => b.type === "text").map((b) => b.text).join(" ");
   return (text || "(non-text input)").slice(0, 60);
 }
+function compareSessionSummaries(a, b) {
+  if (a.startedAt < b.startedAt) return 1;
+  if (a.startedAt > b.startedAt) return -1;
+  return a.id.localeCompare(b.id);
+}
+async function mapWithConcurrency(items, concurrency, fn) {
+  if (items.length === 0) return [];
+  const out = new Array(items.length);
+  let next = 0;
+  const workerCount = Math.min(Math.max(1, concurrency), items.length);
+  const workers = Array.from({ length: workerCount }, async () => {
+    for (; ; ) {
+      const idx = next++;
+      if (idx >= items.length) return;
+      const item = items[idx];
+      if (item !== void 0) out[idx] = await fn(item);
+    }
+  });
+  await Promise.all(workers);
+  return out;
+}
 var QueueStore = class {
   file;
   // Use `| undefined` (not `?`) so exactOptionalPropertyTypes doesn't
@@ -2287,6 +2479,20 @@ var DefaultMemoryStore = class {
    */
   persistBackup;
   backupDir;
+  /**
+   * Per-scope tracked byte sizes — incremented on `remember()`, decremented on
+   * `forget()`, recalculated after `consolidate()`. Eliminates the redundant
+   * readAll() call that previously checked the file size after every write.
+   */
+  _trackedByteSizes = {};
+  /** Result cache for scoreRelevant() — keyed by scope + context hash, TTL 30s. */
+  _scoreCache = /* @__PURE__ */ new Map();
+  /**
+   * Per-entry cached lowercase strings — computed once per scoreRelevant() call,
+   * stored here so repeated scoring of the same entries avoids re-computation.
+   * Cleared on every mutation (remember/forget/consolidate/clear).
+   */
+  _cachedLower = null;
   constructor(opts) {
     this.files = {
       "project-agents": opts.paths.inProjectAgentsFile,
@@ -2320,6 +2526,20 @@ var DefaultMemoryStore = class {
       }
     }
   }
+  /**
+   * Recalculate the tracked byte size for a scope by re-reading the file and
+   * summing the serialized byte length of each line. Called after consolidate()
+   * (which modifies the file) to keep the tracker accurate.
+   */
+  async _recalcTrackedByteSize(scope) {
+    const raw = await this.backend.readAll(scope, this.files[scope]);
+    let total = 0;
+    for (const line of raw.split("\n")) {
+      if (line.trim()) total += Buffer.byteLength(line, "utf8");
+    }
+    this._trackedByteSizes[scope] = total;
+    return total;
+  }
   async readAll() {
     const parts = [];
     for (const scope of ["project-agents", "project-memory", "user-memory"]) {
@@ -2420,6 +2640,7 @@ ${body.trim()}`);
       const t0 = Date.now();
       try {
         await this.backend.remember(scope, entry, filePath);
+        this._scoreCache.clear();
         const dur = Date.now() - t0;
         this.events?.emit("storage.write", {
           sessionId: "~memory~",
@@ -2444,16 +2665,21 @@ ${body.trim()}`);
         });
         throw err;
       }
-      const raw = await this.backend.readAll(scope, this.files[scope]);
-      if (Buffer.byteLength(raw, "utf8") > MAX_BYTES_TOTAL) {
+      let trackedSize = this._trackedByteSizes[scope];
+      if (trackedSize === void 0) {
+        trackedSize = await this._recalcTrackedByteSize(scope);
+      }
+      if (trackedSize > MAX_BYTES_TOTAL) {
         const removed = await this.backend.consolidate(scope, this.files[scope]);
         if (removed > 0) {
           this.events?.emit("memory.consolidated", {
             scope,
             removed
           });
+          await this._recalcTrackedByteSize(scope);
         }
       }
+      this._trackedByteSizes[scope] = (this._trackedByteSizes[scope] ?? 0) + Buffer.byteLength(JSON.stringify(entry), "utf8");
       await this.mirrorBackup(scope);
       this.events?.emit("memory.remembered", {
         scope,
@@ -2472,16 +2698,30 @@ ${body.trim()}`);
   async scoreRelevant(ctx, scope = "project-memory", limit = 8) {
     const all = await this.list(scope);
     if (all.length === 0) return [];
+    const ctxHash = `${scope}|${ctx.currentTask}|${(ctx.activeSkills ?? []).join(",")}|${(ctx.toolNames ?? []).join(",")}`;
+    const now = Date.now();
+    const TTL_MS = 3e4;
+    const cached = this._scoreCache.get(ctxHash);
+    if (cached && cached.expiresAt > now && cached.entries === all) {
+      return cached.scored.slice(0, Math.min(limit, 15));
+    }
     const taskWords = ctx.currentTask.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
     const skillWords = (ctx.activeSkills ?? []).flatMap((s) => s.split("-"));
     const toolWords = (ctx.toolNames ?? []).flatMap((t) => t.toLowerCase().split("_"));
-    const now = Date.now();
+    this._cachedLower = /* @__PURE__ */ new WeakMap();
     const scored = [];
     for (const entry of all) {
       let score = 0;
       const reasons = [];
-      const textLower = entry.text.toLowerCase();
-      const tagsLower = (entry.tags ?? []).map((t) => t.toLowerCase());
+      let cachedLower = this._cachedLower.get(entry);
+      if (!cachedLower) {
+        cachedLower = {
+          textLower: entry.text.toLowerCase(),
+          tagsLower: (entry.tags ?? []).map((t) => t.toLowerCase())
+        };
+        this._cachedLower.set(entry, cachedLower);
+      }
+      const { textLower, tagsLower } = cachedLower;
       let taskHits = 0;
       for (const w of taskWords) {
         if (textLower.includes(w)) {
@@ -2567,6 +2807,7 @@ ${body.trim()}`);
     const relevant = scored.filter(
       (s) => s.score >= threshold || s.priority === "critical" || s.priority === "high"
     );
+    this._scoreCache.set(ctxHash, { entries: all, scored: relevant, expiresAt: now + TTL_MS });
     return relevant.slice(0, Math.min(limit, 15));
   }
   async forget(query, scope = "project-memory") {
@@ -2576,6 +2817,7 @@ ${body.trim()}`);
       let removed = 0;
       try {
         removed = await this.backend.forget(scope, query, filePath);
+        this._scoreCache.clear();
         const dur = Date.now() - t0;
         this.events?.emit("storage.write", {
           sessionId: "~memory~",
@@ -2607,6 +2849,7 @@ ${body.trim()}`);
           removed
         });
         await this.mirrorBackup(scope);
+        await this._recalcTrackedByteSize(scope);
       }
       return removed;
     });
@@ -2618,6 +2861,7 @@ ${body.trim()}`);
       let removed = 0;
       try {
         removed = await this.backend.consolidate(scope, filePath);
+        this._scoreCache.clear();
         const dur = Date.now() - t0;
         this.events?.emit("storage.write", {
           sessionId: "~memory~",
@@ -2648,6 +2892,7 @@ ${body.trim()}`);
           removed
         });
         await this.mirrorBackup(scope);
+        await this._recalcTrackedByteSize(scope);
       }
     });
   }
@@ -2658,6 +2903,7 @@ ${body.trim()}`);
         const t0 = Date.now();
         try {
           await this.backend.clear(scope, filePath);
+          this._scoreCache.clear();
           const dur = Date.now() - t0;
           this.events?.emit("storage.write", {
             sessionId: "~memory~",
@@ -2684,6 +2930,7 @@ ${body.trim()}`);
         }
         this.events?.emit("memory.cleared", { scope });
         await this.mirrorBackup(scope);
+        this._trackedByteSizes[scope] = 0;
       });
       return;
     }
@@ -2767,6 +3014,12 @@ var GraphMemoryBackend = class {
   edges = [];
   loadedScope = null;
   loaded = false;
+  /**
+   * Promise that resolves when the current in-flight _saveGraph completes.
+   * Tests call flush() to await this before deleting the backend or its temp dir.
+   * Each save operation chains onto the previous one so concurrent saves are serialised.
+   */
+  _saveDone = Promise.resolve();
   constructor(opts) {
     this.file = new FileMemoryBackend({ paths: opts.paths });
     this.graphFile = opts.graphPath ?? `${opts.paths.projectDir}/memory-graph.json`;
@@ -2793,7 +3046,8 @@ var GraphMemoryBackend = class {
         tags: entry.tags,
         priority: entry.priority
       });
-      for (const [, other] of this.nodes) {
+      const recentNodes = [...this.nodes.values()].slice(-100);
+      for (const other of recentNodes) {
         if (other.id === nodeId) continue;
         const sim = wordOverlap(entry.text, other.entry.text);
         const tagSim = sharedTags(entry.tags ?? [], other.tags ?? []);
@@ -2809,7 +3063,8 @@ var GraphMemoryBackend = class {
         }
       }
     }
-    await this.saveGraph(scope);
+    this._saveDone = this._saveGraph(scope);
+    await this._saveDone;
   }
   async forget(scope, query, filePath) {
     const removed = await this.file.forget(scope, query, filePath);
@@ -2824,7 +3079,8 @@ var GraphMemoryBackend = class {
       }
       for (const id of toRemove) this.nodes.delete(id);
       this.edges = this.edges.filter((e) => !toRemove.includes(e.from) && !toRemove.includes(e.to));
-      await this.saveGraph(scope);
+      this._saveDone = this._saveGraph(scope);
+      await this._saveDone;
     }
     return removed;
   }
@@ -2936,7 +3192,8 @@ var GraphMemoryBackend = class {
     this.loadedScope = scope;
     this.loaded = true;
   }
-  async saveGraph(scope) {
+  /** Fire-and-forget graph persistence. Named _saveGraph to signal it must not be awaited. */
+  async _saveGraph(scope) {
     this.loadedScope = scope;
     this.loaded = true;
     try {
@@ -2944,16 +3201,21 @@ var GraphMemoryBackend = class {
         nodes: [...this.nodes.entries()],
         edges: this.edges
       };
-      await fsp.mkdir(
-        this.graphFile.substring(0, this.graphFile.lastIndexOf("/")),
-        { recursive: true }
-      );
+      const dir = this.graphFile.substring(0, this.graphFile.lastIndexOf("/"));
+      await fsp.mkdir(dir, { recursive: true });
       const tmp = `${this.graphFile}.tmp`;
       await fsp.writeFile(tmp, JSON.stringify(data));
       await fsp.rename(tmp, this.graphFile);
     } catch {
     }
   }
+  /**
+   * Wait for all in-flight _saveGraph operations to complete.
+   * Call this before deleting the backend or its temp directory.
+   */
+  async flush() {
+    await this._saveDone;
+  }
 };
 function wordOverlap(a, b) {
   const wordsA = new Set(a.toLowerCase().split(/\s+/).filter((w) => w.length > 2));
@@ -3054,84 +3316,89 @@ var SessionMemoryConsolidator = class {
     this.minIterations = opts.minIterations ?? 2;
     this.maxExistingEntries = opts.maxExistingEntries ?? 15;
   }
-  afterRun = async (ctx, result) => {
+  afterRun = (ctx, result) => {
     if (result.status !== "done") return;
     if (!result.finalText || result.finalText.trim().length < 20) return;
     if (result.iterations < this.minIterations) return;
     const provider = this.provider ?? ctx.provider;
     if (!provider?.complete) return;
-    try {
-      const existingEntries = await this.memoryStore.list("project-memory", this.maxExistingEntries);
-      const prompt = buildConsolidationPrompt(
-        result.finalText,
-        result.iterations,
-        existingEntries
-      );
-      const signal = AbortSignal.timeout(15e3);
-      const response = await provider.complete(
-        {
-          model: this.model ?? ctx.model,
-          system: [{ type: "text", text: prompt }],
-          messages: [
-            { role: "user", content: "Review the session and return memory operations as JSON." }
-          ],
-          maxTokens: 500
-        },
-        { signal }
-      );
-      const text = response.content.filter((b) => b.type === "text").map((b) => b.text).join("").trim();
-      if (!text) return;
-      const jsonMatch = text.match(/\{[\s\S]*\}/);
-      if (!jsonMatch) return;
-      const parsed = JSON.parse(jsonMatch[0]);
-      if (!Array.isArray(parsed.operations) || parsed.operations.length === 0) return;
-      let added = 0;
-      let edited = 0;
-      let deleted = 0;
-      for (const op of parsed.operations) {
-        switch (op.action) {
-          case "add": {
-            if (op.text?.trim()) {
-              await this.memoryStore.remember(op.text.trim(), void 0, {
-                type: op.type,
-                tags: op.tags,
-                priority: op.priority
-              });
-              added++;
+    const _finalText = result.finalText;
+    const _iterations = result.iterations;
+    const _model = this.model ?? ctx.model;
+    void (async () => {
+      try {
+        const existingEntries = await this.memoryStore.list("project-memory", this.maxExistingEntries);
+        const prompt = buildConsolidationPrompt(
+          _finalText,
+          _iterations,
+          existingEntries
+        );
+        const signal = AbortSignal.timeout(15e3);
+        const response = await provider.complete(
+          {
+            model: _model,
+            system: [{ type: "text", text: prompt }],
+            messages: [
+              { role: "user", content: "Review the session and return memory operations as JSON." }
+            ],
+            maxTokens: 500
+          },
+          { signal }
+        );
+        const text = response.content.filter((b) => b.type === "text").map((b) => b.text).join("").trim();
+        if (!text) return;
+        const jsonMatch = text.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) return;
+        const parsed = JSON.parse(jsonMatch[0]);
+        if (!Array.isArray(parsed.operations) || parsed.operations.length === 0) return;
+        let added = 0;
+        let edited = 0;
+        let deleted = 0;
+        for (const op of parsed.operations) {
+          switch (op.action) {
+            case "add": {
+              if (op.text?.trim()) {
+                await this.memoryStore.remember(op.text.trim(), void 0, {
+                  type: op.type,
+                  tags: op.tags,
+                  priority: op.priority
+                });
+                added++;
+              }
+              break;
             }
-            break;
-          }
-          case "edit": {
-            if (op.query && op.text?.trim()) {
-              await this.memoryStore.forget(op.query);
-              await this.memoryStore.remember(op.text.trim(), void 0, {
-                type: op.type,
-                tags: op.tags,
-                priority: op.priority
-              });
-              edited++;
+            case "edit": {
+              if (op.query && op.text?.trim()) {
+                await this.memoryStore.forget(op.query);
+                await this.memoryStore.remember(op.text.trim(), void 0, {
+                  type: op.type,
+                  tags: op.tags,
+                  priority: op.priority
+                });
+                edited++;
+              }
+              break;
             }
-            break;
-          }
-          case "delete": {
-            if (op.query) {
-              const n = await this.memoryStore.forget(op.query);
-              deleted += n;
+            case "delete": {
+              if (op.query) {
+                const n = await this.memoryStore.forget(op.query);
+                deleted += n;
+              }
+              break;
             }
-            break;
           }
         }
-      }
-      if (added > 0 || edited > 0 || deleted > 0) {
-        const parts = [];
-        if (added) parts.push(`${added} added`);
-        if (edited) parts.push(`${edited} edited`);
-        if (deleted) parts.push(`${deleted} deleted`);
-        process.stderr.write(`[memory] Session consolidation: ${parts.join(", ")}
+        if (added > 0 || edited > 0 || deleted > 0) {
+          const parts = [];
+          if (added) parts.push(`${added} added`);
+          if (edited) parts.push(`${edited} edited`);
+          if (deleted) parts.push(`${deleted} deleted`);
+          process.stderr.write(`[memory] Session consolidation: ${parts.join(", ")}
 `);
+        }
+      } catch {
       }
-    } catch {
-    }
+    })();
   };
 };
 
@@ -3297,8 +3564,13 @@ function deepFreeze(obj) {
   return Object.freeze(obj);
 }
 var KEY_BYTES = 32;
+var IV_BYTES = 12;
+var TAG_BYTES = 16;
 var KEY_FILE_MAGIC = Buffer.from("WSKV", "ascii");
 KEY_FILE_MAGIC.length + 1 + KEY_BYTES;
+var KEK_MAGIC = Buffer.from("WSKW", "ascii");
+var KEK_SALT_BYTES = 16;
+KEK_MAGIC.length + 1 + KEK_SALT_BYTES + IV_BYTES + TAG_BYTES + KEY_BYTES;
 function decryptConfigSecrets(cfg, vault, opts) {
   const warn = ((msg) => console.warn(msg));
   return walk(cfg, vault, (v, key) => {
@@ -3514,6 +3786,51 @@ var defaultIndexing = {
   watchExternal: true,
   debounceMs: 400
 };
+var IN_PROJECT_FORBIDDEN_KEYS = /* @__PURE__ */ new Set([
+  "provider",
+  "apiKey",
+  "baseUrl",
+  "providers",
+  "mcpServers",
+  "hooks",
+  "plugins",
+  "sync",
+  "yolo",
+  "extensions"
+]);
+function stripUnsafeInProjectFields(inProject, sourcePath, warn = (msg) => console.warn(msg)) {
+  const stripped = [];
+  const out = {};
+  for (const [k, v] of Object.entries(inProject)) {
+    if (IN_PROJECT_FORBIDDEN_KEYS.has(k)) {
+      stripped.push(k);
+      continue;
+    }
+    out[k] = v;
+  }
+  if (stripped.length > 0) {
+    warn(
+      JSON.stringify({
+        level: "warn",
+        event: "config.in_project_unsafe_fields_ignored",
+        path: sourcePath,
+        ignoredKeys: stripped,
+        message: `Ignored ${stripped.length} unsafe field(s) from the repo-committed config "${sourcePath}": ${stripped.join(", ")}. These can only be set in your personal ~/.wrongstack/config.json, not in a project-committed file.`,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+  }
+  return out;
+}
+function samePath(a, b) {
+  let ra = path2.resolve(a);
+  let rb = path2.resolve(b);
+  if (process.platform === "win32" || process.platform === "darwin") {
+    ra = ra.toLowerCase();
+    rb = rb.toLowerCase();
+  }
+  return ra === rb;
+}
 function deepMerge2(base, patch) {
   const opts = { arrayMode: "concat-primitives" };
   if (envBoolOptional(process.env.WRONGSTACK_DEBUG_CONFIG)) {
@@ -3542,14 +3859,15 @@ var DefaultConfigLoader = class {
   }
   async load(opts = {}) {
     let cfg = { ...BEHAVIOR_DEFAULTS };
+    const inProjectCollides = samePath(this.paths.inProjectConfig, this.paths.globalConfig) || samePath(this.paths.inProjectConfig, this.paths.projectLocalConfig);
     const [global, local, inProject] = await Promise.all([
       this.readJson(this.paths.globalConfig),
       this.readJson(this.paths.projectLocalConfig),
-      this.readJson(this.paths.inProjectConfig)
+      inProjectCollides ? Promise.resolve({}) : this.readJson(this.paths.inProjectConfig)
     ]);
     cfg = deepMerge2(cfg, global);
     cfg = deepMerge2(cfg, local);
-    cfg = deepMerge2(cfg, inProject);
+    cfg = deepMerge2(cfg, stripUnsafeInProjectFields(inProject, this.paths.inProjectConfig));
     for (const [key, fn] of Object.entries(ENV_MAP)) {
       const v = process.env[key];
       if (v) fn(cfg, v);
@@ -5814,6 +6132,9 @@ var AgentStatusTracker = class {
   leaderName;
   // Live agent map: agentId → AgentEntry
   agents = /* @__PURE__ */ new Map();
+  // Last full agent list flushed (leader + subagents). Lets external consumers
+  // read the current state synchronously without re-deriving it.
+  lastAgents = [];
   // Leader tracking
   leaderStatus = "idle";
   leaderCurrentTool;
@@ -5825,6 +6146,7 @@ var AgentStatusTracker = class {
   leaderCtxPct;
   leaderModel;
   leaderPartialText = "";
+  leaderStartedAt;
   unsubscribers = [];
   onUpdate;
   sweepTimer = null;
@@ -5835,9 +6157,17 @@ var AgentStatusTracker = class {
     this.leaderName = opts.leaderName ?? "leader";
     this.onUpdate = opts.onUpdate;
   }
+  /** Current full agent list (leader + subagents) as of the last flush. */
+  getAgents() {
+    return this.lastAgents.length > 0 ? [...this.lastAgents] : [];
+  }
   start() {
     this.unsubscribers.push(
-      this.events.onPattern("agent.run.started", () => {
+      this.events.onPattern("agent.run.started", (_event, payload) => {
+        const p = payload;
+        this.markLeaderStarted(p?.at);
+        this.captureLeaderContext(p?.ctx);
+        if (p?.model) this.leaderModel = p.model;
         this.leaderStatus = "running";
         this.leaderIterations++;
         this.flush();
@@ -5845,25 +6175,36 @@ var AgentStatusTracker = class {
     );
     this.unsubscribers.push(
       this.events.onPattern("iteration.started", (_e, payload) => {
-        const ctx = payload?.ctx;
-        if (!ctx) return;
-        if (ctx.model) this.leaderModel = ctx.model;
-        if (typeof ctx.tokenCount === "number" && typeof ctx.maxContext === "number" && ctx.maxContext > 0) {
-          this.leaderCtxPct = Math.round(ctx.tokenCount / ctx.maxContext * 100);
+        const p = payload;
+        const ctx = p?.ctx;
+        this.markLeaderStarted();
+        this.leaderStatus = "running";
+        if (typeof p?.index === "number") {
+          this.leaderIterations = Math.max(this.leaderIterations, p.index + 1);
         }
+        if (!ctx) {
+          this.flush();
+          return;
+        }
+        this.captureLeaderContext(ctx);
         this.flush();
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("agent.run.completed", () => {
-        this.leaderStatus = "idle";
+      this.events.onPattern("agent.run.completed", (_event, payload) => {
+        const p = payload;
+        this.captureLeaderContext(p?.ctx);
+        this.leaderStatus = p?.status === "failed" ? "error" : "idle";
         this.leaderCurrentTool = void 0;
         this.leaderPartialText = "";
+        if (this.leaderStatus === "idle") this.leaderStartedAt = void 0;
         this.flush();
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("agent.run.error", () => {
+      this.events.onPattern("agent.run.error", (_event, payload) => {
+        const p = payload;
+        this.captureLeaderContext(p?.ctx);
         this.leaderStatus = "error";
         this.leaderCurrentTool = void 0;
         this.leaderPartialText = "";
@@ -5874,6 +6215,7 @@ var AgentStatusTracker = class {
       this.events.onPattern("tool.started", (_event, payload) => {
         const p = payload;
         if (p?.name) {
+          this.markLeaderStarted();
           this.leaderCurrentTool = p.name;
           this.leaderToolCalls++;
         }
@@ -5889,12 +6231,14 @@ var AgentStatusTracker = class {
     );
     this.unsubscribers.push(
       this.events.onPattern("brain.ask_human", () => {
+        this.markLeaderStarted();
         this.leaderStatus = "waiting_user";
         this.flush();
       })
     );
     this.unsubscribers.push(
       this.events.onPattern("llm.stream_started", () => {
+        this.markLeaderStarted();
         this.leaderStatus = "streaming";
         this.leaderPartialText = "";
         this.flush();
@@ -5902,14 +6246,42 @@ var AgentStatusTracker = class {
     );
     this.unsubscribers.push(
       this.events.onPattern("provider.text_delta", (_e, payload) => {
-        const text = payload?.text;
+        const p = payload;
+        const text = p?.text;
         if (!text) return;
+        this.markLeaderStarted();
+        this.captureLeaderContext(p?.ctx);
         this.leaderStatus = "streaming";
         const next = this.leaderPartialText + text;
         this.leaderPartialText = next.length > PARTIAL_TEXT_CAP ? next.slice(next.length - PARTIAL_TEXT_CAP) : next;
         this.schedulePartialFlush();
       })
     );
+    this.unsubscribers.push(
+      this.events.onPattern("provider.response", (_e, payload) => {
+        const p = payload;
+        this.captureLeaderContext(p?.ctx);
+        this.flush();
+      })
+    );
+    this.unsubscribers.push(
+      this.events.onPattern("provider.fallback", (_e, payload) => {
+        const p = payload;
+        if (p?.to?.model) {
+          this.leaderModel = p.to.providerId ? `${p.to.providerId}/${p.to.model}` : p.to.model;
+          this.flush();
+        }
+      })
+    );
+    this.unsubscribers.push(
+      this.events.onPattern("ctx.pct", (_e, payload) => {
+        const p = payload;
+        if (typeof p?.load === "number" && Number.isFinite(p.load)) {
+          this.leaderCtxPct = Math.round(p.load * 100);
+          this.flush();
+        }
+      })
+    );
     this.unsubscribers.push(
       this.events.onPattern("token.accounted", (_e, payload) => {
         const p = payload;
@@ -5923,7 +6295,8 @@ var AgentStatusTracker = class {
     const touch = (id) => {
       let entry = this.agents.get(id);
       if (!entry) {
-        entry = { id, name: id, status: "idle", iterations: 0, toolCalls: 0, lastActivityAt: (/* @__PURE__ */ new Date()).toISOString() };
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        entry = { id, name: id, status: "idle", iterations: 0, toolCalls: 0, startedAt: now, lastActivityAt: now };
         this.agents.set(id, entry);
       }
       entry.lastActivityAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -5936,6 +6309,7 @@ var AgentStatusTracker = class {
         const entry = touch(p.subagentId);
         entry.name = p.name?.trim() || entry.name;
         if (p.model) entry.model = p.model;
+        if (!entry.startedAt) entry.startedAt = (/* @__PURE__ */ new Date()).toISOString();
         entry.status = "running";
         this.flush();
       })
@@ -5955,6 +6329,7 @@ var AgentStatusTracker = class {
         if (!p?.subagentId) return;
         const entry = touch(p.subagentId);
         entry.status = "running";
+        if (!entry.startedAt) entry.startedAt = (/* @__PURE__ */ new Date()).toISOString();
         entry.iterations++;
         this.flush();
       })
@@ -5965,6 +6340,7 @@ var AgentStatusTracker = class {
         if (!p?.subagentId) return;
         const entry = touch(p.subagentId);
         entry.status = "running";
+        if (!entry.startedAt) entry.startedAt = (/* @__PURE__ */ new Date()).toISOString();
         entry.currentTool = p.name;
         entry.toolCalls++;
         this.flush();
@@ -5976,6 +6352,7 @@ var AgentStatusTracker = class {
         if (!p?.subagentId) return;
         const entry = touch(p.subagentId);
         entry.status = "running";
+        if (!entry.startedAt) entry.startedAt = (/* @__PURE__ */ new Date()).toISOString();
         if (typeof p.iteration === "number") entry.iterations = p.iteration;
         if (typeof p.toolCalls === "number") entry.toolCalls = p.toolCalls;
         if (typeof p.costUsd === "number") entry.costUsd = p.costUsd;
@@ -6063,6 +6440,7 @@ var AgentStatusTracker = class {
     const leaderEntry = {
       id: "leader",
       name: this.leaderName,
+      startedAt: this.leaderStartedAt,
       status: this.leaderStatus,
       currentTool: this.leaderCurrentTool,
       iterations: this.leaderIterations,
@@ -6076,6 +6454,11 @@ var AgentStatusTracker = class {
       lastActivityAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     const allAgents = [leaderEntry, ...this.agents.values()];
+    this.lastAgents = allAgents;
+    try {
+      this.events.emit("session.agents_updated", { agents: allAgents });
+    } catch {
+    }
     this.registry.updateAgents(allAgents).then(() => {
       try {
         this.onUpdate?.();
@@ -6083,6 +6466,23 @@ var AgentStatusTracker = class {
       }
     }).catch(() => void 0);
   }
+  markLeaderStarted(startedAt) {
+    if (this.leaderStartedAt && (this.leaderStatus === "running" || this.leaderStatus === "streaming" || this.leaderStatus === "waiting_user")) {
+      return;
+    }
+    this.leaderStartedAt = startedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  }
+  captureLeaderContext(ctx) {
+    if (typeof ctx !== "object" || ctx === null) return;
+    const c = ctx;
+    if (typeof c.model === "string" && c.model.length > 0) this.leaderModel = c.model;
+    const metaLimit = c.meta?.["effectiveMaxContext"];
+    const providerMax = c.provider?.capabilities?.maxContext;
+    const maxContext = typeof metaLimit === "number" && metaLimit > 0 ? metaLimit : typeof providerMax === "number" && providerMax > 0 ? providerMax : void 0;
+    if (typeof c.lastRequestTokens === "number" && c.lastRequestTokens > 0 && maxContext !== void 0) {
+      this.leaderCtxPct = Math.round(c.lastRequestTokens / maxContext * 100);
+    }
+  }
 };
 var INSTANCES_FILE = "webui-instances.json";
 var DISCOVERY_TTL_MS = 2500;
@@ -7831,6 +8231,6 @@ function resolveSessionLoggingConfig(cfg) {
   };
 }
 
-export { ALL_SYNC_CATEGORIES, AgentStatusTracker, AnnotationsStore, CORE_RECONSTRUCT_EVENTS, CloudSync, ConfigMigrationError, DEFAULT_CONFIG_MIGRATIONS, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultMemoryStore, DefaultPromptStore, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DirectorStateCheckpoint, FileMemoryBackend, FleetNotifier, GraphMemoryBackend, MAX_JOURNAL_ENTRIES, MAX_PROGRESS_HISTORY, QueueStore, RecoveryLock, ReplayLogStore, STANDARD_AUDIT_EVENTS, SessionAnalyzer, SessionMemoryConsolidator, SessionRecovery, SessionRegistry, ToolAuditLog, addPlanItem, appendJournal, attachPlanCheckpoint, attachTodosCheckpoint, clearPlan, createSessionEventBridge, deriveTodosFromPlanItem, emptyGoal, emptyPlan, emptyTaskFile, formatGoal, formatPlan, formatPlanTemplates, getPlanTemplate, getSessionRegistry, goalFilePath, hasSessionRegistry, listPlanTemplates, loadDirectorState, loadGoal, loadPlan, loadTasks, loadTodosCheckpoint, mutatePlan, mutateTasks, parseEntries, parseProgressFromText, recordProgress, removePlanItem, resolveAuditLevel, resolveSessionLoggingConfig, runConfigMigrations, saveGoal, savePlan, saveTasks, saveTodosCheckpoint, setPlanItemStatus, setProgress, summarizeUsage };
+export { ALL_SYNC_CATEGORIES, AgentStatusTracker, AnnotationsStore, CORE_RECONSTRUCT_EVENTS, CloudSync, ConfigMigrationError, DEFAULT_CONFIG_MIGRATIONS, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultMemoryStore, DefaultPromptStore, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DirectorStateCheckpoint, FileMemoryBackend, FleetNotifier, GraphMemoryBackend, MAX_JOURNAL_ENTRIES, MAX_PROGRESS_HISTORY, QueueStore, RecoveryLock, ReplayLogStore, STANDARD_AUDIT_EVENTS, SessionAnalyzer, SessionMemoryConsolidator, SessionRecovery, SessionRegistry, ToolAuditLog, addPlanItem, appendJournal, attachPlanCheckpoint, attachTodosCheckpoint, clearPlan, createSessionEventBridge, deriveTodosFromPlanItem, emptyGoal, emptyPlan, emptyTaskFile, formatGoal, formatPlan, formatPlanTemplates, generateSessionId, getPlanTemplate, getSessionRegistry, goalFilePath, hasSessionRegistry, listPlanTemplates, loadDirectorState, loadGoal, loadPlan, loadTasks, loadTodosCheckpoint, mutatePlan, mutateTasks, parseEntries, parseProgressFromText, recordProgress, removePlanItem, resolveAuditLevel, resolveSessionLoggingConfig, runConfigMigrations, sanitizeModel, saveGoal, savePlan, saveTasks, saveTodosCheckpoint, setPlanItemStatus, setProgress, summarizeUsage };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map