@wrongstack/core 0.265.1 → 0.268.0

package/dist/coordination/index.js

@@ -449,11 +449,6 @@ function safeParse(input, maxBytes = 5e6) {
   }
 }
 
-// src/utils/string.ts
-function truncate(s, max) {
-  return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
-}
-
 // src/utils/expect-defined.ts
 function expectDefined(value, label) {
   if (value === null || value === void 0) {
@@ -463,111 +458,6 @@ function expectDefined(value, label) {
   }
   return value;
 }
-function projectSlug(absRoot) {
-  const base = slugify(path5.basename(absRoot));
-  const hash = createHash("sha256").update(path5.resolve(absRoot)).digest("hex").slice(0, 6);
-  return `${base}-${hash}`;
-}
-function slugify(name) {
-  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "project";
-}
-function wstackGlobalRoot() {
-  const fromEnv = process.env["WRONGSTACK_HOME"];
-  if (fromEnv && fromEnv.trim().length > 0) return path5.resolve(fromEnv);
-  return path5.join(os.homedir(), ".wrongstack");
-}
-
-// src/utils/message-invariants.ts
-function repairToolUseAdjacency(messages) {
-  const removedToolUses = [];
-  const removedToolResults = [];
-  let removedMessages = 0;
-  let changed = false;
-  const out = [];
-  for (let i = 0; i < messages.length; i++) {
-    const original = expectDefined(messages[i]);
-    let msg = original;
-    if (hasToolUse(msg)) {
-      const nextIds = toolResultIds(messages[i + 1]);
-      const filtered = mapContent(msg, (blocks) => {
-        const next = [];
-        for (const block of blocks) {
-          if (block.type === "tool_use" && !nextIds.has(block.id)) {
-            removedToolUses.push(block.id);
-            changed = true;
-            continue;
-          }
-          next.push(block);
-        }
-        return next;
-      });
-      msg = filtered ?? msg;
-    }
-    if (hasToolResult(msg)) {
-      const allowed = toolUseIds(out[out.length - 1]);
-      const filtered = mapContent(msg, (blocks) => {
-        const next = [];
-        for (const block of blocks) {
-          if (block.type === "tool_result" && !allowed.has(block.tool_use_id)) {
-            removedToolResults.push(block.tool_use_id);
-            changed = true;
-            continue;
-          }
-          next.push(block);
-        }
-        return next;
-      });
-      msg = filtered ?? msg;
-    }
-    if (isEmptyMessage(msg)) {
-      removedMessages++;
-      changed = true;
-      continue;
-    }
-    out.push(msg);
-  }
-  return {
-    messages: changed ? out : messages,
-    report: { changed, removedToolUses, removedToolResults, removedMessages }
-  };
-}
-function hasToolUse(msg) {
-  return contentBlocks(msg).some((b) => b.type === "tool_use");
-}
-function hasToolResult(msg) {
-  return contentBlocks(msg).some((b) => b.type === "tool_result");
-}
-function toolUseIds(msg) {
-  const ids = /* @__PURE__ */ new Set();
-  if (!msg || msg.role !== "assistant") return ids;
-  for (const block of contentBlocks(msg)) {
-    if (block.type === "tool_use") ids.add(block.id);
-  }
-  return ids;
-}
-function toolResultIds(msg) {
-  const ids = /* @__PURE__ */ new Set();
-  if (!msg || msg.role !== "user") return ids;
-  for (const block of contentBlocks(msg)) {
-    if (block.type === "tool_result") ids.add(block.tool_use_id);
-  }
-  return ids;
-}
-function contentBlocks(msg) {
-  return msg && Array.isArray(msg.content) ? msg.content : [];
-}
-function mapContent(msg, fn) {
-  if (!Array.isArray(msg.content)) return msg;
-  const next = fn(msg.content);
-  if (next.length === msg.content.length && next.every((b, idx) => b === msg.content[idx])) {
-    return msg;
-  }
-  return { ...msg, content: next };
-}
-function isEmptyMessage(msg) {
-  if (typeof msg.content === "string") return msg.content.trim().length === 0;
-  return msg.content.length === 0;
-}
 var GLOB_CHARS = /* @__PURE__ */ new Set(["*", "?", "["]);
 var IS_WINDOWS = process.platform === "win32";
 var SEP = IS_WINDOWS ? "\\" : "/";
@@ -684,6 +574,116 @@ async function expandGlob(pattern) {
   return [...results];
 }
 
+// src/utils/message-invariants.ts
+function repairToolUseAdjacency(messages) {
+  const removedToolUses = [];
+  const removedToolResults = [];
+  let removedMessages = 0;
+  let changed = false;
+  const out = [];
+  for (let i = 0; i < messages.length; i++) {
+    const original = expectDefined(messages[i]);
+    let msg = original;
+    if (hasToolUse(msg)) {
+      const nextIds = toolResultIds(messages[i + 1]);
+      const filtered = mapContent(msg, (blocks) => {
+        const next = [];
+        for (const block of blocks) {
+          if (block.type === "tool_use" && !nextIds.has(block.id)) {
+            removedToolUses.push(block.id);
+            changed = true;
+            continue;
+          }
+          next.push(block);
+        }
+        return next;
+      });
+      msg = filtered ?? msg;
+    }
+    if (hasToolResult(msg)) {
+      const allowed = toolUseIds(out[out.length - 1]);
+      const filtered = mapContent(msg, (blocks) => {
+        const next = [];
+        for (const block of blocks) {
+          if (block.type === "tool_result" && !allowed.has(block.tool_use_id)) {
+            removedToolResults.push(block.tool_use_id);
+            changed = true;
+            continue;
+          }
+          next.push(block);
+        }
+        return next;
+      });
+      msg = filtered ?? msg;
+    }
+    if (isEmptyMessage(msg)) {
+      removedMessages++;
+      changed = true;
+      continue;
+    }
+    out.push(msg);
+  }
+  return {
+    messages: changed ? out : messages,
+    report: { changed, removedToolUses, removedToolResults, removedMessages }
+  };
+}
+function hasToolUse(msg) {
+  return contentBlocks(msg).some((b) => b.type === "tool_use");
+}
+function hasToolResult(msg) {
+  return contentBlocks(msg).some((b) => b.type === "tool_result");
+}
+function toolUseIds(msg) {
+  const ids = /* @__PURE__ */ new Set();
+  if (!msg || msg.role !== "assistant") return ids;
+  for (const block of contentBlocks(msg)) {
+    if (block.type === "tool_use") ids.add(block.id);
+  }
+  return ids;
+}
+function toolResultIds(msg) {
+  const ids = /* @__PURE__ */ new Set();
+  if (!msg || msg.role !== "user") return ids;
+  for (const block of contentBlocks(msg)) {
+    if (block.type === "tool_result") ids.add(block.tool_use_id);
+  }
+  return ids;
+}
+function contentBlocks(msg) {
+  return msg && Array.isArray(msg.content) ? msg.content : [];
+}
+function mapContent(msg, fn) {
+  if (!Array.isArray(msg.content)) return msg;
+  const next = fn(msg.content);
+  if (next.length === msg.content.length && next.every((b, idx) => b === msg.content[idx])) {
+    return msg;
+  }
+  return { ...msg, content: next };
+}
+function isEmptyMessage(msg) {
+  if (typeof msg.content === "string") return msg.content.trim().length === 0;
+  return msg.content.length === 0;
+}
+
+// src/utils/string.ts
+function truncate(s, max) {
+  return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
+}
+function projectSlug(absRoot) {
+  const base = slugify(path5.basename(absRoot));
+  const hash = createHash("sha256").update(path5.resolve(absRoot)).digest("hex").slice(0, 6);
+  return `${base}-${hash}`;
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "project";
+}
+function wstackGlobalRoot() {
+  const fromEnv = process.env["WRONGSTACK_HOME"];
+  if (fromEnv && fromEnv.trim().length > 0) return path5.resolve(fromEnv);
+  return path5.join(os.homedir(), ".wrongstack");
+}
+
 // src/types/errors.ts
 var ERROR_CODES = {
   // Provider
@@ -1539,6 +1539,24 @@ Working rules:
 var DEFAULT_SUBAGENT_BASELINE = `You are a subagent operating under a Director. You were spawned to handle
 a specific slice of a larger plan \u2014 do that slice well and report back.
 
+Capabilities & operating rules:
+  - You have full developer tools for your task: read, write/edit, search,
+    shell + build (lint, format, typecheck, test), and dependency install.
+    Use them directly to finish the task end-to-end. You run non-interactively
+    \u2014 there is no human to approve individual tool calls, so routine work is
+    pre-authorized; do not stop to ask for permission to read, edit, or build.
+  - Stay inside the project root. Do not write files outside the repository,
+    and do not touch machine config, credentials, or global state \u2014 those
+    require an explicit grant you do not have.
+  - Prefer the least-destructive path. Do not run irreversible or destructive
+    commands (e.g. \`rm -rf\`, \`git push --force\`, history rewrites, dropping
+    databases, mass deletes) unless the task explicitly requires it and names
+    the target.
+  - When you change code, verify it: run the relevant build / typecheck / tests
+    and fix what you broke before reporting done.
+  - Make only the changes the task calls for \u2014 don't refactor or reformat
+    unrelated code.
+
 Bridge contract:
   - You have a parent (the Director). You may call \`request\` on the
     parent bridge to ask a clarifying question. Use this sparingly; the
@@ -3747,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.
 
@@ -3756,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>" }
@@ -3770,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: {
@@ -3787,6 +3827,13 @@ Working rules:
         "kubernetes",
         "k8s",
         "deploy",
+        "ssh",
+        "remote ssh",
+        "remote server",
+        "sftp",
+        "tunnel",
+        "bastion",
+        "jump host",
         "github actions",
         "container"
       ]
@@ -6782,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
@@ -6996,6 +7044,8 @@ var Director = class _Director {
   sessionsRoot;
   /** Director run id for JSONL path resolution. */
   directorRunId;
+  /** Optional logger for structured logging. Falls back to noop when omitted. */
+  logger;
   /** Resolves task descriptions back from `assign()` so completion events
    *  can also carry a human-readable title. */
   taskDescriptions = /* @__PURE__ */ new Map();
@@ -7084,6 +7134,7 @@ var Director = class _Director {
       opts.checkpointDebounceMs ?? 250
     ) : null;
     this.fleetManager = opts.fleetManager;
+    this.logger = opts.logger;
     if (this.sharedScratchpadPath) {
       void fsp6.mkdir(this.sharedScratchpadPath, { recursive: true }).catch((err) => this.logShutdownError("shared_scratchpad_mkdir", err));
     }
@@ -7383,7 +7434,10 @@ var Director = class _Director {
     entry.session.cancel(reason);
     for (const [_role, subagentId] of entry.session.getSubagentIds()) {
       this.coordinator.stop(subagentId).catch((err) => {
-        console.debug(`[director] stop subagent ${subagentId} failed (may have already completed): ${err}`);
+        this.logger?.debug(`stop subagent ${subagentId} failed (may have already completed)`, {
+          subagentId,
+          err: err instanceof Error ? err.message : String(err)
+        });
       });
     }
   }
@@ -7443,7 +7497,7 @@ var Director = class _Director {
    * Caller-supplied `priceLookup` is optional but recommended — without
    * it the `cost` column in `usage.snapshot()` stays at 0.
    */
-  async spawn(config, priceLookup) {
+  async spawn(callerConfig, priceLookup) {
     if (this.workCompleteFlag) {
       throw new FleetSpawnBudgetError(
         "max_spawns",
@@ -7452,6 +7506,7 @@ var Director = class _Director {
         "workComplete() has been called \u2014 director closed further spawning"
       );
     }
+    const config = { ...callerConfig };
     if (!config.model && this.modelMatrix) {
       const matrix = typeof this.modelMatrix === "function" ? this.modelMatrix() : this.modelMatrix;
       const entry = resolveModelMatrix(matrix, config.role);
@@ -8879,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");
@@ -10375,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);
@@ -10719,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
@@ -10756,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) {
@@ -10788,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) {
@@ -10854,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) {
@@ -10901,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;
@@ -10931,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();
@@ -11743,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;
   }
@@ -12725,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");
   }
@@ -12738,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}"`);
@@ -12761,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) } : {}
     });
@@ -12772,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;
@@ -12985,8 +13083,7 @@ var ChangeManager = class {
       // filled after quality gate
       satisfiesGoals: input.satisfiesGoals
     });
-    void this._runQualityGate(node.id, input.files).then((gate) => {
-      void this.graph.update(node.id, { qualityGate: gate });
+    void this._runQualityGate(node.id, input.files).then((gate) => this.graph.update(node.id, { qualityGate: gate })).catch(() => {
     });
     this._emit("change:proposed", { changeId: node.id, title: node.title });
     return node;
@@ -13702,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);
@@ -13947,7 +14045,7 @@ ${goal.description}`,
     this.agentTaskCounts.set(agentId, next);
   }
 };
-var AutonomousCoordinator = class {
+var AutonomousCoordinator = class _AutonomousCoordinator {
   graph;
   dag;
   auction;
@@ -13963,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(). */
@@ -14019,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" });
@@ -14038,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);
@@ -14045,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
         });
@@ -14108,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
@@ -14204,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 = [];
@@ -14240,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)}`,
@@ -14256,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,
@@ -14264,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;
@@ -14304,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}`);
       }
     }
   }
@@ -14348,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 {