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

package/dist/chunk-KASHT6C5.js

@@ -0,0 +1,784 @@
+import {
+  getProvider
+} from "./chunk-H3POJCFA.js";
+import {
+  appendMeshSinkEvent
+} from "./chunk-PWAHFID5.js";
+import {
+  blendResonance,
+  cosineResonance,
+  hierarchicalResonance,
+  iqPhaseLockResonance,
+  phaseLockingValue,
+  phaseShift,
+  toIQ
+} from "./chunk-WU4OTGJE.js";
+import {
+  registerNode
+} from "./chunk-OCLSAUCD.js";
+import {
+  emitSignal
+} from "./chunk-2WTYE4SW.js";
+import {
+  Combinators,
+  createPAdicAddress
+} from "./chunk-EXI3LJVJ.js";
+
+// ../../lib/terminals-tech/machines/core/nodes/provider.chat.ts
+var PROVIDER_CHAT_NODE_ID = "provider.chat.v1";
+var manifest = {
+  id: PROVIDER_CHAT_NODE_ID,
+  version: "0.1.0",
+  kind: "task",
+  label: "Provider Chat",
+  description: "Calls a chat model on a selected provider",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: {
+      provider: {
+        type: "string",
+        description: "provider id (openai, nous, prime, ...)"
+      },
+      model: { type: "string" },
+      messages: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: { role: { type: "string" }, content: { type: "string" } },
+          required: ["role", "content"]
+        }
+      },
+      temperature: { type: "number" },
+      secretRef: {
+        type: "string",
+        description: "reference key in Secrets store"
+      },
+      baseUrl: { type: "string", description: "override baseUrl for vendor" }
+    },
+    required: ["provider", "model", "messages"]
+  },
+  outputsSchema: {
+    type: "object",
+    properties: { message: { type: "string" }, usage: { type: "object" } }
+  }
+};
+registerNode(manifest);
+async function executeProviderChat(inputs, context) {
+  const adapter = getProvider(inputs.provider);
+  if (!adapter?.chat?.generate) throw new Error(`provider not found: ${inputs.provider}`);
+  const secrets = inputs.secretRef && context.getSecret ? await context.getSecret(inputs.secretRef) : {};
+  const out = await adapter.chat.generate(
+    {
+      model: inputs.model,
+      messages: inputs.messages,
+      temperature: inputs.temperature
+    },
+    secrets
+  );
+  return { message: out.message, usage: out.usage };
+}
+
+// ../../lib/terminals-tech/machines/hvm/bridge.ts
+function calculateValuation(node) {
+  let valuation = 0;
+  valuation += node.inputs.length * 1;
+  if (node.type && node.type !== "any") {
+    valuation += 1;
+  }
+  if (node.outputs.length === 0) {
+    valuation += 0.5;
+  }
+  return valuation;
+}
+function reconcileGraphDepths(nodes) {
+  const depths = /* @__PURE__ */ new Map();
+  const nodeMap = new Map(nodes.map((n) => [n.id, n]));
+  function getDepth(id, visited = /* @__PURE__ */ new Set()) {
+    if (visited.has(id)) return 0;
+    if (depths.has(id)) return depths.get(id);
+    visited.add(id);
+    const node = nodeMap.get(id);
+    if (!node) return 0;
+    let maxParentDepth = -1;
+    for (const inputId of node.inputs) {
+      maxParentDepth = Math.max(maxParentDepth, getDepth(inputId, visited));
+    }
+    const localVal = node.type && node.type !== "any" ? 1 : 0;
+    const depth = maxParentDepth + 1 + localVal;
+    depths.set(id, depth);
+    visited.delete(id);
+    return depth;
+  }
+  nodes.forEach((n) => getDepth(n.id));
+  return depths;
+}
+var TWO_PI = Math.PI * 2;
+function addressPhase(addr) {
+  let x = 0;
+  for (let i = 0; i < addr.coefficients.length; i++) {
+    x += addr.coefficients[i] / Math.pow(addr.base, i + 1);
+  }
+  return x % 1 * TWO_PI;
+}
+function normalizeBiasValue(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(-1, Math.min(1, value));
+}
+function hvmToLogitBias(trace, baseMagnitude = 0.15) {
+  const phase = addressPhase(trace.address);
+  const sin = Math.sin(phase);
+  const cos = Math.cos(phase);
+  const bias = {};
+  switch (trace.type) {
+    case Combinators.CONSTRUCT:
+      bias["control:decompose"] = normalizeBiasValue(baseMagnitude * sin);
+      bias["control:structure"] = normalizeBiasValue(baseMagnitude * 0.7);
+      break;
+    case Combinators.DUPLICATE:
+      bias["control:parallel"] = normalizeBiasValue(baseMagnitude * cos);
+      bias["control:branch"] = normalizeBiasValue(baseMagnitude * 0.6);
+      break;
+    case Combinators.ERASE:
+      bias["control:synthesize"] = normalizeBiasValue(baseMagnitude * sin);
+      bias["control:compress"] = normalizeBiasValue(baseMagnitude * 0.5);
+      break;
+    default:
+      break;
+  }
+  const meta = trace.metadata;
+  const tokenHints = Array.isArray(meta?.tokenHints) ? meta?.tokenHints : [];
+  for (const hint of tokenHints) {
+    if (!bias[hint]) {
+      bias[hint] = normalizeBiasValue(baseMagnitude * 0.4);
+    }
+  }
+  return bias;
+}
+
+// ../../lib/terminals-tech/machines/core/nodes/hvm.proof.edgeCheck.ts
+var HVM_PROOF_EDGE_CHECK_NODE_ID = "hvm.proof.edgeCheck.v1";
+var manifest2 = {
+  id: HVM_PROOF_EDGE_CHECK_NODE_ID,
+  version: "0.1.0",
+  kind: "transform",
+  label: "HVM Edge Proof",
+  description: "Deterministic edge validation with p-adic proof trace.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: {
+      graph: {
+        type: "object",
+        properties: {
+          nodes: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                id: { type: "string" },
+                inputs: { type: "array", items: { type: "string" } },
+                outputs: { type: "array", items: { type: "string" } },
+                type: { type: "string" }
+              },
+              required: ["id", "inputs", "outputs"]
+            }
+          },
+          edges: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                from: { type: "string" },
+                to: { type: "string" }
+              },
+              required: ["from", "to"]
+            }
+          }
+        },
+        required: ["nodes", "edges"]
+      },
+      candidate: {
+        type: "object",
+        properties: {
+          from: { type: "string" },
+          to: { type: "string" },
+          fromType: { type: "string" },
+          toType: { type: "string" }
+        },
+        required: ["from", "to"]
+      },
+      constraints: {
+        type: "object",
+        properties: {
+          disallowCycles: { type: "boolean" },
+          requireTypeMatch: { type: "boolean" }
+        }
+      }
+    },
+    required: ["graph", "candidate"]
+  },
+  outputsSchema: {
+    type: "object",
+    properties: {
+      ok: { type: "boolean" },
+      counterexample: { type: "string" },
+      suggestedAdapters: { type: "array", items: { type: "string" } },
+      valuation: { type: "number" },
+      depths: { type: "object" },
+      proofTrace: { type: "array", items: { type: "object" } },
+      logitBias: { type: "object" }
+    },
+    required: ["ok", "proofTrace"]
+  }
+};
+registerNode(manifest2);
+function hasPath(edges, from, to, visited = /* @__PURE__ */ new Set()) {
+  if (from === to) return true;
+  if (visited.has(from)) return false;
+  visited.add(from);
+  const next = edges.filter((e) => e.from === from).map((e) => e.to);
+  for (const n of next) {
+    if (hasPath(edges, n, to, visited)) return true;
+  }
+  return false;
+}
+function slug(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "_").slice(0, 48);
+}
+async function executeHvmProofEdgeCheck(input, ctx) {
+  const typedInput = input;
+  const graph = typedInput.graph;
+  const candidate = typedInput.candidate;
+  const constraints = typedInput.constraints || {};
+  const proofTrace = [];
+  const nodeMap = new Map(graph.nodes.map((n) => [n.id, n]));
+  let ok = true;
+  let counterexample;
+  let suggestedAdapters = [];
+  const fromNode = nodeMap.get(candidate.from);
+  const toNode = nodeMap.get(candidate.to);
+  if (!fromNode || !toNode) {
+    ok = false;
+    counterexample = "Missing source or target node";
+    proofTrace.push({
+      step: "node_presence",
+      message: counterexample
+    });
+  } else {
+    proofTrace.push({
+      step: "node_presence",
+      message: "Both nodes present",
+      data: { from: fromNode.id, to: toNode.id }
+    });
+  }
+  if (ok && constraints.requireTypeMatch) {
+    const fromType = candidate.fromType || fromNode?.type || "any";
+    const toType = candidate.toType || toNode?.type || "any";
+    if (fromType !== "any" && toType !== "any" && fromType !== toType) {
+      ok = false;
+      counterexample = `Type mismatch: ${fromType} \u2192 ${toType}`;
+      suggestedAdapters = ["transform.object.pickPath.v1"];
+      proofTrace.push({
+        step: "type_check",
+        message: counterexample,
+        data: { fromType, toType }
+      });
+    } else {
+      proofTrace.push({
+        step: "type_check",
+        message: "Type compatibility satisfied",
+        data: { fromType, toType }
+      });
+    }
+  }
+  if (ok && constraints.disallowCycles) {
+    const wouldCycle = hasPath(graph.edges, candidate.to, candidate.from);
+    if (wouldCycle) {
+      ok = false;
+      counterexample = "Cycle detected in candidate edge";
+      proofTrace.push({
+        step: "cycle_check",
+        message: counterexample
+      });
+    } else {
+      proofTrace.push({
+        step: "cycle_check",
+        message: "No cycle detected"
+      });
+    }
+  }
+  const bridgeNodes = graph.nodes.map((node) => ({
+    ...node,
+    type: node.type || "any"
+  }));
+  const valuation = toNode ? calculateValuation({ ...toNode, type: toNode.type || "any" }) : 0;
+  const depths = reconcileGraphDepths(bridgeNodes);
+  const depthMap = {};
+  depths.forEach((v, k) => {
+    depthMap[k] = v;
+  });
+  proofTrace.push({
+    step: "valuation",
+    message: `Valuation computed (${valuation})`,
+    data: { valuation, depth: depthMap[candidate.to] }
+  });
+  const eventType = ok ? Combinators.CONSTRUCT : suggestedAdapters.length ? Combinators.DUPLICATE : Combinators.ERASE;
+  const combinatorEvent = {
+    type: eventType,
+    address: createPAdicAddress(2, [Math.max(0, depthMap[candidate.to] || 0) % 2]),
+    timestamp: Date.now(),
+    metadata: {
+      tokenHints: ok ? ["control:structure"] : ["control:compress"]
+    }
+  };
+  const logitBias = hvmToLogitBias(combinatorEvent, 0.15);
+  const tracePath = `proofs.${slug(ctx.stackId)}.${slug(
+    ctx.nodeId
+  )}.${slug(candidate.from)}_${slug(candidate.to)}`;
+  await appendMeshSinkEvent({
+    tracePath,
+    payload: {
+      ok,
+      counterexample,
+      suggestedAdapters,
+      valuation,
+      depths: depthMap,
+      proofTrace,
+      candidate
+    },
+    logId: `proofs-${ctx.stackId}`,
+    typeOverride: "proof.edgeCheck"
+  });
+  return {
+    ok,
+    counterexample,
+    suggestedAdapters,
+    valuation,
+    depths: depthMap,
+    proofTrace,
+    logitBias
+  };
+}
+
+// ../../lib/terminals-tech/machines/core/nodes/compute.bend.ts
+var COMPUTE_BEND_NODE_ID = "compute.bend.v1";
+var manifest3 = {
+  id: COMPUTE_BEND_NODE_ID,
+  version: "0.1.0",
+  kind: "task",
+  label: "Bend Compute",
+  description: "Execute a precompiled Bend/HVM module (.hvm or .wasm).",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: {
+      hvmModule: {
+        type: "string",
+        description: "Path to .hvm or .wasm module (e.g. /wasm/hvm/agent-logic.hvm)"
+      },
+      bendPath: {
+        type: "string",
+        description: "Optional .bend path (compile to .hvm/.wasm before execution)"
+      },
+      bendSource: {
+        type: "string",
+        description: "Inline Bend source (compile to .hvm/.wasm before execution)"
+      },
+      payload: {
+        type: "object",
+        description: "Input payload passed to the HVM module",
+        additionalProperties: true
+      }
+    }
+  },
+  outputsSchema: {
+    type: "object",
+    properties: {
+      ok: { type: "boolean" },
+      module: { type: "string" },
+      result: {},
+      _hvm: { type: "object" },
+      error: { type: "string" },
+      hint: { type: "string" }
+    },
+    required: ["ok"]
+  }
+};
+registerNode(manifest3);
+async function executeBendCompute(input, ctx) {
+  const rawModule = String(input.hvmModule || "");
+  const bendPath = String(input.bendPath || "");
+  const bendSource = String(input.bendSource || "");
+  const payload = input.payload || {};
+  const moduleFromBendPath = bendPath ? bendPath.endsWith(".bend") ? `/wasm/hvm/${(bendPath.split("/").pop() || "module").replace(/\.bend$/, "")}.hvm` : bendPath : "";
+  const hvmModule = rawModule || moduleFromBendPath;
+  if (!hvmModule) {
+    return {
+      ok: false,
+      error: "No HVM module provided",
+      hint: "Compile a .bend file (scripts/compile-hvm.sh or /api/platform/hvm/compile) and set hvmModule to /wasm/hvm/<file>.hvm or .wasm.",
+      bendSource: bendSource ? "present" : "absent"
+    };
+  }
+  const { runInHVM } = await import("./hvm-CBEP3M4F.js");
+  const manifestOverride = {
+    id: COMPUTE_BEND_NODE_ID,
+    version: "0.1.0",
+    kind: "task",
+    runtimes: ["wasm-hvm"],
+    entrypoints: { "wasm-hvm": { module: hvmModule } }
+  };
+  const output = await runInHVM(manifestOverride, payload, ctx);
+  return {
+    ok: !output?.error,
+    module: hvmModule,
+    result: output?.result ?? output,
+    _hvm: output?._hvm,
+    error: output?.error
+  };
+}
+
+// ../../lib/terminals-tech/machines/core/nodes/system.signal.emit.ts
+var SYSTEM_SIGNAL_EMIT_NODE_ID = "system.signal.emit.v1";
+var SIGNAL_TYPES = [
+  "health_update",
+  "circuit_change",
+  "convergence_update",
+  "coherence_update",
+  "resonance_update",
+  "task_complete",
+  "task_failed",
+  "adaptation_required",
+  "backpressure_warning",
+  "mesh_update",
+  "mesh_query",
+  "session_state_change"
+];
+var LAYERS = ["L1", "L2", "L3", "L4", "L5"];
+registerNode({
+  id: SYSTEM_SIGNAL_EMIT_NODE_ID,
+  version: "0.1.0",
+  kind: "task",
+  label: "Emit Signal",
+  description: "Emits an AXON signal (cross-layer) on the global signal bus.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  metadata: {
+    tags: ["axon", "signals", "observability"]
+  },
+  inputsSchema: {
+    type: "object",
+    properties: {
+      type: { type: "string", enum: SIGNAL_TYPES },
+      source: { type: "string", enum: LAYERS },
+      target: { type: "string", enum: LAYERS },
+      payload: { type: "object" },
+      correlationId: { type: "string" }
+    },
+    required: ["type", "source", "target", "payload"]
+  },
+  outputsSchema: {
+    type: "object",
+    properties: {
+      emitted: { type: "boolean" },
+      signalId: { type: "string" },
+      timestamp: { type: "number" },
+      correlationId: { type: "string" }
+    },
+    required: ["emitted", "signalId", "timestamp"]
+  }
+});
+function isLayer(x) {
+  return typeof x === "string" && LAYERS.includes(x);
+}
+function isSignalType(x) {
+  return typeof x === "string" && SIGNAL_TYPES.includes(x);
+}
+async function executeSystemSignalEmit(input, ctx = {}) {
+  const typeRaw = input?.type;
+  const sourceRaw = input?.source;
+  const targetRaw = input?.target;
+  const payload = input?.payload;
+  const correlationId = typeof input?.correlationId === "string" ? input.correlationId : ctx.stackId || void 0;
+  if (!isSignalType(typeRaw)) {
+    throw new Error(`Invalid signal type: ${String(typeRaw)}`);
+  }
+  if (!isLayer(sourceRaw)) {
+    throw new Error(`Invalid source layer: ${String(sourceRaw)}`);
+  }
+  if (!isLayer(targetRaw)) {
+    throw new Error(`Invalid target layer: ${String(targetRaw)}`);
+  }
+  const signal = emitSignal(typeRaw, sourceRaw, targetRaw, payload, correlationId);
+  return {
+    emitted: true,
+    signalId: signal.id,
+    timestamp: signal.timestamp,
+    correlationId: signal.correlationId
+  };
+}
+
+// ../../lib/terminals-tech/machines/core/nodes/resonance.quadrature.ts
+var BASE_RESONANCE_IQ_ENCODE_NODE_ID = "base.resonance.iq.encode.v1";
+var BASE_RESONANCE_IQ_PHASE_SHIFT_NODE_ID = "base.resonance.iq.phaseShift.v1";
+var BASE_RESONANCE_METRICS_NODE_ID = "base.resonance.metrics.v1";
+var BASE_PHASE_LOCKING_VALUE_NODE_ID = "base.phase.plv.v1";
+var PARADIGM_METADATA = {
+  paradigms: ["resonant-quadrature"],
+  tags: ["iq", "phase", "resonance", "phase-lock"]
+};
+var IQ_SCHEMA = {
+  type: "object",
+  properties: {
+    inPhase: { type: "array", items: { type: "number" } },
+    quadrature: { type: "array", items: { type: "number" } }
+  },
+  required: ["inPhase", "quadrature"]
+};
+var VEC_SCHEMA = { type: "array", items: { type: "number" } };
+registerNode({
+  id: BASE_RESONANCE_IQ_ENCODE_NODE_ID,
+  version: "0.1.0",
+  kind: "transform",
+  label: "IQ Encode",
+  description: "Encode a real vector into a deterministic I/Q embedding.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  metadata: PARADIGM_METADATA,
+  inputsSchema: {
+    type: "object",
+    properties: {
+      vector: VEC_SCHEMA,
+      mode: {
+        type: "string",
+        enum: ["orthogonalTransform", "dualEncoder"],
+        description: "Encoding mode. 'dualEncoder' is reserved and will error until implemented."
+      },
+      normalizePair: { type: "boolean" }
+    },
+    required: ["vector"]
+  },
+  outputsSchema: {
+    type: "object",
+    properties: { iq: IQ_SCHEMA },
+    required: ["iq"]
+  }
+});
+registerNode({
+  id: BASE_RESONANCE_IQ_PHASE_SHIFT_NODE_ID,
+  version: "0.1.0",
+  kind: "transform",
+  label: "IQ Phase Shift",
+  description: "Apply a global phase rotation \u0394 to an I/Q embedding.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  metadata: PARADIGM_METADATA,
+  inputsSchema: {
+    type: "object",
+    properties: {
+      iq: IQ_SCHEMA,
+      delta: { type: "number", description: "Phase rotation \u0394 in radians." }
+    },
+    required: ["iq", "delta"]
+  },
+  outputsSchema: {
+    type: "object",
+    properties: { iq: IQ_SCHEMA },
+    required: ["iq"]
+  }
+});
+registerNode({
+  id: BASE_RESONANCE_METRICS_NODE_ID,
+  version: "0.1.0",
+  kind: "transform",
+  label: "Resonance Metrics",
+  description: "Compute semantic/hierarchical/phase-lock resonance components and blend into systemResonance.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  metadata: PARADIGM_METADATA,
+  inputsSchema: {
+    type: "object",
+    properties: {
+      a: VEC_SCHEMA,
+      b: VEC_SCHEMA,
+      aIQ: IQ_SCHEMA,
+      bIQ: IQ_SCHEMA,
+      weights: {
+        type: "object",
+        properties: {
+          semantic: { type: "number" },
+          hierarchical: { type: "number" },
+          phaseLock: { type: "number" }
+        }
+      }
+    },
+    required: ["a", "b"]
+  },
+  outputsSchema: {
+    type: "object",
+    properties: {
+      metrics: {
+        type: "object",
+        properties: {
+          semantic: { type: "number" },
+          hierarchical: { type: "number" },
+          phaseLock: { type: "number" },
+          systemResonance: { type: "number" },
+          timestamp: { type: "number" }
+        },
+        required: [
+          "semantic",
+          "hierarchical",
+          "phaseLock",
+          "systemResonance",
+          "timestamp"
+        ]
+      }
+    },
+    required: ["metrics"]
+  }
+});
+registerNode({
+  id: BASE_PHASE_LOCKING_VALUE_NODE_ID,
+  version: "0.1.0",
+  kind: "transform",
+  label: "Phase Locking Value (PLV)",
+  description: "Compute PLV between two phase sequences (0..1).",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  metadata: PARADIGM_METADATA,
+  inputsSchema: {
+    type: "object",
+    properties: {
+      phiA: { type: "array", items: { type: "number" } },
+      phiB: { type: "array", items: { type: "number" } }
+    },
+    required: ["phiA", "phiB"]
+  },
+  outputsSchema: {
+    type: "object",
+    properties: { plv: { type: "number" } },
+    required: ["plv"]
+  }
+});
+async function executeIqEncode(inputs) {
+  const vector = Array.isArray(inputs?.vector) ? inputs.vector : [];
+  const mode = inputs?.mode;
+  const iqMode = mode === "orthogonalTransform" || mode === "dualEncoder" ? mode : void 0;
+  const normalizePair = Boolean(inputs?.normalizePair);
+  const iq = toIQ(vector, { mode: iqMode, normalizePair });
+  return { iq: { inPhase: Array.from(iq.inPhase), quadrature: Array.from(iq.quadrature) } };
+}
+async function executeIqPhaseShift(inputs) {
+  const iqIn = inputs?.iq;
+  const inPhase = Array.isArray(iqIn?.inPhase) ? iqIn.inPhase : [];
+  const quadrature = Array.isArray(iqIn?.quadrature) ? iqIn.quadrature : [];
+  const delta = Number(inputs?.delta ?? 0);
+  const shifted = phaseShift(
+    { inPhase: new Float32Array(inPhase), quadrature: new Float32Array(quadrature) },
+    delta
+  );
+  return {
+    iq: { inPhase: Array.from(shifted.inPhase), quadrature: Array.from(shifted.quadrature) }
+  };
+}
+async function executeResonanceMetrics(inputs) {
+  const a = Array.isArray(inputs?.a) ? inputs.a : [];
+  const b = Array.isArray(inputs?.b) ? inputs.b : [];
+  const semantic = cosineResonance(a, b);
+  const hierarchical = hierarchicalResonance(a, b);
+  let phaseLock = 0;
+  if (inputs?.aIQ && inputs?.bIQ) {
+    const aIQ = inputs.aIQ;
+    const bIQ = inputs.bIQ;
+    if (Array.isArray(aIQ?.inPhase) && Array.isArray(aIQ?.quadrature) && Array.isArray(bIQ?.inPhase) && Array.isArray(bIQ?.quadrature)) {
+      phaseLock = iqPhaseLockResonance(
+        {
+          inPhase: new Float32Array(aIQ.inPhase),
+          quadrature: new Float32Array(aIQ.quadrature)
+        },
+        {
+          inPhase: new Float32Array(bIQ.inPhase),
+          quadrature: new Float32Array(bIQ.quadrature)
+        }
+      );
+    }
+  }
+  const weights = inputs?.weights || {};
+  const systemResonance = blendResonance({ semantic, hierarchical, phaseLock }, weights);
+  return {
+    metrics: {
+      semantic,
+      hierarchical,
+      phaseLock,
+      systemResonance,
+      timestamp: Date.now()
+    }
+  };
+}
+async function executePhaseLockingValueNode(inputs) {
+  const phiA = Array.isArray(inputs?.phiA) ? inputs.phiA : [];
+  const phiB = Array.isArray(inputs?.phiB) ? inputs.phiB : [];
+  const plv = phaseLockingValue(phiA, phiB);
+  return { plv };
+}
+
+// ../../lib/terminals-tech/machines/core/nodes/system.schedule.ts
+var SYSTEM_SCHEDULE_NODE_ID = "system.schedule.v1";
+var manifest4 = {
+  id: SYSTEM_SCHEDULE_NODE_ID,
+  version: "0.1.0",
+  kind: "task",
+  label: "Schedule",
+  description: "Schedules a stack to run at a fixed interval (seconds).",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: {
+      everySeconds: { type: "number", description: "Interval in seconds" },
+      enabled: { type: "boolean" }
+    },
+    required: ["everySeconds"]
+  },
+  outputsSchema: {
+    type: "object",
+    properties: {
+      scheduled: { type: "boolean" },
+      everySeconds: { type: "number" }
+    }
+  }
+};
+registerNode(manifest4);
+async function executeSystemSchedule(_input, ctx) {
+  const { scheduleStack } = await import("./scheduler-B5CEYKWT.js");
+  const everySeconds = Math.max(1, Number(_input.everySeconds || 60));
+  const enabled = Boolean(_input.enabled ?? true);
+  if (enabled) await scheduleStack(ctx.stackId, everySeconds);
+  return { scheduled: enabled, everySeconds };
+}
+
+export {
+  PROVIDER_CHAT_NODE_ID,
+  executeProviderChat,
+  HVM_PROOF_EDGE_CHECK_NODE_ID,
+  executeHvmProofEdgeCheck,
+  COMPUTE_BEND_NODE_ID,
+  executeBendCompute,
+  SYSTEM_SIGNAL_EMIT_NODE_ID,
+  executeSystemSignalEmit,
+  BASE_RESONANCE_IQ_ENCODE_NODE_ID,
+  BASE_RESONANCE_IQ_PHASE_SHIFT_NODE_ID,
+  BASE_RESONANCE_METRICS_NODE_ID,
+  BASE_PHASE_LOCKING_VALUE_NODE_ID,
+  executeIqEncode,
+  executeIqPhaseShift,
+  executeResonanceMetrics,
+  executePhaseLockingValueNode,
+  SYSTEM_SCHEDULE_NODE_ID,
+  executeSystemSchedule
+};