@wrongstack/core 0.270.0 → 0.272.1

package/dist/defaults/index.js

@@ -1,9 +1,11 @@
 import * as crypto2 from 'crypto';
-import { randomBytes, createCipheriv, createDecipheriv, randomUUID, createHash } from 'crypto';
+import { randomBytes, createCipheriv, createDecipheriv, randomUUID, scryptSync, createHash } from 'crypto';
 import * as fsp2 from 'fs/promises';
 import * as path4 from 'path';
 import { isAbsolute, resolve } from 'path';
 import * as fs4 from 'fs';
+import { createReadStream } from 'fs';
+import { createInterface } from 'readline';
 import * as os from 'os';
 import { hostname } from 'os';
 import { execFile } from 'child_process';
@@ -105,7 +107,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 {
@@ -138,7 +140,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;
@@ -706,6 +708,7 @@ function escapeRegex(s) {
 }
 var COMPILED_GLOB_CACHE = /* @__PURE__ */ new Map();
 var CACHE_MAX_SIZE = 2e3;
+var NEVER_MATCH = /[^\s\S]/;
 function getCachedGlob(pattern) {
   const cached = COMPILED_GLOB_CACHE.get(pattern);
   if (cached) return cached;
@@ -715,7 +718,12 @@ function getCachedGlob(pattern) {
       COMPILED_GLOB_CACHE.delete(expectDefined(keys[i]));
     }
   }
-  const re = compileGlob(pattern);
+  let re;
+  try {
+    re = compileGlob(pattern);
+  } catch {
+    re = NEVER_MATCH;
+  }
   COMPILED_GLOB_CACHE.set(pattern, re);
   return re;
 }
@@ -874,11 +882,11 @@ function validateAgainstSchema(value, schema) {
   walk(value, schema, "", errors);
   return { ok: errors.length === 0, errors };
 }
-function walk(value, schema, path21, errors) {
+function walk(value, schema, path22, errors) {
   if (schema.enum !== void 0) {
     if (!schema.enum.some((e) => deepEqual(e, value))) {
       errors.push({
-        path: path21 || "<root>",
+        path: path22 || "<root>",
         message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
       });
       return;
@@ -887,7 +895,7 @@ function walk(value, schema, path21, errors) {
   if (typeof schema.type === "string") {
     if (!checkType(value, schema.type)) {
       errors.push({
-        path: path21 || "<root>",
+        path: path22 || "<root>",
         message: `expected ${schema.type}, got ${describeType(value)}`
       });
       return;
@@ -897,20 +905,20 @@ function walk(value, schema, path21, errors) {
     const obj = value;
     for (const req of schema.required ?? []) {
       if (!(req in obj)) {
-        errors.push({ path: joinPath(path21, req), message: "required property missing" });
+        errors.push({ path: joinPath(path22, req), message: "required property missing" });
       }
     }
     if (schema.properties) {
       for (const [key, subSchema] of Object.entries(schema.properties)) {
         if (key in obj) {
-          walk(obj[key], subSchema, joinPath(path21, key), errors);
+          walk(obj[key], subSchema, joinPath(path22, key), errors);
         }
       }
     }
   }
   if (schema.type === "array" && Array.isArray(value) && schema.items) {
     for (let i = 0; i < value.length; i++) {
-      walk(value[i], schema.items, `${path21}[${i}]`, errors);
+      walk(value[i], schema.items, `${path22}[${i}]`, errors);
     }
   }
 }
@@ -1080,7 +1088,7 @@ function safeParse(input, maxBytes = 5e6) {
 
 // src/utils/sleep.ts
 function sleep(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 
 // src/utils/string.ts
@@ -1218,18 +1226,20 @@ var MODEL_FAMILY_RATIO = {
   deepseek: 3.5
 };
 var ESTIMATE_CACHE = /* @__PURE__ */ new Map();
+var _estimateCacheOrder = [];
 var ESTIMATE_CACHE_MAX_SIZE = 5e4;
 function getCachedEstimate(key, compute) {
   const existing = ESTIMATE_CACHE.get(key);
   if (existing !== void 0) return existing;
   if (ESTIMATE_CACHE.size >= ESTIMATE_CACHE_MAX_SIZE) {
-    for (const k of ESTIMATE_CACHE.keys()) {
-      if (ESTIMATE_CACHE.size <= Math.floor(ESTIMATE_CACHE_MAX_SIZE / 2)) break;
-      ESTIMATE_CACHE.delete(k);
+    while (ESTIMATE_CACHE.size > Math.floor(ESTIMATE_CACHE_MAX_SIZE / 2)) {
+      const oldest = _estimateCacheOrder.shift();
+      if (oldest !== void 0) ESTIMATE_CACHE.delete(oldest);
     }
   }
   const estimate = compute(key);
   ESTIMATE_CACHE.set(key, estimate);
+  _estimateCacheOrder.push(key);
   return estimate;
 }
 function estimateToolInputTokens(input) {
@@ -2073,8 +2083,6 @@ function resolveWstackPaths(opts) {
     projectStatus: (projectHash2) => path4.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);
 }
@@ -2085,6 +2093,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;
@@ -2102,6 +2112,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;
@@ -2118,7 +2129,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,
@@ -2233,7 +2244,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: path4.dirname(file),
@@ -2274,19 +2285,93 @@ var DefaultSessionStore = class _DefaultSessionStore {
       const raw = await fsp2.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) {
@@ -2324,20 +2409,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
@@ -2457,43 +2534,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 fsp2.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: path4.join(dir, entry.name) });
+      }
+    }
+    const childFileArrays = await Promise.all(
+      dirEntries.map((entry) => {
+        const childPrefix = depth === 0 ? entry.name : `${prefix}/${entry.name}`;
+        return this.collectSessionFiles(path4.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 fsp2.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(path4.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(path4.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 fsp2.readFile(manifest, "utf8");
-      this.emitRead(id, manifest, "summary", "success", Date.now() - t0);
-      return JSON.parse(raw);
-    } catch {
       const full = this.sessionPath(id, ".jsonl");
       const stat6 = await fsp2.stat(full);
       const summary = await this.summarize(id, stat6.mtime.toISOString());
@@ -2509,9 +2645,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 fsp2.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 stat6 = await fsp2.stat(ref.filePath);
+      if (!stat6.isFile()) {
+        return {
+          id: ref.id,
+          title: "(damaged)",
+          startedAt: stat6.mtime.toISOString(),
+          model: "unknown",
+          provider: "unknown",
+          tokenTotal: 0
+        };
+      }
+      mtime = stat6.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
+      };
     }
   }
   /**
@@ -2636,39 +2844,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,
@@ -2687,75 +2918,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) {
@@ -2815,7 +2995,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;
@@ -2828,24 +3008,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.
@@ -2859,7 +3039,7 @@ var FileSessionWriter = class _FileSessionWriter {
     );
     return write;
   }
-  // ── Enriched summary tracking ──────────────────────────────────────────
+  // ── Enriched summary tracking ──────────────────────────────────────────
   iterationCount = 0;
   toolCallCount = 0;
   toolErrorCount = 0;
@@ -2951,7 +3131,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).
    */
@@ -2974,7 +3154,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).
    */
@@ -3157,7 +3337,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) {
@@ -3314,7 +3494,7 @@ var FileSessionWriter = class _FileSessionWriter {
     await fsp2.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.
@@ -3331,9 +3511,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".
    */
@@ -3350,6 +3530,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;
+}
 
 // src/storage/queue-store.ts
 init_atomic_write();
@@ -3937,6 +4138,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,
@@ -3970,6 +4185,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"]) {
@@ -4070,6 +4299,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~",
@@ -4094,16 +4324,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,
@@ -4122,16 +4357,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)) {
@@ -4217,6 +4466,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") {
@@ -4226,6 +4476,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~",
@@ -4257,6 +4508,7 @@ ${body.trim()}`);
           removed
         });
         await this.mirrorBackup(scope);
+        await this._recalcTrackedByteSize(scope);
       }
       return removed;
     });
@@ -4268,6 +4520,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~",
@@ -4298,6 +4551,7 @@ ${body.trim()}`);
           removed
         });
         await this.mirrorBackup(scope);
+        await this._recalcTrackedByteSize(scope);
       }
     });
   }
