@wrongstack/core 0.264.0 → 0.265.1

package/dist/storage/index.js

@@ -35,8 +35,8 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat6 = await fsp.stat(targetPath);
-      mode = stat6.mode & 511;
+      const stat7 = await fsp.stat(targetPath);
+      mode = stat7.mode & 511;
     } catch {
       mode = opts.mode;
     }
@@ -76,8 +76,8 @@ async function withFileLock(targetPath, fn, opts = {}) {
       }
       if (code !== "EEXIST") throw err;
       try {
-        const stat6 = await fsp.stat(lockPath);
-        if (Date.now() - stat6.mtimeMs > staleMs) {
+        const stat7 = await fsp.stat(lockPath);
+        if (Date.now() - stat7.mtimeMs > staleMs) {
           await fsp.unlink(lockPath);
           continue;
         }
@@ -87,7 +87,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((resolve5) => setTimeout(resolve5, 25));
+      await new Promise((resolve6) => setTimeout(resolve6, 25));
     }
   }
   try {
@@ -121,7 +121,7 @@ async function renameWithRetry(from, to) {
       if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
         throw err;
       }
-      await new Promise((resolve5) => setTimeout(resolve5, delays[i]));
+      await new Promise((resolve6) => setTimeout(resolve6, delays[i]));
     }
   }
   throw lastErr;
@@ -329,7 +329,8 @@ function resolveWstackPaths(opts) {
     projectSddSession: path2.join(projectDir, "sdd-session.json"),
     projectPlan: path2.join(projectDir, "plan.json"),
     projectAutophase: path2.join(projectDir, "autophase"),
-    syncConfig: path2.join(globalRoot, "sync.json")
+    syncConfig: path2.join(globalRoot, "sync.json"),
+    projectStatus: (projectHash2) => path2.join(globalRoot, "projects", projectHash2, "status.json")
   };
 }
 
