@wrongstack/core 0.267.0 → 0.269.0

package/dist/coordination/index.js

@@ -172,8 +172,8 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat6 = await fsp6.stat(targetPath);
-      mode = stat6.mode & 511;
+      const stat7 = await fsp6.stat(targetPath);
+      mode = stat7.mode & 511;
     } catch {
       mode = opts.mode;
     }
@@ -213,8 +213,8 @@ async function withFileLock(targetPath, fn, opts = {}) {
       }
       if (code !== "EEXIST") throw err;
       try {
-        const stat6 = await fsp6.stat(lockPath);
-        if (Date.now() - stat6.mtimeMs > staleMs) {
+        const stat7 = await fsp6.stat(lockPath);
+        if (Date.now() - stat7.mtimeMs > staleMs) {
           await fsp6.unlink(lockPath);
           continue;
         }
@@ -545,8 +545,8 @@ async function expandGlob(pattern) {
       for (const e of entries) {
         const full = `${dir}${SEP}${e}`;
         try {
-          const stat6 = await fsp6.stat(full);
-          if (stat6.isDirectory()) await walk(full, rest);
+          const stat7 = await fsp6.stat(full);
+          if (stat7.isDirectory()) await walk(full, rest);
         } catch {
         }
       }
@@ -563,8 +563,8 @@ async function expandGlob(pattern) {
       if (entries.includes(seg)) {
         const full = `${dir}${SEP}${seg}`;
         try {
-          const stat6 = await fsp6.stat(full);
-          if (stat6.isDirectory()) await walk(full, rest);
+          const stat7 = await fsp6.stat(full);
+          if (stat7.isDirectory()) await walk(full, rest);
         } catch {
         }
       }
@@ -636,7 +636,7 @@ function hasToolResult(msg) {
 }
 function toolUseIds(msg) {
   const ids = /* @__PURE__ */ new Set();
-  if (!msg || msg.role !== "assistant") return ids;
+  if (msg?.role !== "assistant") return ids;
   for (const block of contentBlocks(msg)) {
     if (block.type === "tool_use") ids.add(block.id);
   }
@@ -644,7 +644,7 @@ function toolUseIds(msg) {
 }
 function toolResultIds(msg) {
   const ids = /* @__PURE__ */ new Set();
-  if (!msg || msg.role !== "user") return ids;
+  if (msg?.role !== "user") return ids;
   for (const block of contentBlocks(msg)) {
     if (block.type === "tool_result") ids.add(block.tool_use_id);
   }
@@ -996,7 +996,7 @@ var CollabSession = class extends EventEmitter {
     }
     for (const filePath of allFiles) {
       try {
-        const [content, stat6] = await Promise.all([
+        const [content, stat7] = await Promise.all([
           fsp6.readFile(filePath, "utf8"),
           fsp6.stat(filePath)
         ]);
@@ -1006,8 +1006,8 @@ var CollabSession = class extends EventEmitter {
           path: filePath,
           content,
           language,
-          snapshotMtimeMs: stat6.mtimeMs,
-          snapshotSizeBytes: stat6.size
+          snapshotMtimeMs: stat7.mtimeMs,
+          snapshotSizeBytes: stat7.size
         });
       } catch {
         this.snapshot.files.push({ path: filePath, content: "", language: void 0 });
@@ -1420,9 +1420,9 @@ Emit each evaluation immediately. Do not wait until you have read all reports.`;
     for (const file of this.snapshot.files) {
       if (file.snapshotMtimeMs === void 0 && file.snapshotSizeBytes === void 0) continue;
       try {
-        const stat6 = await fsp6.stat(file.path);
-        const mtimeChanged = file.snapshotMtimeMs !== void 0 && stat6.mtimeMs > file.snapshotMtimeMs + 1;
-        const sizeChanged = file.snapshotSizeBytes !== void 0 && stat6.size !== file.snapshotSizeBytes;
+        const stat7 = await fsp6.stat(file.path);
+        const mtimeChanged = file.snapshotMtimeMs !== void 0 && stat7.mtimeMs > file.snapshotMtimeMs + 1;
+        const sizeChanged = file.snapshotSizeBytes !== void 0 && stat7.size !== file.snapshotSizeBytes;
         if (mtimeChanged || sizeChanged) {
           warnings.push(`${file.path} changed after the collab snapshot was captured.`);
         }
@@ -3765,7 +3765,27 @@ Working rules:
       id: "devops",
       name: "DevOps",
       role: "devops",
-      tools: [...TOOLS.build],
+      tools: [
+        ...TOOLS.build,
+        "mcp__ssh__ssh_list_servers",
+        "mcp__ssh__ssh_connection_status",
+        "mcp__ssh__ssh_execute",
+        "mcp__ssh__ssh_execute_sudo",
+        "mcp__ssh__ssh_upload",
+        "mcp__ssh__ssh_download",
+        "mcp__ssh__ssh_sync",
+        "mcp__ssh__ssh_deploy",
+        "mcp__ssh__ssh_health_check",
+        "mcp__ssh__ssh_service_status",
+        "mcp__ssh__ssh_process_manager",
+        "mcp__ssh__ssh_tunnel",
+        "mcp__ssh__ssh_backup_create",
+        "mcp__ssh__ssh_backup_list",
+        "mcp__ssh__ssh_backup_restore",
+        "mcp__ssh__ssh_db_list",
+        "mcp__ssh__ssh_db_query",
+        "mcp__ssh__ssh_profile"
+      ],
       prompt: `You are the DevOps agent. Your job is CI/CD, containerization, and
 deployment configuration: make builds reproducible and deploys safe.
 
@@ -3774,6 +3794,7 @@ Scope:
 - Write Dockerfiles/compose and optimize image size and layer caching
 - Configure deployment (env, secrets handling, health checks, rollback)
 - Diagnose flaky/broken pipelines
+- Use optional SSH MCP tools for remote hosts when the 'ssh' MCP server is enabled: list servers, run health checks, inspect services, transfer/deploy files, and open tunnels
 
 Input format you accept:
 { "task": "ci | container | deploy | fix-pipeline", "platform": "github-actions | gitlab | docker | k8s", "target": "<what>" }
@@ -3788,7 +3809,8 @@ Working rules:
 - Never hardcode secrets in config; reference the secret store
 - Pin versions for reproducible builds; avoid floating :latest
 - Every deploy path needs a rollback and a health check
-- Treat CI/CD changes as high-risk \u2014 explain blast radius before applying`
+- Treat CI/CD changes as high-risk \u2014 explain blast radius before applying
+- For remote SSH work, start with ssh_list_servers / ssh_connection_status, prefer read-only checks first, and do not run destructive commands without explicit user approval`
     },
     budget: MEDIUM_BUDGET,
     capability: {
@@ -3805,6 +3827,13 @@ Working rules:
         "kubernetes",
         "k8s",
         "deploy",
+        "ssh",
+        "remote ssh",
+        "remote server",
+        "sftp",
+        "tunnel",
+        "bastion",
+        "jump host",
         "github actions",
         "container"
       ]
@@ -5403,7 +5432,7 @@ var SubagentBudget = class _SubagentBudget {
    */
   _busRequestDecision(entry) {
     const bus = this._events;
-    if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
+    if (!bus?.hasListenerFor("budget.threshold_reached")) {
       return Promise.resolve("stop");
     }
     return new Promise((resolve3) => {
@@ -6800,6 +6829,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
         subagentId: result.subagentId,
         taskId: result.taskId,
         status: result.status,
+        result: result.result,
         iterations: result.iterations,
         toolCalls: result.toolCalls,
         durationMs: result.durationMs
@@ -8733,6 +8763,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
    * processes. When the limit is reached, the oldest entry is evicted.
    */
   _loadCache = /* @__PURE__ */ new Map();
+  _indexCache = null;
   static LOAD_CACHE_MAX_ENTRIES = 50;
   constructor(opts) {
     this.dir = opts.dir;
@@ -8894,16 +8925,13 @@ var DefaultSessionStore = class _DefaultSessionStore {
     let errorMsg;
     let cacheHit = false;
     try {
-      let stat6;
-      try {
-        const s = await fsp6.stat(file);
-        stat6 = { mtimeMs: s.mtimeMs, size: s.size };
-      } catch (err) {
-        throw err;
-      }
+      const s = await fsp6.stat(file);
+      const stat7 = { mtimeMs: s.mtimeMs, size: s.size };
       const cached = this._loadCache.get(id);
-      if (cached && cached.mtimeMs === stat6.mtimeMs && cached.size === stat6.size) {
+      if (cached && cached.mtimeMs === stat7.mtimeMs && cached.size === stat7.size) {
         cacheHit = true;
+        this._loadCache.delete(id);
+        this._loadCache.set(id, cached);
         return cached.data;
       }
       const raw = await fsp6.readFile(file, "utf8");
@@ -8928,7 +8956,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
           this._loadCache.delete(oldest);
         }
       }
-      this._loadCache.set(id, { mtimeMs: stat6.mtimeMs, size: stat6.size, data });
+      this._loadCache.set(id, { mtimeMs: stat7.mtimeMs, size: stat7.size, data });
       return data;
     } catch (err) {
       outcome = "failure";
@@ -8989,6 +9017,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       await ensureDir(this.dir);
       const line = JSON.stringify(summary) + "\n";
       await fsp6.appendFile(this.indexFile, line, "utf8");
+      this._indexCache = null;
       this.indexAppendCount++;
       if (this.indexAppendCount >= _DefaultSessionStore.COMPACT_EVERY) {
         await this.compactIndex();
@@ -9003,6 +9032,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       await ensureDir(this.dir);
       const line = JSON.stringify({ action: "delete", id }) + "\n";
       await fsp6.appendFile(this.indexFile, line, "utf8");
+      this._indexCache = null;
       this.indexAppendCount++;
     } catch {
     }
@@ -9022,6 +9052,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       const lines = entries.map((s) => JSON.stringify(s)).join("\n") + "\n";
       await fsp6.writeFile(tmp, lines, "utf8");
       await fsp6.rename(tmp, this.indexFile);
+      this._indexCache = null;
     } catch (err) {
       outcome = "failure";
       errorMsg = toErrorMessage(err);
@@ -9035,10 +9066,22 @@ var DefaultSessionStore = class _DefaultSessionStore {
    * Returns empty array when the index doesn't exist or is corrupt.
    */
   async readIndex() {
+    let stat7;
+    try {
+      const s = await fsp6.stat(this.indexFile);
+      stat7 = { mtimeMs: s.mtimeMs, size: s.size };
+    } catch {
+      this._indexCache = null;
+      return [];
+    }
+    if (this._indexCache !== null && this._indexCache.mtimeMs === stat7.mtimeMs && this._indexCache.size === stat7.size) {
+      return [...this._indexCache.summaries];
+    }
     let raw;
     try {
       raw = await fsp6.readFile(this.indexFile, "utf8");
     } catch {
+      this._indexCache = null;
       return [];
     }
     const deleted = /* @__PURE__ */ new Set();
@@ -9058,7 +9101,9 @@ var DefaultSessionStore = class _DefaultSessionStore {
       } catch {
       }
     }
-    return Array.from(seen.values());
+    const summaries = Array.from(seen.values());
+    this._indexCache = { ...stat7, summaries };
+    return [...summaries];
   }
   /**
    * Rebuild the index from disk by scanning all sessions and writing a
@@ -9072,6 +9117,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const lines = valid.map((s) => JSON.stringify(s)).join("\n") + "\n";
     await fsp6.writeFile(tmp, lines, "utf8");
     await fsp6.rename(tmp, this.indexFile);
+    this._indexCache = null;
     return valid.length;
   }
   /** Recursively collect session IDs from date-shard subdirectories.
@@ -9112,8 +9158,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
       return JSON.parse(raw);
     } catch {
       const full = this.sessionPath(id, ".jsonl");
-      const stat6 = await fsp6.stat(full);
-      const summary = await this.summarize(id, stat6.mtime.toISOString());
+      const stat7 = await fsp6.stat(full);
+      const summary = await this.summarize(id, stat7.mtime.toISOString());
       await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
         const msg = toErrorMessage(err);
         this.emitError(id, manifest, "summary_fallback", msg, true);
@@ -9195,8 +9241,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const pruneFile = async (dir, name, prefix) => {
       const jsonlPath = path5.join(dir, name);
       try {
-        const stat6 = await fsp6.stat(jsonlPath);
-        if (stat6.mtimeMs >= cutoff) return;
+        const stat7 = await fsp6.stat(jsonlPath);
+        if (stat7.mtimeMs >= cutoff) return;
       } catch {
         return;
       }
@@ -9771,6 +9817,12 @@ var FileSessionWriter = class _FileSessionWriter {
       files
     });
   }
+  /**
+   * Truncate the session file to the checkpoint with the given promptIndex,
+   * removing all events that follow it. Uses a single-pass byte-offset scan
+   * so post-checkpoint content is never read or parsed — O(1) memory instead
+   * of O(N) JSON.parse calls over the full file.
+   */
   async truncateToCheckpoint(targetPromptIndex) {
     if (!this.filePath) return 0;
     if (this.flushTimer) {
@@ -9779,51 +9831,118 @@ var FileSessionWriter = class _FileSessionWriter {
     }
     await this.flushBuffer();
     await this.writeChain;
-    const raw = await fsp6.readFile(this.filePath, "utf8");
-    const lines = raw.split("\n");
-    const kept = [];
+    const CHUNK_SIZE = 65536;
+    let fd;
+    let fileOffset = 0;
+    let lineStartOffset = 0;
+    let checkpointByteOffset = -1;
     let removedCount = 0;
-    let targetCheckpointLine = -1;
-    let afterTarget = false;
-    for (let i = 0; i < lines.length; i++) {
-      const line = expectDefined(lines[i]);
-      if (!line.trim()) continue;
-      let event;
-      try {
-        event = JSON.parse(line);
-      } catch {
-        kept.push(line);
-        continue;
-      }
-      if (event.type === "checkpoint") {
-        if (event.promptIndex === targetPromptIndex) {
-          targetCheckpointLine = kept.length;
-          afterTarget = true;
-        } else if (event.promptIndex > targetPromptIndex) {
-          afterTarget = true;
+    let targetCheckpointSeen = false;
+    try {
+      fd = await fsp6.open(this.filePath, "r", 384);
+      while (true) {
+        const buf = Buffer.alloc(CHUNK_SIZE);
+        const { bytesRead } = await fd.read(buf, 0, CHUNK_SIZE, fileOffset);
+        if (bytesRead === 0) break;
+        let chunkPos = 0;
+        while (chunkPos < bytesRead) {
+          const idx = buf.indexOf("\n", chunkPos);
+          if (idx === -1) {
+            lineStartOffset = fileOffset + chunkPos;
+            break;
+          }
+          if (checkpointByteOffset !== -1) {
+            removedCount++;
+          } else {
+            const lineBytes = buf.subarray(chunkPos, idx);
+            const line = new TextDecoder("utf-8", { fatal: false }).decode(lineBytes);
+            if (line.trim()) {
+              try {
+                const event = JSON.parse(line);
+                if (event.type === "checkpoint") {
+                  if (event.promptIndex === targetPromptIndex) {
+                    checkpointByteOffset = lineStartOffset;
+                    targetCheckpointSeen = true;
+                  } else if (event.promptIndex !== void 0 && event.promptIndex > targetPromptIndex) {
+                    checkpointByteOffset = lineStartOffset;
+                  }
+                } else if (targetCheckpointSeen && event.promptIndex !== void 0 && event.promptIndex > targetPromptIndex) {
+                  removedCount++;
+                } else if (targetCheckpointSeen && event.promptIndex === void 0) {
+                  removedCount++;
+                } else if (!targetCheckpointSeen && event.promptIndex === void 0) {
+                  removedCount++;
+                } else if (!targetCheckpointSeen && event.promptIndex !== void 0 && event.promptIndex > targetPromptIndex) {
+                  removedCount++;
+                }
+              } catch {
+              }
+            }
+          }
+          chunkPos = idx + 1;
+          lineStartOffset = fileOffset + chunkPos;
         }
-      }
-      if (event.promptIndex !== void 0 && event.promptIndex > targetPromptIndex) {
-        removedCount++;
-      } else if (event.promptIndex === void 0) {
-        if (!afterTarget || targetCheckpointLine === -1) {
-          kept.push(line);
-        } else {
-          removedCount++;
+        fileOffset += bytesRead;
+        if (chunkPos >= bytesRead) {
+          lineStartOffset = fileOffset;
         }
-      } else {
-        kept.push(line);
       }
+    } finally {
+      await fd?.close();
     }
-    const truncated = kept.join("\n");
+    if (checkpointByteOffset === -1) return 0;
+    await this.writeChain;
+    await this.handle.close();
     const tmpPath = `${this.filePath}.rewind.tmp`;
-    await fsp6.writeFile(tmpPath, truncated + "\n", "utf8");
+    const src = await fsp6.open(this.filePath, "r", 384);
     try {
-      await this.handle.close();
+      const statResult = await src.stat();
+      const totalSize = statResult.size;
+      const prefixBytes = checkpointByteOffset;
+      let newlineAfterCheckpoint = prefixBytes;
+      if (prefixBytes < totalSize) {
+        const probeBuf = Buffer.alloc(Math.min(CHUNK_SIZE, totalSize - prefixBytes));
+        const { bytesRead: probeRead } = await src.read(probeBuf, 0, probeBuf.length, prefixBytes);
+        if (probeRead > 0) {
+          const nl = probeBuf.indexOf("\n");
+          newlineAfterCheckpoint = nl !== -1 ? prefixBytes + nl + 1 : totalSize;
+        }
+      } else {
+        newlineAfterCheckpoint = totalSize;
+      }
+      const writeFd = await fsp6.open(tmpPath, "w", 384);
+      try {
+        let copied = 0;
+        let readOffset = 0;
+        while (readOffset < newlineAfterCheckpoint) {
+          const toCopy = Math.min(CHUNK_SIZE, newlineAfterCheckpoint - readOffset);
+          const copyBuf = Buffer.alloc(toCopy);
+          const { bytesRead: r } = await src.read(copyBuf, 0, toCopy, readOffset);
+          if (r === 0) break;
+          await writeFd.write(copyBuf, 0, r);
+          readOffset += r;
+          copied += r;
+        }
+        const raw = await fsp6.readFile(this.filePath);
+        const tail = raw.subarray(newlineAfterCheckpoint).toString("utf8");
+        for (const line of tail.split("\n")) {
+          if (!line.trim()) continue;
+          try {
+            JSON.parse(line);
+          } catch {
+            await writeFd.write(`${line}
+`, void 0, "utf8");
+          }
+        }
+      } finally {
+        await writeFd.close();
+      }
+      await src.close();
       await fsp6.rename(tmpPath, this.filePath);
       this.handle = await fsp6.open(this.filePath, "a", 384);
     } catch (err) {
       await fsp6.unlink(tmpPath).catch(() => void 0);
+      this.handle = await fsp6.open(this.filePath, "a", 384).catch(() => this.handle);
       throw err;
     }
     await this.append({
@@ -10362,8 +10481,12 @@ function normalizeRecipient(to) {
 // src/coordination/mailbox.ts
 var MAILBOX_FILE = "_mailbox.jsonl";
 var LINE_SEPARATOR = "\n";
+var MESSAGE_CACHE_MAX_ENTRIES = 1e4;
 var DefaultMailbox = class {
   filePath;
+  _messageCache = null;
+  _messageCacheMtime = -1;
+  _messageCacheSize = -1;
   constructor(sessionDir) {
     this.filePath = path5.join(sessionDir, MAILBOX_FILE);
   }
@@ -10393,37 +10516,26 @@ var DefaultMailbox = class {
     await fsp6.mkdir(path5.dirname(this.filePath), { recursive: true });
     await withFileLock(this.filePath, async () => {
       await fsp6.appendFile(this.filePath, line, "utf8");
+      this._pushToCache(msg);
     });
     return msg;
   }
   // ── Query ─────────────────────────────────────────────────────────────
   async query(q) {
-    const all = await this._readAll();
+    const all = await this._readAllCached();
     const limit = q.limit ?? 50;
-    let filtered = all;
-    if (q.to !== void 0) {
-      filtered = filtered.filter((m) => m.to === q.to || m.to === "*");
-    }
-    if (q.from !== void 0) {
-      filtered = filtered.filter((m) => m.from === q.from);
-    }
-    if (q.unreadBy !== void 0) {
-      filtered = filtered.filter((m) => !(q.unreadBy in m.readBy));
-    }
-    if (q.incompleteOnly) {
-      filtered = filtered.filter((m) => !m.completed);
-    }
-    if (q.type !== void 0) {
-      filtered = filtered.filter((m) => m.type === q.type);
-    }
-    if (q.minPriority !== void 0) {
-      const order = { low: 0, normal: 1, high: 2 };
-      const min = order[q.minPriority];
-      filtered = filtered.filter((m) => (order[m.priority] ?? 1) >= min);
-    }
-    if (q.since !== void 0) {
-      const since = q.since;
-      filtered = filtered.filter((m) => m.timestamp > since);
+    const order = q.minPriority !== void 0 ? { low: 0, normal: 1, high: 2 } : null;
+    const minPriorityRank = order && q.minPriority !== void 0 ? order[q.minPriority] : 0;
+    const filtered = [];
+    for (const msg of all) {
+      if (q.to !== void 0 && msg.to !== q.to && msg.to !== "*") continue;
+      if (q.from !== void 0 && msg.from !== q.from) continue;
+      if (q.unreadBy !== void 0 && q.unreadBy in msg.readBy) continue;
+      if (q.incompleteOnly && msg.completed) continue;
+      if (q.type !== void 0 && msg.type !== q.type) continue;
+      if (order !== null && (order[msg.priority] ?? 1) < minPriorityRank) continue;
+      if (q.since !== void 0 && msg.timestamp <= q.since) continue;
+      filtered.push(msg);
     }
     filtered.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
     return filtered.slice(0, limit);
@@ -10465,12 +10577,13 @@ var DefaultMailbox = class {
         const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
         await fsp6.writeFile(this.filePath, serialized, "utf8");
       }
+      this._setMessageCache(all);
     });
     return updated;
   }
   // ── Agent statuses ────────────────────────────────────────────────────
   async getAgentStatuses() {
-    const all = await this._readAll();
+    const all = await this._readAllCached();
     const latest = /* @__PURE__ */ new Map();
     for (const m of all) {
       if (m.type !== "status") continue;
@@ -10506,16 +10619,20 @@ var DefaultMailbox = class {
   async heartbeat(_input) {
   }
   async unreadCount(forAgentId) {
-    const all = await this._readAll();
+    const all = await this._readAllCached();
     return all.filter(
       (m) => (m.to === forAgentId || m.to === "*") && !(forAgentId in m.readBy) && !m.completed
     ).length;
   }
   async close() {
+    this._messageCache = null;
+    this._messageCacheMtime = -1;
+    this._messageCacheSize = -1;
   }
   async clearAll() {
     await withFileLock(this.filePath, async () => {
       await fsp6.writeFile(this.filePath, "", "utf8");
+      this._setMessageCache([]);
     });
   }
   async purgeStale(opts) {
@@ -10523,13 +10640,14 @@ var DefaultMailbox = class {
     const INCOMPLETE_MAX_AGE_MS = opts?.incompleteMaxAgeMs ?? 6048e5;
     let completedPurged = 0;
     let incompletePurged = 0;
+    let remaining = 0;
     await withFileLock(this.filePath, async () => {
-      const all2 = await this._readAll();
+      const all = await this._readAll();
       const now = Date.now();
       const cutoffCompleted = now - COMPLETED_MAX_AGE_MS;
       const cutoffIncomplete = now - INCOMPLETE_MAX_AGE_MS;
       const kept = [];
-      for (const msg of all2) {
+      for (const msg of all) {
         const msgTime = new Date(msg.timestamp).getTime();
         const completedTime = msg.completedAt ? new Date(msg.completedAt).getTime() : 0;
         if (msg.completed && completedTime < cutoffCompleted) {
@@ -10542,17 +10660,18 @@ var DefaultMailbox = class {
         }
         kept.push(msg);
       }
-      if (kept.length < all2.length) {
+      remaining = kept.length;
+      if (kept.length < all.length) {
         const content = kept.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
         await fsp6.writeFile(this.filePath, content, "utf8");
       }
+      this._setMessageCache(kept);
     });
-    const all = await this._readAll();
     return {
       completedPurged,
       incompletePurged,
       totalPurged: completedPurged + incompletePurged,
-      remaining: all.length
+      remaining
     };
   }
   // ── Client registry stubs (not applicable per-session) ─────────────────
@@ -10591,6 +10710,52 @@ var DefaultMailbox = class {
       throw err;
     }
   }
+  async _readAllCached() {
+    try {
+      const st = await fsp6.stat(this.filePath);
+      if (this._messageCache !== null && this._messageCacheMtime === st.mtimeMs && this._messageCacheSize === st.size) {
+        return this._messageCache;
+      }
+      const all = await this._readAll();
+      this._setMessageCache(all, st.mtimeMs, st.size);
+      return all;
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        this._setMessageCache([], -1, -1);
+        return [];
+      }
+      throw err;
+    }
+  }
+  _setMessageCache(messages, mtime, size) {
+    if (messages.length > MESSAGE_CACHE_MAX_ENTRIES) {
+      this._messageCache = null;
+      this._messageCacheMtime = -1;
+      this._messageCacheSize = -1;
+      return;
+    }
+    this._messageCache = messages;
+    if (mtime !== void 0 && size !== void 0) {
+      this._messageCacheMtime = mtime;
+      this._messageCacheSize = size;
+      return;
+    }
+    void fsp6.stat(this.filePath).then((st) => {
+      this._messageCacheMtime = st.mtimeMs;
+      this._messageCacheSize = st.size;
+    }).catch(() => {
+    });
+  }
+  _pushToCache(msg) {
+    if (this._messageCache === null) return;
+    if (this._messageCache.length >= MESSAGE_CACHE_MAX_ENTRIES) {
+      this._messageCache = null;
+      this._messageCacheMtime = -1;
+      this._messageCacheSize = -1;
+      return;
+    }
+    this._messageCache.push(msg);
+  }
 };
 var BrainMonitor = class {
   constructor(opts) {
@@ -10731,7 +10896,7 @@ var CLIENT_STALE_MS = 6e4;
 var HEARTBEAT_THROTTLE_MS = 5e3;
 var REGISTRY_CACHE_TTL_MS = 2e3;
 var LINE_SEPARATOR2 = "\n";
-var MESSAGE_CACHE_MAX_ENTRIES = 1e4;
+var MESSAGE_CACHE_MAX_ENTRIES2 = 1e4;
 function resolveProjectDir(projectRoot, globalRoot) {
   return path5.join(globalRoot, "projects", projectSlug(projectRoot));
 }
@@ -10744,6 +10909,8 @@ var GlobalMailbox = class {
   clientRegistryPath;
   /** Optional event bus for emitting agent registration/heartbeat events. */
   _events;
+  /** Optional HQ publisher for cross-project command-center telemetry. */
+  _hqPublisher;
   /**
    * Local cache of the agent registry to avoid re-reading on every call.
    * Time-bounded: the registry file is shared ACROSS PROCESSES (that's the
@@ -10781,12 +10948,28 @@ var GlobalMailbox = class {
   /**
    * @param projectDir — `~/.wrongstack/projects/<slug>/`
    * @param events — optional EventBus for real-time TUI/WebUI notifications
+   * @param hqPublisher — optional HQ publisher for cross-project telemetry
    */
-  constructor(projectDir, events) {
+  constructor(projectDir, events, hqPublisher) {
     this.messagePath = path5.join(projectDir, MAILBOX_FILE2);
     this.registryPath = path5.join(projectDir, "_mailbox.registry.json");
     this.clientRegistryPath = path5.join(projectDir, CLIENT_REGISTRY_FILE);
     this._events = events;
+    this._hqPublisher = hqPublisher;
+  }
+  get hqMailboxId() {
+    return `${path5.basename(path5.dirname(this.messagePath))}:mailbox`;
+  }
+  publishHqMailboxEvent(input) {
+    try {
+      this._hqPublisher?.publishMailboxEvent(input);
+    } catch {
+    }
+  }
+  publishHqMailboxSnapshot() {
+    if (this._hqPublisher === void 0) return;
+    void this._hqPublisher.publishMailboxSnapshot(this, { mailboxId: this.hqMailboxId }).catch(() => {
+    });
   }
   // ── Messages ────────────────────────────────────────────────────────────
   async send(input) {
@@ -10813,6 +10996,8 @@ var GlobalMailbox = class {
       await fsp6.appendFile(this.messagePath, line, "utf8");
       this._pushToCache(msg);
     });
+    this.publishHqMailboxEvent({ mailboxId: this.hqMailboxId, action: "message.sent", message: msg });
+    this.publishHqMailboxSnapshot();
     return msg;
   }
   async query(q) {
@@ -10879,6 +11064,14 @@ var GlobalMailbox = class {
       cacheSnapshot = all;
     });
     if (cacheSnapshot) this._setMessageCache(cacheSnapshot);
+    for (const message of updated) {
+      this.publishHqMailboxEvent({
+        mailboxId: this.hqMailboxId,
+        action: message.completed ? "message.completed" : "message.read",
+        message
+      });
+    }
+    if (updated.length > 0) this.publishHqMailboxSnapshot();
     return updated;
   }
   async unreadCount(forAgentId) {
@@ -10926,6 +11119,25 @@ var GlobalMailbox = class {
       role: input.role,
       source: input.source
     });
+    this.publishHqMailboxEvent({
+      mailboxId: this.hqMailboxId,
+      action: "agent.registered",
+      agent: {
+        agentId: input.agentId,
+        name: input.name,
+        ...input.role !== void 0 ? { role: input.role } : {},
+        sessionId: input.sessionId,
+        status: "idle",
+        iterations: 0,
+        toolCalls: 0,
+        lastActivityAt: now,
+        lastSeenAt: now,
+        online: true,
+        pid: input.pid,
+        ...input.source !== void 0 ? { source: input.source } : {}
+      }
+    });
+    this.publishHqMailboxSnapshot();
   }
   async heartbeat(input) {
     const last = this._lastHeartbeat.get(input.agentId) ?? 0;
@@ -10956,6 +11168,12 @@ var GlobalMailbox = class {
       currentTool: input.currentTool,
       currentTask: input.currentTask
     });
+    this.publishHqMailboxEvent({
+      mailboxId: this.hqMailboxId,
+      action: "agent.heartbeat",
+      summary: input.agentId
+    });
+    this.publishHqMailboxSnapshot();
   }
   async getAgentStatuses() {
     await this._ensureRegistry();
@@ -11010,6 +11228,7 @@ var GlobalMailbox = class {
       name: input.name,
       source: input.source
     });
+    this.publishHqMailboxSnapshot();
   }
   async clientHeartbeat(input) {
     const last = this._lastClientHeartbeat.get(input.clientId) ?? 0;
@@ -11031,6 +11250,7 @@ var GlobalMailbox = class {
     this._events?.emitCustom("mailbox.client_heartbeat", {
       clientId: input.clientId
     });
+    this.publishHqMailboxSnapshot();
   }
   async getClientStatuses() {
     await this._ensureClientRegistry();
@@ -11177,7 +11397,7 @@ var GlobalMailbox = class {
    * read or wrote it under the file lock).
    */
   _setMessageCache(messages, mtime, size) {
-    if (messages.length > MESSAGE_CACHE_MAX_ENTRIES) {
+    if (messages.length > MESSAGE_CACHE_MAX_ENTRIES2) {
       this._messageCache = null;
       this._messageCacheMtime = -1;
       this._messageCacheSize = -1;
@@ -11203,7 +11423,7 @@ var GlobalMailbox = class {
    */
   _pushToCache(msg) {
     if (this._messageCache === null) return;
-    if (this._messageCache.length >= MESSAGE_CACHE_MAX_ENTRIES) {
+    if (this._messageCache.length >= MESSAGE_CACHE_MAX_ENTRIES2) {
       this._messageCache = null;
       this._messageCacheMtime = -1;
       this._messageCacheSize = -1;
@@ -11252,7 +11472,7 @@ var GlobalMailbox = class {
       obj[id] = agent;
     }
     const tmp = `${this.registryPath}.${randomUUID().slice(0, 8)}.tmp`;
-    await fsp6.writeFile(tmp, JSON.stringify(obj, null, 2), "utf8");
+    await fsp6.writeFile(tmp, JSON.stringify(obj), "utf8");
     await fsp6.rename(tmp, this.registryPath);
   }
   // ── Client registry internals ───────────────────────────────────────────
@@ -11297,7 +11517,7 @@ var GlobalMailbox = class {
       obj[id] = client;
     }
     const tmp = `${this.clientRegistryPath}.${randomUUID().slice(0, 8)}.tmp`;
-    await fsp6.writeFile(tmp, JSON.stringify(obj, null, 2), "utf8");
+    await fsp6.writeFile(tmp, JSON.stringify(obj), "utf8");
     await fsp6.rename(tmp, this.clientRegistryPath);
   }
 };
@@ -11768,13 +11988,13 @@ function makeDependencyWatcherConfig(opts) {
   const globPatterns = patterns.filter((p) => p.includes("*"));
   const plainPatterns = patterns.filter((p) => !p.includes("*"));
   function matchesPattern(filePath) {
-    const basename5 = filePath.split("/").pop()?.split("\\").pop() ?? "";
-    if (plainPatterns.includes(basename5)) return true;
+    const basename6 = filePath.split("/").pop()?.split("\\").pop() ?? "";
+    if (plainPatterns.includes(basename6)) return true;
     for (const gp of globPatterns) {
       const regex = new RegExp(
         "^" + gp.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$"
       );
-      if (regex.test(basename5)) return true;
+      if (regex.test(basename6)) return true;
     }
     return false;
   }
@@ -12490,7 +12710,7 @@ var TaskDAG = class {
     }
     for (const depId of node.dependents) {
       const dep = this.nodes.get(depId);
-      if (dep && dep.deps.every((d) => !this.nodes.has(d) || this.nodes.get(d).status === "done")) {
+      if (dep?.deps.every((d) => !this.nodes.has(d) || this.nodes.get(d).status === "done")) {
         this._transition(depId, "pending", "ready");
       }
     }
@@ -12750,12 +12970,12 @@ var ConsensusProtocol = class {
    * Initiate a vote on a proposed change. Updates the change node's status
    * to 'proposed' and notifies eligible voters via FleetBus.
    */
-  initiateVote(changeId) {
+  async initiateVote(changeId) {
     const change = this.graph.get(changeId);
-    if (!change || change.type !== "change") {
+    if (change?.type !== "change") {
       throw new Error(`ConsensusProtocol: no change found with id "${changeId}"`);
     }
-    this.graph.update(changeId, { status: "proposed", votes: [] });
+    await this.graph.update(changeId, { status: "proposed", votes: [] });
     const eligible = this._eligibleVoters(change);
     this._notifyVoters(change, eligible, "vote_initiated");
   }
@@ -12763,9 +12983,9 @@ var ConsensusProtocol = class {
    * Cast a vote. Updates the change node in the graph and re-evaluates
    * consensus. If the vote triggers a resolution, updates the change status.
    */
-  castVote(changeId, voterId, value, rationale) {
+  async castVote(changeId, voterId, value, rationale) {
     const change = this.graph.get(changeId);
-    if (!change || change.type !== "change") {
+    if (change?.type !== "change") {
       throw new Error(`ConsensusProtocol: no change found for "${changeId}"`);
     }
     const voter = this.voters.get(voterId);
@@ -12786,7 +13006,7 @@ var ConsensusProtocol = class {
     const existingIdx = change.votes.findIndex((v) => v.agentId === voterId);
     const newVotes = existingIdx >= 0 ? change.votes.with(existingIdx, vote) : [...change.votes, vote];
     const result = this._resolve(changeId, newVotes, eligible);
-    this.graph.update(changeId, {
+    await this.graph.update(changeId, {
       votes: newVotes,
       ...result.outcome !== "pending" ? { status: this._toChangeStatus(result.outcome) } : {}
     });
@@ -12797,13 +13017,13 @@ var ConsensusProtocol = class {
    * Resolve the current vote without waiting for all eligible voters.
    * Useful when a timeout fires or an agent decides to finalize early.
    */
-  resolveNow(changeId) {
+  async resolveNow(changeId) {
     const change = this.graph.get(changeId);
     if (!change) throw new Error(`ConsensusProtocol: unknown change "${changeId}"`);
     const eligible = this._eligibleVoters(change);
     const result = this._resolve(changeId, change.votes, eligible);
     if (result.outcome !== "pending") {
-      this.graph.update(changeId, { status: this._toChangeStatus(result.outcome) });
+      await this.graph.update(changeId, { status: this._toChangeStatus(result.outcome) });
       this._notifyVoters(change, eligible, "vote_resolved", { result });
     }
     return result;
@@ -12819,7 +13039,7 @@ var ConsensusProtocol = class {
    */
   getStatus(changeId) {
     const change = this.graph.get(changeId);
-    if (!change || change.type !== "change") return null;
+    if (change?.type !== "change") return null;
     const eligible = this._eligibleVoters(change);
     return this._resolve(changeId, change.votes, eligible);
   }
@@ -13022,7 +13242,7 @@ var ChangeManager = class {
    */
   async submitForReview(changeId) {
     const change = this.graph.get(changeId);
-    if (!change || change.type !== "change") {
+    if (change?.type !== "change") {
       throw new Error(`ChangeManager: no change found "${changeId}"`);
     }
     if (change.status !== "proposed") {
@@ -13084,7 +13304,7 @@ var ChangeManager = class {
    */
   async proposeRollback(appliedChangeId, reason) {
     const original = this.graph.get(appliedChangeId);
-    if (!original || original.type !== "change") return null;
+    if (original?.type !== "change") return null;
     const rollbackFiles = original.files.map((f) => ({
       path: f.path,
       action: f.action === "create" ? "delete" : f.action === "delete" ? "create" : "modify"
@@ -13638,7 +13858,7 @@ var TaskAuctioneer = class {
    */
   async bid(taskId, agent, rationale) {
     const goal = this.graph.get(taskId);
-    if (!goal || goal.type !== "goal") return false;
+    if (goal?.type !== "goal") return false;
     if (goal.status !== "pending") return false;
     const currentCount = this._getAgentTaskCount(agent.agentId);
     if (currentCount >= this.maxTasksPerAgent) return false;
@@ -13687,7 +13907,7 @@ Score: ${score.toFixed(2)}`
    */
   async claim(taskId, agentId, agentName) {
     const goal = this.graph.get(taskId);
-    if (!goal || goal.type !== "goal") return false;
+    if (goal?.type !== "goal") return false;
     if (goal.status !== "pending") return false;
     this._cancelBidWindow(taskId);
     await this.graph.update(taskId, {
@@ -13726,7 +13946,8 @@ Priority: ${goal.priority}`,
     this.agentTaskCount(agentId, -1);
     await this.graph.update(taskId, {
       status: "done",
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ..._result !== void 0 ? { result: _result } : {}
     });
     this.bidRetryCounts.delete(taskId);
     this.pendingBids.delete(taskId);
@@ -13971,7 +14192,7 @@ ${goal.description}`,
     this.agentTaskCounts.set(agentId, next);
   }
 };
-var AutonomousCoordinator = class {
+var AutonomousCoordinator = class _AutonomousCoordinator {
   graph;
   dag;
   auction;
@@ -13987,6 +14208,8 @@ var AutonomousCoordinator = class {
   onCoordinatorEvent;
   running = false;
   iterationCount = 0;
+  lastSyncAt = 0;
+  static SYNC_INTERVAL_MS = 5e3;
   /** Tasks already handled by _onSubagentTerminated (to avoid double goal:failed on fleet event). */
   _handledBySubagent = /* @__PURE__ */ new Set();
   /** FleetBus subscription disposers, detached in dispose(). */
@@ -14043,7 +14266,7 @@ var AutonomousCoordinator = class {
       const taskId = payload?.taskId;
       if (!taskId || this._handledBySubagent.has(taskId)) return;
       this._handledBySubagent.add(taskId);
-      this._emit({ type: "goal:failed", goalId: taskId, text: payload?.error ?? "Task failed" });
+      this._recordTaskFailed(taskId, payload?.error ?? "Task failed");
     });
     if (offFailed) this.unsubs.push(offFailed);
     this._emit({ type: "coordinator:mode", mode: this.fleet ? "fleet" : "standalone" });
@@ -14062,6 +14285,7 @@ var AutonomousCoordinator = class {
     const maxCost = opts.maxCostUsd;
     try {
       await this.graph.load();
+      this._rebuildDagFromGraph();
       const goalConfigs = await this._decomposeGoal(goal);
       for (const g of goalConfigs) {
         const goalId = await this.auction.publishTask(g);
@@ -14069,23 +14293,49 @@ var AutonomousCoordinator = class {
         this._emit({ type: "goal:added", goalId, title: g.title, text: g.description });
       }
       while (this.running) {
+        if (this.dag.getRunning().length > 0 && this.auction.getPendingTasks().length === 0) {
+          await this._waitForDagProgress(1e3);
+          continue;
+        }
         this.iterationCount++;
+        await this._maybeSyncFromGraph();
         if (this.iterationCount >= maxIterations) break;
         if (maxCost !== void 0) {
           const cost = this.fleetManager?.snapshot()?.total?.cost ?? 0;
           if (cost >= maxCost) break;
         }
         if (opts.runUntilComplete && this.dag.isDone()) break;
+        const pendingTasks = this.auction.getPendingTasks();
+        const dispatchable = pendingTasks.filter((task) => {
+          const dagNode = this.dag.getNode(task.id);
+          return !dagNode || dagNode.status === "ready";
+        });
+        if (dispatchable.length === 0) {
+          if (this.dag.getRunning().length > 0 || this.dag.getReady().length > 0) {
+            await this._waitForDagProgress(1e3);
+            continue;
+          }
+          if (pendingTasks.length > 0) {
+            await this._waitForDagProgress(2e3);
+            continue;
+          }
+          if (this.dag.hasDeadlock()) {
+            const blocked = this.dag.getBlocked();
+            (this.events?.emit)("autonomous:deadlock", { blocked });
+            this._emit({ type: "deadlock:detected", goalId: blocked[0]?.id ?? "", text: `Deadlock detected: ${blocked.map((n) => n.id).join(", ")}` });
+          }
+          break;
+        }
         const decision = await this.brain.decideAuto({
           id: randomUUID(),
           source: "system",
           decisionType: "prioritize_goals",
-          question: `What should we work on next? Open goals: ${this.auction.getPendingTasks().map((g) => g.title).join(", ") || "none"}`,
+          question: `What should we work on next? Open goals: ${dispatchable.map((g) => g.title).join(", ")}`,
           context: {
-            goals: this.auction.getPendingTasks(),
+            goals: dispatchable,
             fleetStatus: this._fleetStatus()
           },
-          options: this._goalToOptions(this.auction.getPendingTasks()),
+          options: this._goalToOptions(dispatchable),
           risk: "medium",
           requiresConsensus: false
         });
@@ -14132,6 +14382,55 @@ var AutonomousCoordinator = class {
     this.running = false;
     console.error(`[AutonomousCoordinator] stop signal received \u2014 shutting down (iteration ${this.iterationCount})`);
   }
+  /**
+   * Report that a terminal worker (not a Director subagent) completed a claimed
+   * task. This updates the auction, DAG, publishes a task-result fact, and
+   * extracts follow-up goals — the same path as subagent completion.
+   */
+  async reportTaskCompletion(taskId, result) {
+    this._handledBySubagent.add(taskId);
+    await this._completeTask(taskId, result);
+  }
+  /**
+   * Report that a terminal worker failed a claimed task.
+   */
+  async reportTaskFailure(taskId, error) {
+    this._handledBySubagent.add(taskId);
+    await this._failTask(taskId, error);
+  }
+  /**
+   * Reload the KnowledgeGraph from disk and sync the in-memory DAG with any
+   * changes published by other terminal sessions. New goals are added to the
+   * DAG; existing goals whose status changed (e.g. completed by another
+   * terminal) are transitioned accordingly.
+   *
+   * Safe to call at any time — also used internally by the run loop.
+   */
+  async syncFromGraph() {
+    await this.graph.load();
+    this._rebuildDagFromGraph();
+    this._syncDagStatuses();
+  }
+  _syncDagStatuses() {
+    const goals = this.graph.getGoals({});
+    for (const goal of goals) {
+      const dagNode = this.dag.getNode(goal.id);
+      if (!dagNode) continue;
+      if (goal.status === "done" && dagNode.status !== "done" && dagNode.status !== "failed") {
+        this.dag.complete(goal.id, goal.result ?? "Completed by another session");
+      } else if (goal.status === "failed" && dagNode.status !== "failed" && dagNode.status !== "done") {
+        this.dag.fail(goal.id, goal.result ?? "Failed by another session");
+      } else if (goal.status === "in_progress" && (dagNode.status === "ready" || dagNode.status === "pending")) {
+        this.dag.start(goal.id, goal.assignee ?? "another-session");
+      }
+    }
+  }
+  async _maybeSyncFromGraph() {
+    const now = Date.now();
+    if (now - this.lastSyncAt < _AutonomousCoordinator.SYNC_INTERVAL_MS) return;
+    this.lastSyncAt = now;
+    await this.syncFromGraph();
+  }
   /**
    * Tear down the coordinator for good: stop the loop and detach all FleetBus
    * subscriptions (this coordinator's + the auctioneer's) plus any open bid
@@ -14228,6 +14527,65 @@ ${input.detail}`
     return goal;
   }
   // ── Private ───────────────────────────────────────────────────────────
+  _waitForDagProgress(timeoutMs) {
+    const before = this._dagProgressKey();
+    if (this.dag.isDone()) return Promise.resolve();
+    return new Promise((resolve3) => {
+      let off;
+      const timer = setTimeout(() => {
+        off?.();
+        resolve3();
+      }, timeoutMs);
+      off = this.dag.onEvent(() => {
+        if (this._dagProgressKey() === before) return;
+        clearTimeout(timer);
+        off?.();
+        resolve3();
+      });
+    });
+  }
+  _dagProgressKey() {
+    const s = this.dag.stats();
+    return `${s.pending}:${s.ready}:${s.running}:${s.done}:${s.failed}:${s.skipped}`;
+  }
+  _rebuildDagFromGraph() {
+    const goals = this.graph.getGoals({});
+    const knownGoalIds = new Set(goals.map((goal) => goal.id));
+    const added = /* @__PURE__ */ new Set();
+    const remaining = new Map(goals.map((goal) => [goal.id, goal]));
+    while (remaining.size > 0) {
+      let progressed = false;
+      for (const [id, goal] of Array.from(remaining.entries())) {
+        const deps = goal.blockedBy.filter((depId) => knownGoalIds.has(depId));
+        if (!deps.every((depId) => added.has(depId))) continue;
+        this._rebuildDagNode(goal, deps);
+        added.add(id);
+        remaining.delete(id);
+        progressed = true;
+      }
+      if (!progressed) {
+        for (const [id, goal] of Array.from(remaining.entries())) {
+          this._rebuildDagNode(goal, []);
+          added.add(id);
+          remaining.delete(id);
+        }
+      }
+    }
+  }
+  _rebuildDagNode(goal, deps) {
+    this.dag.addNode(goal.id, goal.description, deps, { tags: goal.tags });
+    if (goal.status === "in_progress") {
+      this.dag.start(goal.id, goal.assignee ?? "unknown");
+      return;
+    }
+    if (goal.status === "done") {
+      this.dag.complete(goal.id, goal.result ?? "Persisted completion");
+      return;
+    }
+    if (goal.status === "failed") {
+      this.dag.fail(goal.id, goal.result ?? "Persisted failure");
+    }
+  }
   async _decomposeGoal(goalText) {
     const category = this._inferCategory(goalText);
     const subGoals = [];
@@ -14264,13 +14622,7 @@ ${input.detail}`
     const goalNode = this.graph.get(goalId);
     if (!goalNode) return;
     const title = goalNode.title || dagNode.description;
-    const taskId = await this.auction.publishTask({
-      title,
-      description: goalNode.description,
-      priority: this._dagPriorityToGoal(dagNode.priority),
-      tags: dagNode.tags
-    });
-    this._emit({ type: "task:ready", goalId, taskId, title });
+    this._emit({ type: "task:ready", goalId, taskId: goalId, title });
     if (this.director) {
       const config = {
         name: `worker-${goalId.slice(0, 8)}`,
@@ -14280,7 +14632,7 @@ ${input.detail}`
         // 10 minutes per goal
       };
       const subagentId = await this.director.spawn(config);
-      await this.auction.claim(taskId, subagentId, config.name);
+      await this.auction.claim(goalId, subagentId, config.name);
       await this.director.assign({
         id: goalId,
         subagentId,
@@ -14288,6 +14640,78 @@ ${input.detail}`
       });
     }
   }
+  _stringifyTaskResult(result) {
+    if (typeof result === "string" && result.trim()) return result.trim();
+    if (result === void 0 || result === null) return "Subagent completed successfully";
+    try {
+      return JSON.stringify(result);
+    } catch {
+      return String(result);
+    }
+  }
+  async _completeTask(taskId, result) {
+    await this.auction.complete(taskId, result);
+    if (this.dag.getNode(taskId)) {
+      this.dag.complete(taskId, result);
+    }
+    await this._publishTaskResultFact(taskId, result);
+    await this._createFollowUpGoalsFromResult(taskId, result);
+    this._emit({ type: "task:completed", goalId: taskId, taskId, text: result });
+  }
+  async _publishTaskResultFact(taskId, result) {
+    const key = `task-result:${taskId}`;
+    if (this.graph.getFacts({ category: "quality" }).some((fact2) => fact2.key === key)) return;
+    const goal = this.graph.get(taskId);
+    const subject = goal?.type === "goal" ? `Task completed: ${goal.title}` : `Task completed: ${taskId}`;
+    const fact = await this.graph.add({
+      type: "fact",
+      category: "quality",
+      subject,
+      detail: result,
+      discoveredBy: this.selfAgentId,
+      discoveredAt: (/* @__PURE__ */ new Date()).toISOString(),
+      tags: ["task-result", "autonomous-coordinator"],
+      key,
+      related: [taskId]
+    });
+    this._emit({ type: "knowledge:added", knowledgeId: fact.id, title: subject, text: result });
+  }
+  async _createFollowUpGoalsFromResult(taskId, result) {
+    const followUps = this._extractFollowUps(result);
+    if (followUps.length === 0) return;
+    const existing = this.graph.getGoals({});
+    for (const title of followUps) {
+      if (existing.some((goal2) => goal2.title === title && goal2.tags.includes("follow-up"))) continue;
+      const goal = await this.createGoal({
+        title,
+        description: title,
+        priority: "medium",
+        tags: ["follow-up", "task-result", taskId]
+      });
+      this._emit({ type: "goal:added", goalId: goal.id, title: goal.title, text: goal.description });
+    }
+  }
+  _extractFollowUps(result) {
+    const found = [];
+    for (const line of result.split(/\r?\n/)) {
+      const match = /^\s*(?:[-*]\s*)?(?:NEXT|TODO|FOLLOW-?UP):\s*(.+)$/i.exec(line);
+      const text = match?.[1]?.trim();
+      if (!text || found.includes(text)) continue;
+      found.push(text);
+      if (found.length >= 5) break;
+    }
+    return found;
+  }
+  async _failTask(taskId, error) {
+    await this.auction.fail(taskId, error);
+    this._recordTaskFailed(taskId, error);
+  }
+  _recordTaskFailed(taskId, error) {
+    if (this.dag.getNode(taskId)) {
+      this.dag.fail(taskId, error);
+    }
+    this._emit({ type: "goal:failed", goalId: taskId, text: error });
+  }
   async _handlePendingChange(change) {
     const result = this.consensus.getStatus(change.id);
     if (result?.outcome !== "pending") return;
@@ -14328,16 +14752,15 @@ ${input.detail}`
   _onSubagentTerminated(e) {
     const payload = e.payload;
     const subagentId = payload?.subagentId ?? e.subagentId;
-    const stopReason = payload?.stopReason ?? (payload?.status === "ok" ? "end_turn" : payload?.status ?? "unknown");
-    const tasks = this.auction.getTasksForAgent(subagentId);
+    const rawStatus = payload?.stopReason ?? payload?.status ?? "unknown";
+    const succeeded = rawStatus === "end_turn" || rawStatus === "ok" || rawStatus === "success";
+    const tasks = payload?.taskId ? this.auction.getTasksForAgent(subagentId).filter((task) => task.id === payload.taskId) : this.auction.getTasksForAgent(subagentId);
     for (const task of tasks) {
       this._handledBySubagent.add(task.id);
-      if (stopReason === "end_turn") {
-        void this.auction.complete(task.id, "Subagent completed successfully");
-        this._emit({ type: "task:completed", goalId: task.id, taskId: task.id, text: "Subagent completed successfully" });
+      if (succeeded) {
+        void this._completeTask(task.id, this._stringifyTaskResult(payload?.result));
       } else {
-        void this.auction.fail(task.id, `Subagent terminated: ${stopReason}`);
-        this._emit({ type: "goal:failed", goalId: task.id, text: `Subagent terminated: ${stopReason}` });
+        void this._failTask(task.id, `Subagent terminated: ${rawStatus}`);
       }
     }
   }
@@ -14372,12 +14795,6 @@ ${input.detail}`
   _optionToGoal(optionId) {
     return this.graph.get(optionId);
   }
-  _dagPriorityToGoal(p) {
-    if (p <= 1) return "critical";
-    if (p <= 2) return "high";
-    if (p <= 4) return "medium";
-    return "low";
-  }
   async _mailboxBroadcast(msg) {
     if (!this.mailbox) return;
     try {