@@ -4308,6 +4562,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~",
@@ -4334,6 +4589,7 @@ ${body.trim()}`);
         }
         this.events?.emit("memory.cleared", { scope });
         await this.mirrorBackup(scope);
+        this._trackedByteSizes[scope] = 0;
       });
       return;
     }
@@ -4647,6 +4903,83 @@ var ALGO = "aes-256-gcm";
 var KEY_FILE_MODE = 384;
 var KEY_FILE_MAGIC = Buffer.from("WSKV", "ascii");
 var VERSIONED_KEY_FILE_SIZE = KEY_FILE_MAGIC.length + 1 + KEY_BYTES;
+var KEK_MAGIC = Buffer.from("WSKW", "ascii");
+var KEK_SALT_BYTES = 16;
+var WRAPPED_KEY_FILE_SIZE = KEK_MAGIC.length + 1 + KEK_SALT_BYTES + IV_BYTES + TAG_BYTES + KEY_BYTES;
+var SCRYPT_N = 1 << 15;
+var SCRYPT_R = 8;
+var SCRYPT_P = 1;
+var SCRYPT_MAXMEM = 64 * 1024 * 1024;
+function getVaultPassphrase() {
+  const v = process.env["WRONGSTACK_VAULT_PASSPHRASE"];
+  return v && v.length > 0 ? v : void 0;
+}
+function isWrappedKeyFile(buf) {
+  return buf.length === WRAPPED_KEY_FILE_SIZE && buf.subarray(0, KEK_MAGIC.length).equals(KEK_MAGIC);
+}
+function deriveKEK(passphrase, salt) {
+  return scryptSync(passphrase, salt, KEY_BYTES, {
+    N: SCRYPT_N,
+    r: SCRYPT_R,
+    p: SCRYPT_P,
+    maxmem: SCRYPT_MAXMEM
+  });
+}
+function wrapDataKey(dataKey, keyVersion, passphrase) {
+  const salt = randomBytes(KEK_SALT_BYTES);
+  const iv = randomBytes(IV_BYTES);
+  const kek = deriveKEK(passphrase, salt);
+  const cipher = createCipheriv(ALGO, kek, iv);
+  const ct = Buffer.concat([cipher.update(dataKey), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  const out = Buffer.alloc(WRAPPED_KEY_FILE_SIZE);
+  let off = 0;
+  KEK_MAGIC.copy(out, off);
+  off += KEK_MAGIC.length;
+  out[off] = keyVersion & 255;
+  off += 1;
+  salt.copy(out, off);
+  off += KEK_SALT_BYTES;
+  iv.copy(out, off);
+  off += IV_BYTES;
+  tag.copy(out, off);
+  off += TAG_BYTES;
+  ct.copy(out, off);
+  return out;
+}
+function unwrapDataKey(buf, keyFile) {
+  const passphrase = getVaultPassphrase();
+  if (!passphrase) {
+    throw new ConfigError({
+      message: `SecretVault: key file ${keyFile} is passphrase-protected \u2014 set the WRONGSTACK_VAULT_PASSPHRASE environment variable to unlock it.`,
+      code: ERROR_CODES.CONFIG_INVALID,
+      context: { keyFile }
+    });
+  }
+  let off = KEK_MAGIC.length;
+  const version = buf[off];
+  off += 1;
+  const salt = buf.subarray(off, off + KEK_SALT_BYTES);
+  off += KEK_SALT_BYTES;
+  const iv = buf.subarray(off, off + IV_BYTES);
+  off += IV_BYTES;
+  const tag = buf.subarray(off, off + TAG_BYTES);
+  off += TAG_BYTES;
+  const ct = buf.subarray(off, off + KEY_BYTES);
+  const kek = deriveKEK(passphrase, salt);
+  const decipher = createDecipheriv(ALGO, kek, iv);
+  decipher.setAuthTag(tag);
+  try {
+    const key = Buffer.concat([decipher.update(ct), decipher.final()]);
+    return { key: Buffer.from(key), version };
+  } catch {
+    throw new ConfigError({
+      message: `SecretVault: failed to unlock key file ${keyFile} \u2014 wrong WRONGSTACK_VAULT_PASSPHRASE (key unwrap authentication failed).`,
+      code: ERROR_CODES.CONFIG_INVALID,
+      context: { keyFile }
+    });
+  }
+}
 function checkKeyFilePermissions(keyFile) {
   if (process.platform === "win32") return;
   try {
@@ -4739,25 +5072,56 @@ var DefaultSecretVault = class {
     const oldVersion = this._keyVersion;
     const newKey = randomBytes(KEY_BYTES);
     const newVersion = oldVersion + 1;
-    const keyFileBuf = Buffer.alloc(VERSIONED_KEY_FILE_SIZE);
-    KEY_FILE_MAGIC.copy(keyFileBuf, 0);
-    keyFileBuf[KEY_FILE_MAGIC.length] = newVersion;
-    newKey.copy(keyFileBuf, KEY_FILE_MAGIC.length + 1);
     fs4.mkdirSync(path4.dirname(this.keyFile), { recursive: true });
-    fs4.writeFileSync(this.keyFile, keyFileBuf, { mode: 384 });
+    const passphrase = getVaultPassphrase();
+    if (passphrase) {
+      fs4.writeFileSync(this.keyFile, wrapDataKey(newKey, newVersion, passphrase), { mode: 384 });
+    } else {
+      const keyFileBuf = Buffer.alloc(VERSIONED_KEY_FILE_SIZE);
+      KEY_FILE_MAGIC.copy(keyFileBuf, 0);
+      keyFileBuf[KEY_FILE_MAGIC.length] = newVersion;
+      newKey.copy(keyFileBuf, KEY_FILE_MAGIC.length + 1);
+      fs4.writeFileSync(this.keyFile, keyFileBuf, { mode: 384 });
+    }
     checkKeyFilePermissions(this.keyFile);
     this.key = newKey;
     this._keyVersion = newVersion;
     return { oldVersion, newVersion };
   }
+  /**
+   * If WRONGSTACK_VAULT_PASSPHRASE is set but the key on disk is still stored
+   * unwrapped (legacy v1 / versioned v2), re-write it in passphrase-wrapped (v3)
+   * form. The data key is preserved, so all existing ciphertext keeps
+   * decrypting. Best-effort: a write failure leaves the working unwrapped file
+   * in place and is not fatal to load.
+   */
+  migrateToWrappedIfPassphrase() {
+    const passphrase = getVaultPassphrase();
+    if (!passphrase || !this.key) return;
+    try {
+      fs4.writeFileSync(this.keyFile, wrapDataKey(this.key, this._keyVersion, passphrase), {
+        mode: 384
+      });
+      checkKeyFilePermissions(this.keyFile);
+    } catch {
+    }
+  }
   loadOrCreateKey() {
     if (this.key) return this.key;
     try {
       const buf = fs4.readFileSync(this.keyFile);
+      if (isWrappedKeyFile(buf)) {
+        const { key: key2, version } = unwrapDataKey(buf, this.keyFile);
+        this.key = key2;
+        this._keyVersion = version;
+        checkKeyFilePermissions(this.keyFile);
+        return this.key;
+      }
       if (buf.length === KEY_BYTES) {
         this.key = buf;
         this._keyVersion = 1;
         checkKeyFilePermissions(this.keyFile);
+        this.migrateToWrappedIfPassphrase();
         return this.key;
       }
       if (buf.length === VERSIONED_KEY_FILE_SIZE) {
@@ -4781,6 +5145,7 @@ var DefaultSecretVault = class {
         this.key = Buffer.from(key2);
         this._keyVersion = version;
         checkKeyFilePermissions(this.keyFile);
+        this.migrateToWrappedIfPassphrase();
         return this.key;
       }
       throw new ConfigError({
@@ -4793,11 +5158,20 @@ var DefaultSecretVault = class {
     }
     fs4.mkdirSync(path4.dirname(this.keyFile), { recursive: true });
     const key = randomBytes(KEY_BYTES);
+    const passphrase = getVaultPassphrase();
+    const initialBytes = passphrase ? wrapDataKey(key, 1, passphrase) : key;
     try {
-      fs4.writeFileSync(this.keyFile, key, { mode: 384, flag: "wx" });
+      fs4.writeFileSync(this.keyFile, initialBytes, { mode: 384, flag: "wx" });
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
       const buf = fs4.readFileSync(this.keyFile);
+      if (isWrappedKeyFile(buf)) {
+        const { key: winnerKey, version } = unwrapDataKey(buf, this.keyFile);
+        this.key = winnerKey;
+        this._keyVersion = version;
+        checkKeyFilePermissions(this.keyFile);
+        return this.key;
+      }
       if (buf.length === KEY_BYTES) {
         this.key = buf;
         this._keyVersion = 1;
@@ -5141,6 +5515,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 = path4.resolve(a);
+  let rb = path4.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)) {
@@ -5169,14 +5588,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);
@@ -7057,6 +7477,9 @@ function isClearlyDestructiveBashCommand(command, projectRoot) {
 }
 
 // src/security/permission-policy.ts
+function matchesTrust(patterns, subject) {
+  return patterns.includes(subject) || matchAny(patterns, subject);
+}
 var DefaultPermissionPolicy = class {
   policy = {};
   loaded = false;
@@ -7193,7 +7616,7 @@ var DefaultPermissionPolicy = class {
       this._evalCache.set(cacheKey, decision);
       return decision;
     }
-    if (entry?.deny && subject && matchAny(entry.deny, subject)) {
+    if (entry?.deny && subject && matchesTrust(entry.deny, subject)) {
       const decision = { permission: "deny", source: "deny", reason: "matched deny pattern" };
       this._evalCache.set(cacheKey, decision);
       return decision;
@@ -7203,7 +7626,7 @@ var DefaultPermissionPolicy = class {
       this._evalCache.set(cacheKey, decision);
       return decision;
     }
-    if (entry?.allow && subject && matchAny(entry.allow, subject)) {
+    if (entry?.allow && subject && matchesTrust(entry.allow, subject)) {
       const decision = { permission: "auto", source: "trust", reason: "matched allow pattern" };
       this._evalCache.set(cacheKey, decision);
       return decision;
@@ -7927,6 +8350,16 @@ function handleMessageStop(state, ev) {
 async function streamProviderToResponse(provider, req, signal, ctx, events, logger) {
   const state = createStreamingState(req.model);
   logger.debug("Stream started", { providerId: provider.id, model: req.model });
+  const TEXT_BATCH_SIZE = 4;
+  let pendingText = "";
+  let pendingCount = 0;
+  const flushText = () => {
+    if (pendingCount > 0) {
+      events.emit("provider.text_delta", { ctx, text: pendingText });
+      pendingText = "";
+      pendingCount = 0;
+    }
+  };
   const iter = provider.stream(req, { signal })[Symbol.asyncIterator]();
   try {
     for (; ; ) {
@@ -7946,9 +8379,12 @@ async function streamProviderToResponse(provider, req, signal, ctx, events, logg
             break;
           case "text_delta":
             handleTextDelta(state, ev.text);
-            events.emit("provider.text_delta", { ctx, text: ev.text });
+            pendingText += ev.text;
+            pendingCount++;
+            if (pendingCount >= TEXT_BATCH_SIZE) flushText();
             break;
           case "tool_use_start": {
+            flushText();
             const idVal = ev.id;
             const nameVal = ev.name;
             handleToolUseStart(state, { id: idVal, name: nameVal });
@@ -7960,6 +8396,7 @@ async function streamProviderToResponse(provider, req, signal, ctx, events, logg
             handleToolUseInputDelta(state, ev);
             break;
           case "tool_use_stop": {
+            flushText();
             const stoppedName = state.tools.get(ev.id)?.name ?? "unknown";
             handleToolUseStop(state, ev);
             events.emit("provider.tool_use_stop", { ctx, id: ev.id, name: stoppedName });
@@ -7969,6 +8406,7 @@ async function streamProviderToResponse(provider, req, signal, ctx, events, logg
             handleThinkingStart(state, ev);
             break;
           case "thinking_delta":
+            flushText();
             handleThinkingDelta(state, ev.text);
             events.emit("provider.thinking_delta", { ctx, text: ev.text });
             break;
@@ -8000,6 +8438,7 @@ async function streamProviderToResponse(provider, req, signal, ctx, events, logg
           eventType: String(evAny.type),
           errorMessage: errMsg
         });
+        flushText();
         events.emit("provider.stream_error", {
           ctx,
           eventType: String(evAny.type),
@@ -8010,6 +8449,7 @@ async function streamProviderToResponse(provider, req, signal, ctx, events, logg
   } catch (err) {
     if (signal.aborted) {
       state.stopReason = "end_turn";
+      flushText();
       logger.debug("Stream aborted \u2014 returning partial state", {
         providerId: provider.id,
         model: req.model,
@@ -8028,8 +8468,8 @@ async function streamProviderToResponse(provider, req, signal, ctx, events, logg
         });
         await Promise.race([
           drainPromise,
-          new Promise((resolve6) => {
-            drainTimer = setTimeout(resolve6, STREAM_DRAIN_TIMEOUT_MS);
+          new Promise((resolve7) => {
+            drainTimer = setTimeout(resolve7, STREAM_DRAIN_TIMEOUT_MS);
           })
         ]);
       } finally {
@@ -8038,6 +8478,7 @@ async function streamProviderToResponse(provider, req, signal, ctx, events, logg
     } catch {
     }
   }
+  flushText();
   logger.debug("Stream completed", {
     providerId: provider.id,
     model: req.model,
@@ -8135,7 +8576,7 @@ async function runProviderWithRetry(opts) {
           description
         });
       }
-      await new Promise((resolve6, reject) => {
+      await new Promise((resolve7, reject) => {
         let settled = false;
         const cleanup = () => {
           clearTimeout(t);
@@ -8151,7 +8592,7 @@ async function runProviderWithRetry(opts) {
           if (settled) return;
           settled = true;
           cleanup();
-          resolve6();
+          resolve7();
         }, delay);
         if (signal.aborted) {
           onAbort();
@@ -8224,17 +8665,9 @@ function findPreserveStart(messages, preserveK) {
     const prev = messages[preserveStart - 1];
     if (!first || !prev || first.role !== "user" || prev.role !== "assistant") break;
     if (typeof first.content === "string" || typeof prev.content === "string") break;
-    const resultIds = /* @__PURE__ */ new Set();
-    for (const block of first.content) {
-      pairRepairInnerIterations++;
-      if (block.type === "tool_result") resultIds.add(block.tool_use_id);
-    }
-    if (resultIds.size === 0) break;
-    const hasMatchingUse = prev.content.some((block) => {
-      pairRepairInnerIterations++;
-      return block.type === "tool_use" && resultIds.has(block.id);
-    });
-    if (!hasMatchingUse) break;
+    const pairCheck = hasMatchingToolPair(first.content, prev.content);
+    pairRepairInnerIterations += pairCheck.iterations;
+    if (!pairCheck.matched) break;
     preserveStart--;
   }
   if (compactionDebugEnabled()) {
@@ -8253,9 +8686,34 @@ function findPreserveStart(messages, preserveK) {
   }
   return preserveStart;
 }
+function hasMatchingToolPair(resultContent, useContent) {
+  let iterations = 0;
+  let firstResultId;
+  let resultIds;
+  for (const block of resultContent) {
+    iterations++;
+    if (block.type !== "tool_result") continue;
+    if (firstResultId === void 0) {
+      firstResultId = block.tool_use_id;
+    } else {
+      resultIds ??= /* @__PURE__ */ new Set([firstResultId]);
+      resultIds.add(block.tool_use_id);
+    }
+  }
+  if (firstResultId === void 0) return { matched: false, iterations };
+  for (const block of useContent) {
+    iterations++;
+    if (block.type !== "tool_use") continue;
+    if (resultIds ? resultIds.has(block.id) : block.id === firstResultId) {
+      return { matched: true, iterations };
+    }
+  }
+  return { matched: false, iterations };
+}
 function eliseOldToolResults(messages, opts) {
   const preserveStart = findPreserveStart(messages, opts.preserveK);
   let hasOversized = false;
+  let firstOversizedIndex = -1;
   let fastPathIterations = 0;
   let fastPathInnerIterations = 0;
   for (let i = 0; i < preserveStart && !hasOversized; i++) {
@@ -8267,6 +8725,7 @@ function eliseOldToolResults(messages, opts) {
       const oversized = b.type === "tool_result" && estimateToolResultTokens(b.content) >= opts.eliseThreshold || b.type === "tool_use" && estimateToolInputTokens(b.input) >= opts.eliseThreshold;
       if (oversized) {
         hasOversized = true;
+        firstOversizedIndex = i;
         break;
       }
     }
@@ -8289,26 +8748,29 @@ function eliseOldToolResults(messages, opts) {
   let changed = false;
   let fullPassIterations = 0;
   let fullPassInnerIterations = 0;
-  const next = new Array(messages.length);
-  for (let i = 0; i < messages.length; i++) {
+  let next;
+  for (let i = firstOversizedIndex; i < preserveStart; i++) {
     fullPassIterations++;
     const msg = messages[i];
-    if (i >= preserveStart || !msg || !Array.isArray(msg.content)) {
-      next[i] = msg;
-      continue;
-    }
+    if (!msg || !Array.isArray(msg.content)) continue;
     const original = msg.content;
-    const newContent = original.map((b) => {
+    let newContent;
+    for (let idx = 0; idx < original.length; idx++) {
+      fullPassInnerIterations++;
+      const b = original[idx];
+      if (!b) continue;
       if (b.type === "tool_use") {
         const tokens2 = estimateToolInputTokens(b.input);
-        if (tokens2 < opts.eliseThreshold) return b;
+        if (tokens2 < opts.eliseThreshold) continue;
         const elidedInput = summarizeToolUseInputElision(b, tokens2);
         saved += Math.max(0, tokens2 - estimateToolInputTokens(elidedInput));
-        return { ...b, input: elidedInput };
+        newContent ??= original.slice();
+        newContent[idx] = { ...b, input: elidedInput };
+        continue;
       }
-      if (b.type !== "tool_result") return b;
+      if (b.type !== "tool_result") continue;
       const tokens = estimateToolResultTokens(b.content);
-      if (tokens < opts.eliseThreshold) return b;
+      if (tokens < opts.eliseThreshold) continue;
       saved += tokens;
       const elided = {
         type: "tool_result",
@@ -8316,15 +8778,14 @@ function eliseOldToolResults(messages, opts) {
         content: summarizeToolResultElision(b, tokens),
         is_error: b.is_error
       };
-      return elided;
-    });
-    if (newContent.every((b, idx) => b === original[idx])) {
-      next[i] = msg;
-    } else {
+      newContent ??= original.slice();
+      newContent[idx] = elided;
+    }
+    if (newContent) {
+      next ??= messages.slice();
       next[i] = { ...msg, content: newContent };
       changed = true;
     }
-    fullPassInnerIterations += original.length;
     if (compactionDebugEnabled()) {
       const ratio = fullPassInnerIterations / fullPassIterations;
       if (ratio > 10) {
@@ -8351,7 +8812,7 @@ function eliseOldToolResults(messages, opts) {
     tokensSaved: saved,
     changed
   });
-  return { messages: changed ? next : messages, saved, changed };
+  return { messages: changed && next ? next : messages, saved, changed };
 }
 function summarizeToolUseInputElision(block, tokens) {
   const fields = {};
@@ -10659,7 +11120,14 @@ var EternalAutonomyEngine = class {
     try {
       const reloaded = await loadGoal(this.goalPath, this.opts.events);
       iterationIndex = reloaded?.iterations ?? 0;
-    } catch {
+    } catch (err) {
+      console.error(JSON.stringify({
+        level: "warn",
+        event: "autonomy.goal_reload_failed",
+        message: toErrorMessage(err),
+        context: { goalPath: this.goalPath },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }));
     }
     this.opts.onIteration?.({
       at: (this.opts.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
@@ -10894,7 +11362,14 @@ ${lastFew}` : "No prior iterations yet.",
       } finally {
         clearTimeout(timer);
       }
