gauss-ai 4.0.0

package/dist/agent-graph-AMQYAWNF.js

@@ -0,0 +1,1422 @@
+import {
+  AsciiGraphAdapter,
+  MermaidGraphAdapter
+} from "./chunk-C5NLWJS2.js";
+import {
+  AbstractBuilder,
+  Agent,
+  VirtualFilesystem
+} from "./chunk-BI2G665F.js";
+import "./chunk-ZFJKX4DP.js";
+import "./chunk-PWOQDXNQ.js";
+import "./chunk-X2GHUHAF.js";
+import "./chunk-K6SAETGP.js";
+import "./chunk-KYIMVRIM.js";
+import "./chunk-ZNAIP2XV.js";
+import "./chunk-E7WG3MO5.js";
+
+// src/domain/graph.schema.ts
+import { z } from "zod";
+var GraphConfigSchema = z.object({
+  maxDepth: z.number().default(10),
+  maxConcurrency: z.number().default(5),
+  timeoutMs: z.number().default(6e5),
+  maxTokenBudget: z.number().default(1e6)
+});
+var NodeConfigSchema = z.object({
+  id: z.string(),
+  type: z.enum(["agent", "graph"])
+});
+var NodeResultSchema = z.object({
+  nodeId: z.string(),
+  output: z.string(),
+  tokenUsage: z.object({
+    input: z.number(),
+    output: z.number()
+  }).optional(),
+  durationMs: z.number()
+});
+var GraphResultSchema = z.object({
+  output: z.string(),
+  nodeResults: z.record(z.string(), NodeResultSchema),
+  totalDurationMs: z.number(),
+  totalTokenUsage: z.object({
+    input: z.number(),
+    output: z.number()
+  })
+});
+
+// src/graph/agent-node.ts
+var AgentNode = class {
+  id;
+  type;
+  config;
+  constructor(config) {
+    this.id = config.id;
+    this.type = config.type;
+    this.config = config;
+  }
+  async run(prompt, sharedContext) {
+    const start = Date.now();
+    if (this.config.type === "graph" && this.config.graph) {
+      const graphResult = await this.config.graph.run(prompt);
+      const result = {
+        nodeId: this.id,
+        output: graphResult.output,
+        tokenUsage: graphResult.totalTokenUsage,
+        durationMs: Date.now() - start
+      };
+      await sharedContext.setNodeResult(this.id, result.output);
+      return result;
+    }
+    if (!this.config.agentConfig) {
+      throw new Error(`Node "${this.id}" has no agentConfig or graph`);
+    }
+    const agent = Agent.minimal(this.config.agentConfig);
+    try {
+      const agentResult = await agent.run(prompt);
+      const result = {
+        nodeId: this.id,
+        output: agentResult.text,
+        durationMs: Date.now() - start
+      };
+      await sharedContext.setNodeResult(this.id, result.output);
+      return result;
+    } finally {
+      await agent.dispose();
+    }
+  }
+};
+
+// src/graph/priority-queue.ts
+var PriorityQueue = class {
+  heap = [];
+  compare;
+  constructor(compare) {
+    this.compare = compare;
+  }
+  get size() {
+    return this.heap.length;
+  }
+  enqueue(item) {
+    this.heap.push(item);
+    this.bubbleUp(this.heap.length - 1);
+  }
+  dequeue() {
+    if (this.heap.length === 0) return void 0;
+    const top = this.heap[0];
+    const last = this.heap.pop();
+    if (this.heap.length > 0) {
+      this.heap[0] = last;
+      this.sinkDown(0);
+    }
+    return top;
+  }
+  peek() {
+    return this.heap[0];
+  }
+  bubbleUp(i) {
+    while (i > 0) {
+      const parent = i - 1 >> 1;
+      if (this.compare(this.heap[i], this.heap[parent]) >= 0) break;
+      [this.heap[i], this.heap[parent]] = [this.heap[parent], this.heap[i]];
+      i = parent;
+    }
+  }
+  sinkDown(i) {
+    const n = this.heap.length;
+    while (true) {
+      let smallest = i;
+      const left = 2 * i + 1;
+      const right = 2 * i + 2;
+      if (left < n && this.compare(this.heap[left], this.heap[smallest]) < 0) {
+        smallest = left;
+      }
+      if (right < n && this.compare(this.heap[right], this.heap[smallest]) < 0) {
+        smallest = right;
+      }
+      if (smallest === i) break;
+      [this.heap[i], this.heap[smallest]] = [this.heap[smallest], this.heap[i]];
+      i = smallest;
+    }
+  }
+};
+
+// src/graph/worker-pool.ts
+var DEFAULT_POOL_CONFIG = {
+  initialSize: 4,
+  minSize: 1,
+  maxSize: 16,
+  taskTimeoutMs: 6e4,
+  heartbeatIntervalMs: 5e3,
+  idleShrinkMs: 3e4,
+  growThreshold: 3
+};
+var WorkerPool = class _WorkerPool {
+  queue;
+  workers = /* @__PURE__ */ new Map();
+  executor;
+  config;
+  onEvent;
+  latencies = [];
+  completionTimestamps = [];
+  static MAX_METRICS_ENTRIES = 1e3;
+  nextWorkerId = 0;
+  draining = false;
+  drainingResolve;
+  heartbeatTimer = null;
+  totalCompleted = 0;
+  totalFailed = 0;
+  workStealCount = 0;
+  constructor(executor, config, onEvent) {
+    this.executor = executor;
+    this.config = { ...DEFAULT_POOL_CONFIG, ...config };
+    this.onEvent = onEvent;
+    this.queue = new PriorityQueue(
+      (a, b) => a.priority - b.priority
+    );
+    for (let i = 0; i < this.config.initialSize; i++) {
+      this.spawnWorker();
+    }
+    this.startHeartbeatMonitor();
+  }
+  // ── Public API ─────────────────────────────────────────────────────────────
+  submit(id, input, priority = 0) {
+    if (this.draining) throw new Error("Pool is draining, cannot submit");
+    return new Promise((resolve, reject) => {
+      const task = {
+        id,
+        input,
+        priority,
+        enqueuedAt: Date.now(),
+        abortController: new AbortController(),
+        resolve,
+        reject
+      };
+      this.queue.enqueue(task);
+      this.wakeOneIdleWorker();
+    });
+  }
+  async drain(timeoutMs = 3e4) {
+    this.draining = true;
+    if (this.allIdle() && this.queue.size === 0) {
+      this.cleanup();
+      this.emit({ type: "pool:drained" });
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      this.drainingResolve = () => {
+        this.cleanup();
+        this.emit({ type: "pool:drained" });
+        resolve();
+      };
+      const timer = setTimeout(() => {
+        for (const [, slot] of this.workers) {
+          slot.currentTask?.abortController.abort(
+            new Error("Pool drain timeout")
+          );
+          slot.state = "dead";
+          if (slot.wakeResolve) {
+            slot.wakeResolve();
+            slot.wakeResolve = null;
+          }
+        }
+        this.cleanup();
+        reject(new Error(`Drain timeout after ${timeoutMs}ms`));
+      }, timeoutMs);
+      const originalResolve = this.drainingResolve;
+      this.drainingResolve = () => {
+        clearTimeout(timer);
+        originalResolve();
+      };
+      for (const [, slot] of this.workers) {
+        if (slot.state === "idle" && slot.wakeResolve) {
+          slot.wakeResolve();
+          slot.wakeResolve = null;
+        }
+      }
+    });
+  }
+  getMetrics() {
+    let active = 0;
+    let idle = 0;
+    for (const slot of this.workers.values()) {
+      if (slot.state === "busy") active++;
+      else if (slot.state === "idle") idle++;
+    }
+    const now = Date.now();
+    const windowMs = 6e4;
+    const recentCompletions = this.completionTimestamps.filter(
+      (t) => now - t < windowMs
+    );
+    const sorted = [...this.latencies].sort((a, b) => a - b);
+    const p = (pct) => {
+      if (sorted.length === 0) return 0;
+      const idx = Math.min(
+        Math.floor(pct / 100 * sorted.length),
+        sorted.length - 1
+      );
+      return sorted[idx];
+    };
+    return {
+      activeWorkers: active,
+      idleWorkers: idle,
+      queueDepth: this.queue.size,
+      totalCompleted: this.totalCompleted,
+      totalFailed: this.totalFailed,
+      throughputPerSecond: recentCompletions.length > 0 ? recentCompletions.length / (windowMs / 1e3) : 0,
+      latencyP50Ms: p(50),
+      latencyP95Ms: p(95),
+      latencyP99Ms: p(99),
+      utilizationRatio: this.workers.size > 0 ? active / this.workers.size : 0,
+      workStealCount: this.workStealCount
+    };
+  }
+  // ── Worker lifecycle ───────────────────────────────────────────────────────
+  spawnWorker() {
+    const id = this.nextWorkerId++;
+    const slot = {
+      state: "idle",
+      currentTask: null,
+      idleSince: Date.now(),
+      wakeResolve: null
+    };
+    this.workers.set(id, slot);
+    this.emit({
+      type: "worker:spawned",
+      workerId: id,
+      poolSize: this.workers.size
+    });
+    this.workerLoop(id).catch(() => {
+    });
+  }
+  removeWorker(id, reason) {
+    const slot = this.workers.get(id);
+    if (!slot) return;
+    slot.state = "dead";
+    if (slot.wakeResolve) {
+      slot.wakeResolve();
+      slot.wakeResolve = null;
+    }
+    this.workers.delete(id);
+    this.emit({
+      type: "worker:removed",
+      workerId: id,
+      poolSize: this.workers.size,
+      reason
+    });
+  }
+  async workerLoop(workerId) {
+    const slot = this.workers.get(workerId);
+    while (slot.state !== "dead") {
+      const task = this.queue.dequeue();
+      if (!task) {
+        slot.state = "idle";
+        slot.idleSince = Date.now();
+        if (this.draining && this.allIdle() && this.queue.size === 0) {
+          this.drainingResolve?.();
+          return;
+        }
+        await new Promise((resolve) => {
+          slot.wakeResolve = resolve;
+        });
+        if (slot.state === "dead") return;
+        continue;
+      }
+      this.workStealCount++;
+      slot.state = "busy";
+      slot.currentTask = task;
+      this.emit({ type: "task:started", taskId: task.id, workerId });
+      const startMs = Date.now();
+      try {
+        const result = await this.executeWithTimeout(task, workerId);
+        const durationMs = Date.now() - startMs;
+        this.latencies.push(durationMs);
+        this.completionTimestamps.push(Date.now());
+        if (this.latencies.length > _WorkerPool.MAX_METRICS_ENTRIES) {
+          this.latencies.splice(0, this.latencies.length - _WorkerPool.MAX_METRICS_ENTRIES);
+        }
+        if (this.completionTimestamps.length > _WorkerPool.MAX_METRICS_ENTRIES) {
+          this.completionTimestamps.splice(0, this.completionTimestamps.length - _WorkerPool.MAX_METRICS_ENTRIES);
+        }
+        this.totalCompleted++;
+        this.emit({
+          type: "task:completed",
+          taskId: task.id,
+          result,
+          durationMs
+        });
+        task.resolve(result);
+      } catch (error) {
+        const durationMs = Date.now() - startMs;
+        this.latencies.push(durationMs);
+        this.totalFailed++;
+        const err = error instanceof Error ? error : new Error(String(error));
+        this.emit({
+          type: "task:failed",
+          taskId: task.id,
+          error: err,
+          durationMs
+        });
+        task.reject(err);
+      } finally {
+        slot.currentTask = null;
+      }
+    }
+  }
+  executeWithTimeout(task, workerId) {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const timer = setTimeout(() => {
+        if (!settled) {
+          settled = true;
+          task.abortController.abort(
+            new Error(`Task timeout after ${this.config.taskTimeoutMs}ms`)
+          );
+          this.emit({
+            type: "task:timeout",
+            taskId: task.id,
+            workerId
+          });
+          reject(
+            new Error(`Task "${task.id}" timed out after ${this.config.taskTimeoutMs}ms`)
+          );
+        }
+      }, this.config.taskTimeoutMs);
+      this.executor(task.input, task.abortController.signal).then(
+        (result) => {
+          if (!settled) {
+            settled = true;
+            clearTimeout(timer);
+            resolve(result);
+          }
+        },
+        (error) => {
+          if (!settled) {
+            settled = true;
+            clearTimeout(timer);
+            reject(error);
+          }
+        }
+      );
+    });
+  }
+  // ── Autoscaling ────────────────────────────────────────────────────────────
+  autoscale() {
+    const now = Date.now();
+    let active = 0;
+    let idle = 0;
+    for (const slot of this.workers.values()) {
+      if (slot.state === "busy") active++;
+      else if (slot.state === "idle") idle++;
+    }
+    if (this.queue.size > this.config.growThreshold && idle === 0 && this.workers.size < this.config.maxSize) {
+      const toAdd = Math.min(
+        Math.ceil(this.queue.size / 2),
+        this.config.maxSize - this.workers.size
+      );
+      for (let i = 0; i < toAdd; i++) this.spawnWorker();
+    }
+    if (idle > 1 && this.workers.size > this.config.minSize) {
+      for (const [id, slot] of this.workers) {
+        if (slot.state === "idle" && now - slot.idleSince > this.config.idleShrinkMs && this.workers.size > this.config.minSize) {
+          this.removeWorker(id, "idle-timeout");
+        }
+      }
+    }
+  }
+  // ── Health monitoring ──────────────────────────────────────────────────────
+  startHeartbeatMonitor() {
+    this.heartbeatTimer = setInterval(() => {
+      this.autoscale();
+    }, this.config.heartbeatIntervalMs);
+  }
+  // ── Helpers ────────────────────────────────────────────────────────────────
+  wakeOneIdleWorker() {
+    for (const [, slot] of this.workers) {
+      if (slot.state === "idle" && slot.wakeResolve) {
+        slot.wakeResolve();
+        slot.wakeResolve = null;
+        return;
+      }
+    }
+  }
+  allIdle() {
+    for (const slot of this.workers.values()) {
+      if (slot.state === "busy") return false;
+    }
+    return true;
+  }
+  emit(event) {
+    this.onEvent?.(event);
+  }
+  cleanup() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    for (const [id] of this.workers) {
+      const slot = this.workers.get(id);
+      slot.state = "dead";
+      if (slot.wakeResolve) {
+        slot.wakeResolve();
+        slot.wakeResolve = null;
+      }
+    }
+  }
+};
+
+// src/graph/async-channel.ts
+var AsyncChannel = class {
+  buffer = [];
+  waiters = [];
+  closed = false;
+  push(value) {
+    if (this.closed) return;
+    if (this.waiters.length > 0) {
+      const waiter = this.waiters.shift();
+      waiter.resolve({ value, done: false });
+    } else {
+      this.buffer.push(value);
+    }
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    for (const waiter of this.waiters) {
+      waiter.resolve({ value: void 0, done: true });
+    }
+    this.waiters = [];
+  }
+  get isClosed() {
+    return this.closed;
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        if (this.buffer.length > 0) {
+          return Promise.resolve({ value: this.buffer.shift(), done: false });
+        }
+        if (this.closed) {
+          return Promise.resolve({
+            value: void 0,
+            done: true
+          });
+        }
+        return new Promise((resolve) => {
+          this.waiters.push({ resolve });
+        });
+      }
+    };
+  }
+};
+
+// src/graph/incremental-ready-tracker.ts
+var IncrementalReadyTracker = class {
+  /** nodeId → number of pending (uncompleted) dependencies */
+  pendingDeps;
+  /** nodeId → list of successor nodeIds (reverse edges) */
+  successors;
+  /** Callback invoked when a node becomes ready (all deps satisfied) */
+  onReady;
+  constructor(edges, allNodeIds, onReady) {
+    this.onReady = onReady;
+    this.pendingDeps = /* @__PURE__ */ new Map();
+    this.successors = /* @__PURE__ */ new Map();
+    for (const nodeId of allNodeIds) {
+      const deps = edges.get(nodeId) ?? [];
+      this.pendingDeps.set(nodeId, deps.length);
+      for (const dep of deps) {
+        let succ = this.successors.get(dep);
+        if (!succ) {
+          succ = [];
+          this.successors.set(dep, succ);
+        }
+        succ.push(nodeId);
+      }
+    }
+  }
+  /** Emit all nodes with zero dependencies */
+  seedInitialReady() {
+    for (const [nodeId, count] of this.pendingDeps) {
+      if (count === 0) {
+        this.onReady(nodeId);
+      }
+    }
+  }
+  /** Mark a node as completed; returns list of newly-ready successors */
+  markCompleted(nodeId) {
+    const newlyReady = [];
+    const succs = this.successors.get(nodeId) ?? [];
+    for (const succ of succs) {
+      const remaining = this.pendingDeps.get(succ) - 1;
+      this.pendingDeps.set(succ, remaining);
+      if (remaining === 0) {
+        newlyReady.push(succ);
+        this.onReady(succ);
+      }
+    }
+    return newlyReady;
+  }
+  /** Snapshot current pending-deps state for checkpoint */
+  snapshot() {
+    return new Map(this.pendingDeps);
+  }
+  /** Restore from a previously taken snapshot */
+  restoreFrom(snap) {
+    for (const [k, v] of snap) {
+      this.pendingDeps.set(k, v);
+    }
+  }
+};
+
+// src/graph/token-budget-controller.ts
+var DEFAULT_BUDGET_CONFIG = {
+  softLimitRatio: 0.8,
+  hardLimitRatio: 0.95,
+  estimatedTokensPerNode: 5e3
+};
+var TokenBudgetController = class {
+  config;
+  reserved = 0;
+  consumed = 0;
+  recentUsages = [];
+  constructor(totalBudget, config) {
+    this.config = { ...DEFAULT_BUDGET_CONFIG, totalBudget, ...config };
+  }
+  /**
+   * Reserve budget BEFORE executing a node.
+   * Returns whether it was granted and an optional throttle delay.
+   */
+  acquire(_nodeId) {
+    const estimated = this.config.estimatedTokensPerNode;
+    const projected = this.consumed + this.reserved + estimated;
+    const ratio = projected / this.config.totalBudget;
+    if (ratio > this.config.hardLimitRatio) {
+      return { granted: false, delayMs: 0 };
+    }
+    if (ratio > this.config.softLimitRatio) {
+      const pressure = (ratio - this.config.softLimitRatio) / (this.config.hardLimitRatio - this.config.softLimitRatio);
+      const delayMs = Math.round(pressure * 5e3);
+      this.reserved += estimated;
+      return { granted: true, delayMs };
+    }
+    this.reserved += estimated;
+    return { granted: true, delayMs: 0 };
+  }
+  /**
+   * Finalize actual consumption. Moves tokens from reserved to consumed.
+   */
+  release(actual) {
+    this.reserved = Math.max(
+      0,
+      this.reserved - this.config.estimatedTokensPerNode
+    );
+    this.consumed += actual.input + actual.output;
+    this.updateEstimate(actual.input + actual.output);
+  }
+  /** Check current budget status without reserving */
+  check(usage) {
+    const total = usage.input + usage.output;
+    const ratio = total / this.config.totalBudget;
+    if (ratio >= this.config.hardLimitRatio) return "hard-limit";
+    if (ratio >= this.config.softLimitRatio) return "soft-limit";
+    return "ok";
+  }
+  /** Remaining budget (total - consumed - reserved) */
+  remaining() {
+    return Math.max(
+      0,
+      this.config.totalBudget - this.consumed - this.reserved
+    );
+  }
+  /** Estimated number of nodes that can still execute */
+  estimatedRemainingNodes() {
+    return Math.floor(this.remaining() / this.config.estimatedTokensPerNode);
+  }
+  /** Rolling average of last N executions to refine estimates */
+  updateEstimate(actual) {
+    this.recentUsages.push(actual);
+    if (this.recentUsages.length > 20) this.recentUsages.shift();
+    this.config.estimatedTokensPerNode = Math.ceil(
+      this.recentUsages.reduce((a, b) => a + b, 0) / this.recentUsages.length
+    );
+  }
+};
+
+// src/graph/fork-coordinator.ts
+var ForkCoordinator = class {
+  constructor(forkId, nodeIds, timeoutMs, minResults, onPartial) {
+    this.forkId = forkId;
+    this.minResults = minResults;
+    this.onPartial = onPartial;
+    this.total = nodeIds.length;
+    this.promise = new Promise((resolve, reject) => {
+      this.resolveAll = resolve;
+      this.rejectAll = reject;
+    });
+    this.timeoutTimer = setTimeout(() => {
+      if (this.settled) return;
+      if (this.results.size >= this.minResults) {
+        this.settle();
+        this.resolveAll([...this.results.values()]);
+      } else {
+        this.settle();
+        this.rejectAll(
+          new Error(
+            `Fork "${forkId}" timeout: only ${this.results.size}/${this.total} completed (minimum: ${this.minResults})`
+          )
+        );
+      }
+    }, timeoutMs);
+  }
+  results = /* @__PURE__ */ new Map();
+  errors = /* @__PURE__ */ new Map();
+  total;
+  resolveAll;
+  rejectAll;
+  promise;
+  timeoutTimer;
+  settled = false;
+  onNodeComplete(nodeId, result) {
+    if (this.settled) return;
+    this.results.set(nodeId, result);
+    this.onPartial?.([...this.results.values()]);
+    if (this.results.size === this.total) {
+      this.settle();
+      this.resolveAll([...this.results.values()]);
+    } else {
+      this.tryEagerResolve();
+    }
+  }
+  onNodeError(nodeId, error) {
+    if (this.settled) return;
+    this.errors.set(nodeId, error);
+    if (this.errors.size > this.total - this.minResults) {
+      this.settle();
+      this.rejectAll(
+        new Error(
+          `Fork "${this.forkId}": too many failures (${this.errors.size}/${this.total})`
+        )
+      );
+    } else {
+      this.tryEagerResolve();
+    }
+  }
+  /** Eagerly resolve when all nodes reported and we have enough successes */
+  tryEagerResolve() {
+    if (this.settled) return;
+    if (this.results.size + this.errors.size === this.total && this.results.size >= this.minResults) {
+      this.settle();
+      this.resolveAll([...this.results.values()]);
+    }
+  }
+  dispose() {
+    this.settle();
+  }
+  settle() {
+    if (this.settled) return;
+    this.settled = true;
+    if (this.timeoutTimer) {
+      clearTimeout(this.timeoutTimer);
+      this.timeoutTimer = void 0;
+    }
+  }
+};
+
+// src/graph/graph-executor.ts
+var GraphExecutor = class _GraphExecutor {
+  constructor(nodes, edges, forks, config, sharedContext, eventBus, telemetry) {
+    this.nodes = nodes;
+    this.edges = edges;
+    this.forks = forks;
+    this.config = config;
+    this.sharedContext = sharedContext;
+    this.eventBus = eventBus;
+    this.telemetry = telemetry;
+  }
+  static CHECKPOINT_INTERVAL = 5;
+  async execute(prompt) {
+    let result;
+    for await (const event of this.stream(prompt)) {
+      if (event.type === "graph:complete") {
+        result = event.result;
+      }
+      if (event.type === "graph:error") {
+        throw new Error(event.error);
+      }
+    }
+    if (!result) throw new Error("Graph execution produced no result");
+    return result;
+  }
+  async *stream(prompt) {
+    const start = Date.now();
+    const nodeResults = /* @__PURE__ */ new Map();
+    let totalInput = 0;
+    let totalOutput = 0;
+    let completedCount = 0;
+    const totalNodes = this.nodes.size;
+    let terminated = false;
+    const channel = new AsyncChannel();
+    const budgetCtrl = new TokenBudgetController(this.config.maxTokenBudget);
+    const pool = new WorkerPool(
+      async (task, signal) => {
+        const { nodeId } = task;
+        this.eventBus?.emit("node:start", { nodeId });
+        channel.push({ type: "node:start", nodeId });
+        const nodeSpan = this.telemetry?.startSpan(
+          `graph.node.${nodeId}`,
+          { "node.id": nodeId }
+        );
+        try {
+          const fork = this.forks.get(nodeId);
+          if (fork) {
+            const result2 = await this.executeForkTask(
+              nodeId,
+              prompt,
+              fork,
+              nodeResults,
+              channel
+            );
+            nodeSpan?.setAttribute("node.duration_ms", result2.durationMs);
+            nodeSpan?.setStatus("OK");
+            return result2;
+          }
+          const node = this.nodes.get(nodeId);
+          if (!node) throw new Error(`Node "${nodeId}" not found`);
+          const enrichedPrompt = this.buildNodePrompt(prompt, nodeId, nodeResults);
+          const result = await node.run(enrichedPrompt, this.sharedContext);
+          nodeSpan?.setAttribute("node.duration_ms", result.durationMs);
+          nodeSpan?.setStatus("OK");
+          return result;
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          nodeSpan?.setStatus("ERROR", errorMsg);
+          throw error;
+        } finally {
+          nodeSpan?.end();
+        }
+      },
+      {
+        initialSize: this.config.maxConcurrency,
+        minSize: 1,
+        maxSize: this.config.maxConcurrency,
+        taskTimeoutMs: 6e5,
+        heartbeatIntervalMs: 6e4,
+        idleShrinkMs: 3e4,
+        growThreshold: 10
+      }
+    );
+    const emitError = (errorMsg) => {
+      if (terminated) return;
+      terminated = true;
+      const partialResults = {};
+      for (const [id, r] of nodeResults) {
+        partialResults[id] = r;
+      }
+      this.eventBus?.emit("graph:complete", {
+        totalDurationMs: Date.now() - start,
+        totalTokenUsage: { input: totalInput, output: totalOutput },
+        error: errorMsg
+      });
+      channel.push({ type: "graph:error", error: errorMsg, partialResults });
+      channel.close();
+    };
+    const emitCompletion = () => {
+      if (terminated) return;
+      terminated = true;
+      const lastNodeId = this.findTerminalNode();
+      const lastResult = nodeResults.get(lastNodeId);
+      const resultMap = {};
+      for (const [id, r] of nodeResults) {
+        resultMap[id] = r;
+      }
+      const result = {
+        output: lastResult.output,
+        nodeResults: resultMap,
+        totalDurationMs: Date.now() - start,
+        totalTokenUsage: { input: totalInput, output: totalOutput }
+      };
+      this.eventBus?.emit("graph:complete", {
+        totalDurationMs: result.totalDurationMs,
+        totalTokenUsage: result.totalTokenUsage
+      });
+      channel.push({ type: "graph:complete", result });
+      channel.close();
+    };
+    const tracker = new IncrementalReadyTracker(
+      this.edges,
+      this.nodes.keys(),
+      (nodeId) => {
+        if (nodeResults.has(nodeId) || terminated) return;
+        pool.submit(nodeId, { nodeId, prompt }, 0).then((result) => {
+          if (terminated) return;
+          nodeResults.set(result.nodeId, result);
+          completedCount++;
+          if (result.tokenUsage) {
+            totalInput += result.tokenUsage.input;
+            totalOutput += result.tokenUsage.output;
+            budgetCtrl.release(result.tokenUsage);
+          }
+          this.eventBus?.emit("node:complete", { nodeId, result });
+          channel.push({ type: "node:complete", nodeId, result });
+          if (totalInput + totalOutput > this.config.maxTokenBudget) {
+            emitError("Token budget exceeded");
+            return;
+          }
+          const budgetStatus = budgetCtrl.check({ input: totalInput, output: totalOutput });
+          if (budgetStatus === "soft-limit") {
+            channel.push({
+              type: "budget:warning",
+              remaining: budgetCtrl.remaining(),
+              used: totalInput + totalOutput,
+              threshold: "soft"
+            });
+          } else if (budgetStatus === "hard-limit") {
+            channel.push({
+              type: "budget:warning",
+              remaining: budgetCtrl.remaining(),
+              used: totalInput + totalOutput,
+              threshold: "hard"
+            });
+          }
+          if (completedCount % _GraphExecutor.CHECKPOINT_INTERVAL === 0 && completedCount < totalNodes) {
+            const cp = {
+              completedNodes: new Map(nodeResults),
+              pendingDepsSnapshot: tracker.snapshot(),
+              tokenUsage: { input: totalInput, output: totalOutput },
+              elapsedMs: Date.now() - start,
+              prompt
+            };
+            channel.push({
+              type: "checkpoint:saved",
+              checkpoint: JSON.stringify({
+                completedNodeIds: [...cp.completedNodes.keys()],
+                tokenUsage: cp.tokenUsage,
+                elapsedMs: cp.elapsedMs
+              }),
+              completedCount
+            });
+          }
+          tracker.markCompleted(nodeId);
+          if (completedCount === totalNodes) {
+            emitCompletion();
+          }
+        }).catch((error) => {
+          if (terminated) return;
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          this.eventBus?.emit("node:complete", { nodeId, error: errorMsg });
+          channel.push({ type: "node:error", nodeId, error: errorMsg });
+          emitError(errorMsg);
+        });
+      }
+    );
+    this.eventBus?.emit("graph:start", { nodeCount: totalNodes });
+    yield { type: "graph:start", nodeCount: totalNodes };
+    tracker.seedInitialReady();
+    if (completedCount === 0 && totalNodes > 0 && terminated === false) {
+      let hasZeroDeps = false;
+      for (const nodeId of this.nodes.keys()) {
+        const deps = this.edges.get(nodeId) ?? [];
+        if (deps.length === 0) {
+          hasZeroDeps = true;
+          break;
+        }
+      }
+      if (!hasZeroDeps) {
+        emitError("Deadlock: no nodes ready but graph incomplete");
+      }
+    }
+    const timeoutTimer = setTimeout(() => {
+      emitError("Graph execution timed out");
+    }, this.config.timeoutMs);
+    try {
+      for await (const event of channel) {
+        yield event;
+        if (event.type === "graph:complete" || event.type === "graph:error") {
+          break;
+        }
+      }
+    } finally {
+      clearTimeout(timeoutTimer);
+      await pool.drain(5e3).catch(() => {
+      });
+    }
+  }
+  // ── Fork execution with ForkCoordinator ──
+  async executeForkTask(forkId, prompt, fork, previousResults, channel) {
+    const forkStart = Date.now();
+    const enrichedPrompt = this.buildNodePrompt(prompt, forkId, previousResults);
+    this.eventBus?.emit("fork:start", { forkId, agentCount: fork.nodes.length });
+    channel.push({ type: "fork:start", forkId, agentCount: fork.nodes.length });
+    const coordinator = new ForkCoordinator(
+      forkId,
+      fork.nodes.map((n) => n.id),
+      Math.max(this.config.timeoutMs / 2, 5e3),
+      Math.max(1, Math.ceil(fork.nodes.length / 2)),
+      (partial) => {
+        channel.push({
+          type: "fork:partial",
+          forkId,
+          completedCount: partial.length,
+          totalCount: fork.nodes.length,
+          partialResults: partial
+        });
+      }
+    );
+    const promises = fork.nodes.map(async (node) => {
+      try {
+        const result2 = await node.run(enrichedPrompt, this.sharedContext);
+        coordinator.onNodeComplete(node.id, result2);
+      } catch (error) {
+        coordinator.onNodeError(
+          node.id,
+          error instanceof Error ? error : new Error(String(error))
+        );
+      }
+    });
+    let results;
+    try {
+      results = await coordinator.promise;
+      await Promise.allSettled(promises);
+    } catch (error) {
+      await Promise.allSettled(promises);
+      coordinator.dispose();
+      this.eventBus?.emit("fork:complete", {
+        forkId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      channel.push({ type: "fork:complete", forkId, results: [] });
+      throw error;
+    }
+    this.eventBus?.emit("fork:complete", { forkId, resultCount: results.length });
+    channel.push({ type: "fork:complete", forkId, results });
+    let output;
+    let tokenUsage = { input: 0, output: 0 };
+    for (const r of results) {
+      if (r.tokenUsage) {
+        tokenUsage.input += r.tokenUsage.input;
+        tokenUsage.output += r.tokenUsage.output;
+      }
+    }
+    if (fork.consensus) {
+      this.eventBus?.emit("consensus:start", { forkId });
+      channel.push({ type: "consensus:start", forkId });
+      try {
+        const consensusInput = results.map((r) => ({
+          id: r.nodeId,
+          output: r.output
+        }));
+        const consensusResult = await fork.consensus.evaluate(consensusInput);
+        this.eventBus?.emit("consensus:result", {
+          forkId,
+          winnerId: consensusResult.winnerId,
+          merged: !!consensusResult.merged
+        });
+        output = consensusResult.merged ?? consensusResult.winnerOutput;
+        channel.push({ type: "consensus:result", forkId, output });
+      } catch (error) {
+        this.eventBus?.emit("consensus:result", {
+          forkId,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        channel.push({ type: "consensus:result", forkId, output: "" });
+        coordinator.dispose();
+        throw error;
+      }
+    } else {
+      output = results[0].output;
+    }
+    const result = {
+      nodeId: forkId,
+      output,
+      tokenUsage,
+      durationMs: Date.now() - forkStart
+    };
+    await this.sharedContext.setNodeResult(forkId, output);
+    coordinator.dispose();
+    return result;
+  }
+  // ── Helpers ──
+  buildNodePrompt(basePrompt, nodeId, previousResults) {
+    const deps = this.edges.get(nodeId) ?? [];
+    if (deps.length === 0) return basePrompt;
+    const context = deps.map((depId) => {
+      const r = previousResults.get(depId);
+      return r ? `[${depId}]: ${r.output}` : "";
+    }).filter(Boolean).join("\n\n");
+    return `${basePrompt}
+
+--- Previous results ---
+${context}`;
+  }
+  findTerminalNode() {
+    const isDependency = /* @__PURE__ */ new Set();
+    for (const deps of this.edges.values()) {
+      for (const d of deps) isDependency.add(d);
+    }
+    for (const nodeId of this.nodes.keys()) {
+      if (!isDependency.has(nodeId)) return nodeId;
+    }
+    return [...this.nodes.keys()].pop();
+  }
+};
+
+// src/graph/shared-context.ts
+var VersionConflictError = class extends Error {
+  constructor(key, expected, actual) {
+    super(
+      `Version conflict on "${key}": expected ${expected}, actual ${actual}`
+    );
+    this.name = "VersionConflictError";
+  }
+};
+var SharedContext = class _SharedContext {
+  constructor(fs, namespace = "/.shared", parent) {
+    this.fs = fs;
+    this.namespace = namespace;
+    this.parent = parent;
+  }
+  watchers = /* @__PURE__ */ new Map();
+  versions = /* @__PURE__ */ new Map();
+  parent;
+  // ---- helpers ------------------------------------------------------------
+  keyPath(key) {
+    return `${this.namespace}/${key}`;
+  }
+  getVersion(key) {
+    return this.versions.get(key) ?? 0;
+  }
+  bumpVersion(key) {
+    const next = this.getVersion(key) + 1;
+    this.versions.set(key, next);
+    return next;
+  }
+  // ---- notify watchers ----------------------------------------------------
+  notify(change) {
+    const keyHandlers = this.watchers.get(change.key);
+    const wildHandlers = this.watchers.get("*");
+    if (keyHandlers) {
+      for (const h of keyHandlers) h(change);
+    }
+    if (wildHandlers) {
+      for (const h of wildHandlers) h(change);
+    }
+    if (this.parent) {
+      this.parent.notify(change);
+    }
+  }
+  // ---- original API (backward compatible) ---------------------------------
+  async set(key, value) {
+    const oldValue = await this.get(key);
+    await this.fs.write(this.keyPath(key), JSON.stringify(value));
+    const version = this.bumpVersion(key);
+    this.notify({
+      key,
+      oldValue,
+      newValue: value,
+      version,
+      source: this.namespace,
+      timestamp: Date.now()
+    });
+  }
+  async get(key) {
+    const path = this.keyPath(key);
+    if (!await this.fs.exists(path)) return null;
+    const raw = await this.fs.read(path);
+    return JSON.parse(raw);
+  }
+  async delete(key) {
+    const path = this.keyPath(key);
+    if (await this.fs.exists(path)) {
+      const oldValue = await this.get(key);
+      await this.fs.delete(path);
+      const version = this.bumpVersion(key);
+      this.notify({
+        key,
+        oldValue,
+        newValue: void 0,
+        version,
+        source: this.namespace,
+        timestamp: Date.now()
+      });
+    }
+  }
+  async list() {
+    if (!await this.fs.exists(this.namespace)) return [];
+    const entries = await this.fs.list(this.namespace);
+    return entries.filter((e) => !e.isDirectory).map((e) => e.name);
+  }
+  async getNodeResult(nodeId) {
+    return this.get(`results/${nodeId}`);
+  }
+  async setNodeResult(nodeId, result) {
+    await this.set(`results/${nodeId}`, result);
+  }
+  // ---- watchers -----------------------------------------------------------
+  /**
+   * Subscribe to changes on a specific key, or use "*" for all changes.
+   * Returns an unsubscribe function.
+   */
+  watch(key, handler) {
+    let handlers = this.watchers.get(key);
+    if (!handlers) {
+      handlers = /* @__PURE__ */ new Set();
+      this.watchers.set(key, handlers);
+    }
+    handlers.add(handler);
+    return () => {
+      handlers.delete(handler);
+      if (handlers.size === 0) this.watchers.delete(key);
+    };
+  }
+  // ---- versioning (optimistic locking) ------------------------------------
+  async getVersioned(key) {
+    const value = await this.get(key);
+    if (value === null) return null;
+    return { value, version: this.getVersion(key) };
+  }
+  async setVersioned(key, value, expectedVersion) {
+    const actual = this.getVersion(key);
+    if (actual !== expectedVersion) {
+      throw new VersionConflictError(key, expectedVersion, actual);
+    }
+    this.bumpVersion(key);
+    const oldValue = await this.get(key);
+    await this.fs.write(this.keyPath(key), JSON.stringify(value));
+    this.notify({
+      key,
+      oldValue,
+      newValue: value,
+      version: this.getVersion(key),
+      source: this.namespace,
+      timestamp: Date.now()
+    });
+  }
+  // ---- CRDT merge ---------------------------------------------------------
+  /**
+   * Read-then-write with a merge function using optimistic locking.
+   * Default mergeFn is Last-Writer-Wins (returns newValue).
+   * Retries on version conflict (CAS pattern).
+   */
+  async merge(key, value, mergeFn = (_old, nw) => nw) {
+    const maxRetries = 3;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      const currentVersion = this.getVersion(key);
+      const current = await this.get(key);
+      const merged = mergeFn(current, value);
+      try {
+        await this.setVersioned(key, merged, currentVersion);
+        return;
+      } catch (err) {
+        if (err instanceof VersionConflictError && attempt < maxRetries) {
+          continue;
+        }
+        throw err;
+      }
+    }
+  }
+  // ---- scoping ------------------------------------------------------------
+  createScoped(scope) {
+    return new _SharedContext(this.fs, `${this.namespace}/${scope}`, this);
+  }
+};
+
+// src/graph/agent-graph.ts
+var AgentGraph = class {
+  constructor(nodes, edges, forks, config, fs, eventBus, telemetry) {
+    this.nodes = nodes;
+    this.edges = edges;
+    this.forks = forks;
+    this.config = config;
+    this.fs = fs;
+    this.eventBus = eventBus;
+    this.telemetry = telemetry;
+  }
+  getNodes() {
+    return this.nodes;
+  }
+  getEdges() {
+    return this.edges;
+  }
+  getForks() {
+    return this.forks;
+  }
+  describe() {
+    const nodes = [...this.nodes.values()].map((n) => ({
+      id: n.id,
+      type: n.type
+    }));
+    const edges = [];
+    for (const [to, sources] of this.edges) {
+      for (const from of sources) {
+        edges.push({ from, to });
+      }
+    }
+    const forks = [...this.forks.entries()].map(([id, f]) => ({
+      id,
+      nodeIds: f.nodes.map((n) => n.id)
+    }));
+    return { nodes, edges, forks };
+  }
+  visualize(format = "ascii") {
+    const descriptor = this.describe();
+    if (format === "mermaid") {
+      return new MermaidGraphAdapter().toMermaid(descriptor);
+    }
+    return new AsciiGraphAdapter().toAscii(descriptor);
+  }
+  static create(config) {
+    return new AgentGraphBuilder(config);
+  }
+  async run(prompt) {
+    const sharedContext = new SharedContext(this.fs);
+    const executor = new GraphExecutor(
+      this.nodes,
+      this.edges,
+      this.forks,
+      this.config,
+      sharedContext,
+      this.eventBus,
+      this.telemetry
+    );
+    return executor.execute(prompt);
+  }
+  async *stream(prompt) {
+    const sharedContext = new SharedContext(this.fs);
+    const executor = new GraphExecutor(
+      this.nodes,
+      this.edges,
+      this.forks,
+      this.config,
+      sharedContext,
+      this.eventBus,
+      this.telemetry
+    );
+    yield* executor.stream(prompt);
+  }
+};
+var AgentGraphBuilder = class extends AbstractBuilder {
+  nodeMap = /* @__PURE__ */ new Map();
+  edgeMap = /* @__PURE__ */ new Map();
+  forkMap = /* @__PURE__ */ new Map();
+  config;
+  fs;
+  eventBus;
+  telemetryAdapter;
+  constructor(config) {
+    super();
+    this.config = GraphConfigSchema.parse(config ?? {});
+  }
+  node(id, config) {
+    if (this.nodeMap.has(id)) {
+      throw new Error(`Node "${id}" already exists`);
+    }
+    this.nodeMap.set(
+      id,
+      new AgentNode({ id, type: "agent", agentConfig: config })
+    );
+    return this;
+  }
+  edge(from, to) {
+    const deps = this.edgeMap.get(to) ?? [];
+    deps.push(from);
+    this.edgeMap.set(to, deps);
+    return this;
+  }
+  fork(id, configs) {
+    if (configs.length < 2) {
+      throw new Error(`Fork "${id}" requires at least 2 configs`);
+    }
+    if (this.nodeMap.has(id) || this.forkMap.has(id)) {
+      throw new Error(`Node "${id}" already exists`);
+    }
+    const forkNodes = configs.map(
+      (cfg, i) => new AgentNode({
+        id: `${id}__fork_${i}`,
+        type: "agent",
+        agentConfig: cfg
+      })
+    );
+    this.nodeMap.set(
+      id,
+      new AgentNode({ id, type: "agent" })
+    );
+    this.forkMap.set(id, { nodes: forkNodes });
+    return this;
+  }
+  consensus(forkId, strategy) {
+    const fork = this.forkMap.get(forkId);
+    if (!fork) {
+      throw new Error(
+        `Cannot set consensus: "${forkId}" is not a fork node`
+      );
+    }
+    fork.consensus = strategy;
+    return this;
+  }
+  withFilesystem(fs) {
+    this.fs = fs;
+    return this;
+  }
+  withEventBus(eventBus) {
+    this.eventBus = eventBus;
+    return this;
+  }
+  withTelemetry(adapter) {
+    this.telemetryAdapter = adapter;
+    return this;
+  }
+  validate() {
+    this.validateEdges();
+    this.validateNoCycles();
+  }
+  construct() {
+    return new AgentGraph(
+      this.nodeMap,
+      this.edgeMap,
+      this.forkMap,
+      this.config,
+      this.fs ?? new VirtualFilesystem(),
+      this.eventBus,
+      this.telemetryAdapter
+    );
+  }
+  validateEdges() {
+    for (const [to, deps] of this.edgeMap) {
+      if (!this.nodeMap.has(to)) {
+        throw new Error(`Edge target "${to}" does not exist`);
+      }
+      for (const from of deps) {
+        if (!this.nodeMap.has(from)) {
+          throw new Error(`Edge source "${from}" does not exist`);
+        }
+      }
+    }
+  }
+  validateNoCycles() {
+    const visited = /* @__PURE__ */ new Set();
+    const stack = /* @__PURE__ */ new Set();
+    const visit = (nodeId) => {
+      if (stack.has(nodeId)) {
+        throw new Error(`Cycle detected involving node "${nodeId}"`);
+      }
+      if (visited.has(nodeId)) return;
+      stack.add(nodeId);
+      const deps = this.edgeMap.get(nodeId) ?? [];
+      for (const dep of deps) {
+        visit(dep);
+      }
+      stack.delete(nodeId);
+      visited.add(nodeId);
+    };
+    for (const nodeId of this.nodeMap.keys()) {
+      visit(nodeId);
+    }
+  }
+};
+export {
+  AgentGraph,
+  AgentGraphBuilder
+};
+//# sourceMappingURL=agent-graph-AMQYAWNF.js.map