@wrongstack/core 0.87.0 → 0.89.3

package/dist/defaults/index.js

@@ -5,18 +5,13 @@ import * as path3 from 'path';
 import { isAbsolute, resolve } from 'path';
 import * as fs5 from 'fs';
 import * as os from 'os';
+import { hostname } from 'os';
 import { execFile } from 'child_process';
 import { promisify } from 'util';
 import { EventEmitter } from 'events';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -29,7 +24,8 @@ var __export = (target, all) => {
 var atomic_write_exports = {};
 __export(atomic_write_exports, {
   atomicWrite: () => atomicWrite,
-  ensureDir: () => ensureDir
+  ensureDir: () => ensureDir,
+  withFileLock: () => withFileLock
 });
 async function atomicWrite(targetPath, content, opts = {}) {
   const dir = path3.dirname(targetPath);
@@ -52,8 +48,8 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat5 = await fsp.stat(targetPath);
-      mode = stat5.mode & 511;
+      const stat6 = await fsp.stat(targetPath);
+      mode = stat6.mode & 511;
     } catch {
       mode = opts.mode;
     }
@@ -72,6 +68,49 @@ async function atomicWrite(targetPath, content, opts = {}) {
 async function ensureDir(dir) {
   await fsp.mkdir(dir, { recursive: true });
 }
+async function withFileLock(targetPath, fn, opts = {}) {
+  const dir = path3.dirname(targetPath);
+  await fsp.mkdir(dir, { recursive: true });
+  const lockPath = path3.join(dir, `.${path3.basename(targetPath)}.lock`);
+  const timeoutMs = opts.timeoutMs ?? 5e3;
+  const staleMs = opts.staleMs ?? 3e4;
+  const started = Date.now();
+  let handle;
+  for (; ; ) {
+    try {
+      handle = await fsp.open(lockPath, "wx");
+      await handle.writeFile(`${process.pid}:${Date.now()}`);
+      break;
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+      try {
+        const stat6 = await fsp.stat(lockPath);
+        if (Date.now() - stat6.mtimeMs > staleMs) {
+          await fsp.unlink(lockPath);
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      if (Date.now() - started >= timeoutMs) {
+        throw new Error(`Timed out waiting for file lock: ${targetPath}`);
+      }
+      await new Promise((resolve5) => setTimeout(resolve5, 25));
+    }
+  }
+  try {
+    return await fn();
+  } finally {
+    try {
+      await handle?.close();
+    } catch {
+    }
+    try {
+      await fsp.unlink(lockPath);
+    } catch {
+    }
+  }
+}
 async function renameWithRetry(from, to) {
   if (process.platform !== "win32") {
     await fsp.rename(from, to);
@@ -119,10 +158,15 @@ function writeErr(s, stream = process.stderr) {
 
 // src/utils/color.ts
 var isColorTty = () => {
-  if (process.env.NO_COLOR) return false;
-  if (process.env.FORCE_COLOR) return true;
+  if (envFlag(process.env.NO_COLOR)) return false;
+  if (envFlag(process.env.FORCE_COLOR)) return true;
   return isStdoutTTY();
 };
+function envFlag(value) {
+  if (value === void 0) return false;
+  if (value.trim() === "") return false;
+  return !/^(0|false|no|off)$/i.test(value.trim());
+}
 var COLOR = isColorTty();
 var wrap = (open3, close) => (s) => COLOR ? `\x1B[${open3}m${s}\x1B[${close}m` : s;
 var color = {
@@ -159,6 +203,7 @@ var COLORS = {
   debug: color.gray,
   trace: color.dim
 };
+var LOG_LEVELS = /* @__PURE__ */ new Set(["error", "warn", "info", "debug", "trace"]);
 var DefaultLogger = class _DefaultLogger {
   level;
   file;
@@ -166,7 +211,7 @@ var DefaultLogger = class _DefaultLogger {
   pretty;
   stderr;
   constructor(opts = {}) {
-    this.level = opts.level ?? process.env.WRONGSTACK_LOG_LEVEL ?? "info";
+    this.level = opts.level ?? parseLogLevel(process.env.WRONGSTACK_LOG_LEVEL);
     this.file = opts.file;
     this.bindings = opts.bindings ?? {};
     this.pretty = opts.pretty ?? true;
@@ -231,6 +276,9 @@ var DefaultLogger = class _DefaultLogger {
     }
   }
 };
+function parseLogLevel(raw) {
+  return raw && LOG_LEVELS.has(raw) ? raw : "info";
+}
 function formatCtx(ctx) {
   if (ctx instanceof Error) return color.dim(ctx.message);
   if (typeof ctx === "string") return color.dim(ctx);
@@ -241,16 +289,18 @@ function formatCtx(ctx) {
   }
 }
 
-// src/storage/session-store.ts
-init_atomic_write();
-
-// src/utils/message-invariants.ts
-function expectDefined(value) {
+// src/utils/expect-defined.ts
+function expectDefined(value, label) {
   if (value === null || value === void 0) {
     throw new Error("Expected value to be defined");
   }
   return value;
 }
+
+// src/storage/session-store.ts
+init_atomic_write();
+
+// src/utils/message-invariants.ts
 function repairToolUseAdjacency(messages) {
   const removedToolUses = [];
   const removedToolResults = [];
@@ -343,12 +393,6 @@ function isEmptyMessage(msg) {
 }
 
 // src/storage/session-store.ts
-function expectDefined2(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 function sanitizeModel(model) {
   return model.replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
 }
@@ -614,8 +658,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
       return JSON.parse(raw);
     } catch {
       const full = this.sessionPath(id, ".jsonl");
-      const stat5 = await fsp.stat(full);
-      const summary = await this.summarize(id, stat5.mtime.toISOString());
+      const stat6 = await fsp.stat(full);
+      const summary = await this.summarize(id, stat6.mtime.toISOString());
       await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
         console.warn(
           `[session-store] Failed to write manifest for "${id}":`,
@@ -663,8 +707,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
         if (!file.isFile() || !file.name.endsWith(".jsonl")) continue;
         const jsonlPath = path3.join(dateDir, file.name);
         try {
-          const stat5 = await fsp.stat(jsonlPath);
-          if (stat5.mtimeMs >= cutoff) continue;
+          const stat6 = await fsp.stat(jsonlPath);
+          if (stat6.mtimeMs >= cutoff) continue;
         } catch {
           continue;
         }
@@ -1059,7 +1103,7 @@ var FileSessionWriter = class {
     let targetCheckpointLine = -1;
     let afterTarget = false;
     for (let i = 0; i < lines.length; i++) {
-      const line = expectDefined2(lines[i]);
+      const line = expectDefined(lines[i]);
       if (!line.trim()) continue;
       let event;
       try {
@@ -1355,11 +1399,235 @@ function mergeAdjacentText(blocks) {
   return out;
 }
 
-// src/storage/memory-store.ts
+// src/types/memory.ts
+var MEMORY_TYPE_LABELS = {
+  fact: "Fact",
+  decision: "Decision",
+  convention: "Convention",
+  preference: "Preference",
+  reference: "Reference",
+  anti_pattern: "Anti-pattern"
+};
+
+// src/storage/memory-backend.ts
 init_atomic_write();
+var TYPE_PRIORITY_RE = /^\[(\w+)\|(\w+)\]\s+/;
+var TAG_RE = /#([\w-]+)/g;
+function formatMetadata(entry) {
+  const parts = [];
+  if (entry.type && entry.priority) {
+    parts.push(`[${entry.type}|${entry.priority}]`);
+  } else if (entry.type) {
+    parts.push(`[${entry.type}]`);
+  } else if (entry.priority) {
+    parts.push(`[${entry.priority}]`);
+  }
+  if (entry.tags && entry.tags.length > 0) {
+    parts.push(entry.tags.map((t) => `#${t}`).join(" "));
+  }
+  return parts.length > 0 ? ` ${parts.join(" ")}` : "";
+}
+function lineToEntry(line, scope) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("- [")) return null;
+  const tsMatch = trimmed.match(/^-\s*\[([^\]]+)\]/);
+  if (!tsMatch) return null;
+  const ts = tsMatch[1] ?? "";
+  let rest = trimmed.slice(tsMatch[0].length).trim();
+  let type;
+  let priority;
+  const tpMatch = rest.match(TYPE_PRIORITY_RE);
+  if (tpMatch) {
+    const a = tpMatch[1] ?? "";
+    const b = tpMatch[2] ?? "";
+    if (isMemoryType(a)) {
+      type = a;
+      priority = isPriority(b) ? b : void 0;
+    } else if (isPriority(a)) {
+      priority = a;
+    }
+    rest = rest.slice(tpMatch[0].length).trim();
+  }
+  const idMatch = rest.match(/^mem_\d+_\w+\s+/);
+  let text;
+  if (idMatch) {
+    text = rest.slice(idMatch[0].length).trim();
+  } else {
+    text = rest.trim();
+  }
+  const tags = [];
+  let tagMatch;
+  TAG_RE.lastIndex = 0;
+  while ((tagMatch = TAG_RE.exec(text)) !== null) {
+    tags.push(tagMatch[1] ?? "");
+  }
+  const cleanText = text.replace(TAG_RE, "").replace(/\s{2,}/g, " ").trim();
+  if (!cleanText) return null;
+  return {
+    scope,
+    text: cleanText,
+    ts,
+    type,
+    priority,
+    tags: tags.length > 0 ? tags : void 0
+  };
+}
+function isMemoryType(s) {
+  return s in MEMORY_TYPE_LABELS;
+}
+function isPriority(s) {
+  return s === "critical" || s === "high" || s === "medium" || s === "low";
+}
+var FileMemoryBackend = class {
+  kind = "file";
+  files;
+  constructor(opts) {
+    this.files = {
+      "project-agents": opts.paths.inProjectAgentsFile,
+      "project-memory": opts.paths.projectMemory,
+      "user-memory": opts.paths.globalMemory
+    };
+  }
+  resolveFile(filePath, scope) {
+    return filePath || this.files[scope];
+  }
+  async remember(scope, entry, filePath) {
+    const file = this.resolveFile(filePath, scope);
+    await ensureDir(path3.dirname(file));
+    let existing = "";
+    try {
+      existing = await fsp.readFile(file, "utf8");
+    } catch {
+    }
+    const id = `mem_${Date.now()}_${randomUUID().slice(0, 8)}`;
+    const meta = formatMetadata(entry);
+    const line = `
+- [${entry.ts}] ${id}${meta} ${entry.text.replace(/\n/g, " ")}
+`;
+    const next = existing.trim() ? existing.replace(/\n+$/, "") + line : `# WrongStack Memory
+${line}`;
+    await atomicWrite(file, next);
+  }
+  async forget(scope, query, filePath) {
+    const file = this.resolveFile(filePath, scope);
+    let existing;
+    try {
+      existing = await fsp.readFile(file, "utf8");
+    } catch {
+      return 0;
+    }
+    const needle = query.toLowerCase();
+    const idMatcher = /mem_\d+_\w+/;
+    let removed = 0;
+    const lines = existing.split("\n").filter((line) => {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("- ")) return true;
+      if (idMatcher.test(query)) {
+        const entryIdMatch = /mem_\d+_\w+/.exec(trimmed);
+        if (entryIdMatch && entryIdMatch[0] === query) {
+          removed++;
+          return false;
+        }
+      }
+      if (trimmed.toLowerCase().includes(needle)) {
+        removed++;
+        return false;
+      }
+      return true;
+    });
+    if (removed > 0) {
+      if (lines.length === 0 || lines.length === 1 && !lines[0]?.trim()) {
+        await atomicWrite(file, "");
+      } else {
+        await atomicWrite(file, lines.join("\n"));
+      }
+    }
+    return removed;
+  }
+  async readAll(scope, filePath) {
+    const file = this.resolveFile(filePath, scope);
+    try {
+      return await fsp.readFile(file, "utf8");
+    } catch {
+      return "";
+    }
+  }
+  async list(scope, filePath, limit) {
+    const raw = await this.readAll(scope, filePath);
+    if (!raw.trim()) return [];
+    const entries = parseEntries(raw, scope);
+    return limit ? entries.slice(0, limit) : entries;
+  }
+  async search(scope, query, filePath, limit) {
+    const entries = await this.list(scope, filePath);
+    const needle = query.toLowerCase().split(/\s+/);
+    const scored = entries.map((e) => {
+      const words = e.text.toLowerCase().split(/\s+/);
+      let score = 0;
+      for (const n of needle) {
+        if (words.some((w) => w.includes(n))) score += 1;
+        if (e.tags?.some((t) => t.toLowerCase().includes(n))) score += 2;
+      }
+      return { entry: e, score };
+    });
+    scored.sort((a, b) => b.score - a.score);
+    const matched = scored.filter((s) => s.score > 0).map((s) => s.entry);
+    return limit ? matched.slice(0, limit) : matched;
+  }
+  async clear(scope, filePath) {
+    const file = this.resolveFile(filePath, scope);
+    await atomicWrite(file, "");
+  }
+  async consolidate(scope, filePath) {
+    const file = this.resolveFile(filePath, scope);
+    let existing;
+    try {
+      existing = await fsp.readFile(file, "utf8");
+    } catch {
+      return 0;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    let removed = 0;
+    const lines = existing.split("\n").filter((line) => {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("- ")) return true;
+      const norm = trimmed.replace(/\[[^\]]+\]/g, "").replace(/\bmem_\d+_\w+\s*/, "").replace(/#[\w-]+/g, "").replace(/\s+/g, " ").trim().toLowerCase();
+      if (seen.has(norm)) {
+        removed++;
+        return false;
+      }
+      seen.add(norm);
+      return true;
+    });
+    const next = lines.join("\n");
+    const backup = `${file}.bak.${Date.now()}`;
+    try {
+      await fsp.copyFile(file, backup);
+    } catch {
+    }
+    try {
+      await atomicWrite(file, next);
+    } catch {
+      return 0;
+    }
+    return removed;
+  }
+};
+function parseEntries(raw, scope = "project-memory") {
+  const entries = [];
+  for (const line of raw.split("\n")) {
+    const entry = lineToEntry(line, scope);
+    if (entry) entries.push(entry);
+  }
+  return entries.reverse();
+}
+
+// src/storage/memory-store.ts
 var MAX_BYTES_TOTAL = 32e3;
 var DefaultMemoryStore = class {
   files;
+  events;
+  backend;
   /**
    * Per-scope serialization queue. `remember` / `forget` / `consolidate` /
    * `clear` are read-modify-write against a single file; without a lock,
@@ -1376,12 +1644,29 @@ var DefaultMemoryStore = class {
   writeChain = /* @__PURE__ */ new Map();
   /** Last write error per scope — surfaced as warnings on the next readAll(). */
   writeErrors = /* @__PURE__ */ new Map();
+  /**
+   * When the global root is a temporary directory (opencode, CI sandboxes),
+   * memory files are also mirrored to the project tree so they survive
+   * session cleanup. The primary path stays in the temp root for isolation;
+   * this backup ensures memory is never lost.
+   */
+  persistBackup;
+  backupDir;
   constructor(opts) {
     this.files = {
       "project-agents": opts.paths.inProjectAgentsFile,
       "project-memory": opts.paths.projectMemory,
       "user-memory": opts.paths.globalMemory
     };
+    this.events = opts.events;
+    this.backend = opts.backend ?? new FileMemoryBackend({ paths: opts.paths });
+    const root = opts.paths.globalRoot.toLowerCase();
+    this.persistBackup = /[/\\](tmp|temp|cache)[/\\]/.test(root);
+    this.backupDir = this.persistBackup ? opts.paths.inProjectAgentsFile.replace(/AGENTS\.md$/, "memory-persist") : "";
+  }
+  /** Expose the backend for plugin introspection and advanced queries. */
+  getBackend() {
+    return this.backend;
   }
   async runSerialized(scope, work) {
     const prior = this.writeChain.get(scope) ?? Promise.resolve();
@@ -1408,7 +1693,7 @@ var DefaultMemoryStore = class {
       if (writeErr2) {
         parts.push(`> \u26A0\uFE0F Memory write error (${labelOf(scope)}): ${writeErr2.message}`);
       }
-      const body = await this.read(scope);
+      const body = await this.backend.readAll(scope, this.files[scope]);
       if (body.trim()) parts.push(`## ${labelOf(scope)}
 
 ${body.trim()}`);
@@ -1416,117 +1701,214 @@ ${body.trim()}`);
     return parts.join("\n\n");
   }
   async read(scope) {
-    try {
-      return await fsp.readFile(this.files[scope], "utf8");
-    } catch {
-      return "";
+    return this.backend.readAll(scope, this.files[scope]);
+  }
+  /**
+   * List entries from a scope, newest first. Delegates to the backend
+   * so graph/semantic backends can return enriched or filtered results.
+   */
+  async list(scope = "project-memory", limit) {
+    return this.backend.list(scope, this.files[scope], limit);
+  }
+  /**
+   * Find memories related to the given text via graph traversal.
+   * Falls back to content search when no graph backend is available.
+   */
+  async findRelated(text, scope = "project-memory", limit = 5) {
+    if (this.backend.findRelated) {
+      return this.backend.findRelated(scope, this.files[scope], text, limit);
     }
+    return this.search(text, scope, limit);
+  }
+  async search(query, scope = "project-memory", limit) {
+    return this.backend.search(scope, query, this.files[scope], limit);
   }
-  async remember(text, scope = "project-memory") {
+  async remember(text, scope = "project-memory", metadata) {
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
     return this.runSerialized(scope, async () => {
-      const file = this.files[scope];
-      await ensureDir(path3.dirname(file));
-      let existing = "";
-      try {
-        existing = await fsp.readFile(file, "utf8");
-      } catch {
-      }
-      const ts = (/* @__PURE__ */ new Date()).toISOString();
-      const id = `mem_${Date.now()}_${randomUUID().slice(0, 8)}`;
-      const entry = `
-- [${ts}] ${id} ${text.replace(/\n/g, " ")}
-`;
-      const next = existing.trim() ? existing.replace(/\n+$/, "") + entry : `# WrongStack Memory
-${entry}`;
-      await atomicWrite(file, next);
-      const buf = Buffer.byteLength(next, "utf8");
-      if (buf > MAX_BYTES_TOTAL) {
-        await this.consolidateUnsafe(scope);
+      const entry = { scope, text, ts, ...metadata };
+      await this.backend.remember(scope, entry, this.files[scope]);
+      const raw = await this.backend.readAll(scope, this.files[scope]);
+      if (Buffer.byteLength(raw, "utf8") > MAX_BYTES_TOTAL) {
+        const removed = await this.backend.consolidate(scope, this.files[scope]);
+        if (removed > 0) {
+          this.events?.emit("memory.consolidated", {
+            scope,
+            removed
+          });
+        }
       }
+      await this.mirrorBackup(scope);
+      this.events?.emit("memory.remembered", {
+        scope,
+        text,
+        ts,
+        type: entry.type,
+        tags: entry.tags,
+        priority: entry.priority
+      });
     });
   }
-  async forget(query, scope = "project-memory") {
-    return this.runSerialized(scope, async () => this.forgetUnsafe(query, scope));
-  }
-  async forgetUnsafe(query, scope) {
-    const file = this.files[scope];
-    let existing;
-    try {
-      existing = await fsp.readFile(file, "utf8");
-    } catch {
-      return 0;
-    }
-    const needle = query.toLowerCase();
-    const idMatcher = /mem_\d+_\w+/;
-    let removed = 0;
-    const lines = existing.split("\n").filter((line) => {
-      const trimmed = line.trim();
-      if (!trimmed.startsWith("- ")) return true;
-      if (idMatcher.test(query)) {
-        const afterBracket = trimmed.indexOf("] ");
-        if (afterBracket !== -1) {
-          const afterTs = trimmed.slice(afterBracket + 2);
-          const entryIdMatch = /^mem_\d+_\w+/.exec(afterTs);
-          if (entryIdMatch && entryIdMatch[0] === query) {
-            removed++;
-            return false;
-          }
+  /**
+   * Score and rank memories by relevance to the current context.
+   * Returns entries with score >= MIN_RELEVANCE_SCORE, sorted highest first.
+   */
+  async scoreRelevant(ctx, scope = "project-memory", limit = 8) {
+    const all = await this.list(scope);
+    if (all.length === 0) return [];
+    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();
+    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 taskHits = 0;
+      for (const w of taskWords) {
+        if (textLower.includes(w)) {
+          taskHits++;
+          score += 2;
+        }
+        if (tagsLower.some((t) => t.includes(w))) {
+          taskHits++;
+          score += 3;
         }
       }
-      if (trimmed.toLowerCase().includes(needle)) {
-        removed++;
-        return false;
+      if (taskHits > 0) reasons.push(`task match (${taskHits})`);
+      let skillHits = 0;
+      for (const w of skillWords) {
+        if (w.length > 2 && (textLower.includes(w) || tagsLower.some((t) => t.includes(w)))) {
+          skillHits++;
+        }
+      }
+      score += skillHits;
+      if (skillHits > 0) reasons.push(`skill match (${skillHits})`);
+      for (const w of toolWords) {
+        if (w.length > 2 && (textLower.includes(w) || tagsLower.some((t) => t.includes(w)))) {
+          score += 1;
+          reasons.push(`tool mention: ${w}`);
+        }
+      }
+      switch (entry.priority) {
+        case "critical":
+          score += 5;
+          reasons.push("critical");
+          break;
+        case "high":
+          score += 3;
+          reasons.push("high priority");
+          break;
+        case "medium":
+          score += 1;
+          break;
+        case "low":
+          score -= 2;
+          reasons.push("low priority");
+          break;
+      }
+      switch (entry.type) {
+        case "decision":
+          score += 2;
+          reasons.push("decision");
+          break;
+        case "convention":
+          score += 2;
+          reasons.push("convention");
+          break;
+        case "anti_pattern":
+          score += 3;
+          reasons.push("anti-pattern");
+          break;
+        case "preference":
+          score += 1;
+          reasons.push("preference");
+          break;
+      }
+      const ageDays = (now - new Date(entry.ts).getTime()) / (1e3 * 60 * 60 * 24);
+      if (ageDays < 1) score += 1;
+      else if (ageDays > 30) score -= 1;
+      if (entry.confidence !== void 0 && entry.confidence < 0.5) {
+        score -= 2;
+        reasons.push("low confidence");
+      }
+      if (entry.lastAccessed) {
+        const hoursSinceAccess = (now - new Date(entry.lastAccessed).getTime()) / (1e3 * 60 * 60);
+        if (hoursSinceAccess < 1) score -= 1;
+      }
+      if (score > 0) {
+        scored.push({
+          ...entry,
+          score,
+          matchReason: reasons.join(", ") || "keyword match"
+        });
       }
-      return true;
-    });
-    if (removed > 0) {
-      await atomicWrite(file, lines.join("\n"));
     }
-    return removed;
+    scored.sort((a, b) => b.score - a.score);
+    const threshold = 2;
+    const relevant = scored.filter(
+      (s) => s.score >= threshold || s.priority === "critical" || s.priority === "high"
+    );
+    return relevant.slice(0, Math.min(limit, 15));
   }
-  async consolidate(scope) {
-    return this.runSerialized(scope, async () => this.consolidateUnsafe(scope));
+  async forget(query, scope = "project-memory") {
+    return this.runSerialized(scope, async () => {
+      const removed = await this.backend.forget(scope, query, this.files[scope]);
+      if (removed > 0) {
+        this.events?.emit("memory.forgotten", {
+          scope,
+          query,
+          removed
+        });
+        await this.mirrorBackup(scope);
+      }
+      return removed;
+    });
   }
-  async consolidateUnsafe(scope) {
-    const file = this.files[scope];
-    let existing;
-    try {
-      existing = await fsp.readFile(file, "utf8");
-    } catch {
-      return;
-    }
-    const seen = /* @__PURE__ */ new Set();
-    const lines = existing.split("\n").filter((line) => {
-      const trimmed = line.trim();
-      if (!trimmed.startsWith("- ")) return true;
-      const norm = trimmed.replace(/\[[^\]]+\]/, "").replace(/\bmem_\d+_\w+\s*/, "").trim().toLowerCase();
-      if (seen.has(norm)) return false;
-      seen.add(norm);
-      return true;
+  async consolidate(scope) {
+    return this.runSerialized(scope, async () => {
+      const removed = await this.backend.consolidate(scope, this.files[scope]);
+      if (removed > 0) {
+        this.events?.emit("memory.consolidated", {
+          scope,
+          removed
+        });
+        await this.mirrorBackup(scope);
+      }
     });
-    const next = lines.join("\n");
-    const backup = `${file}.bak.${Date.now()}`;
-    try {
-      await fsp.copyFile(file, backup);
-    } catch {
-    }
-    try {
-      await atomicWrite(file, next);
-    } catch {
-      return;
-    }
   }
   async clear(scope) {
     if (scope) {
-      await this.runSerialized(scope, async () => atomicWrite(this.files[scope], ""));
+      await this.runSerialized(scope, async () => {
+        await this.backend.clear(scope, this.files[scope]);
+        this.events?.emit("memory.cleared", { scope });
+        await this.mirrorBackup(scope);
+      });
       return;
     }
     await Promise.all(
       ["project-agents", "project-memory", "user-memory"].map(
-        (s) => this.runSerialized(s, async () => atomicWrite(this.files[s], ""))
+        (s) => this.runSerialized(s, async () => {
+          await this.backend.clear(s, this.files[s]);
+          this.events?.emit("memory.cleared", { scope: s });
+          await this.mirrorBackup(s);
+        })
       )
     );
   }
+  /** Mirror current memory content to the persistent backup directory. */
+  async mirrorBackup(scope) {
+    if (!this.persistBackup || scope === "project-agents") return;
+    try {
+      const content = await this.backend.readAll(scope, this.files[scope]);
+      const { writeFile: writeFile4, mkdir: mkdir6 } = await import('fs/promises');
+      await mkdir6(this.backupDir, { recursive: true });
+      await writeFile4(`${this.backupDir}/${scope}.md`, content, "utf8");
+    } catch {
+    }
+  }
 };
 function labelOf(scope) {
   switch (scope) {
@@ -1774,6 +2156,13 @@ var BEHAVIOR_DEFAULTS = {
 function envBool(v) {
   return !/^(0|false|no|off)$/i.test(v.trim());
 }
+function envBoolOptional(v) {
+  return v !== void 0 && envBool(v);
+}
+var LOG_LEVELS2 = /* @__PURE__ */ new Set(["error", "warn", "info", "debug", "trace"]);
+function envLogLevel(v) {
+  return LOG_LEVELS2.has(v) ? v : "info";
+}
 var ENV_MAP = {
   WRONGSTACK_PROVIDER: (c, v) => {
     c.provider = v;
@@ -1797,7 +2186,7 @@ var ENV_MAP = {
   },
   WRONGSTACK_LOG_LEVEL: (c, v) => {
     if (!c.log) c.log = { level: "info" };
-    c.log.level = v;
+    c.log.level = envLogLevel(v);
   },
   WRONGSTACK_INDEX_ON_START: (c, v) => {
     c.indexing = { ...defaultIndexing, ...c.indexing, onSessionStart: envBool(v) };
@@ -1839,7 +2228,7 @@ function deepMerge(base, patch) {
         out[k] = [.../* @__PURE__ */ new Set([...existing, ...v])];
       } else {
         out[k] = v;
-        if (process.env.WRONGSTACK_DEBUG_CONFIG) {
+        if (envBoolOptional(process.env.WRONGSTACK_DEBUG_CONFIG)) {
           console.warn(
             `[config] Non-primitive array for "${k}" replaced (global + local config merge). Global entries: ${existing?.length ?? 0}, local entries: ${v.length}.`
           );
@@ -2235,12 +2624,6 @@ function compileUserRegex(pattern, flags) {
 }
 
 // src/storage/session-reader.ts
-function expectDefined3(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 var DefaultSessionReader = class {
   store;
   constructor(opts) {
@@ -2302,7 +2685,7 @@ var DefaultSessionReader = class {
         continue;
       }
       for (let i = 0; i < data.events.length; i++) {
-        const ev = expectDefined3(data.events[i]);
+        const ev = expectDefined(data.events[i]);
         if (allowedTypes && !allowedTypes.has(ev.type)) continue;
         const text = eventText(ev);
         if (text === null) continue;
@@ -2751,7 +3134,10 @@ function attachTodosCheckpoint(state, filePath, sessionId) {
   let pending = null;
   let writeChain = Promise.resolve();
   const enqueueWrite = (todos) => {
-    writeChain = writeChain.then(() => saveTodosCheckpoint(filePath, sessionId, todos));
+    writeChain = writeChain.then(() => saveTodosCheckpoint(filePath, sessionId, todos)).catch((err) => {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`[TodosCheckpoint] save failed for session ${sessionId}: ${msg}`);
+    });
     return writeChain;
   };
   const flush = () => {
@@ -3055,7 +3441,7 @@ async function acquireDirectorStateLock(lockPath, processId = process.pid) {
   }
   const lock = {
     pid: processId,
-    hostname: __require("os").hostname(),
+    hostname: hostname(),
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   await atomicWrite(lockPath, JSON.stringify(lock), { mode: 384 });
@@ -3467,9 +3853,18 @@ async function restrictFilePermissions(filePath, opts) {
       const { execFile: execFile2 } = await import('child_process');
       const { promisify: promisify2 } = await import('util');
       const execFileAsync = promisify2(execFile2);
-      await execFileAsync("icacls", [filePath, "/inheritance:r", "/grant:r", `${process.env.USERNAME}:(F)`]);
+      const user = windowsAccountName();
+      if (!user) {
+        warn(
+          `[secret-vault] Could not determine the current Windows user for ${filePath}; skipping icacls hardening.`
+        );
+        return;
+      }
+      await execFileAsync("icacls", [filePath, "/inheritance:r", "/grant:r", `${user}:(F)`]);
     } catch {
-      warn(`[secret-vault] Could not restrict permissions on ${filePath} \u2014 config file may be readable by other users on this system.`);
+      warn(
+        `[secret-vault] Could not restrict permissions on ${filePath} \u2014 config file may be readable by other users on this system.`
+      );
     }
   } else {
     try {
@@ -3478,6 +3873,13 @@ async function restrictFilePermissions(filePath, opts) {
     }
   }
 }
+function windowsAccountName() {
+  const username = process.env.USERNAME || process.env.USER;
+  if (!username || username.includes("\0")) return void 0;
+  const domain = process.env.USERDOMAIN;
+  if (domain && !domain.includes("\0")) return `${domain}\\${username}`;
+  return username;
+}
 function walkCount(node, vault, counter) {
   if (node === null || node === void 0) return node;
   if (typeof node !== "object") return node;
@@ -3565,12 +3967,6 @@ function getDangerousCapabilities(toolOrCaps) {
 init_atomic_write();
 
 // src/utils/glob-match.ts
-function expectDefined4(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 function escapeRegex(s) {
   return s.replace(/[.+^${}()|\\]/g, "\\$&");
 }
@@ -3582,7 +3978,7 @@ function getCachedGlob(pattern) {
   if (COMPILED_GLOB_CACHE.size >= CACHE_MAX_SIZE) {
     const keys = [...COMPILED_GLOB_CACHE.keys()];
     for (let i = 0; i < Math.floor(CACHE_MAX_SIZE / 4); i++) {
-      COMPILED_GLOB_CACHE.delete(expectDefined4(keys[i]));
+      COMPILED_GLOB_CACHE.delete(expectDefined(keys[i]));
     }
   }
   const re = compileGlob(pattern);
@@ -4447,12 +4843,6 @@ function parseDescription(raw) {
 }
 
 // src/utils/json-repair.ts
-function expectDefined5(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 function completePartialObject(s) {
   if (!s.trim().startsWith("{")) return s;
   if (tryParse(s).ok) return s;
@@ -4464,7 +4854,7 @@ function completePartialObject(s) {
   let contentEnd = 0;
   let stringBraceDepth = 0;
   for (let i = 0; i < s.length; i++) {
-    const ch = expectDefined5(s[i]);
+    const ch = expectDefined(s[i]);
     if (inString) {
       contentEnd = i + 1;
       if (escaped) {
@@ -4542,6 +4932,7 @@ function tryParse(s) {
 }
 
 // src/core/streaming-response-builder.ts
+var STREAM_DRAIN_TIMEOUT_MS = 500;
 function buildResponse(state) {
   const content = [];
   for (const b of state.blockOrder) {
@@ -4754,7 +5145,7 @@ async function streamProviderToResponse(provider, req, signal, ctx, events) {
         await Promise.race([
           Promise.resolve(iter.return?.()),
           new Promise((resolve5) => {
-            drainTimer = setTimeout(resolve5, 500);
+            drainTimer = setTimeout(resolve5, STREAM_DRAIN_TIMEOUT_MS);
           })
         ]);
       } finally {
@@ -4849,12 +5240,6 @@ var DefaultProviderRunner = class {
 };
 
 // src/utils/token-estimate.ts
-function expectDefined6(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 var RoughTokenEstimate = (text, charsPerToken = 3.5) => Math.max(1, Math.ceil(text.length / charsPerToken));
 var ESTIMATE_CACHE = /* @__PURE__ */ new Map();
 var ESTIMATE_CACHE_MAX_SIZE = 1e4;
@@ -4864,7 +5249,7 @@ function getCachedEstimate(key, compute) {
   if (ESTIMATE_CACHE.size >= ESTIMATE_CACHE_MAX_SIZE) {
     const keys = [...ESTIMATE_CACHE.keys()];
     for (let i = 0; i < Math.floor(ESTIMATE_CACHE_MAX_SIZE / 4); i++) {
-      ESTIMATE_CACHE.delete(expectDefined6(keys[i]));
+      ESTIMATE_CACHE.delete(expectDefined(keys[i]));
     }
   }
   const estimate = compute();
@@ -5357,12 +5742,6 @@ var IntelligentCompactor = class {
 };
 
 // src/models/llm-selector.ts
-function expectDefined7(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 var DEFAULT_SYSTEM_PROMPT = `You are a context pruning assistant. Given a conversation history and a token budget, decide which message ranges are worth keeping verbatim and which should be collapsed into summaries.
 
 Output a JSON object with this structure:
@@ -5403,7 +5782,7 @@ function formatMessages(messages, maxChars = 8e3) {
   const lines = [];
   let used = 0;
   for (let i = 0; i < messages.length; i++) {
-    const m = expectDefined7(messages[i]);
+    const m = expectDefined(messages[i]);
     const role = m.role.padEnd(10, " ");
     let text;
     if (typeof m.content === "string") {
@@ -5468,7 +5847,7 @@ IMPORTANT: Total conversation (${totalTokens} tokens) exceeds budget (${effectiv
     let tokenCount = 0;
     let startIdx = 0;
     for (let i = messages.length - 1; i >= 0; i--) {
-      const m = expectDefined7(messages[i]);
+      const m = expectDefined(messages[i]);
       const cost = typeof m.content === "string" ? Math.ceil(m.content.length / 4) : m.content.reduce(
         (acc, b) => acc + (b.type === "text" ? Math.ceil(b.text.length / 4) : Math.ceil(JSON.stringify(b).length / 4)),
         0
@@ -6075,17 +6454,12 @@ function createToolOutputSerializer(opts = {}) {
 }
 
 // src/execution/tool-executor.ts
-function expectDefined8(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 var ToolExecutor = class {
   constructor(registry, opts) {
     this.registry = registry;
     this.opts = opts;
     this.iterationTimeoutMs = opts.iterationTimeoutMs ?? 3e5;
+    this.maxToolTimeoutMs = opts.maxToolTimeoutMs ?? 3e5;
     this.serializer = createToolOutputSerializer({
       perIterationOutputCapBytes: opts.perIterationOutputCapBytes ?? 1e5
     });
@@ -6094,6 +6468,7 @@ var ToolExecutor = class {
   opts;
   serializer;
   iterationTimeoutMs;
+  maxToolTimeoutMs;
   /**
    * Clear the interactive confirm awaiter so the executor returns
    * `ToolConfirmPendingResult` instead of blocking on stdin. Used by
@@ -6331,7 +6706,10 @@ ${post.additionalContext}` };
       if (parentSignal.reason instanceof Error) throw parentSignal.reason;
       throw new Error(typeof parentSignal.reason === "string" ? parentSignal.reason : "aborted");
     }
-    const timeoutMs = tool.timeoutMs ?? this.iterationTimeoutMs;
+    const timeoutMs = clampTimeoutMs(
+      tool.timeoutMs ?? this.iterationTimeoutMs,
+      this.maxToolTimeoutMs
+    );
     const ctrl = new AbortController();
     const timer = setTimeout(() => ctrl.abort(new Error("tool timeout")), timeoutMs);
     const combined = AbortSignal.any([parentSignal, ctrl.signal]);
@@ -6466,6 +6844,12 @@ ${excerpt}`;
     return void 0;
   }
 };
+function clampTimeoutMs(timeoutMs, maxTimeoutMs) {
+  const fallback = 3e5;
+  const finiteTimeout = Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : fallback;
+  const finiteMax = Number.isFinite(maxTimeoutMs) && maxTimeoutMs > 0 ? maxTimeoutMs : fallback;
+  return Math.max(1, Math.min(finiteTimeout, finiteMax));
+}
 var MALFORMED_ARG_MARKERS = ["__raw", "__raw_arguments", "_raw"];
 function hasMalformedArguments(input) {
   if (!input || typeof input !== "object" || Array.isArray(input)) return false;
@@ -6476,7 +6860,7 @@ function hasMalformedArguments(input) {
 function extractMalformedRaw(input) {
   if (!hasMalformedArguments(input)) return void 0;
   const obj = input;
-  const value = obj[expectDefined8(Object.keys(obj)[0])];
+  const value = obj[expectDefined(Object.keys(obj)[0])];
   if (value === void 0 || value === null) return void 0;
   if (typeof value === "string") return value;
   try {
@@ -7278,6 +7662,7 @@ ${recentJournal}` : "No prior iterations.",
 };
 
 // src/coordination/subagent-budget.ts
+var TIMEOUT_PREEMPT_FRACTION = 0.85;
 var BudgetExceededError = class extends Error {
   kind;
   limit;
@@ -7633,15 +8018,7 @@ function makeAgentSubagentRunner(opts) {
     let budgetError = null;
     const onBudgetError = (err) => {
       if (err instanceof BudgetThresholdSignal) {
-        err.decision.then((decision) => {
-          if (decision === "stop") {
-            budgetError = new BudgetExceededError(err.kind, err.limit, err.used);
-            aborter.abort();
-          }
-        }).catch(() => {
-          budgetError = new BudgetExceededError(err.kind, err.limit, err.used);
-          aborter.abort();
-        });
+        budgetError = err;
         return;
       }
       aborter.abort();
@@ -7749,15 +8126,23 @@ function makeAgentSubagentRunner(opts) {
     }
     if (budgetError) {
       if ("decision" in budgetError) {
-        const decision = await budgetError.decision;
-        if (decision === "stop") {
+        try {
+          const decision = await budgetError.decision;
+          if (decision === "stop") {
+            budgetError = new BudgetExceededError(
+              budgetError.kind,
+              budgetError.limit,
+              budgetError.used
+            );
+          } else {
+            budgetError = null;
+          }
+        } catch {
           budgetError = new BudgetExceededError(
             budgetError.kind,
             budgetError.limit,
             budgetError.used
           );
-        } else {
-          budgetError = null;
         }
       }
       if (budgetError) throw budgetError;
@@ -10079,16 +10464,17 @@ Do not add prose, markdown, or code fences.`;
     const raw = (await complete(prompt)).trim();
     const match = raw.match(/\{[\s\S]*\}/);
     if (!match) return null;
-    try {
-      const parsed = JSON.parse(match[0]);
-      if (typeof parsed.role !== "string") return null;
-      const role = parsed.role.trim();
-      const valid = candidates.some((c) => c.role === role);
-      if (!valid) return null;
-      return { role, reason: typeof parsed.reason === "string" ? parsed.reason : void 0 };
-    } catch {
-      return null;
-    }
+    const parsed = safeParse(
+      match[0]
+    );
+    if (!parsed.ok || !parsed.value || typeof parsed.value.role !== "string") return null;
+    const role = parsed.value.role.trim();
+    const valid = candidates.some((c) => c.role === role);
+    if (!valid) return null;
+    return {
+      role,
+      reason: typeof parsed.value.reason === "string" ? parsed.value.reason : void 0
+    };
   };
 }
 
@@ -11043,15 +11429,38 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
     }
     const start = Date.now();
     let timer = null;
+    let preemptedForLimit = null;
     const timeoutPromise = new Promise((_, reject) => {
       const armFor = (ms) => {
         if (timer) clearTimeout(timer);
         timer = setTimeout(onTick, Math.max(0, ms));
       };
       const scheduleNext = () => {
-        const wallRemaining = initialTimeoutMs === void 0 ? Number.POSITIVE_INFINITY : (budget.limits.timeoutMs ?? initialTimeoutMs) - (Date.now() - start);
+        const wallLimit = budget.limits.timeoutMs ?? initialTimeoutMs;
+        const wallRemaining = initialTimeoutMs === void 0 ? Number.POSITIVE_INFINITY : wallLimit - (Date.now() - start);
         const idleRemaining = idleLimitMs === void 0 ? Number.POSITIVE_INFINITY : (budget.limits.idleTimeoutMs ?? idleLimitMs) - budget.idleMs();
-        armFor(Math.max(25, Math.min(wallRemaining, idleRemaining)));
+        const preemptRemaining = initialTimeoutMs === void 0 || preemptedForLimit === wallLimit ? Number.POSITIVE_INFINITY : wallLimit * TIMEOUT_PREEMPT_FRACTION - (Date.now() - start);
+        armFor(Math.max(25, Math.min(wallRemaining, idleRemaining, preemptRemaining)));
+      };
+      const negotiateTimeout = async (used, limit) => {
+        const handler = budget.onThreshold;
+        if (!handler) return "stop";
+        const result = handler({
+          kind: "timeout",
+          used,
+          limit,
+          requestDecision: () => new Promise((resolveDecision) => {
+            budget._events?.emit("budget.threshold_reached", {
+              kind: "timeout",
+              used,
+              limit,
+              timeoutMs: 6e4,
+              extend: (extra) => resolveDecision({ extend: extra }),
+              deny: () => resolveDecision("stop")
+            });
+          })
+        });
+        return typeof result === "string" ? result : await result;
       };
       const onTick = async () => {
         const elapsed = Date.now() - start;
@@ -11064,6 +11473,21 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
           reject(new BudgetExceededError("timeout", idleLimit ?? 0, budget.idleMs()));
           return;
         }
+        if (wallLimit !== void 0 && !wallExceeded && budget.onThreshold && preemptedForLimit !== wallLimit && elapsed >= wallLimit * TIMEOUT_PREEMPT_FRACTION) {
+          try {
+            const decision = await negotiateTimeout(elapsed, wallLimit);
+            if (typeof decision !== "string" && decision.extend.timeoutMs !== void 0) {
+              budget.limits.timeoutMs = decision.extend.timeoutMs;
+              preemptedForLimit = null;
+            } else {
+              preemptedForLimit = wallLimit;
+            }
+          } catch {
+            preemptedForLimit = wallLimit;
+          }
+          scheduleNext();
+          return;
+        }
         if (!wallExceeded) {
           scheduleNext();
           return;
@@ -11075,28 +11499,15 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
           return;
         }
         try {
-          const result = budget.onThreshold({
-            kind: "timeout",
-            used: elapsed,
-            limit,
-            requestDecision: () => new Promise((resolveDecision) => {
-              budget._events?.emit("budget.threshold_reached", {
-                kind: "timeout",
-                used: elapsed,
-                limit,
-                timeoutMs: 6e4,
-                extend: (extra) => resolveDecision({ extend: extra }),
-                deny: () => resolveDecision("stop")
-              });
-            })
-          });
-          const decision = typeof result === "string" ? result : await result;
+          const decision = await negotiateTimeout(elapsed, limit);
           if (decision === "continue" || decision === "throw" || decision === "stop") {
+            preemptedForLimit = null;
             armFor(Math.max(1e3, limit));
             return;
           }
           if (decision.extend.timeoutMs !== void 0) {
             budget.limits.timeoutMs = decision.extend.timeoutMs;
+            preemptedForLimit = null;
             scheduleNext();
             return;
           }
@@ -11227,12 +11638,6 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
 };
 
 // src/execution/parallel-eternal-engine.ts
-function expectDefined9(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 var GOAL_COMPLETE_MARKER2 = /^\s*\[goal[_\s-]?complete\]\s*$/im;
 var ParallelEternalEngine = class {
   constructor(opts) {
@@ -11388,7 +11793,7 @@ var ParallelEternalEngine = class {
   // Fan-out
   // -------------------------------------------------------------------------
   async fanOut(goal, tasks) {
-    const coordinator = expectDefined9(this.coordinator);
+    const coordinator = expectDefined(this.coordinator);
     const slotCount = Math.min(this.slots, tasks.length);
     const routes = this.dispatchEnabled ? await Promise.all(
       tasks.slice(0, slotCount).map(
@@ -11420,7 +11825,7 @@ ${recentJournal}` : "No prior iterations.",
     const routeInfo = [];
     const spawnPromises = [];
     for (let i = 0; i < slotCount; i++) {
-      const task = expectDefined9(tasks[i]);
+      const task = expectDefined(tasks[i]);
       const route = routes[i] ?? null;
       const subagentId = `parallel-${this.iterations}-${i}`;
       const taskId = randomUUID();
@@ -11911,12 +12316,6 @@ function createMessage(type, from, payload, to) {
     priority: "normal"
   };
 }
-function expectDefined10(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 var GLOB_CHARS = /* @__PURE__ */ new Set(["*", "?", "["]);
 var IS_WINDOWS = process.platform === "win32";
 var SEP = IS_WINDOWS ? "\\" : "/";
@@ -11930,7 +12329,7 @@ function globToRegex(pat) {
   let i = 0;
   let re = "^";
   while (i < pat.length) {
-    const c = expectDefined10(pat[i]);
+    const c = expectDefined(pat[i]);
     if (c === "*") {
       if (pat[i + 1] === "*") {
         re += ".*";
@@ -11969,7 +12368,7 @@ function globToRegex(pat) {
 }
 function baseDir(pat) {
   let i = pat.length - 1;
-  while (i >= 0 && !GLOB_CHARS.has(expectDefined10(pat[i])) && pat[i] !== SEP && pat[i] !== "/") i--;
+  while (i >= 0 && !GLOB_CHARS.has(expectDefined(pat[i])) && pat[i] !== SEP && pat[i] !== "/") i--;
   const cut = i >= 0 ? pat.lastIndexOf(SEP, i) : pat.lastIndexOf("/", i);
   return cut < 0 ? "." : pat.slice(0, cut);
 }
@@ -12004,8 +12403,8 @@ async function expandGlob(pattern) {
       for (const e of entries) {
         const full = `${dir}${SEP}${e}`;
         try {
-          const stat5 = await fsp.stat(full);
-          if (stat5.isDirectory()) await walk4(full, rest);
+          const stat6 = await fsp.stat(full);
+          if (stat6.isDirectory()) await walk4(full, rest);
         } catch {
         }
       }
@@ -12022,8 +12421,8 @@ async function expandGlob(pattern) {
       if (entries.includes(seg)) {
         const full = `${dir}${SEP}${seg}`;
         try {
-          const stat5 = await fsp.stat(full);
-          if (stat5.isDirectory()) await walk4(full, rest);
+          const stat6 = await fsp.stat(full);
+          if (stat6.isDirectory()) await walk4(full, rest);
         } catch {
         }
       }
@@ -12050,7 +12449,9 @@ var CollabSession = class extends EventEmitter {
   settled = false;
   timeoutMs;
   cancelled = false;
+  _raceResolved = false;
   alerts = [];
+  snapshotWarnings = [];
   /** Tracks tool call counts per subagent for progress-based timeout decisions. */
   progressBySubagent = /* @__PURE__ */ new Map();
   /** Last tool call count when a timeout warning was handled. */
@@ -12120,10 +12521,19 @@ var CollabSession = class extends EventEmitter {
     }
     for (const filePath of allFiles) {
       try {
-        const content = await fsp.readFile(filePath, "utf8");
+        const [content, stat6] = await Promise.all([
+          fsp.readFile(filePath, "utf8"),
+          fsp.stat(filePath)
+        ]);
         const ext = filePath.split(".").pop() ?? "";
         const language = ext === "ts" || ext === "tsx" ? "typescript" : ext === "js" || ext === "jsx" ? "javascript" : ext === "md" ? "markdown" : ext === "json" ? "json" : void 0;
-        this.snapshot.files.push({ path: filePath, content, language });
+        this.snapshot.files.push({
+          path: filePath,
+          content,
+          language,
+          snapshotMtimeMs: stat6.mtimeMs,
+          snapshotSizeBytes: stat6.size
+        });
       } catch {
         this.snapshot.files.push({ path: filePath, content: "", language: void 0 });
       }
@@ -12136,7 +12546,7 @@ var CollabSession = class extends EventEmitter {
    * Safe to call multiple times (idempotent after first call).
    */
   cancel(reason = "Director cancelled collab session") {
-    if (this.settled) return;
+    if (this.cancelled) return;
     this.cancelled = true;
     if (this._timeoutTimer) {
       clearTimeout(this._timeoutTimer);
@@ -12146,7 +12556,11 @@ var CollabSession = class extends EventEmitter {
       subagentId: this.director.id,
       ts: Date.now(),
       type: "director.cancel_collab",
-      payload: { sessionId: this.sessionId, reason, cancelledAt: (/* @__PURE__ */ new Date()).toISOString() }
+      payload: {
+        sessionId: this.sessionId,
+        reason,
+        cancelledAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
     });
     this.fleetBus.emit({
       subagentId: this.director.id,
@@ -12170,6 +12584,7 @@ var CollabSession = class extends EventEmitter {
     this.subagentIds.set("critic", criticId);
     const timeout = new Promise((_, reject) => {
       this._timeoutTimer = setTimeout(() => {
+        if (this._raceResolved) return;
         this.cancel("Session-level timeout reached");
         reject(new Error(`CollabSession timed out after ${this.timeoutMs}ms`));
       }, this.timeoutMs);
@@ -12185,6 +12600,7 @@ var CollabSession = class extends EventEmitter {
         timeout
       ]);
     } catch (err) {
+      this._raceResolved = true;
       if (this._timeoutTimer) {
         clearTimeout(this._timeoutTimer);
         this._timeoutTimer = void 0;
@@ -12197,7 +12613,9 @@ var CollabSession = class extends EventEmitter {
     for (const result of results?.flat() ?? []) {
       await this.parseAndEmit(result);
     }
+    this.snapshotWarnings = await this.checkSnapshotFreshness();
     const report = this.assembleReport();
+    this._raceResolved = true;
     this.cleanup();
     this.emit("session.done", report);
     return report;
@@ -12260,7 +12678,7 @@ var CollabSession = class extends EventEmitter {
     const defaults = {
       "bug-hunter": { maxIterations: 2e3, maxToolCalls: 5e3, timeoutMs: 10 * 60 * 1e3 },
       "refactor-planner": { maxIterations: 1500, maxToolCalls: 4e3, timeoutMs: 8 * 60 * 1e3 },
-      "critic": { maxIterations: 1e3, maxToolCalls: 3e3, timeoutMs: 6 * 60 * 1e3 }
+      critic: { maxIterations: 1e3, maxToolCalls: 3e3, timeoutMs: 6 * 60 * 1e3 }
     };
     return defaults[role] ?? { maxIterations: 1500, maxToolCalls: 4e3, timeoutMs: 8 * 60 * 1e3 };
   }
@@ -12340,7 +12758,10 @@ Emit each evaluation immediately. Do not wait until you have read all reports.`;
   }
   wireFleetBus() {
     const dTool = this.fleetBus.filter("tool.executed", (e) => {
-      this.progressBySubagent.set(e.subagentId, (this.progressBySubagent.get(e.subagentId) ?? 0) + 1);
+      this.progressBySubagent.set(
+        e.subagentId,
+        (this.progressBySubagent.get(e.subagentId) ?? 0) + 1
+      );
     });
     this.disposers.push(dTool);
     const dBudget = this.fleetBus.filter("budget.threshold_reached", (e) => {
@@ -12379,7 +12800,10 @@ Emit each evaluation immediately. Do not wait until you have read all reports.`;
           return;
         }
         this.lastTimeoutProgress.set(e.subagentId, progress);
-        const newLimit = Math.min(Math.ceil((payload.timeoutMs ?? payload.limit) * 2), 24 * 60 * 6e4);
+        const newLimit = Math.min(
+          Math.ceil((payload.timeoutMs ?? payload.limit) * 2),
+          24 * 60 * 6e4
+        );
         setImmediate(() => {
           payload.extend({ timeoutMs: newLimit });
         });
@@ -12489,15 +12913,18 @@ Emit each evaluation immediately. Do not wait until you have read all reports.`;
       needs_revision: 1,
       reject: 2
     };
-    const overallVerdict = evalList.reduce(
-      (worst, eval_) => {
-        const w = verdictOrder[worst];
-        const c = verdictOrder[eval_.verdict];
-        return c > w ? eval_.verdict : worst;
-      },
-      "approve"
+    const overallVerdict = evalList.reduce((worst, eval_) => {
+      const w = verdictOrder[worst];
+      const c = verdictOrder[eval_.verdict];
+      return c > w ? eval_.verdict : worst;
+    }, "approve");
+    const summary = this.buildMarkdownSummary(
+      bugList,
+      planList,
+      evalList,
+      overallVerdict,
+      disposition
     );
-    const summary = this.buildMarkdownSummary(bugList, planList, evalList, overallVerdict, disposition);
     return {
       sessionId: this.sessionId,
       startedAt: this.snapshot.createdAt,
@@ -12508,10 +12935,28 @@ Emit each evaluation immediately. Do not wait until you have read all reports.`;
       refactorPlans: planList,
       evaluations: evalList,
       alerts: [...this.alerts],
+      ...this.snapshotWarnings.length > 0 ? { snapshotWarnings: this.snapshotWarnings } : {},
       overallVerdict,
       summary
     };
   }
+  async checkSnapshotFreshness() {
+    const warnings = [];
+    for (const file of this.snapshot.files) {
+      if (file.snapshotMtimeMs === void 0 && file.snapshotSizeBytes === void 0) continue;
+      try {
+        const stat6 = await fsp.stat(file.path);
+        const mtimeChanged = file.snapshotMtimeMs !== void 0 && stat6.mtimeMs > file.snapshotMtimeMs + 1;
+        const sizeChanged = file.snapshotSizeBytes !== void 0 && stat6.size !== file.snapshotSizeBytes;
+        if (mtimeChanged || sizeChanged) {
+          warnings.push(`${file.path} changed after the collab snapshot was captured.`);
+        }
+      } catch {
+        warnings.push(`${file.path} could not be checked after the collab snapshot was captured.`);
+      }
+    }
+    return warnings;
+  }
   buildMarkdownSummary(bugs, plans, evals, overallVerdict, disposition) {
     const lines = [
       `## Collaborative Debugging Report \u2014 ${this.sessionId}`,
@@ -12528,10 +12973,19 @@ Emit each evaluation immediately. Do not wait until you have read all reports.`;
       }
       lines.push("");
     }
+    if (this.snapshotWarnings.length > 0) {
+      lines.push("### Snapshot Warnings", "");
+      for (const warning of this.snapshotWarnings) {
+        lines.push(`- ${warning}`);
+      }
+      lines.push("");
+    }
     if (bugs.length > 0) {
       lines.push("### Bugs Found", "");
       for (const b of bugs) {
-        lines.push(`- **[${b.severity.toUpperCase()}]** \`${b.location.file}:${b.location.line}\` \u2014 ${b.description}`);
+        lines.push(
+          `- **[${b.severity.toUpperCase()}]** \`${b.location.file}:${b.location.line}\` \u2014 ${b.description}`
+        );
       }
       lines.push("");
     }
@@ -13134,6 +13588,7 @@ var FleetBus = class {
     set.add(handler);
     return () => {
       set.delete(handler);
+      if (set.size === 0) this.byId.delete(subagentId);
     };
   }
   /** Subscribe to one event type across all subagents. */
@@ -13146,6 +13601,7 @@ var FleetBus = class {
     set.add(handler);
     return () => {
       set.delete(handler);
+      if (set.size === 0) this.byType.delete(type);
     };
   }
   /** Subscribe to literally everything. The fleet roll-up uses this. */
@@ -13179,6 +13635,11 @@ var FleetBus = class {
       }
     }
   }
+  clear() {
+    this.byId.clear();
+    this.byType.clear();
+    this.any.clear();
+  }
 };
 var FleetUsageAggregator = class {
   constructor(bus, priceLookup, metaLookup) {
@@ -14411,7 +14872,9 @@ var Director = class _Director {
     let toolUses = 0;
     for (const line of targetLines) {
       try {
-        const ev = JSON.parse(line);
+        const parsed = safeParse(line);
+        if (!parsed.ok || !parsed.value) continue;
+        const ev = parsed.value;
         if (ev.type === "assistant" && typeof ev.text === "string") {
           lastAssistantText = ev.text;
         } else if (ev.type === "stop" && ev.stopReason) {
@@ -14725,7 +15188,7 @@ function createDelegateTool(opts) {
           const offIter = dir.fleet.filter("iteration.started", bump);
           const offProgress = dir.fleet.filter("tool.progress", bump);
           arm();
-          dir.awaitTasks([taskId]).then((r) => finish(r[0] ?? { __timeout: true })).catch(() => finish({ __timeout: true }));
+          dir.awaitTasks([taskId]).then((r) => finish(r[0] ?? { __emptyResult: true })).catch(() => finish({ __timeout: true }));
         });
         if ("__timeout" in result) {
           const partial2 = await readSubagentPartial(opts, subagentId);
@@ -14750,6 +15213,29 @@ function createDelegateTool(opts) {
             partial: partial2
           };
         }
+        if ("__emptyResult" in result) {
+          const partial2 = await readSubagentPartial(opts, subagentId);
+          opts.events?.emit("delegate.completed", {
+            target,
+            task: i.task,
+            ok: false,
+            status: "empty_result",
+            summary: `[${target}] completed without a task result`,
+            durationMs: 0,
+            iterations: partial2?.events ?? 0,
+            toolCalls: partial2?.toolUsesObserved ?? 0,
+            subagentId
+          });
+          return {
+            ok: false,
+            stopReason: "error",
+            error: "Director returned no task result for the delegated task.",
+            hint: "Check fleet state with /fleet status, then retry or reassign the task.",
+            subagentId,
+            taskId,
+            partial: partial2
+          };
+        }
         const baseStopReason = result.status === "success" ? "end_turn" : result.status === "timeout" ? "subagent_timeout" : result.status === "stopped" ? "aborted" : "budget_exhausted";
         const partial = result.status === "success" ? void 0 : await readSubagentPartial(opts, subagentId);
         const errorKind = result.error?.kind;
@@ -14922,7 +15408,9 @@ async function readSubagentPartial(opts, subagentId) {
     let toolUses = 0;
     for (const line of lines) {
       try {
-        const ev = JSON.parse(line);
+        const parsed = safeParse(line);
+        if (!parsed.ok || !parsed.value) continue;
+        const ev = parsed.value;
         if (ev.type === "tool_use") toolUses += 1;
         if (ev.type === "llm_response") {
           if (typeof ev.stopReason === "string") lastStopReason = ev.stopReason;
@@ -15694,8 +16182,8 @@ async function loadProjectModes(modesDir) {
     for (const entry of entries) {
       if (!entry.endsWith(".md") && !entry.endsWith(".txt")) continue;
       const filePath = path3.join(modesDir, entry);
-      const stat5 = await fsp.stat(filePath);
-      if (!stat5.isFile()) continue;
+      const stat6 = await fsp.stat(filePath);
+      if (!stat6.isFile()) continue;
       const content = await fsp.readFile(filePath, "utf8");
       const id = path3.basename(entry, path3.extname(entry));
       modes.push({
@@ -16835,12 +17323,6 @@ var TaskGraphStore = class {
 };
 
 // src/sdd/spec-builder.ts
-function expectDefined11(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 function buildQuestioningPrompt(session, min, max) {
   const answered = session.answers.length;
   const remaining = Math.max(0, min - answered);
@@ -16886,7 +17368,7 @@ function buildQuestioningPrompt(session, min, max) {
   if (answered > 0) {
     lines.push("", "**Conversation so far:**");
     for (let i = 0; i < answered; i++) {
-      const a = expectDefined11(session.answers[i]);
+      const a = expectDefined(session.answers[i]);
       lines.push(``, `Q${i + 1}: ${a.question}`, `A${i + 1}: ${a.answer}`);
     }
   }
@@ -17628,12 +18110,6 @@ function truncate2(str, maxLen) {
 }
 
 // src/sdd/critical-path.ts
-function expectDefined12(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 function analyzeCriticalPath(graph) {
   const nodes = Array.from(graph.nodes.values());
   const topoOrder = topologicalSort(graph);
@@ -17709,7 +18185,7 @@ function getTransitiveBlocked(_graph, taskId, blocksMap) {
   const visited = /* @__PURE__ */ new Set();
   const queue = [taskId];
   while (queue.length > 0) {
-    const current = expectDefined12(queue.shift());
+    const current = expectDefined(queue.shift());
     const blocked = blocksMap.get(current);
     if (!blocked) continue;
     for (const id of blocked) {
@@ -17755,7 +18231,7 @@ function computeCriticalPath(graph, _topoOrder, blockedByMap) {
     if (!changed) break;
   }
   let maxDist = 0;
-  let maxId = expectDefined12(allIds[0]);
+  let maxId = expectDefined(allIds[0]);
   for (const id of allIds) {
     const d = dist.get(id) ?? 0;
     if (d > maxDist) {
@@ -18224,12 +18700,6 @@ var SddTaskDecomposer = class {
     return nodes.some((n) => n.status === "blocked");
   }
 };
-function expectDefined13(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 var SddParallelRun = class {
   constructor(opts) {
     this.opts = opts;
@@ -18378,8 +18848,8 @@ var SddParallelRun = class {
     const successCount = results.filter((r) => r.status === "success").length;
     const failCount = results.length - successCount;
     for (let i = 0; i < results.length; i++) {
-      const result = expectDefined13(results[i]);
-      const taskId = expectDefined13(taskIds[i]);
+      const result = expectDefined(results[i]);
+      const taskId = expectDefined(taskIds[i]);
       if (result.status === "success") {
         this.opts.tracker.updateNodeStatus(taskId, "completed");
       } else {