@@ -443,11 +444,34 @@ var DefaultSessionStore = class _DefaultSessionStore {
   dir;
   events;
   secretScrubber;
+  /**
+   * In-memory cache for load() results, keyed by session ID. The cache is
+   * invalidated when the file's mtimeMs or size changes (indicating the
+   * file was written to). This eliminates redundant full-file reads and
+   * JSON parses when the same session is loaded multiple times within the
+   * store's lifetime (e.g., webui session detail views, list() fallbacks).
+   *
+   * Max size is capped to prevent unbounded memory growth in long-running
+   * processes. When the limit is reached, the oldest entry is evicted.
+   */
+  _loadCache = /* @__PURE__ */ new Map();
+  static LOAD_CACHE_MAX_ENTRIES = 50;
   constructor(opts) {
     this.dir = opts.dir;
     this.events = opts.events;
     this.secretScrubber = opts.secretScrubber;
   }
+  /**
+   * Clear the load() cache. Useful for testing or when the caller knows
+   * the file has changed externally (e.g., another process wrote to it).
+   */
+  clearLoadCache(sessionId) {
+    if (sessionId !== void 0) {
+      this._loadCache.delete(sessionId);
+    } else {
+      this._loadCache.clear();
+    }
+  }
   // ── Storage event helpers ───────────────────────────────────────────────────
   emitRead(sessionId, filePath, operation, outcome, durationMs, error) {
     this.events?.emit("storage.read", {
@@ -590,7 +614,20 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const t0 = Date.now();
     let outcome = "success";
     let errorMsg;
+    let cacheHit = false;
     try {
+      let stat7;
+      try {
+        const s = await fsp.stat(file);
+        stat7 = { mtimeMs: s.mtimeMs, size: s.size };
+      } catch (err) {
+        throw err;
+      }
+      const cached = this._loadCache.get(id);
+      if (cached && cached.mtimeMs === stat7.mtimeMs && cached.size === stat7.size) {
+        cacheHit = true;
+        return cached.data;
+      }
       const raw = await fsp.readFile(file, "utf8");
       const lines = raw.split("\n").filter((l) => l.trim());
       const events = [];
@@ -606,13 +643,30 @@ var DefaultSessionStore = class _DefaultSessionStore {
       const meta = this.metaFromEvents(id, events);
       const { messages, usage } = this.replay(events, id);
       const toolCallEnds = extractToolCallEnds(events);
-      return { metadata: meta, events, messages, usage, toolCallEnds };
+      const data = { metadata: meta, events, messages, usage, toolCallEnds };
+      if (this._loadCache.size >= _DefaultSessionStore.LOAD_CACHE_MAX_ENTRIES) {
+        const oldest = this._loadCache.keys().next().value;
+        if (oldest !== void 0) {
+          this._loadCache.delete(oldest);
+        }
+      }
+      this._loadCache.set(id, { mtimeMs: stat7.mtimeMs, size: stat7.size, data });
+      return data;
     } catch (err) {
       outcome = "failure";
       errorMsg = toErrorMessage(err);
       throw err;
     } finally {
       this.emitRead(id, file, "load", outcome, Date.now() - t0, errorMsg);
+      if (cacheHit) {
+        this.events?.emit("storage.cache_hit", {
+          sessionId: id,
+          store: "session",
+          filePath: file,
+          operation: "load",
+          durationMs: Date.now() - t0
+        });
+      }
     }
   }
   async list(limit = 20) {
@@ -780,8 +834,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
       return JSON.parse(raw);
     } catch {
       const full = this.sessionPath(id, ".jsonl");
-      const stat6 = await fsp.stat(full);
-      const summary = await this.summarize(id, stat6.mtime.toISOString());
+      const stat7 = await fsp.stat(full);
+      const summary = await this.summarize(id, stat7.mtime.toISOString());
       await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
         const msg = toErrorMessage(err);
         this.emitError(id, manifest, "summary_fallback", msg, true);
@@ -863,8 +917,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const pruneFile = async (dir, name, prefix) => {
       const jsonlPath = path2.join(dir, name);
       try {
-        const stat6 = await fsp.stat(jsonlPath);
-        if (stat6.mtimeMs >= cutoff) return;
+        const stat7 = await fsp.stat(jsonlPath);
+        if (stat7.mtimeMs >= cutoff) return;
       } catch {
         return;
       }
@@ -3137,6 +3191,9 @@ function deepFreeze(obj) {
   }
   return Object.freeze(obj);
 }
+var KEY_BYTES = 32;
+var KEY_FILE_MAGIC = Buffer.from("WSKV", "ascii");
+KEY_FILE_MAGIC.length + 1 + KEY_BYTES;
 function decryptConfigSecrets(cfg, vault, opts) {
   const warn = ((msg) => console.warn(msg));
   return walk(cfg, vault, (v, key) => {
@@ -3234,7 +3291,8 @@ var DEFAULT_TOOLS_CONFIG = Object.freeze({
   iterationTimeoutMs: 3e5,
   sessionTimeoutMs: 18e5,
   perIterationOutputCapBytes: 1e5,
-  autoExtendLimit: true
+  autoExtendLimit: true,
+  restrictToProjectRoot: false
 });
 var DEFAULT_CONTEXT_CONFIG = Object.freeze({
   preserveK: 10,
@@ -3274,7 +3332,8 @@ var BEHAVIOR_DEFAULTS = {
     iterationTimeoutMs: DEFAULT_TOOLS_CONFIG.iterationTimeoutMs,
     sessionTimeoutMs: DEFAULT_TOOLS_CONFIG.sessionTimeoutMs,
     perIterationOutputCapBytes: DEFAULT_TOOLS_CONFIG.perIterationOutputCapBytes,
-    autoExtendLimit: DEFAULT_TOOLS_CONFIG.autoExtendLimit
+    autoExtendLimit: DEFAULT_TOOLS_CONFIG.autoExtendLimit,
+    restrictToProjectRoot: DEFAULT_TOOLS_CONFIG.restrictToProjectRoot
   },
   log: { level: "info" },
   features: {
@@ -4710,15 +4769,15 @@ var SessionRecovery = class {
   async detectStale(sessionId) {
     const fp = this.filePath(sessionId);
     const TAIL_SIZE = 8192;
-    let stat6;
+    let stat7;
     try {
-      stat6 = await fsp.stat(fp);
+      stat7 = await fsp.stat(fp);
     } catch (err) {
       if (err.code === "ENOENT") return null;
       return null;
     }
-    if (stat6.size === 0) return null;
-    const position = Math.max(0, stat6.size - TAIL_SIZE);
+    if (stat7.size === 0) return null;
+    const position = Math.max(0, stat7.size - TAIL_SIZE);
     const buf = Buffer.alloc(TAIL_SIZE);
     let fh;
     try {
@@ -5281,6 +5340,8 @@ var SessionAnalyzer = class {
 var REGISTRY_FILE = "session-registry.json";
 var HEARTBEAT_INTERVAL_MS = 5e3;
 var STALE_TIMEOUT_MS = 3e4;
+var CLOSING_GRACE_MS = 15e3;
+var STALE_LOCK_MS = 1e4;
 function pidAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -5293,6 +5354,12 @@ var SessionRegistry = class {
   filePath;
   heartbeatTimer = null;
   currentSessionId = null;
+  /**
+   * Last full entry this process registered. Kept so the heartbeat can
+   * re-create our entry if it ever goes missing — e.g. our initial register()
+   * write was dropped (a wedged lock), the file was reset, or we were pruned.
+   */
+  lastEntry = null;
   constructor(globalRoot) {
     this.filePath = path2.join(globalRoot, REGISTRY_FILE);
   }
@@ -5314,6 +5381,7 @@ var SessionRegistry = class {
       agentCount: entry.agents?.length ?? 0,
       agents: entry.agents ?? []
     };
+    this.lastEntry = full;
     await this.atomicUpdate((registry) => {
       const now = Date.now();
       for (const [id, existing] of Object.entries(registry)) {
@@ -5339,16 +5407,28 @@ var SessionRegistry = class {
    */
   async updateAgents(agents) {
     if (!this.currentSessionId) return;
+    const hasRunning = agents.some((a) => a.status === "running" || a.status === "streaming");
+    const hasWaiting = agents.some((a) => a.status === "waiting_user");
+    const hasError = agents.some((a) => a.status === "error");
+    const status = hasRunning || hasWaiting || hasError ? "active" : "idle";
+    const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+    if (this.lastEntry) {
+      this.lastEntry.agents = agents;
+      this.lastEntry.agentCount = agents.length;
+      this.lastEntry.status = status;
+      this.lastEntry.lastHeartbeatAt = nowIso;
+    }
     await this.atomicUpdate((registry) => {
-      const entry = registry[this.currentSessionId];
-      if (!entry) return;
+      let entry = registry[this.currentSessionId];
+      if (!entry) {
+        if (!this.lastEntry) return;
+        entry = { ...this.lastEntry };
+        registry[this.currentSessionId] = entry;
+      }
       entry.agents = agents;
       entry.agentCount = agents.length;
-      const hasRunning = agents.some((a) => a.status === "running" || a.status === "streaming");
-      const hasWaiting = agents.some((a) => a.status === "waiting_user");
-      const hasError = agents.some((a) => a.status === "error");
-      entry.status = hasRunning ? "active" : hasWaiting ? "active" : hasError ? "active" : "idle";
-      entry.lastHeartbeatAt = (/* @__PURE__ */ new Date()).toISOString();
+      entry.status = status;
+      entry.lastHeartbeatAt = nowIso;
     });
   }
   /**
@@ -5426,6 +5506,12 @@ var SessionRegistry = class {
           entry.status = hasRunning ? "active" : "idle";
         }
         await this.writeAtomic(registry);
+      } else if (this.lastEntry) {
+        await this.atomicUpdate((reg) => {
+          if (!reg[this.currentSessionId] && this.lastEntry) {
+            reg[this.currentSessionId] = { ...this.lastEntry, lastHeartbeatAt: (/* @__PURE__ */ new Date()).toISOString() };
+          }
+        });
       }
     } catch {
     }
@@ -5438,6 +5524,11 @@ var SessionRegistry = class {
       let pruned = false;
       for (const [id, entry] of Object.entries(registry)) {
         const heartbeatAge = now - new Date(entry.lastHeartbeatAt).getTime();
+        if (entry.status === "closing" && heartbeatAge > CLOSING_GRACE_MS) {
+          delete registry[id];
+          pruned = true;
+          continue;
+        }
         if (heartbeatAge > STALE_TIMEOUT_MS && !pidAlive(entry.pid)) {
           entry.status = "stale";
           const startedAge = now - new Date(entry.startedAt).getTime();
@@ -5457,17 +5548,23 @@ var SessionRegistry = class {
   }
   async atomicUpdate(fn) {
     const lockPath = `${this.filePath}.lock`;
-    const maxRetries = 5;
+    const maxRetries = 8;
     const retryDelayMs = 20;
     for (let attempt = 0; attempt < maxRetries; attempt++) {
       try {
         await fsp.mkdir(path2.dirname(this.filePath), { recursive: true });
-        const lockHandle = await fsp.open(lockPath, "wx").catch(() => null);
+        let lockHandle = await fsp.open(lockPath, "wx").catch(() => null);
         if (!lockHandle) {
-          await new Promise((r) => setTimeout(r, retryDelayMs * (attempt + 1)));
-          continue;
+          if (await this.breakStaleLock(lockPath)) {
+            lockHandle = await fsp.open(lockPath, "wx").catch(() => null);
+          }
+          if (!lockHandle) {
+            await new Promise((r) => setTimeout(r, retryDelayMs * (attempt + 1)));
+            continue;
+          }
         }
         try {
+          await lockHandle.writeFile(String(process.pid)).catch(() => void 0);
           const raw = await fsp.readFile(this.filePath, "utf8").catch(() => "{}");
           const registry = JSON.parse(raw);
           fn(registry);
@@ -5482,6 +5579,31 @@ var SessionRegistry = class {
       }
     }
   }
+  /**
+   * Break a contended lock if it is stale: the recorded owner pid is no longer
+   * alive, or the lock is older than {@link STALE_LOCK_MS}. Returns true when the
+   * lock was removed (caller should retry acquisition). Best-effort and
+   * race-tolerant — a fresh lock (age ~0, live owner) is never broken, so the
+   * common concurrent case self-heals on the next heartbeat.
+   */
+  async breakStaleLock(lockPath) {
+    try {
+      const [stat7, content] = await Promise.all([
+        fsp.stat(lockPath),
+        fsp.readFile(lockPath, "utf8").catch(() => "")
+      ]);
+      const ageMs = Date.now() - stat7.mtimeMs;
+      const ownerPid = Number.parseInt(content.trim(), 10);
+      const ownerDead = Number.isInteger(ownerPid) && ownerPid > 0 && ownerPid !== process.pid && !pidAlive(ownerPid);
+      if (ownerDead || ageMs > STALE_LOCK_MS) {
+        await fsp.unlink(lockPath).catch(() => void 0);
+        return true;
+      }
+      return false;
+    } catch {
+      return true;
+    }
+  }
   async writeAtomicLocked(registry) {
     const tmp = `${this.filePath}.${randomUUID().slice(0, 8)}.tmp`;
     await fsp.writeFile(tmp, JSON.stringify(registry, null, 2), "utf8");
@@ -5509,6 +5631,10 @@ function hasSessionRegistry() {
 }
 
 // src/agent-status-tracker.ts
+var AGENT_REAP_MS = 3e4;
+var AGENT_SWEEP_INTERVAL_MS = 1e4;
+var PARTIAL_TEXT_CAP = 1200;
+var PARTIAL_FLUSH_THROTTLE_MS = 300;
 var AgentStatusTracker = class {
   events;
   registry;
@@ -5520,11 +5646,21 @@ var AgentStatusTracker = class {
   leaderCurrentTool;
   leaderIterations = 0;
   leaderToolCalls = 0;
+  leaderCostUsd = 0;
+  leaderTokensIn = 0;
+  leaderTokensOut = 0;
+  leaderCtxPct;
+  leaderModel;
+  leaderPartialText = "";
   unsubscribers = [];
+  onUpdate;
+  sweepTimer = null;
+  partialTimer = null;
   constructor(opts) {
     this.events = opts.events;
     this.registry = opts.registry;
     this.leaderName = opts.leaderName ?? "leader";
+    this.onUpdate = opts.onUpdate;
   }
   start() {
     this.unsubscribers.push(
@@ -5534,10 +5670,22 @@ var AgentStatusTracker = class {
         this.flush();
       })
     );
+    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);
+        }
+        this.flush();
+      })
+    );
     this.unsubscribers.push(
       this.events.onPattern("agent.run.completed", () => {
         this.leaderStatus = "idle";
         this.leaderCurrentTool = void 0;
+        this.leaderPartialText = "";
         this.flush();
       })
     );
@@ -5545,6 +5693,7 @@ var AgentStatusTracker = class {
       this.events.onPattern("agent.run.error", () => {
         this.leaderStatus = "error";
         this.leaderCurrentTool = void 0;
+        this.leaderPartialText = "";
         this.flush();
       })
     );
@@ -5574,74 +5723,120 @@ var AgentStatusTracker = class {
     this.unsubscribers.push(
       this.events.onPattern("llm.stream_started", () => {
         this.leaderStatus = "streaming";
+        this.leaderPartialText = "";
         this.flush();
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("fleet.subagent.spawned", (_event, payload) => {
+      this.events.onPattern("provider.text_delta", (_e, payload) => {
+        const text = payload?.text;
+        if (!text) return;
+        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("token.accounted", (_e, payload) => {
         const p = payload;
-        if (p?.subagentId) {
-          this.agents.set(p.subagentId, {
-            id: p.subagentId,
-            name: p.name ?? p.subagentId,
-            status: "idle",
-            iterations: 0,
-            toolCalls: 0,
-            lastActivityAt: (/* @__PURE__ */ new Date()).toISOString()
-          });
-          this.flush();
-        }
+        if (!p) return;
+        this.leaderTokensIn += p.usage?.input ?? 0;
+        this.leaderTokensOut += p.usage?.output ?? 0;
+        this.leaderCostUsd += p.cost?.total ?? 0;
+        this.flush();
       })
     );
+    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() };
+        this.agents.set(id, entry);
+      }
+      entry.lastActivityAt = (/* @__PURE__ */ new Date()).toISOString();
+      return entry;
+    };
     this.unsubscribers.push(
-      this.events.onPattern("fleet.subagent.task_started", (_event, payload) => {
+      this.events.onPattern("subagent.spawned", (_e, payload) => {
         const p = payload;
-        if (p?.subagentId) {
-          const entry = this.agents.get(p.subagentId);
-          if (entry) {
-            entry.status = "running";
-            entry.iterations++;
-            entry.lastActivityAt = (/* @__PURE__ */ new Date()).toISOString();
-            this.flush();
-          }
-        }
+        if (!p?.subagentId) return;
+        const entry = touch(p.subagentId);
+        entry.name = p.name?.trim() || entry.name;
+        if (p.model) entry.model = p.model;
+        entry.status = "running";
+        this.flush();
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("fleet.subagent.task_completed", (_event, payload) => {
+      this.events.onPattern("subagent.ctx_pct", (_e, payload) => {
         const p = payload;
-        if (p?.subagentId) {
-          const entry = this.agents.get(p.subagentId);
-          if (entry) {
-            entry.status = "idle";
-            entry.lastActivityAt = (/* @__PURE__ */ new Date()).toISOString();
-            this.flush();
-          }
-        }
+        if (!p?.subagentId) return;
+        const entry = touch(p.subagentId);
+        if (typeof p.load === "number") entry.ctxPct = Math.round(p.load * 100);
+        this.flush();
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("fleet.subagent.error", (_event, payload) => {
+      this.events.onPattern("subagent.task_started", (_e, payload) => {
         const p = payload;
-        if (p?.subagentId) {
-          const entry = this.agents.get(p.subagentId);
-          if (entry) {
-            entry.status = "error";
-            entry.lastActivityAt = (/* @__PURE__ */ new Date()).toISOString();
-            this.flush();
-          }
-        }
+        if (!p?.subagentId) return;
+        const entry = touch(p.subagentId);
+        entry.status = "running";
+        entry.iterations++;
+        this.flush();
       })
     );
     this.unsubscribers.push(
-      this.events.onPattern("fleet.subagent.stopped", (_event, payload) => {
+      this.events.onPattern("subagent.tool_executed", (_e, payload) => {
         const p = payload;
-        if (p?.subagentId) {
-          this.agents.delete(p.subagentId);
-          this.flush();
+        if (!p?.subagentId) return;
+        const entry = touch(p.subagentId);
+        entry.status = "running";
+        entry.currentTool = p.name;
+        entry.toolCalls++;
+        this.flush();
+      })
+    );
+    this.unsubscribers.push(
+      this.events.onPattern("subagent.iteration_summary", (_e, payload) => {
+        const p = payload;
+        if (!p?.subagentId) return;
+        const entry = touch(p.subagentId);
+        entry.status = "running";
+        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;
+        if (p.currentTool) entry.currentTool = p.currentTool;
+        if (typeof p.partialText === "string") {
+          entry.partialText = p.partialText.length > PARTIAL_TEXT_CAP ? p.partialText.slice(p.partialText.length - PARTIAL_TEXT_CAP) : p.partialText;
         }
+        this.flush();
+      })
+    );
+    this.unsubscribers.push(
+      this.events.onPattern("subagent.task_completed", (_e, payload) => {
+        const p = payload;
+        if (!p?.subagentId) return;
+        const entry = this.agents.get(p.subagentId);
+        if (!entry) return;
+        entry.status = p.status === "failed" || p.status === "timeout" ? "error" : "idle";
+        entry.currentTool = void 0;
+        entry.partialText = void 0;
+        if (typeof p.iterations === "number") entry.iterations = p.iterations;
+        if (typeof p.toolCalls === "number") entry.toolCalls = p.toolCalls;
+        entry.lastActivityAt = (/* @__PURE__ */ new Date()).toISOString();
+        this.flush();
       })
     );
+    this.unsubscribers.push(
+      this.events.onPattern("subagent.stopped", (_e, payload) => {
+        const p = payload;
+        if (!p?.subagentId) return;
+        if (this.agents.delete(p.subagentId)) this.flush();
+      })
+    );
+    this.sweepTimer = setInterval(() => this.sweep(), AGENT_SWEEP_INTERVAL_MS);
+    if (typeof this.sweepTimer.unref === "function") this.sweepTimer.unref();
   }
   stop() {
     for (const unsub of this.unsubscribers) {
@@ -5651,6 +5846,45 @@ var AgentStatusTracker = class {
       }
     }
     this.unsubscribers = [];
+    if (this.sweepTimer) {
+      clearInterval(this.sweepTimer);
+      this.sweepTimer = null;
+    }
+    if (this.partialTimer) {
+      clearTimeout(this.partialTimer);
+      this.partialTimer = null;
+    }
+  }
+  /**
+   * Coalesce streamed-text flushes: at most one registry write per
+   * {@link PARTIAL_FLUSH_THROTTLE_MS} while text streams in, so per-token
+   * deltas never thrash the cross-process registry file.
+   */
+  schedulePartialFlush() {
+    if (this.partialTimer) return;
+    this.partialTimer = setTimeout(() => {
+      this.partialTimer = null;
+      this.flush();
+    }, PARTIAL_FLUSH_THROTTLE_MS);
+    if (typeof this.partialTimer.unref === "function") this.partialTimer.unref();
+  }
+  /**
+   * Remove subagents that have been finished (idle/error) for longer than
+   * {@link AGENT_REAP_MS}. Running / streaming / waiting_user agents are kept
+   * regardless of age — only *not-working* agents are reaped.
+   */
+  sweep() {
+    const now = Date.now();
+    let removed = false;
+    for (const [id, a] of this.agents) {
+      const finished = a.status !== "running" && a.status !== "streaming" && a.status !== "waiting_user";
+      const age = now - Date.parse(a.lastActivityAt);
+      if (finished && Number.isFinite(age) && age > AGENT_REAP_MS) {
+        this.agents.delete(id);
+        removed = true;
+      }
+    }
+    if (removed) this.flush();
   }
   flush() {
     const leaderEntry = {
@@ -5660,12 +5894,105 @@ var AgentStatusTracker = class {
       currentTool: this.leaderCurrentTool,
       iterations: this.leaderIterations,
       toolCalls: this.leaderToolCalls,
+      costUsd: this.leaderCostUsd,
+      tokensIn: this.leaderTokensIn,
+      tokensOut: this.leaderTokensOut,
+      ctxPct: this.leaderCtxPct,
+      model: this.leaderModel,
+      partialText: this.leaderPartialText || void 0,
       lastActivityAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     const allAgents = [leaderEntry, ...this.agents.values()];
-    this.registry.updateAgents(allAgents).catch(() => void 0);
+    this.registry.updateAgents(allAgents).then(() => {
+      try {
+        this.onUpdate?.();
+      } catch {
+      }
+    }).catch(() => void 0);
+  }
+};
+var INSTANCES_FILE = "webui-instances.json";
+var DISCOVERY_TTL_MS = 2500;
+var COALESCE_MS = 50;
+var POST_TIMEOUT_MS = 500;
+function pidAlive2(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code !== "ESRCH";
+  }
+}
+function normRoot(root) {
+  const resolved = path2.resolve(root);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+var FleetNotifier = class {
+  baseDir;
+  projectRoot;
+  selfPid;
+  doPost;
+  cache = null;
+  timer = null;
+  disposed = false;
+  constructor(opts) {
+    this.baseDir = opts.baseDir;
+    this.projectRoot = normRoot(opts.projectRoot);
+    this.selfPid = opts.selfPid ?? process.pid;
+    this.doPost = opts.post ?? defaultPost;
+  }
+  /** Coalesced, best-effort nudge. Safe to call on every status change. */
+  notify() {
+    if (this.disposed || this.timer) return;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.flush();
+    }, COALESCE_MS);
+    if (typeof this.timer.unref === "function") this.timer.unref();
+  }
+  /** Resolve same-project WebUI ping URLs (cached briefly). Exposed for tests. */
+  async endpoints() {
+    const now = Date.now();
+    if (this.cache && now - this.cache.at < DISCOVERY_TTL_MS) return this.cache.urls;
+    const urls = await this.discover();
+    this.cache = { at: now, urls };
+    return urls;
+  }
+  dispose() {
+    this.disposed = true;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+  async flush() {
+    const urls = await this.endpoints();
+    await Promise.all(urls.map((u) => this.doPost(u).catch(() => void 0)));
+  }
+  async discover() {
+    try {
+      const raw = await fsp.readFile(path2.join(this.baseDir, INSTANCES_FILE), "utf8");
+      const data = JSON.parse(raw);
+      const list = Array.isArray(data?.instances) ? data.instances : [];
+      return list.filter((i) => i && typeof i.httpPort === "number").filter((i) => i.pid !== this.selfPid).filter((i) => normRoot(i.projectRoot) === this.projectRoot).filter((i) => pidAlive2(i.pid)).map((i) => {
+        const host = i.host === "0.0.0.0" || i.host === "::" || !i.host ? "127.0.0.1" : i.host;
+        return `http://${host}:${i.httpPort}/api/fleet/ping`;
+      });
+    } catch {
+      return [];
+    }
   }
 };
+async function defaultPost(url) {
+  const ac = new AbortController();
+  const t = setTimeout(() => ac.abort(), POST_TIMEOUT_MS);
+  try {
+    await fetch(url, { method: "POST", signal: ac.signal });
+  } finally {
+    clearTimeout(t);
+  }
+}
 var DefaultSessionRewinder = class {
   constructor(sessionsDir, projectRoot) {
     this.sessionsDir = sessionsDir;
@@ -6034,6 +6361,7 @@ async function savePlan(filePath, plan, events) {
       outcome: "success",
       durationMs: Date.now() - t0
     });
+    return true;
   } catch (err) {
     events?.emit("storage.error", {
       sessionId: "~boot~",
@@ -6047,6 +6375,7 @@ async function savePlan(filePath, plan, events) {
       "[plan-store] save failed:",
       toErrorMessage(err)
     );
+    return false;
   }
 }
 function emptyPlan(sessionId, title) {
@@ -6148,7 +6477,10 @@ async function mutatePlan(filePath, sessionId, fn) {
   return withFileLock(filePath, async () => {
     const plan = await loadPlan(filePath) ?? emptyPlan(sessionId);
     const updated = await fn(plan);
-    await savePlan(filePath, updated);
+    const persisted = await savePlan(filePath, updated);
+    if (!persisted) {
+      throw new Error(`Failed to persist plan to ${filePath} \u2014 the change was NOT saved.`);
+    }
     return updated;
   });
 }
@@ -6346,6 +6678,7 @@ async function saveTasks(filePath, tasks, events, traceId) {
       durationMs: Date.now() - t0,
       ...traceId !== void 0 && { traceId }
     });
+    return true;
   } catch (err) {
     events?.emit("storage.error", {
       sessionId: traceId ?? "~boot~",
@@ -6361,13 +6694,17 @@ async function saveTasks(filePath, tasks, events, traceId) {
       "[task-store] save failed:",
       toErrorMessage(err)
     );
+    return false;
   }
 }
 async function mutateTasks(filePath, sessionId, fn, events, traceId) {
   return withFileLock(filePath, async () => {
     const file = await loadTasks(filePath, events, traceId) ?? emptyTaskFile(sessionId);
     const updated = await fn(file);
-    await saveTasks(filePath, updated, events, traceId);
+    const persisted = await saveTasks(filePath, updated, events, traceId);
+    if (!persisted) {
+      throw new Error(`Failed to persist tasks to ${filePath} \u2014 the change was NOT saved.`);
+    }
     return updated;
   });
 }
@@ -7091,8 +7428,8 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat6 = await fsp.stat(localPath);
-        if (stat6.isDirectory()) {
+        const stat7 = await fsp.stat(localPath);
+        if (stat7.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
             const content = await fsp.readFile(file, "utf8");
@@ -7117,8 +7454,8 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat6 = await fsp.stat(localPath);
-        if (stat6.isDirectory()) {
+        const stat7 = await fsp.stat(localPath);
+        if (stat7.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
             const content = await fsp.readFile(file);
@@ -7145,6 +7482,7 @@ var CloudSync = class {
         return this.paths.globalMemory;
       case "history":
         return this.paths.historyFile;
+      /* v8 ignore next -- unreachable: SyncCategory is exhaustively matched above */
       default:
         return null;
     }
@@ -7323,6 +7661,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, 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, 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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map