@wrongstack/core 0.267.0 → 0.268.0

package/dist/coordination/index.js

@@ -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"
       ]
@@ -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
@@ -8904,6 +8934,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
       const cached = this._loadCache.get(id);
       if (cached && cached.mtimeMs === stat6.mtimeMs && cached.size === stat6.size) {
         cacheHit = true;
+        this._loadCache.delete(id);
+        this._loadCache.set(id, cached);
         return cached.data;
       }
       const raw = await fsp6.readFile(file, "utf8");
@@ -10400,30 +10432,18 @@ var DefaultMailbox = class {
   async query(q) {
     const all = await this._readAll();
     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);
@@ -10744,6 +10764,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 +10803,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 +10851,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 +10919,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 +10974,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 +11023,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();
@@ -11768,13 +11841,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;
   }
@@ -12750,12 +12823,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") {
       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,7 +12836,7 @@ 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") {
       throw new Error(`ConsensusProtocol: no change found for "${changeId}"`);
@@ -12786,7 +12859,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 +12870,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;
@@ -13726,7 +13799,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 +14045,7 @@ ${goal.description}`,
     this.agentTaskCounts.set(agentId, next);
   }
 };
-var AutonomousCoordinator = class {
+var AutonomousCoordinator = class _AutonomousCoordinator {
   graph;
   dag;
   auction;
@@ -13987,6 +14061,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 +14119,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 +14138,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 +14146,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 +14235,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 +14380,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 +14475,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 +14485,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 +14493,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 +14605,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 +14648,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 {