@wrongstack/core 0.89.1 → 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;
 };
@@ -294,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 = [];
@@ -396,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);
 }
@@ -1112,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 {
@@ -1408,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,
@@ -1429,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();
@@ -1461,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()}`);
@@ -1469,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 remember(text, scope = "project-memory") {
+  async search(query, scope = "project-memory", limit) {
+    return this.backend.search(scope, query, this.files[scope], limit);
+  }
+  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) {
@@ -2295,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) {
@@ -2362,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;
@@ -2811,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 = () => {
@@ -3115,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 });
@@ -3641,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, "\\$&");
 }
@@ -3658,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);
@@ -4523,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;
@@ -4540,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) {
@@ -4926,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;
@@ -4941,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();
@@ -5434,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:
@@ -5480,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") {
@@ -5545,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
@@ -6152,12 +6454,6 @@ 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;
@@ -6564,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 {
@@ -7722,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();
@@ -7838,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;
@@ -11342,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) {
@@ -11503,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(
@@ -11535,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();
@@ -12026,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 ? "\\" : "/";
@@ -12045,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 += ".*";
@@ -12084,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);
 }
@@ -12165,6 +12449,7 @@ 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. */
@@ -12261,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);
@@ -12299,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);
@@ -12314,6 +12600,7 @@ var CollabSession = class extends EventEmitter {
         timeout
       ]);
     } catch (err) {
+      this._raceResolved = true;
       if (this._timeoutTimer) {
         clearTimeout(this._timeoutTimer);
         this._timeoutTimer = void 0;
@@ -12328,6 +12615,7 @@ var CollabSession = class extends EventEmitter {
     }
     this.snapshotWarnings = await this.checkSnapshotFreshness();
     const report = this.assembleReport();
+    this._raceResolved = true;
     this.cleanup();
     this.emit("session.done", report);
     return report;
@@ -17035,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);
@@ -17086,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}`);
     }
   }
@@ -17828,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);
@@ -17909,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) {
@@ -17955,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) {
@@ -18424,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;
@@ -18578,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 {