@wrongstack/core 0.73.1 → 0.82.6

package/dist/defaults/index.js

@@ -1,7 +1,7 @@
 import * as crypto2 from 'crypto';
 import { randomBytes, randomUUID, createCipheriv, createDecipheriv, createHash } from 'crypto';
 import * as fsp from 'fs/promises';
-import * as path16 from 'path';
+import * as path3 from 'path';
 import { isAbsolute, resolve } from 'path';
 import * as fs5 from 'fs';
 import * as os from 'os';
@@ -32,9 +32,9 @@ __export(atomic_write_exports, {
   ensureDir: () => ensureDir
 });
 async function atomicWrite(targetPath, content, opts = {}) {
-  const dir = path16.dirname(targetPath);
+  const dir = path3.dirname(targetPath);
   await fsp.mkdir(dir, { recursive: true });
-  const tmp = path16.join(dir, `.${path16.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
+  const tmp = path3.join(dir, `.${path3.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
   try {
     if (typeof content === "string") {
       await fsp.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
@@ -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);
@@ -162,14 +164,16 @@ var DefaultLogger = class _DefaultLogger {
   file;
   bindings;
   pretty;
+  stderr;
   constructor(opts = {}) {
     this.level = opts.level ?? process.env.WRONGSTACK_LOG_LEVEL ?? "info";
     this.file = opts.file;
     this.bindings = opts.bindings ?? {};
     this.pretty = opts.pretty ?? true;
+    this.stderr = opts.stderr !== false;
     if (this.file) {
       try {
-        fs5.mkdirSync(path16.dirname(this.file), { recursive: true });
+        fs5.mkdirSync(path3.dirname(this.file), { recursive: true });
       } catch {
       }
     }
@@ -194,6 +198,7 @@ var DefaultLogger = class _DefaultLogger {
       level: this.level,
       file: this.file,
       pretty: this.pretty,
+      stderr: this.stderr,
       bindings: { ...this.bindings, ...bindings }
     });
   }
@@ -213,6 +218,7 @@ var DefaultLogger = class _DefaultLogger {
       } catch {
       }
     }
+    if (!this.stderr) return;
     if (r <= LEVEL_RANK.warn || this.level === "debug" || this.level === "trace") {
       const head = `${color.dim(ts)} ${COLORS[level](level.toUpperCase().padEnd(5))} ${msg}`;
       if (ctx !== void 0) {
@@ -239,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 = [];
@@ -246,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]);
@@ -331,7 +343,23 @@ function isEmptyMessage(msg) {
 }
 
 // src/storage/session-store.ts
-var DefaultSessionStore = class {
+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);
+}
+function generateSessionId(startedAt, model) {
+  const date = startedAt.slice(0, 10);
+  const time = startedAt.slice(11, 19).replace(/:/g, "-");
+  const suffix = randomBytes(2).toString("hex");
+  const modelPart = model ? `_${sanitizeModel(model)}` : "";
+  return `${date}/${time}Z${modelPart}_${suffix}`;
+}
+var DefaultSessionStore = class _DefaultSessionStore {
   dir;
   events;
   secretScrubber;
@@ -340,19 +368,29 @@ 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 path16.join(this.dir, `${id}${ext}`);
+    return path3.join(this.dir, `${id}${ext}`);
   }
-  async ensureShardDir(_id) {
-    await ensureDir(this.dir);
-    return this.dir;
+  /**
+   * Ensure the directory implied by the session ID exists. When the ID
+   * contains a date prefix like `2026-06-06/...`, this creates the date
+   * subdirectory so sessions group naturally by day.
+   */
+  async ensureShardDir(id) {
+    const dirPath = path3.dirname(path3.join(this.dir, id));
+    await ensureDir(dirPath);
+    return dirPath;
   }
   async create(meta) {
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const id = meta.id ?? `${startedAt.replace(/[:.]/g, "-")}-${randomBytes(2).toString("hex")}`;
+    const id = meta.id && meta.id.length > 0 ? meta.id : generateSessionId(startedAt, meta.model ?? meta.provider);
     const shardDir = await this.ensureShardDir(id);
-    const file = path16.join(shardDir, `${id}.jsonl`);
+    const file = path3.join(shardDir, `${path3.basename(id)}.jsonl`);
     let handle;
     try {
       handle = await fsp.open(file, "a", 384);
@@ -366,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(() => {
@@ -397,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) {
@@ -427,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);
@@ -440,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 = path16.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;
@@ -472,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);
@@ -496,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 {
@@ -601,9 +844,10 @@ var FileSessionWriter = class {
     this.meta = meta;
     this.events = events;
     this.resumed = opts.resumed ?? false;
-    this.manifestFile = opts.dir ? path16.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)",
@@ -633,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
@@ -710,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) };
@@ -722,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 {
@@ -775,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 {
@@ -883,7 +1167,7 @@ init_atomic_write();
 var QueueStore = class {
   file;
   constructor(opts) {
-    this.file = path16.join(opts.dir, "queue.json");
+    this.file = path3.join(opts.dir, "queue.json");
   }
   async write(items) {
     if (items.length === 0) {
@@ -953,7 +1237,7 @@ var DefaultAttachmentStore = class {
     let data = input.data;
     if (this.spoolDir && bytes >= this.spoolThreshold) {
       await fsp.mkdir(this.spoolDir, { recursive: true });
-      spooledPath = path16.join(this.spoolDir, `${id}.bin`);
+      spooledPath = path3.join(this.spoolDir, `${id}.bin`);
       await atomicWrite(spooledPath, input.data, {
         encoding: input.kind === "image" ? "base64" : "utf8"
       });
@@ -1141,7 +1425,7 @@ ${body.trim()}`);
   async remember(text, scope = "project-memory") {
     return this.runSerialized(scope, async () => {
       const file = this.files[scope];
-      await ensureDir(path16.dirname(file));
+      await ensureDir(path3.dirname(file));
       let existing = "";
       try {
         existing = await fsp.readFile(file, "utf8");
@@ -1789,7 +2073,7 @@ var RecoveryLock = class {
   sessionStore;
   probe;
   constructor(opts) {
-    this.file = path16.join(opts.dir, LOCK_FILE);
+    this.file = path3.join(opts.dir, LOCK_FILE);
     this.pid = opts.pid ?? process.pid;
     this.hostname = opts.hostname ?? os.hostname();
     this.maxAgeMs = opts.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
@@ -1847,7 +2131,7 @@ var RecoveryLock = class {
    * null return before calling this.
    */
   async write(sessionId) {
-    await ensureDir(path16.dirname(this.file));
+    await ensureDir(path3.dirname(this.file));
     const lock = {
       v: 1,
       sessionId,
@@ -1951,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) {
@@ -2012,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;
@@ -2317,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;
   }
 };
@@ -2431,7 +2724,7 @@ async function loadTodosCheckpoint(filePath) {
     const parsed = JSON.parse(raw);
     if (parsed?.version !== 1 || !Array.isArray(parsed.todos)) return null;
     return parsed.todos.filter(
-      (t) => !!t && typeof t.id === "string" && typeof t.content === "string" && typeof t.status === "string"
+      (t) => !!t && typeof t.id === "string" && typeof t.content === "string" && typeof t.status === "string" && (t.activeForm === void 0 || typeof t.activeForm === "string")
     );
   } catch {
     return null;
@@ -3074,7 +3367,7 @@ var DefaultSecretVault = class {
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
     }
-    fs5.mkdirSync(path16.dirname(this.keyFile), { recursive: true });
+    fs5.mkdirSync(path3.dirname(this.keyFile), { recursive: true });
     const key = randomBytes(KEY_BYTES);
     try {
       fs5.writeFileSync(this.keyFile, key, { mode: 384, flag: "wx" });
@@ -3143,7 +3436,7 @@ async function rewriteConfigEncrypted(configPath, vault, patch) {
   }
   const merged = deepMerge2(current, patch ?? {});
   const encrypted = encryptConfigSecrets(merged, vault);
-  await fsp.mkdir(path16.dirname(configPath), { recursive: true });
+  await fsp.mkdir(path3.dirname(configPath), { recursive: true });
   await atomicWrite(configPath, JSON.stringify(encrypted, null, 2), { mode: 384 });
   await restrictFilePermissions(configPath);
 }
@@ -3271,6 +3564,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, "\\$&");
 }
@@ -3282,7 +3581,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);
@@ -3367,9 +3666,9 @@ function getInputString(input, key) {
 function pathLooksInsideProject(rawPath, projectRoot) {
   if (!projectRoot) return false;
   if (rawPath === "~" || rawPath.startsWith("~/") || rawPath.startsWith("~\\")) return false;
-  const resolved = path16.resolve(projectRoot, rawPath);
-  const relative2 = path16.relative(projectRoot, resolved);
-  return !!relative2 && !relative2.startsWith("..") && !path16.isAbsolute(relative2);
+  const resolved = path3.resolve(projectRoot, rawPath);
+  const relative2 = path3.relative(projectRoot, resolved);
+  return !!relative2 && !relative2.startsWith("..") && !path3.isAbsolute(relative2);
 }
 function tokenizeShell(command) {
   return command.match(/"[^"]*"|'[^']*'|\S+/g)?.map((token) => token.replace(/^['"]|['"]$/g, "")) ?? [];
@@ -3379,7 +3678,7 @@ function pathTokenIsOutsideProject(token, projectRoot) {
   if (token === "/" || token === "~" || token === "." || token === "..") return token !== ".";
   if (token.includes("*")) return true;
   if (token.startsWith("..") || token.includes("../") || token.includes("..\\")) return true;
-  if (path16.isAbsolute(token) || token.startsWith("~/")) return !pathLooksInsideProject(token, projectRoot);
+  if (path3.isAbsolute(token) || token.startsWith("~/")) return !pathLooksInsideProject(token, projectRoot);
   return false;
 }
 function hasDangerousDeleteTarget(tokens, start, projectRoot) {
@@ -4035,7 +4334,7 @@ var DefaultSkillLoader = class {
         const entries = await fsp.readdir(dir, { withFileTypes: true });
         for (const e of entries) {
           if (!e.isDirectory()) continue;
-          const skillFile = path16.join(dir, e.name, "SKILL.md");
+          const skillFile = path3.join(dir, e.name, "SKILL.md");
           try {
             const raw = await fsp.readFile(skillFile, "utf8");
             const meta = parseFrontmatter(raw);
@@ -4140,13 +4439,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;
@@ -4158,7 +4463,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) {
@@ -4543,6 +4848,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;
@@ -4552,7 +4863,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();
@@ -4942,7 +5253,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)";
@@ -5045,6 +5356,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:
@@ -5085,7 +5402,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") {
@@ -5150,7 +5467,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
@@ -5361,6 +5678,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;
@@ -5756,6 +6074,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;
@@ -6044,6 +6368,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") {
@@ -6148,7 +6475,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 {
@@ -6327,8 +6654,8 @@ var AutonomousRunner = class {
 init_atomic_write();
 var MAX_JOURNAL_ENTRIES = 500;
 function goalFilePath(projectRoot) {
-  const hash = createHash("sha256").update(path16.resolve(projectRoot)).digest("hex").slice(0, 12);
-  return path16.join(os.homedir(), ".wrongstack", "projects", hash, "goal.json");
+  const hash = createHash("sha256").update(path3.resolve(projectRoot)).digest("hex").slice(0, 12);
+  return path3.join(os.homedir(), ".wrongstack", "projects", hash, "goal.json");
 }
 async function loadGoal(filePath) {
   let raw;
@@ -7109,16 +7436,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) {
@@ -7126,8 +7453,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);
   }
   /**
@@ -7149,8 +7477,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,
@@ -9633,6 +9964,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()} `;
 }
@@ -9660,7 +9996,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);
@@ -9676,7 +10012,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(", ")}`,
@@ -9684,7 +10020,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
@@ -9694,7 +10030,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",
@@ -9707,17 +10043,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",
@@ -10530,6 +10866,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);
@@ -10721,14 +11058,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));
@@ -10887,6 +11224,12 @@ 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;
+}
 function sleep2(ms) {
   return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
@@ -11045,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(
@@ -11077,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();
@@ -11450,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) {
@@ -11568,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 ? "\\" : "/";
@@ -11581,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 += ".*";
@@ -11620,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);
 }
@@ -11845,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();
@@ -11906,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 },
@@ -12359,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 = {
@@ -13842,7 +14191,7 @@ var Director = class _Director {
       })),
       usage: this.usage.snapshot()
     };
-    await fsp.mkdir(path16.dirname(this.manifestPath), { recursive: true });
+    await fsp.mkdir(path3.dirname(this.manifestPath), { recursive: true });
     await atomicWrite(this.manifestPath, JSON.stringify(manifest, null, 2), { mode: 384 });
     return this.manifestPath;
   }
@@ -14048,7 +14397,7 @@ var Director = class _Director {
    */
   async readSession(subagentId, tail) {
     if (!this.sessionsRoot) return null;
-    const filePath = path16.join(this.sessionsRoot, this.directorRunId, `${subagentId}.jsonl`);
+    const filePath = path3.join(this.sessionsRoot, this.directorRunId, `${subagentId}.jsonl`);
     let raw;
     try {
       raw = await fsp.readFile(filePath, "utf8");
@@ -14284,6 +14633,7 @@ function createDelegateTool(opts) {
       if (typeof i.task !== "string" || !i.task.trim()) {
         return { ok: false, error: "`task` is required." };
       }
+      const target = i.role ?? i.name ?? "subagent";
       try {
         let director = await opts.host.ensureDirector();
         if (!director) {
@@ -14344,6 +14694,7 @@ function createDelegateTool(opts) {
         if (!cfg.timeoutMs) {
           cfg.timeoutMs = Math.max(3e4, timeoutMs - SUBAGENT_TIMEOUT_BUFFER_MS);
         }
+        opts.events?.emit("delegate.started", { target, task: i.task });
         const subagentId = await director.spawn(cfg);
         const taskId = await director.assign({
           id: `${randomUUID()}`,
@@ -14378,6 +14729,17 @@ function createDelegateTool(opts) {
         });
         if ("__timeout" in result) {
           const partial2 = await readSubagentPartial(opts, subagentId);
+          opts.events?.emit("delegate.completed", {
+            target,
+            task: i.task,
+            ok: false,
+            status: "host_timeout",
+            summary: `[${target}] timed out \u2014 no result within ${Math.round(timeoutMs / 1e3)}s`,
+            durationMs: timeoutMs,
+            iterations: partial2?.events ?? 0,
+            toolCalls: partial2?.toolUsesObserved ?? 0,
+            subagentId
+          });
           return {
             ok: false,
             stopReason: "host_timeout",
@@ -14394,6 +14756,24 @@ function createDelegateTool(opts) {
         const retryable = result.error?.retryable;
         const backoffMs = result.error?.backoffMs;
         const summary = buildDelegateSummary(i.role, result);
+        let costUsd;
+        try {
+          costUsd = dir.snapshot().perSubagent[result.subagentId]?.cost;
+        } catch {
+          costUsd = void 0;
+        }
+        opts.events?.emit("delegate.completed", {
+          target,
+          task: i.task,
+          ok: result.status === "success",
+          status: result.status,
+          summary,
+          durationMs: result.durationMs,
+          iterations: result.iterations,
+          toolCalls: result.toolCalls,
+          costUsd,
+          subagentId: result.subagentId
+        });
         return {
           ok: result.status === "success",
           status: result.status,
@@ -14415,10 +14795,21 @@ function createDelegateTool(opts) {
           summary
         };
       } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        opts.events?.emit("delegate.completed", {
+          target,
+          task: i.task,
+          ok: false,
+          status: "error",
+          summary: `[${target}] failed \u2014 ${message}`,
+          durationMs: 0,
+          iterations: 0,
+          toolCalls: 0
+        });
         return {
           ok: false,
           stopReason: "error",
-          error: err instanceof Error ? err.message : String(err)
+          error: message
         };
       }
     }
@@ -14505,13 +14896,13 @@ async function readSubagentPartial(opts, subagentId) {
   if (!opts.sessionsRoot) return void 0;
   const candidates = [];
   if (opts.directorRunId) {
-    candidates.push(path16.join(opts.sessionsRoot, opts.directorRunId, `${subagentId}.jsonl`));
+    candidates.push(path3.join(opts.sessionsRoot, opts.directorRunId, `${subagentId}.jsonl`));
   } else {
     try {
       const entries = await fsp.readdir(opts.sessionsRoot, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          candidates.push(path16.join(opts.sessionsRoot, entry.name, `${subagentId}.jsonl`));
+          candidates.push(path3.join(opts.sessionsRoot, entry.name, `${subagentId}.jsonl`));
         }
       }
     } catch {
@@ -14558,9 +14949,9 @@ function makeDirectorSessionFactory(opts) {
   let dir;
   if (opts.store) {
     store = opts.store;
-    dir = opts.sessionsRoot ? path16.join(opts.sessionsRoot, runId) : "(caller-managed)";
+    dir = opts.sessionsRoot ? path3.join(opts.sessionsRoot, runId) : "(caller-managed)";
   } else if (opts.sessionsRoot) {
-    dir = path16.join(opts.sessionsRoot, runId);
+    dir = path3.join(opts.sessionsRoot, runId);
     store = new DefaultSessionStore({ dir });
   } else {
     throw new Error("makeDirectorSessionFactory requires either `store` or `sessionsRoot`");
@@ -14614,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();
@@ -14628,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 });
     })
@@ -14764,7 +15158,7 @@ var DefaultModelsRegistry = class {
     this.overlay = opts.overlay;
     this.overlayUrl = opts.overlayUrl;
     this.overlayFile = opts.overlayFile;
-    this.overlayCacheFile = opts.overlayCacheFile ?? (opts.overlayUrl ? path16.join(path16.dirname(opts.cacheFile), "models-overlay-cache.json") : void 0);
+    this.overlayCacheFile = opts.overlayCacheFile ?? (opts.overlayUrl ? path3.join(path3.dirname(opts.cacheFile), "models-overlay-cache.json") : void 0);
   }
   async load(opts = {}) {
     if (this.payload && !opts.force) return this.payload;
@@ -14977,7 +15371,7 @@ var DefaultModelsRegistry = class {
   }
   /** Used by `wstack models refresh` to expose where the cache lives. */
   cacheLocation() {
-    return path16.resolve(this.cacheFile);
+    return path3.resolve(this.cacheFile);
   }
 };
 function hasEntries(payload) {
@@ -15273,7 +15667,7 @@ var DefaultModeStore = class {
   }
   async loadActiveMode() {
     try {
-      const configPath = path16.join(this.configDir, "mode.json");
+      const configPath = path3.join(this.configDir, "mode.json");
       const content = await fsp.readFile(configPath, "utf8");
       const data = JSON.parse(content);
       this.activeModeId = data.activeMode ?? null;
@@ -15284,7 +15678,7 @@ var DefaultModeStore = class {
   async saveActiveMode() {
     try {
       await fsp.mkdir(this.configDir, { recursive: true });
-      const configPath = path16.join(this.configDir, "mode.json");
+      const configPath = path3.join(this.configDir, "mode.json");
       await atomicWrite(
         configPath,
         JSON.stringify({ activeMode: this.activeModeId }, null, 2)
@@ -15299,11 +15693,11 @@ async function loadProjectModes(modesDir) {
     const entries = await fsp.readdir(modesDir);
     for (const entry of entries) {
       if (!entry.endsWith(".md") && !entry.endsWith(".txt")) continue;
-      const filePath = path16.join(modesDir, entry);
+      const filePath = path3.join(modesDir, entry);
       const stat5 = await fsp.stat(filePath);
       if (!stat5.isFile()) continue;
       const content = await fsp.readFile(filePath, "utf8");
-      const id = path16.basename(entry, path16.extname(entry));
+      const id = path3.basename(entry, path3.extname(entry));
       modes.push({
         id,
         name: id.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
@@ -15319,7 +15713,7 @@ async function loadProjectModes(modesDir) {
 async function loadUserModes(modesDir) {
   const modes = [];
   try {
-    const manifestPath = path16.join(modesDir, "modes.json");
+    const manifestPath = path3.join(modesDir, "modes.json");
     const content = await fsp.readFile(manifestPath, "utf8");
     const manifest = JSON.parse(content);
     for (const mode of manifest.modes) {
@@ -15927,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;
@@ -16236,7 +16630,7 @@ var SpecStore = class {
   indexPath;
   constructor(opts) {
     this.baseDir = opts.baseDir;
-    this.indexPath = path16.join(this.baseDir, "_index.json");
+    this.indexPath = path3.join(this.baseDir, "_index.json");
   }
   async save(spec) {
     await ensureDir(this.baseDir);
@@ -16305,7 +16699,7 @@ var SpecStore = class {
     return updated;
   }
   filePath(id) {
-    return path16.join(this.baseDir, `${id}.json`);
+    return path3.join(this.baseDir, `${id}.json`);
   }
   async readIndex() {
     try {
@@ -16362,7 +16756,7 @@ var TaskGraphStore = class {
   indexPath;
   constructor(opts) {
     this.baseDir = opts.baseDir;
-    this.indexPath = path16.join(this.baseDir, "_index.json");
+    this.indexPath = path3.join(this.baseDir, "_index.json");
   }
   async save(graph) {
     await ensureDir(this.baseDir);
@@ -16400,7 +16794,7 @@ var TaskGraphStore = class {
     }
   }
   filePath(id) {
-    return path16.join(this.baseDir, `${id}.json`);
+    return path3.join(this.baseDir, `${id}.json`);
   }
   async readIndex() {
     try {
@@ -16441,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);
@@ -16486,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}`);
     }
   }
@@ -17228,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);
@@ -17236,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 = [];
@@ -17303,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) {
@@ -17328,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;
@@ -17349,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) {
@@ -17818,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;
@@ -17918,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",
@@ -17927,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,
           "",
@@ -17941,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: "",
@@ -17964,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 {