@wrongstack/core 0.77.0 → 0.84.1

package/dist/defaults/index.js

@@ -108,8 +108,10 @@ function isStdoutTTY() {
 }
 function writeTo(s, stream) {
   if (!stream || typeof stream.write !== "function") return false;
-  stream.write(s);
-  return true;
+  {
+    stream.write(s);
+    return true;
+  }
 }
 function writeErr(s, stream = process.stderr) {
   return writeTo(s, stream);
@@ -243,6 +245,12 @@ function formatCtx(ctx) {
 init_atomic_write();
 
 // src/utils/message-invariants.ts
+function expectDefined(value) {
+  if (value === null || value === void 0) {
+    throw new Error("Expected value to be defined");
+  }
+  return value;
+}
 function repairToolUseAdjacency(messages) {
   const removedToolUses = [];
   const removedToolResults = [];
@@ -250,7 +258,7 @@ function repairToolUseAdjacency(messages) {
   let changed = false;
   const out = [];
   for (let i = 0; i < messages.length; i++) {
-    const original = messages[i];
+    const original = expectDefined(messages[i]);
     let msg = original;
     if (hasToolUse(msg)) {
       const nextIds = toolResultIds(messages[i + 1]);
@@ -335,6 +343,12 @@ 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);
 }
@@ -345,7 +359,7 @@ function generateSessionId(startedAt, model) {
   const modelPart = model ? `_${sanitizeModel(model)}` : "";
   return `${date}/${time}Z${modelPart}_${suffix}`;
 }
-var DefaultSessionStore = class {
+var DefaultSessionStore = class _DefaultSessionStore {
   dir;
   events;
   secretScrubber;
@@ -354,6 +368,10 @@ var DefaultSessionStore = class {
     this.events = opts.events;
     this.secretScrubber = opts.secretScrubber;
   }
+  /** Absolute path to the session index file. */
+  get indexFile() {
+    return path3.join(this.dir, "_index.jsonl");
+  }
   /** Join session ID to its absolute path within the store directory. */
   sessionPath(id, ext) {
     return path3.join(this.dir, `${id}${ext}`);
@@ -386,7 +404,8 @@ var DefaultSessionStore = class {
       return new FileSessionWriter(id, handle, startedAt, meta, this.events, {
         dir: shardDir,
         filePath: file,
-        secretScrubber: this.secretScrubber
+        secretScrubber: this.secretScrubber,
+        onClose: (s) => this.appendToIndex(s)
       });
     } catch (err) {
       await handle.close().catch(() => {
@@ -417,7 +436,7 @@ var DefaultSessionStore = class {
           provider: data.metadata.provider
         },
         this.events,
-        { resumed: true, dir: this.dir, filePath: file, secretScrubber: this.secretScrubber }
+        { resumed: true, dir: this.dir, filePath: file, secretScrubber: this.secretScrubber, onClose: (s) => this.appendToIndex(s) }
       );
       return { writer, data };
     } catch (err) {
@@ -447,6 +466,15 @@ var DefaultSessionStore = class {
   async list(limit = 20) {
     try {
       await ensureDir(this.dir);
+      const indexed = await this.readIndex();
+      if (indexed.length > 0) {
+        indexed.sort((a, b) => {
+          if (a.startedAt < b.startedAt) return 1;
+          if (a.startedAt > b.startedAt) return -1;
+          return a.id.localeCompare(b.id);
+        });
+        return indexed.slice(0, limit);
+      }
       const ids = await this.collectSessionIds(this.dir);
       const sessions = await Promise.all(ids.map((id) => this.summaryFor(id).catch(() => null)));
       const out = sessions.filter((s) => s !== null);
@@ -460,16 +488,121 @@ var DefaultSessionStore = class {
       return [];
     }
   }
-  /** Recursively collect all session IDs from shard subdirectories. */
-  async collectSessionIds(dir) {
+  // ── Session index (_index.jsonl) ─────────────────────────────────────────
+  //
+  // One JSON line per closed session, appended atomically on close().
+  // When a session is deleted, a tombstone {action:"delete",id:"..."} is
+  // appended. On read, tombstones filter out matching session entries.
+  // This keeps listing O(lines-in-index) instead of O(files-on-disk).
+  //
+  // The index auto-compacts every N appends to prevent unbounded growth
+  // from tombstones and duplicate entries (resume cycles).
+  indexAppendCount = 0;
+  static COMPACT_EVERY = 30;
+  /** Append a session summary to the index. */
+  async appendToIndex(summary) {
+    try {
+      await ensureDir(this.dir);
+      const line = JSON.stringify(summary) + "\n";
+      await fsp.appendFile(this.indexFile, line, "utf8");
+      this.indexAppendCount++;
+      if (this.indexAppendCount >= _DefaultSessionStore.COMPACT_EVERY) {
+        await this.compactIndex();
+        this.indexAppendCount = 0;
+      }
+    } catch {
+    }
+  }
+  /** Append a tombstone entry for a deleted session. */
+  async writeTombstone(id) {
+    try {
+      await ensureDir(this.dir);
+      const line = JSON.stringify({ action: "delete", id }) + "\n";
+      await fsp.appendFile(this.indexFile, line, "utf8");
+      this.indexAppendCount++;
+    } catch {
+    }
+  }
+  /**
+   * Compact the index: read all entries, drop tombstones, deduplicate
+   * (keep latest per session), and rewrite. Atomic via temp+rename.
+   */
+  async compactIndex() {
+    const entries = await this.readIndex();
+    if (entries.length === 0) return;
+    const tmp = `${this.indexFile}.compact.tmp`;
+    const lines = entries.map((s) => JSON.stringify(s)).join("\n") + "\n";
+    await fsp.writeFile(tmp, lines, "utf8");
+    await fsp.rename(tmp, this.indexFile);
+  }
+  /**
+   * Read the index file and return deduplicated session summaries.
+   * Entries with a matching tombstone are filtered out.
+   * Returns empty array when the index doesn't exist or is corrupt.
+   */
+  async readIndex() {
+    let raw;
+    try {
+      raw = await fsp.readFile(this.indexFile, "utf8");
+    } catch {
+      return [];
+    }
+    const deleted = /* @__PURE__ */ new Set();
+    const seen = /* @__PURE__ */ new Map();
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        if (entry.action === "delete" && entry.id) {
+          deleted.add(entry.id);
+          seen.delete(entry.id);
+          continue;
+        }
+        if (entry.id && !deleted.has(entry.id)) {
+          seen.set(entry.id, entry);
+        }
+      } catch {
+      }
+    }
+    return Array.from(seen.values());
+  }
+  /**
+   * Rebuild the index from disk by scanning all sessions and writing a
+   * fresh _index.jsonl. Useful after manual cleanup or index corruption.
+   */
+  async rebuildIndex() {
+    const ids = await this.collectSessionIds(this.dir);
+    const summaries = await Promise.all(ids.map((id) => this.summaryFor(id).catch(() => null)));
+    const valid = summaries.filter((s) => s !== null);
+    const tmp = `${this.indexFile}.tmp`;
+    const lines = valid.map((s) => JSON.stringify(s)).join("\n") + "\n";
+    await fsp.writeFile(tmp, lines, "utf8");
+    await fsp.rename(tmp, this.indexFile);
+    return valid.length;
+  }
+  /** Recursively collect session IDs from date-shard subdirectories.
+   *  IDs include the date-prefix path (e.g. "2026-06-06/17-46-57Z_…").
+   *  Skips `.jsonl`/`.summary.json` root files, dot-files, and
+   *  sub-directories that belong to fleet/subagent sessions. */
+  async collectSessionIds(dir, prefix = "", depth = 0) {
     const ids = [];
-    const entries = await fsp.readdir(dir, { withFileTypes: true });
+    let entries;
+    try {
+      entries = await fsp.readdir(dir, { withFileTypes: true });
+    } catch {
+      return ids;
+    }
     for (const entry of entries) {
-      const full = path3.join(dir, entry.name);
+      if (entry.name.startsWith(".") && entry.name !== ".wrongstack") continue;
+      if (entry.name === "shared" || entry.name === "subagents" || entry.name === "attachments")
+        continue;
       if (entry.isDirectory()) {
-        ids.push(...await this.collectSessionIds(full));
+        const childPrefix = depth === 0 ? entry.name : `${prefix}/${entry.name}`;
+        ids.push(...await this.collectSessionIds(path3.join(dir, entry.name), childPrefix, depth + 1));
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
-        ids.push(entry.name.replace(/\.jsonl$/, ""));
+        if (entry.name === "_index.jsonl") continue;
+        const base = entry.name.replace(/\.jsonl$/, "");
+        ids.push(prefix ? `${prefix}/${base}` : base);
       }
     }
     return ids;
@@ -492,9 +625,70 @@ var DefaultSessionStore = class {
       return summary;
     }
   }
-  async delete(id) {
-    await fsp.unlink(this.sessionPath(id, ".jsonl"));
+  /**
+   * Delete a session and all associated files: JSONL, summary, plan/todos
+   * sidecars, and the session directory (fleet.json, shared/, subagents/).
+   */
+  async deleteSession(id) {
+    await fsp.unlink(this.sessionPath(id, ".jsonl")).catch(() => void 0);
     await fsp.unlink(this.sessionPath(id, ".summary.json")).catch(() => void 0);
+    const shardDir = path3.dirname(path3.join(this.dir, id));
+    const base = path3.basename(id);
+    for (const ext of [".plan.json", ".todos.json"]) {
+      await fsp.unlink(path3.join(shardDir, `${base}${ext}`)).catch(() => void 0);
+    }
+    const sessDir = path3.join(shardDir, base);
+    await fsp.rm(sessDir, { recursive: true, force: true }).catch(() => void 0);
+    await this.writeTombstone(id);
+  }
+  async delete(id) {
+    await this.deleteSession(id);
+  }
+  async prune(maxAgeDays = 30) {
+    const cutoff = Date.now() - maxAgeDays * 864e5;
+    let deleted = 0;
+    let activeSessionId = null;
+    try {
+      const raw = await fsp.readFile(path3.join(this.dir, "active.json"), "utf8");
+      const active = JSON.parse(raw);
+      activeSessionId = active.sessionId ?? null;
+    } catch {
+    }
+    const entries = await fsp.readdir(this.dir, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const dateDir = path3.join(this.dir, entry.name);
+      const files = await fsp.readdir(dateDir, { withFileTypes: true }).catch(() => []);
+      for (const file of files) {
+        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;
+        } catch {
+          continue;
+        }
+        const id = `${entry.name}/${file.name.replace(/\.jsonl$/, "")}`;
+        if (activeSessionId && id === activeSessionId) continue;
+        await this.deleteSession(id);
+        deleted++;
+      }
+    }
+    if (deleted > 0) {
+      await this.compactIndex().catch(() => void 0);
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const dateDir = path3.join(this.dir, entry.name);
+      try {
+        const remaining = await fsp.readdir(dateDir);
+        if (remaining.length === 0) {
+          await fsp.rmdir(dateDir).catch(() => void 0);
+        }
+      } catch {
+      }
+    }
+    return deleted;
   }
   async clearHistory(id) {
     await this.ensureShardDir(id);
@@ -516,13 +710,42 @@ var DefaultSessionStore = class {
       const data = await this.load(id);
       const firstUser = data.events.find((e) => e.type === "user_input");
       const title = firstUser && firstUser.type === "user_input" ? userInputTitle(firstUser.content) : "(empty session)";
+      let iterationCount = 0;
+      let toolCallCount = 0;
+      let toolErrorCount = 0;
+      let fileChangeCount = 0;
+      const toolBreakdown = {};
+      let outcome = void 0;
+      const lastEvent = data.events[data.events.length - 1];
+      for (const e of data.events) {
+        if (e.type === "in_flight_start") iterationCount++;
+        else if (e.type === "tool_call_start") {
+          toolCallCount++;
+          toolBreakdown[e.name] = (toolBreakdown[e.name] ?? 0) + 1;
+        } else if (e.type === "tool_result" && e.isError) toolErrorCount++;
+        else if (e.type === "file_snapshot") fileChangeCount += e.files.length;
+      }
+      if (lastEvent?.type === "session_end") {
+        outcome = "completed";
+      } else if (lastEvent?.type === "in_flight_start") {
+        outcome = "aborted";
+      } else if (data.events.some((e) => e.type === "error")) {
+        outcome = "error";
+      }
       return {
         id,
         title,
         startedAt: data.metadata.startedAt,
+        endedAt: data.metadata.endedAt,
         model: data.metadata.model ?? "unknown",
         provider: data.metadata.provider ?? "unknown",
-        tokenTotal: data.usage.input + data.usage.output
+        tokenTotal: data.usage.input + data.usage.output,
+        iterationCount: iterationCount > 0 ? iterationCount : void 0,
+        toolCallCount: toolCallCount > 0 ? toolCallCount : void 0,
+        toolErrorCount: toolErrorCount > 0 ? toolErrorCount : void 0,
+        fileChangeCount: fileChangeCount > 0 ? fileChangeCount : void 0,
+        toolBreakdown: Object.keys(toolBreakdown).length > 0 ? toolBreakdown : {},
+        outcome
       };
     } catch {
       return {
@@ -621,9 +844,10 @@ var FileSessionWriter = class {
     this.meta = meta;
     this.events = events;
     this.resumed = opts.resumed ?? false;
-    this.manifestFile = opts.dir ? path3.join(opts.dir, `${id}.summary.json`) : "";
+    this.manifestFile = opts.dir ? path3.join(opts.dir, `${path3.basename(id)}.summary.json`) : "";
     this.filePath = opts.filePath ?? "";
     this.secretScrubber = opts.secretScrubber;
+    this.onCloseCb = opts.onClose;
     this.summary = {
       id,
       title: "(empty session)",
@@ -653,6 +877,15 @@ var FileSessionWriter = class {
   appendFailCount = 0;
   lastAppendWarnAt = 0;
   secretScrubber;
+  onCloseCb;
+  // ── Enriched summary tracking ──────────────────────────────────────────
+  iterationCount = 0;
+  toolCallCount = 0;
+  toolErrorCount = 0;
+  toolBreakdown = {};
+  fileChangeCount = 0;
+  compactionCount = 0;
+  outcome = void 0;
   /**
    * Scrub secrets out of conversation-turn events before they are observed
    * for the summary, written to the JSONL log, or surfaced on resume. Only
@@ -730,8 +963,22 @@ var FileSessionWriter = class {
   observeForSummary(event) {
     if (event.type === "tool_use") {
       this.openToolUses.add(event.id);
+    } else if (event.type === "tool_call_start") {
+      this.toolCallCount++;
+      this.toolBreakdown[event.name] = (this.toolBreakdown[event.name] ?? 0) + 1;
     } else if (event.type === "tool_result") {
       this.openToolUses.delete(event.id);
+      if (event.isError) {
+        this.toolErrorCount++;
+        this.outcome = "error";
+      }
+    } else if (event.type === "file_snapshot") {
+      this.fileChangeCount += event.files.length;
+    } else if (event.type === "compaction") {
+      this.compactionCount++;
+    }
+    if (event.type === "error" || event.type === "provider_error") {
+      this.outcome = "error";
     }
     if (event.type === "user_input" && this.summary.title === "(empty session)") {
       this.summary = { ...this.summary, title: userInputTitle(event.content) };
@@ -742,18 +989,35 @@ var FileSessionWriter = class {
     } else if (event.type === "session_end") {
       const total = event.usage.input + event.usage.output;
       if (total > 0) this.summary = { ...this.summary, tokenTotal: total };
+    } else if (event.type === "in_flight_start") {
+      this.iterationCount++;
     }
   }
   async close() {
     if (this.closing) return;
     this.closing = true;
     this.closed = true;
+    this.summary = {
+      ...this.summary,
+      endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      iterationCount: this.iterationCount,
+      toolCallCount: this.toolCallCount,
+      toolErrorCount: this.toolErrorCount,
+      fileChangeCount: this.fileChangeCount,
+      compactionCount: this.compactionCount > 0 ? this.compactionCount : void 0,
+      toolBreakdown: { ...this.toolBreakdown },
+      outcome: this.outcome ?? "completed"
+    };
     if (this.manifestFile) {
       try {
         await atomicWrite(this.manifestFile, JSON.stringify(this.summary), { mode: 384 });
       } catch {
       }
     }
+    try {
+      await this.onCloseCb?.(this.summary);
+    } catch {
+    }
     try {
       await this.handle.close();
     } catch {
@@ -795,7 +1059,7 @@ var FileSessionWriter = class {
     let targetCheckpointLine = -1;
     let afterTarget = false;
     for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
+      const line = expectDefined2(lines[i]);
       if (!line.trim()) continue;
       let event;
       try {
@@ -1971,6 +2235,12 @@ 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) {
@@ -2032,7 +2302,7 @@ var DefaultSessionReader = class {
         continue;
       }
       for (let i = 0; i < data.events.length; i++) {
-        const ev = data.events[i];
+        const ev = expectDefined3(data.events[i]);
         if (allowedTypes && !allowedTypes.has(ev.type)) continue;
         const text = eventText(ev);
         if (text === null) continue;
@@ -2337,8 +2607,11 @@ var SessionAnalyzer = class {
   }
   calcDuration(events) {
     if (events.length < 2) return 0;
-    const first = new Date(events[0].ts).getTime();
-    const last = new Date(events[events.length - 1].ts).getTime();
+    const firstEvent = events[0];
+    const lastEvent = events[events.length - 1];
+    if (!firstEvent || !lastEvent) return 0;
+    const first = new Date(firstEvent.ts).getTime();
+    const last = new Date(lastEvent.ts).getTime();
     return last - first;
   }
 };
@@ -3113,20 +3386,20 @@ var DefaultSecretVault = class {
     return key;
   }
 };
-function decryptConfigSecrets2(cfg, vault) {
+function decryptConfigSecrets2(cfg, vault, opts) {
+  const warn = opts?.warn ?? ((msg) => console.warn(msg));
   return walk2(cfg, vault, (v, key) => {
     try {
       return vault.decrypt(v);
     } catch (err) {
-      console.warn(
-        `[secret-vault] Failed to decrypt "${key}":`,
-        err instanceof Error ? err.message : err
+      warn(
+        `[secret-vault] Failed to decrypt "${key}": ${err instanceof Error ? err.message : err}`
       );
       return "";
     }
   });
 }
-function encryptConfigSecrets(cfg, vault) {
+function encryptConfigSecrets(cfg, vault, _opts) {
   return walk2(cfg, vault, (v) => vault.encrypt(v));
 }
 function walk2(node, vault, transform) {
@@ -3187,7 +3460,8 @@ async function migratePlaintextSecrets(configPath, vault) {
   await restrictFilePermissions(configPath);
   return { migrated: counter.n, file: configPath };
 }
-async function restrictFilePermissions(filePath) {
+async function restrictFilePermissions(filePath, opts) {
+  const warn = ((msg) => console.warn(msg));
   if (process.platform === "win32") {
     try {
       const { execFile: execFile2 } = await import('child_process');
@@ -3195,7 +3469,7 @@ async function restrictFilePermissions(filePath) {
       const execFileAsync = promisify2(execFile2);
       await execFileAsync("icacls", [filePath, "/inheritance:r", "/grant:r", `${process.env.USERNAME}:(F)`]);
     } catch {
-      console.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 {
@@ -3291,6 +3565,12 @@ 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, "\\$&");
 }
@@ -3302,7 +3582,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(keys[i]);
+      COMPILED_GLOB_CACHE.delete(expectDefined4(keys[i]));
     }
   }
   const re = compileGlob(pattern);
@@ -4160,13 +4440,19 @@ function parseDescription(raw) {
   const scope = [];
   const coversMatch = /(?:covers|for|including)\s+([^.]+)/i.exec(desc);
   if (coversMatch) {
-    const items = coversMatch[1].replace(/[·•]/g, ",").split(",").map((s) => s.trim()).filter(Boolean);
+    const items = coversMatch[1] ?? "".replace(/[·•]/g, ",").split(",").map((s) => s.trim()).filter(Boolean);
     scope.push(...items);
   }
   return { trigger, scope };
 }
 
 // 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;
@@ -4178,7 +4464,7 @@ function completePartialObject(s) {
   let contentEnd = 0;
   let stringBraceDepth = 0;
   for (let i = 0; i < s.length; i++) {
-    const ch = s[i];
+    const ch = expectDefined5(s[i]);
     if (inString) {
       contentEnd = i + 1;
       if (escaped) {
@@ -4314,7 +4600,7 @@ function handleContentBlockStart(state, ev) {
     state.textBuffers.push("");
     state.blockOrder.push({ kind: "text", idx: state.currentTextIndex });
   } else if (kind === "tool_use") {
-    const id = ev.id ?? crypto.randomUUID();
+    const id = ev.id ?? randomUUID();
     state.tools.set(id, { name: ev.name ?? "unknown", partial: "" });
     state.blockOrder.push({ kind: "tool", id });
     state.currentTextIndex = -1;
@@ -4563,6 +4849,12 @@ 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;
@@ -4572,7 +4864,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(keys[i]);
+      ESTIMATE_CACHE.delete(expectDefined6(keys[i]));
     }
   }
   const estimate = compute();
@@ -4962,7 +5254,7 @@ var IntelligentCompactor = class {
       maxTokens: 1024
     };
     const ac = ctx.signal ? void 0 : new AbortController();
-    const signal = ctx.signal ?? ac.signal;
+    const signal = ctx.signal ?? ac?.signal;
     const res = await this.provider.complete(req, { signal });
     const textBlocks = res.content.filter(isTextBlock);
     return textBlocks.map((b) => b.text).join("\n").trim() || "(empty summary)";
@@ -5065,6 +5357,12 @@ 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:
@@ -5105,7 +5403,7 @@ function formatMessages(messages, maxChars = 8e3) {
   const lines = [];
   let used = 0;
   for (let i = 0; i < messages.length; i++) {
-    const m = messages[i];
+    const m = expectDefined7(messages[i]);
     const role = m.role.padEnd(10, " ");
     let text;
     if (typeof m.content === "string") {
@@ -5170,7 +5468,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 = messages[i];
+      const m = expectDefined7(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
@@ -5381,6 +5679,7 @@ Summarize the following message range:`;
     let boundary = preserveIdx;
     for (let i = preserveIdx; i < messages.length && i < preserveIdx + 6; i++) {
       const m = messages[i];
+      if (!m) continue;
       if (m.role === "user" && this.hasTextContent(m)) {
         boundary = i;
         break;
@@ -5776,6 +6075,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;
@@ -6064,6 +6369,9 @@ ${post.additionalContext}` };
   async runStreamedTool(tool, input, ctx, signal, toolUseId) {
     let finalOutput;
     let sawFinal = false;
+    if (!tool.executeStream) {
+      throw new Error(`Tool "${tool.name}" does not support streaming execution`);
+    }
     const stream = tool.executeStream(input, ctx, { signal });
     for await (const ev of stream) {
       if (ev.type === "final") {
@@ -6168,7 +6476,7 @@ function hasMalformedArguments(input) {
 function extractMalformedRaw(input) {
   if (!hasMalformedArguments(input)) return void 0;
   const obj = input;
-  const value = obj[Object.keys(obj)[0]];
+  const value = obj[expectDefined8(Object.keys(obj)[0])];
   if (value === void 0 || value === null) return void 0;
   if (typeof value === "string") return value;
   try {
@@ -6393,6 +6701,11 @@ function appendJournal(goal, entry) {
   };
 }
 
+// src/utils/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
+}
+
 // src/execution/eternal-autonomy.ts
 var execFileP = promisify(execFile);
 var BRAINSTORM_DONE = /* @__PURE__ */ Symbol("brainstorm-done");
@@ -6963,9 +7276,6 @@ ${recentJournal}` : "No prior iterations.",
     await saveGoal(this.goalPath, { ...current, engineState: state });
   }
 };
-function sleep(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
-}
 
 // src/coordination/subagent-budget.ts
 var BudgetExceededError = class extends Error {
@@ -7129,16 +7439,16 @@ var SubagentBudget = class _SubagentBudget {
     }
     if (exceeded.length === 0) return [];
     if (!this._onThreshold) {
-      const first2 = exceeded[0];
+      const first2 = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
       throw new BudgetExceededError(first2.kind, first2.limit, first2.used);
     }
     if (this._mode === "sync") {
-      const first2 = exceeded[0];
+      const first2 = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
       throw new BudgetExceededError(first2.kind, first2.limit, first2.used);
     }
     const bus = this._events;
     if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
-      const first2 = exceeded[0];
+      const first2 = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
       throw new BudgetExceededError(first2.kind, first2.limit, first2.used);
     }
     for (const entry of exceeded) {
@@ -7146,8 +7456,9 @@ var SubagentBudget = class _SubagentBudget {
       const decision2 = this._negotiateExtension(entry.kind, exceeded);
       this._pendingNegotiations.set(entry.kind, decision2);
     }
-    const first = exceeded[0];
+    const first = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
     const decision = this._pendingNegotiations.get(first.kind);
+    if (!decision) throw new Error(`No pending negotiation for ${first.kind}`);
     throw new BudgetThresholdSignal(first.kind, first.limit, first.used, decision);
   }
   /**
@@ -7169,8 +7480,11 @@ var SubagentBudget = class _SubagentBudget {
    * a fresh signal.
    */
   async _negotiateExtension(kind, exceeded) {
+    if (!this._onThreshold) {
+      return "stop";
+    }
     try {
-      const first = exceeded[0];
+      const first = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
       const result = this._onThreshold({
         kind: first.kind,
         used: first.used,
@@ -9653,6 +9967,11 @@ function getAgentDefinition(role) {
 
 // src/coordination/dispatcher.ts
 var DEFAULT_DISPATCH_ROLE = "executor";
+var FALLBACK_DEFINITION = {
+  config: { role: "unknown", name: "Unknown Agent" },
+  budget: {},
+  capability: { phase: "meta", summary: "", keywords: [] }
+};
 function normalize(text) {
   return ` ${text.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim()} `;
 }
@@ -9680,7 +9999,7 @@ function scoreAgents(task, catalog = AGENT_CATALOG) {
 }
 function heuristicConfidence(candidates) {
   if (candidates.length === 0) return 0;
-  const top = candidates[0].score;
+  const top = candidates[0]?.score ?? 0;
   const second = candidates[1]?.score ?? 0;
   const strength = Math.min(1, top / 3);
   const margin = (top - second + 1) / (top + 1);
@@ -9696,7 +10015,7 @@ async function dispatchAgent(task, opts = {}) {
   if (top && confidence >= threshold) {
     return {
       role: top.role,
-      definition: catalog[top.role],
+      definition: catalog[top.role] ?? FALLBACK_DEFINITION,
       confidence,
       method: "heuristic",
       reason: `Matched keywords: ${top.matched.slice(0, 4).join(", ")}`,
@@ -9704,7 +10023,7 @@ async function dispatchAgent(task, opts = {}) {
     };
   }
   if (opts.classifier) {
-    const pool = (candidates.length > 0 ? candidates.slice(0, maxCandidates).map((c) => catalog[c.role]) : ALL_AGENT_DEFINITIONS).map((d) => ({
+    const pool = (candidates.length > 0 ? candidates.slice(0, maxCandidates).map((c) => catalog[c.role] ?? FALLBACK_DEFINITION) : ALL_AGENT_DEFINITIONS).map((d) => ({
       role: d.config.role,
       name: d.config.name,
       summary: d.capability.summary
@@ -9714,7 +10033,7 @@ async function dispatchAgent(task, opts = {}) {
       if (choice && catalog[choice.role]) {
         return {
           role: choice.role,
-          definition: catalog[choice.role],
+          definition: catalog[choice.role] ?? FALLBACK_DEFINITION,
           confidence: 1,
           method: "llm",
           reason: choice.reason ?? "Selected by LLM classifier",
@@ -9727,17 +10046,17 @@ async function dispatchAgent(task, opts = {}) {
   if (top) {
     return {
       role: top.role,
-      definition: catalog[top.role],
+      definition: catalog[top.role] ?? FALLBACK_DEFINITION,
       confidence,
       method: "heuristic",
       reason: `Weak match (${top.matched.slice(0, 3).join(", ") || "low signal"})`,
       alternatives: candidates.slice(1, maxCandidates)
     };
   }
-  const fallbackRole = catalog[DEFAULT_DISPATCH_ROLE] ? DEFAULT_DISPATCH_ROLE : Object.keys(catalog)[0];
+  const fallbackRole = catalog[DEFAULT_DISPATCH_ROLE] ? DEFAULT_DISPATCH_ROLE : Object.keys(catalog)[0] ?? DEFAULT_DISPATCH_ROLE;
   return {
     role: fallbackRole,
-    definition: catalog[fallbackRole],
+    definition: catalog[fallbackRole] ?? FALLBACK_DEFINITION,
     confidence: 0,
     method: "fallback",
     reason: "No keyword signal; defaulting to the generalist Executor",
@@ -10550,6 +10869,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
   takeNextDispatchableTask() {
     for (let i = 0; i < this.pendingTasks.length; i++) {
       const task = this.pendingTasks[i];
+      if (!task) continue;
       const subagentId = task.subagentId ? this.isIdleSubagent(task.subagentId) ? task.subagentId : null : this.findIdleSubagent();
       if (!subagentId) continue;
       this.pendingTasks.splice(i, 1);
@@ -10741,14 +11061,14 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
         const idleExceeded = idleLimit !== void 0 && budget.idleMs() >= idleLimit;
         if (idleExceeded && !wallExceeded) {
           this.subagents.get(ctx.subagentId)?.abortController.abort();
-          reject(new BudgetExceededError("timeout", idleLimit, budget.idleMs()));
+          reject(new BudgetExceededError("timeout", idleLimit ?? 0, budget.idleMs()));
           return;
         }
         if (!wallExceeded) {
           scheduleNext();
           return;
         }
-        const limit = wallLimit;
+        const limit = wallLimit ?? 0;
         if (!budget.onThreshold) {
           this.subagents.get(ctx.subagentId)?.abortController.abort();
           reject(new BudgetExceededError("timeout", limit, elapsed));
@@ -10907,8 +11227,11 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
 };
 
 // src/execution/parallel-eternal-engine.ts
-function sleep2(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+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 {
@@ -10984,7 +11307,7 @@ var ParallelEternalEngine = class {
           );
         }
         if (this.stopRequested) break;
-        await sleep2(2e3);
+        await sleep(2e3);
       }
     } finally {
       this.state = "stopped";
@@ -11065,7 +11388,7 @@ var ParallelEternalEngine = class {
   // Fan-out
   // -------------------------------------------------------------------------
   async fanOut(goal, tasks) {
-    const coordinator = this.coordinator;
+    const coordinator = expectDefined9(this.coordinator);
     const slotCount = Math.min(this.slots, tasks.length);
     const routes = this.dispatchEnabled ? await Promise.all(
       tasks.slice(0, slotCount).map(
@@ -11097,7 +11420,7 @@ ${recentJournal}` : "No prior iterations.",
     const routeInfo = [];
     const spawnPromises = [];
     for (let i = 0; i < slotCount; i++) {
-      const task = tasks[i];
+      const task = expectDefined9(tasks[i]);
       const route = routes[i] ?? null;
       const subagentId = `parallel-${this.iterations}-${i}`;
       const taskId = randomUUID();
@@ -11470,7 +11793,7 @@ var InMemoryBridgeTransport = class {
   }
   subscribe(agentId, handler) {
     if (!this.subs.has(agentId)) this.subs.set(agentId, /* @__PURE__ */ new Set());
-    this.subs.get(agentId).add(handler);
+    this.subs.get(agentId)?.add(handler);
     return () => this.subs.get(agentId)?.delete(handler);
   }
   close(agentId) {
@@ -11588,6 +11911,12 @@ 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 ? "\\" : "/";
@@ -11601,7 +11930,7 @@ function globToRegex(pat) {
   let i = 0;
   let re = "^";
   while (i < pat.length) {
-    const c = pat[i];
+    const c = expectDefined10(pat[i]);
     if (c === "*") {
       if (pat[i + 1] === "*") {
         re += ".*";
@@ -11640,7 +11969,7 @@ function globToRegex(pat) {
 }
 function baseDir(pat) {
   let i = pat.length - 1;
-  while (i >= 0 && !GLOB_CHARS.has(pat[i]) && pat[i] !== SEP && pat[i] !== "/") i--;
+  while (i >= 0 && !GLOB_CHARS.has(expectDefined10(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);
 }
@@ -11865,7 +12194,7 @@ var CollabSession = class extends EventEmitter {
       this.emit("session.error", error);
       throw error;
     }
-    for (const result of results.flat()) {
+    for (const result of results?.flat() ?? []) {
       await this.parseAndEmit(result);
     }
     const report = this.assembleReport();
@@ -11926,7 +12255,7 @@ var CollabSession = class extends EventEmitter {
   }
   budgetForRole(role) {
     if (this.options.budgetOverrides?.[role]) {
-      return this.options.budgetOverrides[role];
+      return this.options.budgetOverrides[role] ?? { maxIterations: 0, maxToolCalls: 0, timeoutMs: 0 };
     }
     const defaults = {
       "bug-hunter": { maxIterations: 2e3, maxToolCalls: 5e3, timeoutMs: 10 * 60 * 1e3 },
@@ -12379,7 +12708,7 @@ function makeSpawnTool(director, roster) {
         });
         const dispatchRole = dispatchResult.role;
         if (roster?.[dispatchRole]) {
-          cfg = instantiateRosterConfig(dispatchRole, roster[dispatchRole]);
+          cfg = instantiateRosterConfig(dispatchRole, roster[dispatchRole] ?? {});
         } else {
           const def = dispatchResult.definition;
           cfg = {
@@ -14676,7 +15005,10 @@ function attachAutoExtend(events, policy = {}) {
       if (kind === "timeout" || kind === "idle_timeout") {
         if (progress > lastTimeoutProgress) {
           lastTimeoutProgress = progress;
-          const next2 = Math.min(Math.ceil(limit * (1 + factor)), ceiling.timeoutMs);
+          const next2 = Math.min(
+            Math.ceil(limit * (1 + factor)),
+            ceiling.timeoutMs ?? DEFAULT_CEILING.timeoutMs
+          );
           extend({ timeoutMs: next2 });
         } else {
           deny();
@@ -14690,7 +15022,7 @@ function attachAutoExtend(events, policy = {}) {
       }
       extendCounts.set(kind, count + 1);
       const field = FIELD_BY_KIND[kind];
-      const cap = ceiling[field];
+      const cap = ceiling[field] ?? DEFAULT_CEILING[field];
       const next = Math.min(Math.ceil(limit * (1 + factor)), cap);
       extend({ [field]: next });
     })
@@ -15989,7 +16321,7 @@ var TaskTracker = class {
         if (filter.type?.length && !filter.type.includes(n.type)) return false;
         if (filter.assignee?.length && n.assignee && !filter.assignee.includes(n.assignee))
           return false;
-        if (filter.tags?.length && n.tags && !n.tags.some((t) => filter.tags.includes(t)))
+        if (filter.tags?.length && n.tags && !n.tags.some((t) => filter.tags?.includes(t)))
           return false;
         if (filter.specRequirementId && n.specRequirementId !== filter.specRequirementId)
           return false;
@@ -16503,6 +16835,12 @@ 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);
@@ -16548,7 +16886,7 @@ function buildQuestioningPrompt(session, min, max) {
   if (answered > 0) {
     lines.push("", "**Conversation so far:**");
     for (let i = 0; i < answered; i++) {
-      const a = session.answers[i];
+      const a = expectDefined11(session.answers[i]);
       lines.push(``, `Q${i + 1}: ${a.question}`, `A${i + 1}: ${a.answer}`);
     }
   }
@@ -17290,6 +17628,12 @@ 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);
@@ -17298,9 +17642,9 @@ function analyzeCriticalPath(graph) {
   for (const edge of graph.edges) {
     if (edge.type === "depends_on") {
       if (!blockedByMap.has(edge.from)) blockedByMap.set(edge.from, /* @__PURE__ */ new Set());
-      blockedByMap.get(edge.from).add(edge.to);
+      blockedByMap.get(edge.from)?.add(edge.to);
       if (!blocksMap.has(edge.to)) blocksMap.set(edge.to, /* @__PURE__ */ new Set());
-      blocksMap.get(edge.to).add(edge.from);
+      blocksMap.get(edge.to)?.add(edge.from);
     }
   }
   const readyTasks = [];
@@ -17365,7 +17709,7 @@ function getTransitiveBlocked(_graph, taskId, blocksMap) {
   const visited = /* @__PURE__ */ new Set();
   const queue = [taskId];
   while (queue.length > 0) {
-    const current = queue.shift();
+    const current = expectDefined12(queue.shift());
     const blocked = blocksMap.get(current);
     if (!blocked) continue;
     for (const id of blocked) {
@@ -17390,7 +17734,7 @@ function computeCriticalPath(graph, _topoOrder, blockedByMap) {
   for (const [taskId, blockers] of blockedByMap) {
     for (const blockerId of blockers) {
       if (!blocksMap.has(blockerId)) blocksMap.set(blockerId, /* @__PURE__ */ new Set());
-      blocksMap.get(blockerId).add(taskId);
+      blocksMap.get(blockerId)?.add(taskId);
     }
   }
   const n = allIds.length;
@@ -17411,7 +17755,7 @@ function computeCriticalPath(graph, _topoOrder, blockedByMap) {
     if (!changed) break;
   }
   let maxDist = 0;
-  let maxId = allIds[0];
+  let maxId = expectDefined12(allIds[0]);
   for (const id of allIds) {
     const d = dist.get(id) ?? 0;
     if (d > maxDist) {
@@ -17880,6 +18224,12 @@ 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;
@@ -17980,8 +18330,10 @@ var SddParallelRun = class {
       "\u2022 Do not ask before routine in-project tool use; if a permission gate appears, wait for that flow.",
       "\u2022 Keep output concise \u2014 summarize changes, do not transcribe files."
     ].join("\n");
+    if (!this.coordinator) throw new Error("SDD parallel runner requires a coordinator");
+    const coordinator = this.coordinator;
     const spawns = subagentIds.map(
-      (subagentId) => this.coordinator.spawn({
+      (subagentId) => coordinator.spawn({
         id: subagentId,
         name: subagentId,
         role: "executor",
@@ -17989,12 +18341,12 @@ var SddParallelRun = class {
       })
     );
     const spawnResults = await Promise.all(spawns);
-    if (!spawnResults.every((r) => r.subagentId)) {
+    if (!spawnResults.every((r) => Boolean(r.subagentId))) {
       throw new Error("One or more subagent spawns failed");
     }
     const assignPromises = tasks.map((task, i) => {
       const spec = {
-        id: taskIds[i],
+        id: taskIds[i] ?? task.id,
         description: [
           directivePreamble,
           "",
@@ -18003,15 +18355,15 @@ var SddParallelRun = class {
           "",
           task.description
         ].join("\n"),
-        subagentId: subagentIds[i],
+        subagentId: subagentIds[i] ?? spawnResults[i]?.subagentId ?? task.id,
         timeoutMs: this.timeoutMs
       };
-      return this.coordinator.assign(spec);
+      return this.coordinator?.assign(spec);
     });
     await Promise.all(assignPromises);
     let results;
     try {
-      results = await this.coordinator.awaitTasks(taskIds);
+      results = await coordinator.awaitTasks(taskIds);
     } catch (err) {
       results = taskIds.map((id) => ({
         subagentId: "",
@@ -18026,8 +18378,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 = results[i];
-      const taskId = taskIds[i];
+      const result = expectDefined13(results[i]);
+      const taskId = expectDefined13(taskIds[i]);
       if (result.status === "success") {
         this.opts.tracker.updateNodeStatus(taskId, "completed");
       } else {