@terminals-tech/sdk 1.0.0-rc.1 → 1.0.0-rc.2

package/dist/chunk-PUZ2S62E.js

@@ -0,0 +1,977 @@
+import {
+  getGlobalStore
+} from "./chunk-VZA2NUH3.js";
+import {
+  resolveSecretValue
+} from "./chunk-QWXPVB2L.js";
+import {
+  onMeshFeedback,
+  orchestratorToMesh
+} from "./chunk-Q2VI6ICE.js";
+import {
+  registerManifestProvider
+} from "./chunk-3CEM77QZ.js";
+import {
+  safeDbOperation
+} from "./chunk-WGBCRNMB.js";
+import {
+  getDB,
+  isDatabaseReady,
+  withDB
+} from "./chunk-AFDUOYHD.js";
+
+// ../../lib/terminals-tech/machines/core/stacksStore.ts
+var globalStore = globalThis;
+var memStacks = globalStore.__memStacks || /* @__PURE__ */ new Map();
+globalStore.__memStacks = memStacks;
+var pendingDeletes = globalStore.__pendingStackDeletes || /* @__PURE__ */ new Set();
+globalStore.__pendingStackDeletes = pendingDeletes;
+registerManifestProvider("stacksStore", loadStack);
+async function loadStack(id) {
+  const { getDB: getDB2, safeDbOperation: safeDbOperation2 } = await import("./pgliteService-IUGNNOVU.js");
+  const dbResult = await safeDbOperation2(async () => {
+    const db = await getDB2();
+    await db.query(`ALTER TABLE stacks ADD COLUMN IF NOT EXISTS deleted_at TIMESTAMP`);
+    const r = await db.query(
+      `SELECT manifest FROM stacks WHERE id = $1 AND deleted_at IS NULL`,
+      [id]
+    );
+    if (!r.rows[0]) return null;
+    return r.rows[0].manifest;
+  }, null);
+  if (dbResult) return dbResult;
+  return memStacks.get(id)?.manifest || null;
+}
+
+// ../../lib/terminals-tech/machines/core/manifests.ts
+function isNodeManifest(manifest) {
+  return "kind" in manifest && "entrypoints" in manifest;
+}
+
+// ../../lib/terminals-tech/machines/core/validator.ts
+function isAcyclic(nodes, edges) {
+  const incoming = /* @__PURE__ */ new Map();
+  const out = /* @__PURE__ */ new Map();
+  nodes.forEach((n) => {
+    incoming.set(n.id, 0);
+    out.set(n.id, []);
+  });
+  edges.forEach((e) => {
+    incoming.set(e.to, (incoming.get(e.to) || 0) + 1);
+    const fromList = out.get(e.from);
+    if (fromList) fromList.push(e.to);
+  });
+  const queue = nodes.filter((n) => (incoming.get(n.id) || 0) === 0).map((n) => n.id);
+  let visited = 0;
+  while (queue.length) {
+    const id = queue.shift();
+    if (!id) break;
+    visited++;
+    for (const to of out.get(id) || []) {
+      incoming.set(to, (incoming.get(to) || 0) - 1);
+      if ((incoming.get(to) || 0) === 0) queue.push(to);
+    }
+  }
+  return visited === nodes.length;
+}
+function validateStack(manifest) {
+  const issues = [];
+  const ids = /* @__PURE__ */ new Set();
+  for (const n of manifest.nodes) {
+    if (ids.has(n.id))
+      issues.push({
+        code: "node.duplicateId",
+        message: `Duplicate node id: ${n.id}`,
+        details: { nodeId: n.id }
+      });
+    ids.add(n.id);
+    if (!n.nodeRef)
+      issues.push({
+        code: "node.nodeRef.required",
+        message: `Node ${n.id} missing nodeRef`,
+        details: { nodeId: n.id }
+      });
+  }
+  for (const e of manifest.edges || []) {
+    if (!ids.has(e.from))
+      issues.push({
+        code: "edge.from.missing",
+        message: `Edge from missing node: ${e.from}`,
+        details: { fromId: e.from }
+      });
+    if (!ids.has(e.to))
+      issues.push({
+        code: "edge.to.missing",
+        message: `Edge to missing node: ${e.to}`,
+        details: { toId: e.to }
+      });
+    if (e.from === e.to)
+      issues.push({
+        code: "edge.self",
+        message: `Self edge not allowed: ${e.from}`,
+        details: { fromId: e.from, toId: e.to }
+      });
+  }
+  if (!isAcyclic(manifest.nodes, manifest.edges || []))
+    issues.push({
+      code: "graph.cycle",
+      message: "Graph contains a cycle; v0 requires DAG"
+    });
+  if (manifest.runtimes?.default && manifest.runtimes.default.length === 0)
+    issues.push({
+      code: "runtimes.default.empty",
+      message: "Runtimes default cannot be empty"
+    });
+  if (manifest.runtimes?.overrides) {
+    for (const [nid, arr] of Object.entries(manifest.runtimes.overrides)) {
+      if (!ids.has(nid))
+        issues.push({
+          code: "runtimes.override.unknownNode",
+          message: `Runtime override for unknown node: ${nid}`,
+          details: { nodeId: nid }
+        });
+      if (!arr || arr.length === 0)
+        issues.push({
+          code: "runtimes.override.empty",
+          message: `Runtime override empty for node: ${nid}`,
+          details: { nodeId: nid }
+        });
+    }
+  }
+  if (manifest.secrets) {
+    for (const [name, scope] of Object.entries(manifest.secrets)) {
+      for (const nid of scope.scope)
+        if (!ids.has(nid))
+          issues.push({
+            code: "secrets.scope.unknownNode",
+            message: `Secret ${name} references unknown node ${nid}`,
+            details: { secretName: name, nodeId: nid }
+          });
+    }
+  }
+  return issues.length === 0 ? { ok: true } : { ok: false, issues };
+}
+function toSimpleType(t) {
+  if (!t) return void 0;
+  if (typeof t === "string") return t;
+  if (Array.isArray(t)) {
+    const arr = t.filter((x) => typeof x === "string");
+    if (arr.length === 1) return arr[0];
+  }
+  return void 0;
+}
+function getRequiredInputs(manifest) {
+  const required = /* @__PURE__ */ new Set();
+  const schema = manifest.inputsSchema;
+  if (schema && Array.isArray(schema.required)) {
+    for (const k of schema.required) if (typeof k === "string") required.add(k);
+  }
+  return required;
+}
+function getPropertyType(schema, key) {
+  if (!schema || typeof schema !== "object") return void 0;
+  const props = schema.properties || {};
+  const prop = props ? props[key] : void 0;
+  if (!prop) return void 0;
+  return toSimpleType(prop.type);
+}
+async function linkAndValidateStack(manifest, resolver) {
+  const base = validateStack(manifest);
+  const issues = base.ok ? [] : base.issues.slice();
+  const nodeIdToManifest = /* @__PURE__ */ new Map();
+  for (const node of manifest.nodes) {
+    const m = await resolver(node.nodeRef);
+    if (!m) {
+      issues.push({
+        code: "link.nodeRef.unresolved",
+        message: `NodeRef '${node.nodeRef}' for node '${node.id}' could not be resolved.`,
+        details: { nodeId: node.id, nodeRef: node.nodeRef }
+      });
+      continue;
+    }
+    nodeIdToManifest.set(node.id, m);
+  }
+  if (issues.length > 0) return { ok: false, issues };
+  const inboundInputs = /* @__PURE__ */ new Map();
+  for (const e of manifest.edges || []) {
+    const toSet = inboundInputs.get(e.to) || /* @__PURE__ */ new Set();
+    const map = e.map || {};
+    for (const inKey of Object.values(map)) toSet.add(inKey);
+    inboundInputs.set(e.to, toSet);
+  }
+  for (const e of manifest.edges || []) {
+    const fromM = nodeIdToManifest.get(e.from);
+    const toM = nodeIdToManifest.get(e.to);
+    if (!fromM || !toM) continue;
+    const fromSchema = fromM.outputsSchema;
+    const toSchema = toM.inputsSchema;
+    const map = e.map || {};
+    for (const [outKey, inKey] of Object.entries(map)) {
+      const outType = getPropertyType(fromSchema, outKey);
+      const inType = getPropertyType(toSchema, inKey);
+      if (fromSchema && fromSchema.properties && !(outKey in fromSchema.properties)) {
+        issues.push({
+          code: "link.output.missing",
+          message: `Edge ${e.from}->${e.to} maps missing output '${outKey}' in '${fromM.id}'.`,
+          details: { fromId: e.from, toId: e.to, outKey, inKey }
+        });
+      }
+      if (toSchema && toSchema.properties && !(inKey in toSchema.properties)) {
+        issues.push({
+          code: "link.input.missing",
+          message: `Edge ${e.from}->${e.to} maps to missing input '${inKey}' in '${toM.id}'.`,
+          details: { fromId: e.from, toId: e.to, outKey, inKey }
+        });
+      }
+      if (outType && inType && outType !== inType) {
+        issues.push({
+          code: "link.typeMismatch",
+          message: `Type mismatch ${e.from}.${outKey} (${outType}) -> ${e.to}.${inKey} (${inType}).`,
+          details: { fromId: e.from, toId: e.to, outKey, inKey }
+        });
+      }
+    }
+  }
+  const nodeById = /* @__PURE__ */ new Map();
+  for (const n of manifest.nodes) nodeById.set(n.id, n);
+  for (const n of manifest.nodes) {
+    const m = nodeIdToManifest.get(n.id);
+    if (!m) continue;
+    const required = getRequiredInputs(m);
+    if (required.size === 0) continue;
+    const satisfiedByEdges = inboundInputs.get(n.id) || /* @__PURE__ */ new Set();
+    for (const key of required) {
+      const satisfiedByConfig = n.config && Object.prototype.hasOwnProperty.call(n.config, key);
+      const ok = satisfiedByConfig || satisfiedByEdges.has(key);
+      if (!ok) {
+        issues.push({
+          code: "link.requiredInput.unconnected",
+          message: `Node '${n.id}' (${m.id}) requires input '${key}' but it is neither in config nor provided by inbound edges.`,
+          details: { nodeId: n.id, inputKey: key }
+        });
+      }
+    }
+  }
+  return issues.length === 0 ? { ok: true } : { ok: false, issues };
+}
+
+// ../../lib/terminals-tech/machines/core/tracing.ts
+var InMemoryTracer = class {
+  spans = [];
+  startSpan(name, attributes) {
+    const span = {
+      traceId: `${Date.now()}`,
+      spanId: Math.random().toString(36).slice(2),
+      name,
+      startTime: Date.now(),
+      attributes,
+      events: []
+    };
+    this.spans.push(span);
+    return span;
+  }
+  endSpan(span) {
+    span.endTime = Date.now();
+  }
+  addEvent(span, event) {
+    span.events?.push(event);
+  }
+  async export() {
+    return this.spans.slice();
+  }
+};
+
+// ../../lib/terminals-tech/machines/core/runStore.ts
+var store = getGlobalStore("run_store");
+function persistRunTrace(runId, spans) {
+  store.set(runId, { spans });
+}
+
+// ../../lib/terminals-tech/machines/core/traceStore.ts
+async function persistSpans(spans) {
+  const runId = spans[0]?.traceId;
+  if (runId) persistRunTrace(runId, spans);
+  await safeDbOperation(async () => {
+    const db = await getDB();
+    for (const s of spans) {
+      await db.query(
+        `INSERT INTO run_spans (trace_id, span_id, name, start_time, end_time, attributes)
+         VALUES ($1,$2,$3,$4,$5,$6)
+         ON CONFLICT (trace_id, span_id) DO UPDATE SET end_time = EXCLUDED.end_time, attributes = EXCLUDED.attributes`,
+        [
+          s.traceId,
+          s.spanId,
+          s.name,
+          new Date(s.startTime).toISOString(),
+          s.endTime ? new Date(s.endTime).toISOString() : null,
+          JSON.stringify(s.attributes || {})
+        ]
+      );
+      for (const ev of s.events || []) {
+        await db.query(
+          `INSERT INTO run_span_events (trace_id, span_id, ts, event, attributes)
+           VALUES ($1,$2,$3,$4,$5)
+           ON CONFLICT DO NOTHING`,
+          [
+            s.traceId,
+            s.spanId,
+            new Date(ev.time).toISOString(),
+            ev.event,
+            JSON.stringify(ev.attributes || {})
+          ]
+        );
+      }
+    }
+  }, void 0);
+}
+
+// ../../lib/terminals-tech/machines/core/runsMeta.ts
+var memoryStore = /* @__PURE__ */ new Map();
+async function persistRunMeta(meta) {
+  const list = memoryStore.get(meta.stackId) || [];
+  const merged = [meta, ...list.filter((m) => m.runId !== meta.runId)].slice(0, 50);
+  memoryStore.set(meta.stackId, merged);
+  if (!isDatabaseReady()) {
+    return;
+  }
+  try {
+    await withDB(async (db) => {
+      await db.query(
+        `INSERT INTO runs (run_id, stack_id, shape_hash, started_at, ended_at, status, metrics, feedback, replay_url, commit_sha, packages)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
+         ON CONFLICT (run_id) DO UPDATE SET
+           ended_at = EXCLUDED.ended_at,
+           status = EXCLUDED.status,
+           metrics = EXCLUDED.metrics,
+           feedback = COALESCE(runs.feedback, '{}'::jsonb) || COALESCE(EXCLUDED.feedback, '{}'::jsonb),
+           replay_url = COALESCE(EXCLUDED.replay_url, runs.replay_url)`,
+        [
+          meta.runId,
+          meta.stackId,
+          meta.shapeHash || null,
+          meta.startedAt,
+          meta.endedAt,
+          meta.status,
+          JSON.stringify(meta.metrics || {}),
+          JSON.stringify(meta.feedback || {}),
+          meta.replayUrl || null,
+          meta.commit || null,
+          JSON.stringify(meta.packages || {})
+        ]
+      );
+    });
+  } catch (err) {
+    console.warn("[runsMeta] PGLite persist failed:", err);
+  }
+}
+
+// ../../lib/terminals-tech/machines/core/core.machine.orchestrator.ts
+var Semaphore = class {
+  permits;
+  waiting = [];
+  constructor(permits) {
+    this.permits = permits;
+  }
+  async acquire() {
+    if (this.permits > 0) {
+      this.permits--;
+      return;
+    }
+    return new Promise((resolve) => this.waiting.push(resolve));
+  }
+  release() {
+    if (this.waiting.length > 0) {
+      const next = this.waiting.shift();
+      next?.();
+    } else {
+      this.permits++;
+    }
+  }
+};
+async function getPackageVersions() {
+  try {
+    const core = await import("./package-VGL7HYTO.js").catch(() => ({
+      version: "unavailable"
+    }));
+    const graph = await import("./package-EXUIU2RL.js").catch(() => ({
+      version: "unavailable"
+    }));
+    const embeddings = await import("./package-XHMLOAQ4.js").catch(() => ({
+      version: "unavailable"
+    }));
+    return {
+      core: core.version,
+      graph: graph.version,
+      embeddings: embeddings.version
+    };
+  } catch (err) {
+    console.error("[getPackageVersions] Failed to load package versions:", err);
+    return { core: "unknown", graph: "unknown", embeddings: "unknown" };
+  }
+}
+var OrchestratorV0 = class {
+  /**
+   * Creates a new orchestrator instance.
+   *
+   * @param catalogResolver - Function to resolve node/stack manifests by reference
+   * @param tracer - Distributed tracer for observability (default: InMemoryTracer)
+   *
+   * @example
+   * ```typescript
+   * import { OrchestratorV0, resolveNode } from '@terminals-tech/machines';
+   *
+   * const orchestrator = new OrchestratorV0(resolveNode);
+   * ```
+   */
+  constructor(catalogResolver, tracer = new InMemoryTracer()) {
+    this.catalogResolver = catalogResolver;
+    this.tracer = tracer;
+    this.meshFeedbackUnsub = onMeshFeedback((data) => {
+      this.handleMeshFeedback(data);
+    });
+  }
+  // Adaptive concurrency based on mesh feedback (0.0 - 1.0 multiplier)
+  concurrencyMultiplier = 1;
+  // Mesh feedback unsubscriber
+  meshFeedbackUnsub = null;
+  // Track if we're under backpressure
+  underBackpressure = false;
+  // ============================================================================
+  // Neuro-Adaptive Execution State (Phase 3)
+  // ============================================================================
+  /** Whether execution is currently paused due to cognitive load */
+  isPaused = false;
+  /** Whether to check mood before each node batch (can be disabled for testing) */
+  moodCheckEnabled = true;
+  /** Resolver for waitForResume() promise */
+  resumeResolver = null;
+  /** Current run ID for pause/resume events */
+  currentRunId = null;
+  /** Coherence threshold below which to pause (0.0 - 1.0) */
+  pauseCoherenceThreshold = 0.3;
+  /**
+   * Handle feedback from mesh (L3 → L2)
+   * Adjusts concurrency and retry policy based on system health
+   */
+  handleMeshFeedback(data) {
+    switch (data.type) {
+      case "health_warning":
+        console.log(`[OrchestratorV0] Health warning from mesh: ${data.warning}`);
+        this.underBackpressure = true;
+        this.concurrencyMultiplier = Math.max(0.25, this.concurrencyMultiplier * 0.75);
+        break;
+      case "metrics_update":
+        if (data.metrics) {
+          const { healthScore, errorRate } = data.metrics;
+          if (healthScore > 0.7 && errorRate < 0.1 && this.underBackpressure) {
+            this.concurrencyMultiplier = Math.min(1, this.concurrencyMultiplier * 1.1);
+            if (this.concurrencyMultiplier >= 0.95) {
+              this.underBackpressure = false;
+              this.concurrencyMultiplier = 1;
+            }
+          }
+          if (healthScore < 0.3) {
+            this.underBackpressure = true;
+            this.concurrencyMultiplier = Math.max(0.1, this.concurrencyMultiplier * 0.5);
+          }
+        }
+        break;
+      case "policy_update":
+        console.log("[OrchestratorV0] Received policy update from mesh");
+        break;
+      case "mood_recovery":
+        if (this.isPaused && data.recovery) {
+          const { coherence, healthScore } = data.recovery;
+          if (coherence > this.pauseCoherenceThreshold && healthScore > 0.3) {
+            console.log(
+              `[OrchestratorV0] Mood recovered (coherence: ${coherence.toFixed(2)}, health: ${healthScore.toFixed(2)}), resuming execution`
+            );
+            this.resume();
+          }
+        }
+        break;
+    }
+  }
+  // ============================================================================
+  // Neuro-Adaptive Execution Methods (Phase 3)
+  // ============================================================================
+  /**
+   * Enable or disable mood checking before node batches.
+   * Useful for testing or when running trusted/internal stacks.
+   */
+  setMoodCheckEnabled(enabled) {
+    this.moodCheckEnabled = enabled;
+  }
+  /**
+   * Check if the orchestrator is currently paused.
+   */
+  getIsPaused() {
+    return this.isPaused;
+  }
+  /**
+   * Manually pause execution (e.g., from user request).
+   */
+  pause(reason = "user_requested") {
+    if (this.isPaused) return;
+    this.isPaused = true;
+    if (this.currentRunId) {
+      orchestratorToMesh.onSystemPause(this.currentRunId, reason);
+    }
+    console.log(`[OrchestratorV0] Execution paused: ${reason}`);
+  }
+  /**
+   * Resume paused execution.
+   */
+  resume() {
+    if (!this.isPaused) return;
+    this.isPaused = false;
+    if (this.currentRunId) {
+      orchestratorToMesh.onSystemResume(this.currentRunId);
+    }
+    console.log("[OrchestratorV0] Execution resumed");
+    if (this.resumeResolver) {
+      this.resumeResolver();
+      this.resumeResolver = null;
+    }
+  }
+  /**
+   * Wait for resume signal when paused.
+   * Returns immediately if not paused.
+   */
+  waitForResume() {
+    if (!this.isPaused) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      this.resumeResolver = resolve;
+    });
+  }
+  /**
+   * Check current mood/coherence and pause if critical.
+   * Called before each batch of node executions.
+   *
+   * @returns true if execution can proceed, false if paused
+   */
+  async checkMoodAndMaybePause(runId) {
+    if (!this.moodCheckEnabled) {
+      return true;
+    }
+    try {
+      const { neuroState } = await import("./neuro-state-XHRGIRVO.js");
+      const currentState = await new Promise((resolve) => {
+        let resolved = false;
+        let subscription = null;
+        const handleValue = (state) => {
+          if (resolved) return;
+          resolved = true;
+          resolve(state);
+          if (subscription) {
+            subscription.unsubscribe();
+          } else {
+            setTimeout(() => subscription?.unsubscribe(), 0);
+          }
+        };
+        subscription = neuroState.state$.subscribe(handleValue);
+        setTimeout(() => {
+          if (!resolved) {
+            resolved = true;
+            subscription?.unsubscribe();
+            resolve({
+              coherence: { overall: 1 },
+              convergence: { healthScore: 1 },
+              mood: "focused"
+            });
+          }
+        }, 50);
+      });
+      const { coherence, convergence, mood } = currentState;
+      if (mood === "overloaded" || coherence.overall < this.pauseCoherenceThreshold) {
+        console.log(
+          `[OrchestratorV0] Cognitive load critical (mood: ${mood}, coherence: ${coherence.overall.toFixed(2)}), pausing...`
+        );
+        this.pause("cognitive_load_critical");
+        return false;
+      }
+      if (convergence.healthScore < 0.3) {
+        console.log(
+          `[OrchestratorV0] Health degraded (score: ${convergence.healthScore.toFixed(2)}), pausing...`
+        );
+        this.pause("health_degraded");
+        return false;
+      }
+      return true;
+    } catch (err) {
+      console.warn("[OrchestratorV0] Mood check failed, continuing:", err);
+      return true;
+    }
+  }
+  /**
+   * Clean up mesh feedback subscription and release resources.
+   *
+   * Should be called when the orchestrator is no longer needed.
+   */
+  dispose() {
+    if (this.meshFeedbackUnsub) {
+      this.meshFeedbackUnsub();
+      this.meshFeedbackUnsub = null;
+    }
+  }
+  /**
+   * Execute a stack workflow with DAG orchestration.
+   *
+   * Performs topological execution of all nodes in the stack, managing
+   * dependencies, parallelism, retries, and caching.
+   *
+   * @param stack - Stack manifest defining the workflow DAG
+   * @param opts - Execution options (concurrency, retry policy, etc.)
+   * @returns Promise resolving to run result with outputs or error
+   *
+   * @example
+   * ```typescript
+   * const stack: StackManifestV0 = {
+   *   id: 'my-workflow',
+   *   version: '1.0.0',
+   *   nodes: [
+   *     { id: 'step1', nodeRef: 'http-fetch', config: { url: '...' } },
+   *     { id: 'step2', nodeRef: 'transform' }
+   *   ],
+   *   edges: [{ from: 'step1', to: 'step2', map: { data: 'input' } }]
+   * };
+   *
+   * const result = await orchestrator.run(stack, {
+   *   maxConcurrency: 4,
+   *   retryPolicy: { maxRetries: 2 }
+   * });
+   * ```
+   */
+  async run(stack, opts = {}) {
+    const startedAt = Date.now();
+    const runId = `${stack.id}:${startedAt}`;
+    const packageVersions = await getPackageVersions();
+    this.currentRunId = runId;
+    orchestratorToMesh.onRunStart(runId, stack.id);
+    try {
+      const validation = await linkAndValidateStack(stack, this.catalogResolver);
+      if (!validation.ok) {
+        const msg = validation.issues.map((i) => `${i.code}`).join(", ");
+        throw new Error(`Stack validation failed: ${msg}`);
+      }
+      const edges = (stack.edges || []).slice();
+      const incoming = /* @__PURE__ */ new Map();
+      stack.nodes.forEach((n) => incoming.set(n.id, 0));
+      edges.forEach((e) => incoming.set(e.to, (incoming.get(e.to) || 0) + 1));
+      let ready = stack.nodes.filter((n) => (incoming.get(n.id) || 0) === 0);
+      const outputs = /* @__PURE__ */ new Map();
+      const inFlight = /* @__PURE__ */ new Map();
+      const completed = /* @__PURE__ */ new Set();
+      const nodeAttempts = /* @__PURE__ */ new Map();
+      const baseConcurrency = opts.maxConcurrency || Infinity;
+      const effectiveConcurrency = baseConcurrency === Infinity ? Math.floor(1e3 * this.concurrencyMultiplier) : Math.max(1, Math.floor(baseConcurrency * this.concurrencyMultiplier));
+      const semaphore = new Semaphore(effectiveConcurrency);
+      if (this.concurrencyMultiplier < 1) {
+        console.log(
+          `[OrchestratorV0] Running with reduced concurrency: ${effectiveConcurrency} (multiplier: ${this.concurrencyMultiplier.toFixed(2)})`
+        );
+      }
+      const retryPolicy = {
+        maxRetries: opts.retryPolicy?.maxRetries ?? 2,
+        backoffMs: opts.retryPolicy?.backoffMs ?? 1e3,
+        backoffMultiplier: opts.retryPolicy?.backoffMultiplier ?? 2
+      };
+      let shapeHash;
+      try {
+        const { computeShapeHash: computeShapeHash2 } = await import("./topology-CIWWNVAN.js");
+        shapeHash = await computeShapeHash2(stack);
+      } catch (err) {
+        console.error("[OrchestratorV0] Failed to compute shape hash:", err);
+      }
+      const processNode = async (node) => {
+        await semaphore.acquire();
+        const manifest = await this.catalogResolver(node.nodeRef);
+        if (!manifest) throw new Error(`Node manifest not found: ${node.nodeRef}`);
+        const tier = this.pickTier(stack, node, manifest);
+        const baseInput = this.buildInputs(node, edges, outputs);
+        const input = {
+          ...baseInput,
+          ...opts.configOverrides?.[node.id] || {}
+        };
+        const modelId = input.model || node.config?.model || "default";
+        const span = this.tracer.startSpan(`node:${node.id}`, {
+          stackId: stack.id,
+          nodeRef: node.nodeRef,
+          runtimeTier: tier,
+          commit: process.env.GIT_COMMIT_SHA,
+          packages: packageVersions,
+          modelId,
+          policies: JSON.stringify(node.policies || manifest.policies || {})
+        });
+        let result = null;
+        let lastError = null;
+        const currentAttempt = (nodeAttempts.get(node.id) || 0) + 1;
+        nodeAttempts.set(node.id, currentAttempt);
+        try {
+          const { makeKey, getCachedOutput, setCachedOutput } = await import("./cache-VKYSQRXX.js");
+          const cacheKey = makeKey(shapeHash, node.id, input);
+          const cached = getCachedOutput(cacheKey);
+          if (cached) {
+            this.tracer.addEvent(span, {
+              time: Date.now(),
+              event: "cache.hit"
+            });
+            result = cached;
+          } else {
+            for (let attempt = 1; attempt <= retryPolicy.maxRetries + 1; attempt++) {
+              try {
+                result = await this.executeNode(stack.id, node, manifest, tier, input, opts);
+                lastError = null;
+                break;
+              } catch (execErr) {
+                lastError = execErr instanceof Error ? execErr : new Error(String(execErr));
+                this.tracer.addEvent(span, {
+                  time: Date.now(),
+                  event: "retry",
+                  attributes: {
+                    attempt,
+                    maxRetries: retryPolicy.maxRetries,
+                    error: lastError?.message
+                  }
+                });
+                if (attempt <= retryPolicy.maxRetries) {
+                  const backoffTime = retryPolicy.backoffMs * Math.pow(retryPolicy.backoffMultiplier, attempt - 1);
+                  await new Promise((resolve) => setTimeout(resolve, backoffTime));
+                }
+              }
+            }
+            if (lastError) {
+              throw lastError;
+            }
+            if (result && Object.keys(result).length > 0) setCachedOutput(cacheKey, result);
+          }
+          this.tracer.addEvent(span, {
+            time: Date.now(),
+            event: "finished",
+            attributes: { ok: true, result }
+          });
+        } catch (err) {
+          const errorMessage = err instanceof Error ? err.message : String(err);
+          this.tracer.addEvent(span, {
+            time: Date.now(),
+            event: "error",
+            attributes: { message: errorMessage }
+          });
+          throw err;
+        } finally {
+          this.tracer.endSpan(span);
+          semaphore.release();
+        }
+        outputs.set(node.id, result || {});
+        return node.id;
+      };
+      while (completed.size < stack.nodes.length) {
+        const canProceed = await this.checkMoodAndMaybePause(runId);
+        if (!canProceed) {
+          if (inFlight.size > 0) {
+            const finishedWhilePaused = await Promise.race(Array.from(inFlight.values()));
+            inFlight.delete(finishedWhilePaused);
+            completed.add(finishedWhilePaused);
+            orchestratorToMesh.onNodeComplete(
+              runId,
+              finishedWhilePaused,
+              true,
+              Date.now() - startedAt
+            );
+          }
+          await this.waitForResume();
+        }
+        for (const node of ready) {
+          if (!inFlight.has(node.id)) {
+            inFlight.set(node.id, processNode(node));
+          }
+        }
+        if (inFlight.size === 0) {
+          throw new Error(
+            "Orchestration failed: no nodes are ready or in-flight, but not all nodes have completed."
+          );
+        }
+        const finishedNodeId = await Promise.race(Array.from(inFlight.values()));
+        inFlight.delete(finishedNodeId);
+        completed.add(finishedNodeId);
+        orchestratorToMesh.onNodeComplete(runId, finishedNodeId, true, Date.now() - startedAt);
+        const newlyReady = [];
+        edges.filter((e) => e.from === finishedNodeId).forEach((e) => {
+          const to = e.to;
+          const newCount = (incoming.get(to) || 0) - 1;
+          incoming.set(to, newCount);
+          if (newCount === 0) {
+            const target = stack.nodes.find((n) => n.id === to);
+            if (target) newlyReady.push(target);
+          }
+        });
+        ready = newlyReady;
+      }
+      const spans = await this.tracer.export?.() || [];
+      for (const s of spans) {
+        s.traceId = runId;
+      }
+      try {
+        await persistSpans(spans);
+      } catch (err) {
+        console.error("[OrchestratorV0] Failed to persist spans:", err);
+      }
+      const endedAt = Date.now();
+      const totalDurationMs = endedAt - startedAt;
+      const nodeDurations = {};
+      for (const s of spans) {
+        const name = s.name;
+        if (name?.startsWith("node:") && s.startTime && s.endTime) {
+          const nodeId = name.slice("node:".length);
+          nodeDurations[nodeId] = (nodeDurations[nodeId] || 0) + (s.endTime - s.startTime);
+        }
+      }
+      persistRunMeta({
+        runId,
+        stackId: stack.id,
+        shapeHash,
+        startedAt,
+        endedAt,
+        status: "succeeded",
+        commit: process.env.GIT_COMMIT_SHA,
+        packages: packageVersions,
+        metrics: { totalDurationMs, nodeDurations }
+      });
+      orchestratorToMesh.onRunComplete(runId, true, totalDurationMs);
+      this.currentRunId = null;
+      return { runId, succeeded: true, outputs };
+    } catch (e) {
+      const runError = e instanceof Error ? e : new Error(String(e));
+      try {
+        const spans = await this.tracer.export?.() || [];
+        for (const s of spans) {
+          s.traceId = runId;
+        }
+        await persistSpans(spans);
+      } catch (err) {
+        console.error("[OrchestratorV0] Failed to persist error spans:", err);
+      }
+      const failedAt = Date.now();
+      persistRunMeta({
+        runId,
+        stackId: stack.id,
+        startedAt,
+        endedAt: failedAt,
+        status: "failed",
+        commit: process.env.GIT_COMMIT_SHA,
+        packages: packageVersions,
+        // capture error message in feedback tags for now
+        feedback: { tags: [runError.message] }
+      });
+      orchestratorToMesh.onRunComplete(runId, false, failedAt - startedAt);
+      this.currentRunId = null;
+      return { runId, succeeded: false, error: runError };
+    }
+  }
+  pickTier(stack, node, manifest) {
+    if (node.runtimes?.includes("stack")) return "stack";
+    const typedManifest = manifest;
+    const preferred = node.runtimes || stack.runtimes?.overrides?.[node.id] || stack.runtimes?.default || (Array.isArray(typedManifest.runtimes) ? typedManifest.runtimes : typedManifest.runtimes?.default) || ["worker"];
+    if (!typedManifest.kind && typedManifest.nodes && preferred[0] === "worker") {
+      return "stack";
+    }
+    return preferred[0];
+  }
+  buildInputs(node, edges, outputs) {
+    const inbound = edges.filter((e) => e.to === node.id);
+    const input = { ...node.config || {} };
+    for (const edge of inbound) {
+      const from = outputs.get(edge.from) || {};
+      const map = edge.map || {};
+      for (const [outKey, inKey] of Object.entries(map)) {
+        input[inKey] = from[outKey];
+      }
+    }
+    return input;
+  }
+  async executeNode(stackId, node, manifest, tier, input, options) {
+    void stackId;
+    void node;
+    if (typeof window === "undefined") {
+      const { ensureServerRunnersRegistered } = await import("./server-7DM74VFW.js");
+      await ensureServerRunnersRegistered();
+    }
+    const { runners } = await import("./registry-BL3TDQDB.js");
+    const tierRunner = runners.getRunner(tier);
+    if (tierRunner) {
+      return await tierRunner(manifest, input, {
+        stackId,
+        nodeId: node.id,
+        policies: node.policies || manifest.policies,
+        userId: options?.userId,
+        appletId: options?.appletId,
+        worldId: options?.worldId,
+        terminalId: options?.terminalId
+      });
+    }
+    if (tier === "worker") {
+      const fn = runners.getWorker(manifest.id);
+      const secretNames = node.secrets && node.secrets.length > 0 ? node.secrets : isNodeManifest(manifest) ? (manifest.secrets || []).map((s) => s.name) : [];
+      const secrets = {};
+      for (const name of secretNames) {
+        const scope = {
+          ownerId: options?.userId || "anonymous",
+          stackId,
+          appletId: options?.appletId,
+          worldId: options?.worldId,
+          terminalId: options?.terminalId,
+          nodeId: node.id
+        };
+        const value = await resolveSecretValue(name, scope);
+        if (value) secrets[name] = value;
+      }
+      if (fn)
+        return fn(
+          manifest,
+          { ...input, __secrets: secrets },
+          {
+            stackId,
+            nodeId: node.id,
+            policies: node.policies || manifest.policies,
+            userId: options?.userId,
+            appletId: options?.appletId,
+            worldId: options?.worldId,
+            terminalId: options?.terminalId
+          }
+        );
+      return { ...input };
+    }
+    if (tier === "webcontainer") {
+      const { runInWebContainer } = await import("./webcontainer-3LDJVIIL.js");
+      return await runInWebContainer(manifest, input, {
+        stackId,
+        nodeId: node.id,
+        policies: node.policies || manifest.policies
+      });
+    }
+    if (tier === "wasm-hvm") {
+      const { runInHVM } = await import("./hvm-DRQK2MUT.js");
+      return await runInHVM(manifest, input, {
+        stackId,
+        nodeId: node.id,
+        policies: node.policies || manifest.policies
+      });
+    }
+    if (isNodeManifest(manifest) && manifest.kind === "mcp") {
+      const { runMcpNode } = await import("./mcp-NK34ZNM5.js");
+      return await runMcpNode(manifest, input, {
+        stackId,
+        nodeId: node.id,
+        policies: node.policies || manifest.policies
+      });
+    }
+    return {};
+  }
+};
+
+export {
+  loadStack,
+  OrchestratorV0
+};