-    } catch {
+    } catch (err) {
+      console.error(JSON.stringify({
+        level: "warn",
+        event: "autonomy.brainstorm_failed",
+        message: toErrorMessage(err),
+        context: { goal: goal.goal.slice(0, 100) },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }));
       return null;
     }
   }
@@ -11417,13 +11892,13 @@ var SubagentBudget = class _SubagentBudget {
     if (!bus?.hasListenerFor("budget.threshold_reached")) {
       return Promise.resolve("stop");
     }
-    return new Promise((resolve6) => {
+    return new Promise((resolve7) => {
       let resolved = false;
       const respond = (d) => {
         if (resolved) return;
         resolved = true;
         clearTimeout(fallback);
-        resolve6(d);
+        resolve7(d);
       };
       const fallback = setTimeout(() => respond("stop"), _SubagentBudget.DECISION_TIMEOUT_MS);
       bus.emit("budget.threshold_reached", {
@@ -14774,6 +15249,68 @@ Working rules:
 - When in doubt, flag as medium rather than ignoring potential issues`
   // Budgets are set by the orchestrator per task — see fleet.ts header.
 };
+var SHADOW_AGENT = {
+  id: "shadow-agent",
+  name: "Shadow",
+  role: "shadow-agent",
+  prompt: `You are the Shadow Agent \u2014 a silent background monitor for the WrongStack fleet.
+
+Your job is to observe, detect anomalies, and be ready to intervene \u2014 but only when commanded.
+
+## Core Responsibilities
+
+1. **Fleet Monitoring** (every 30s)
+   - Call \`fleet_status\` + \`fleet_health\` on each heartbeat
+   - Track what each agent is doing (task descriptions)
+   - Detect stuck agents (>5min no events), idle agents, crashed agents
+
+2. **FleetBus Subscription**
+   - Subscribe to \`subagent.*\` events to track lifecycle
+   - Subscribe to \`tool.executed\` to monitor activity
+   - Track agent joins (subagent.started) and leaves (subagent.stopped)
+
+3. **Mailbox Surveillance**
+   - Monitor for \`control\` type messages starting with "hoop"
+   - Detect orphan assigns (assign without result within 5min)
+   - Cross-session awareness via shared project mailbox
+
+4. **Spike Detection**
+   - Track task duration per agent
+   - Flag agents that spawn and die within <5 seconds
+   - Log spike events with reason (completed/error/killed/timeout)
+
+5. **Intervention Commands**
+   Parse these from mailbox control messages:
+   - \`hoop <agentId>\` \u2014 terminate specific agent
+   - \`hoop all\` \u2014 terminate all running agents
+   - \`shadow status\` \u2014 report current fleet snapshot
+   - \`shadow mute\` \u2014 pause heartbeat monitoring
+   - \`shadow resume\` \u2014 resume heartbeat monitoring
+   - \`shadow interval <ms>\` \u2014 change heartbeat interval
+   - \`shadow model <model-id>\` \u2014 change analysis model
+
+## Operating Rules
+
+- **Silent by default**: Use DEBUG level logging unless anomaly detected
+- **Deterministic**: Same state always produces same actions \u2014 no randomness
+- **Report on anomaly**: When anomaly detected, use \`mail_send\` to broadcast warning
+- **Never auto-intervene**: Always report unless explicitly commanded
+- **Minimal footprint**: Small state, efficient snapshots
+
+## Startup Sequence
+
+1. Send broadcast: \`shadow:started { intervalMs, model, startTime }\`
+2. Subscribe to FleetBus for all relevant events
+3. Schedule heartbeat cron job at configured interval
+4. Wait for commands or anomalies
+
+## Shutdown Sequence
+
+1. Cancel all cron jobs (\`cron_cancel\`)
+2. Send broadcast: \`shadow:stopped { reason, finalState }\`
+3. Clean up FleetBus subscriptions`
+  // Budgets are set by the orchestrator per task — see fleet.ts header.
+};
 var CRITIC_AGENT = {
   id: "critic",
   name: "Critic",
@@ -14814,6 +15351,7 @@ var FLEET_ROSTER = {
   "refactor-planner": REFACTOR_PLANNER_AGENT,
   "security-scanner": SECURITY_SCANNER_AGENT,
   "critic": CRITIC_AGENT,
+  "shadow-agent": SHADOW_AGENT,
   ...Object.fromEntries(
     ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, d.config])
   )
@@ -14825,6 +15363,8 @@ var FLEET_ROSTER_BUDGETS = {
   "refactor-planner": { timeoutMs: 7.5 * 60 * 60 * 1e3, maxIterations: 6e3, maxToolCalls: 18e3 },
   "security-scanner": { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 },
   "critic": { timeoutMs: 5 * 60 * 60 * 1e3, maxIterations: 4e3, maxToolCalls: 12e3 },
+  "shadow-agent": { timeoutMs: 24 * 60 * 60 * 1e3, maxIterations: 1e4, maxToolCalls: 5e3 },
+  // Long-running background monitor
   ...Object.fromEntries(
     ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, d.budget])
   )
@@ -15263,7 +15803,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       taskIds.map((id) => {
         const cached = this.completedResults.find((r) => r.taskId === id);
         if (cached) return cached;
-        return new Promise((resolve6, reject) => {
+        return new Promise((resolve7, reject) => {
           const timeout = setTimeout(() => {
             this.off("task.completed", handler);
             reject(new Error(`awaitTasks timed out waiting for task "${id}"`));
@@ -15272,7 +15812,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
             if (result.taskId === id) {
               clearTimeout(timeout);
               this.off("task.completed", handler);
-              resolve6(result);
+              resolve7(result);
             }
           };
           this.on("task.completed", handler);
@@ -15540,12 +16080,12 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
             }
             return new Promise((resolveDecision) => {
               let settled = false;
-              const resolve6 = (d) => {
+              const resolve7 = (d) => {
                 if (settled) return;
                 settled = true;
                 resolveDecision(d);
               };
-              const fallback = setTimeout(() => resolve6("stop"), DECISION_TIMEOUT_MS);
+              const fallback = setTimeout(() => resolve7("stop"), DECISION_TIMEOUT_MS);
               budget._events?.emit("budget.threshold_reached", {
                 kind: "timeout",
                 used,
@@ -15561,11 +16101,11 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
                 // disagreeing, resolves as a stop). Async grants still resolve.
                 extend: (extra) => {
                   clearTimeout(fallback);
-                  queueMicrotask(() => resolve6({ extend: extra }));
+                  queueMicrotask(() => resolve7({ extend: extra }));
                 },
                 deny: () => {
                   clearTimeout(fallback);
-                  resolve6("stop");
+                  resolve7("stop");
                 }
               });
             });
@@ -16032,7 +16572,14 @@ ${personaLine}Task: ${task}
             subagentIds.push(subagentId);
             taskIds.push(taskId);
             await coordinator.assign(spec);
-          } catch {
+          } catch (err) {
+            console.error(JSON.stringify({
+              level: "warn",
+              event: "parallel_engine.spawn_failed",
+              message: toErrorMessage(err),
+              context: { slot: i, task, subagentId },
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            }));
           }
         })()
       );
@@ -16057,7 +16604,14 @@ ${personaLine}Task: ${task}
       } finally {
         clearTimeout(timer);
       }
-    } catch {
+    } catch (err) {
+      console.error(JSON.stringify({
+        level: "warn",
+        event: "parallel_engine.brainstorm_results_failed",
+        message: toErrorMessage(err),
+        context: { slotCount, taskIds },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }));
       results = coordinator.results().slice(-taskIds.length);
     }
     await Promise.allSettled(subagentIds.map((id) => coordinator.remove(id)));
@@ -16091,7 +16645,14 @@ ${personaLine}Task: ${task}
             if (file) tasks.push(`[git] inspect and fix: ${file}`);
           }
         }
-      } catch {
+      } catch (err) {
+        console.error(JSON.stringify({
+          level: "warn",
+          event: "parallel_engine.git_status_failed",
+          message: toErrorMessage(err),
+          context: { projectRoot: this.opts.projectRoot },
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }));
       }
     }
     if (tasks.length < this.slots) {
@@ -16454,7 +17015,7 @@ var InMemoryAgentBridge = class {
       });
     }
     this.inflightGuards.add(correlationId);
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       const timer = setTimeout(() => {
         this.inflightGuards.delete(correlationId);
         this.pendingRequests.delete(correlationId);
@@ -16473,7 +17034,7 @@ var InMemoryAgentBridge = class {
         return;
       }
       this.pendingRequests.set(correlationId, {
-        resolve: resolve6,
+        resolve: resolve7,
         reject,
         timer
       });
@@ -18935,11 +19496,11 @@ var Director = class _Director {
         if (cached) return cached;
         const existing = this.taskWaiters.get(id);
         if (existing) return existing.promise;
-        let resolve6;
+        let resolve7;
         const promise = new Promise((res) => {
-          resolve6 = res;
+          resolve7 = res;
         });
-        this.taskWaiters.set(id, { promise, resolve: resolve6 });
+        this.taskWaiters.set(id, { promise, resolve: resolve7 });
         return promise;
       })
     );
@@ -19335,7 +19896,7 @@ function createDelegateTool(opts) {
           subagentId
         });
         const dir = director;
-        const result = await new Promise((resolve6) => {
+        const result = await new Promise((resolve7) => {
           let settled = false;
           let timer;
           const finish = (value) => {
@@ -19345,7 +19906,7 @@ function createDelegateTool(opts) {
             offTool();
             offIter();
             offProgress();
-            resolve6(value);
+            resolve7(value);
           };
           const arm = () => {
             if (timer) clearTimeout(timer);
@@ -19705,6 +20266,7 @@ var NULL_FLEET_BUS = new FleetBus();
 // src/models/models-registry.ts
 init_atomic_write();
 var DEFAULT_URL = "https://models.dev/api.json";
+var ENV_URL_KEY = "WRONGSTACK_MODELS_DEV_URL";
 var DEFAULT_TTL_SECONDS = 24 * 3600;
 var DEFAULT_REFRESH_TIMEOUT_MS = 15e3;
 var FAMILY_BY_NPM = {
@@ -19750,7 +20312,7 @@ var DefaultModelsRegistry = class {
   overlayCacheFile;
   constructor(opts) {
     this.cacheFile = opts.cacheFile;
-    this.url = opts.url ?? DEFAULT_URL;
+    this.url = opts.url ?? process.env[ENV_URL_KEY] ?? DEFAULT_URL;
     this.ttlMs = (opts.ttlSeconds ?? DEFAULT_TTL_SECONDS) * 1e3;
     this.fetchImpl = opts.fetchImpl ?? fetch;
     this.seed = opts.seed;
@@ -19795,6 +20357,10 @@ var DefaultModelsRegistry = class {
       const cached = await this.readCacheAt(this.cacheFile);
       if (cached && this.isWithinMaxStaleAge(cached.fetchedAt)) {
         this.fetchedAt = new Date(cached.fetchedAt);
+        const ageSeconds = Math.floor((Date.now() - this.fetchedAt.getTime()) / 1e3);
+        console.warn(
+          `ModelsRegistry: models.dev unavailable (${toErrorMessage(err)}); using stale cache from ${formatAge(ageSeconds)} ago. Run \`wstack models refresh\` to retry.`
+        );
         return cached.payload;
       }
       if (overlayAvailable) {
@@ -19880,7 +20446,13 @@ var DefaultModelsRegistry = class {
       return json;
     } catch {
       const cached = await this.readCacheAt(this.overlayCacheFile);
-      if (cached && this.isWithinMaxStaleAge(cached.fetchedAt)) return cached.payload;
+      if (cached && this.isWithinMaxStaleAge(cached.fetchedAt)) {
+        const ageSeconds = Math.floor((Date.now() - new Date(cached.fetchedAt).getTime()) / 1e3);
+        console.warn(
+          `ModelsRegistry: overlay unavailable; using stale overlay from ${formatAge(ageSeconds)} ago.`
+        );
+        return cached.payload;
+      }
       return void 0;
     }
   }
@@ -19977,6 +20549,16 @@ var DefaultModelsRegistry = class {
     return path4.resolve(this.cacheFile);
   }
 };
+function formatAge(seconds) {
+  if (seconds < 60) return "<1m";
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m`;
+  if (seconds < 86400) {
+    const h = Math.floor(seconds / 3600);
+    const m = Math.floor(seconds % 3600 / 60);
+    return m > 0 ? `${h}h ${m}m` : `${h}h`;
+  }
+  return `${Math.floor(seconds / 86400)}d`;
+}
 function hasEntries(payload) {
   return payload !== void 0 && Object.keys(payload).length > 0;
 }
@@ -21777,9 +22359,9 @@ var AISpecBuilder = class {
     if (!this.sessionPath) return;
     try {
       const fsp16 = await import('fs/promises');
-      const path21 = await import('path');
+      const path22 = await import('path');
       const { atomicWrite: atomicWrite2 } = await Promise.resolve().then(() => (init_atomic_write(), atomic_write_exports));
-      await fsp16.mkdir(path21.dirname(this.sessionPath), { recursive: true });
+      await fsp16.mkdir(path22.dirname(this.sessionPath), { recursive: true });
       await atomicWrite2(this.sessionPath, JSON.stringify(this.session, null, 2));
     } catch {
     }
@@ -22506,15 +23088,15 @@ function computeCriticalPath(graph, _topoOrder, blockedByMap) {
       maxId = id;
     }
   }
-  const path21 = [];
+  const path22 = [];
   let current = maxId;
   const visited = /* @__PURE__ */ new Set();
   while (current && !visited.has(current)) {
     visited.add(current);
-    path21.unshift(current);
+    path22.unshift(current);
     current = prev.get(current) ?? null;
   }
-  return path21;
+  return path22;
 }
 function computeParallelGroups(graph, blockedByMap) {
   const groups = [];
@@ -23337,9 +23919,9 @@ var DefaultHealthRegistry = class {
   }
   async runOne(check) {
     let timer = null;
-    const timeout = new Promise((resolve6) => {
+    const timeout = new Promise((resolve7) => {
       timer = setTimeout(
-        () => resolve6({ status: "unhealthy", detail: `timeout after ${this.timeoutMs}ms` }),
+        () => resolve7({ status: "unhealthy", detail: `timeout after ${this.timeoutMs}ms` }),
         this.timeoutMs
       );
     });
@@ -23522,7 +24104,7 @@ async function startMetricsServer(opts) {
   const tls = opts.tls;
   const useHttps = !!(tls?.cert && tls?.key);
   const host = opts.host ?? "127.0.0.1";
-  const path21 = opts.path ?? "/metrics";
+  const path22 = opts.path ?? "/metrics";
   const healthPath = opts.healthPath ?? "/healthz";
   const healthRegistry = opts.healthRegistry;
   const listener = (req, res) => {
@@ -23532,7 +24114,7 @@ async function startMetricsServer(opts) {
       return;
     }
     const url = req.url.split("?")[0];
-    if (url === path21) {
+    if (url === path22) {
       let body;
       try {
         body = renderPrometheus(opts.sink.snapshot());
@@ -23578,14 +24160,14 @@ async function startMetricsServer(opts) {
     const { createServer } = await import('http');
     server = createServer(listener);
   }
-  await new Promise((resolve6, reject) => {
+  await new Promise((resolve7, reject) => {
     const onError = (err) => {
       server.off("listening", onListening);
       reject(err);
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve6();
+      resolve7();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -23596,9 +24178,9 @@ async function startMetricsServer(opts) {
   const protocol = useHttps ? "https" : "http";
   return {
     port: boundPort,
-    url: `${protocol}://${host}:${boundPort}${path21}`,
-    close: () => new Promise((resolve6, reject) => {
-      server.close((err) => err ? reject(err) : resolve6());
+    url: `${protocol}://${host}:${boundPort}${path22}`,
+    close: () => new Promise((resolve7, reject) => {
+      server.close((err) => err ? reject(err) : resolve7());
     })
   };
 }