@ex7/mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,2110 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// ../sdk/src/auth/provider.ts
+function staticToken(token) {
+  const value = token && token.length > 0 ? token : null;
+  return { getToken: () => value };
+}
+function envToken(name = "EX7_TOKEN") {
+  return {
+    getToken: () => {
+      if (typeof process === "undefined" || !process.env)
+        return null;
+      const v = process.env[name];
+      return v && v.length > 0 ? v : null;
+    }
+  };
+}
+function chainAuth(...providers) {
+  const list = providers.filter((p) => !!p);
+  const provider = {
+    async getToken(ctx) {
+      for (const p of list) {
+        const t = await p.getToken(ctx);
+        if (t)
+          return t;
+      }
+      return null;
+    }
+  };
+  if (list.some((p) => typeof p.invalidate === "function")) {
+    provider.invalidate = async () => {
+      for (const p of list)
+        await p.invalidate?.();
+    };
+  }
+  return provider;
+}
+
+// ../sdk/src/config.ts
+var SDK_VERSION = "0.1.0";
+var DEFAULT_BASE_URL = "https://ex7capital.com";
+var DEFAULT_TIMEOUT_MS = 30000;
+function resolveConfig(config = {}) {
+  const baseUrl = (config.baseUrl ?? envBaseUrl() ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const auth = config.auth ?? chainAuth(staticToken(config.token), envToken("EX7_TOKEN"));
+  const resolved = {
+    baseUrl,
+    auth,
+    timeoutMs: config.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    userAgent: config.userAgent ?? `@ex7/sdk/${SDK_VERSION}`
+  };
+  if (config.agentToken !== undefined)
+    resolved.agentToken = config.agentToken;
+  if (config.fetch !== undefined)
+    resolved.fetch = config.fetch;
+  if (config.headers !== undefined)
+    resolved.headers = config.headers;
+  return resolved;
+}
+function envBaseUrl() {
+  if (typeof process === "undefined" || !process.env)
+    return;
+  return process.env.EX7_API_URL || undefined;
+}
+
+// ../sdk/src/errors.ts
+class EX7Error extends Error {
+  status;
+  code;
+  detail;
+  requestId;
+  constructor(status, code, message, detail, requestId) {
+    super(message);
+    this.name = "EX7Error";
+    this.status = status;
+    this.code = code;
+    this.detail = detail;
+    if (requestId !== undefined)
+      this.requestId = requestId;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+class EX7AuthError extends EX7Error {
+  constructor(status, code, message, detail, requestId) {
+    super(status, code, message, detail, requestId);
+    this.name = "EX7AuthError";
+  }
+}
+
+class EX7QuotaError extends EX7Error {
+  constructor(status, code, message, detail, requestId) {
+    super(status, code, message, detail, requestId);
+    this.name = "EX7QuotaError";
+  }
+}
+
+class EX7RateLimitError extends EX7Error {
+  retryAfterMs;
+  constructor(status, code, message, detail, requestId, retryAfterMs) {
+    super(status, code, message, detail, requestId);
+    this.name = "EX7RateLimitError";
+    if (retryAfterMs !== undefined)
+      this.retryAfterMs = retryAfterMs;
+  }
+}
+
+class EX7ValidationError extends EX7Error {
+  issues;
+  constructor(status, code, message, issues = [], detail, requestId) {
+    super(status, code, message, detail, requestId);
+    this.name = "EX7ValidationError";
+    this.issues = issues;
+  }
+}
+
+class EX7NotFoundError extends EX7Error {
+  constructor(status, code, message, detail, requestId) {
+    super(status, code, message, detail, requestId);
+    this.name = "EX7NotFoundError";
+  }
+}
+
+class EX7GateError extends EX7Error {
+  constructor(status, code, message, detail, requestId) {
+    super(status, code, message, detail, requestId);
+    this.name = "EX7GateError";
+  }
+}
+
+class EX7NetworkError extends EX7Error {
+  constructor(code, message, detail) {
+    super(0, code, message, detail);
+    this.name = "EX7NetworkError";
+  }
+}
+function extractIssues(body) {
+  if (Array.isArray(body.issues))
+    return body.issues;
+  if (body.detail && typeof body.detail === "object" && Array.isArray(body.detail.issues)) {
+    return body.detail.issues;
+  }
+  return [];
+}
+function errorFromStatus(status, body, fallbackMessage, headers) {
+  const code = body?.error ?? body?.code ?? (status > 0 ? `http_${status}` : "network_error");
+  const message = body?.message ?? body?.reason ?? fallbackMessage;
+  const detail = body?.detail ?? body?.details ?? undefined;
+  const requestId = headers?.get("x-request-id") ?? undefined;
+  switch (status) {
+    case 401:
+    case 403:
+      return new EX7AuthError(status, code, message, detail, requestId);
+    case 402:
+      return new EX7QuotaError(status, code, message, detail, requestId);
+    case 404:
+      return new EX7NotFoundError(status, code, message, detail, requestId);
+    case 409:
+      return new EX7GateError(status, code, message, detail, requestId);
+    case 422:
+      return new EX7ValidationError(status, code, message, body ? extractIssues(body) : [], detail, requestId);
+    case 429: {
+      const ra = headers?.get("retry-after");
+      const retryAfterMs = ra ? parseRetryAfter(ra) : undefined;
+      return new EX7RateLimitError(status, code, message, detail, requestId, retryAfterMs);
+    }
+    default:
+      if (code === "quota_exceeded") {
+        return new EX7QuotaError(status, code, message, detail, requestId);
+      }
+      return new EX7Error(status, code, message, detail, requestId);
+  }
+}
+function parseRetryAfter(value) {
+  const secs = Number(value);
+  if (Number.isFinite(secs))
+    return secs * 1000;
+  const date = Date.parse(value);
+  if (Number.isFinite(date))
+    return Math.max(0, date - Date.now());
+  return;
+}
+async function parseErrorResponse(res) {
+  const fallback = `HTTP ${res.status} ${res.statusText}`;
+  const ct = res.headers.get("content-type") ?? "";
+  if (ct.includes("application/json")) {
+    try {
+      const body = await res.json();
+      return errorFromStatus(res.status, body, fallback, res.headers);
+    } catch {
+      return errorFromStatus(res.status, undefined, fallback, res.headers);
+    }
+  }
+  let textDetail;
+  try {
+    const txt = await res.text();
+    if (txt)
+      textDetail = txt.slice(0, 1000);
+  } catch {}
+  return errorFromStatus(res.status, textDetail ? { detail: textDetail } : undefined, fallback, res.headers);
+}
+
+// ../sdk/src/http.ts
+class HttpClient {
+  cfg;
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  get baseUrl() {
+    return this.cfg.baseUrl;
+  }
+  getFetch() {
+    const f = this.cfg.fetch ?? globalThis.fetch;
+    if (!f) {
+      throw new EX7NetworkError("no_fetch", "global fetch is unavailable; pass a fetch implementation to createClient");
+    }
+    return f;
+  }
+  buildUrl(opts) {
+    const base = this.cfg.baseUrl.replace(/\/+$/, "");
+    const path = opts.path.replace(/^\/+/, "");
+    let url = `${base}/${path}`;
+    if (opts.query) {
+      const qs = new URLSearchParams;
+      for (const [k, v] of Object.entries(opts.query)) {
+        if (v === undefined)
+          continue;
+        qs.set(k, String(v));
+      }
+      const s = qs.toString();
+      if (s)
+        url += `?${s}`;
+    }
+    return url;
+  }
+  async buildHeaders(opts, accept) {
+    const h = {
+      accept,
+      "user-agent": this.cfg.userAgent,
+      ...this.cfg.defaultHeaders ?? {},
+      ...opts.headers ?? {}
+    };
+    if (opts.body !== undefined && !h["content-type"]) {
+      h["content-type"] = "application/json";
+    }
+    const mode = opts.auth ?? "bearer";
+    if (mode === "agent") {
+      if (!this.cfg.agentToken) {
+        throw new EX7Error(0, "no_agent_token", "agent auth was requested but no agentToken is configured on the client");
+      }
+      h["x-ex7-agent-id"] = this.cfg.agentToken;
+    } else if (mode === "bearer") {
+      const token = await this.cfg.auth.getToken({ baseUrl: this.cfg.baseUrl });
+      if (token)
+        h["authorization"] = `Bearer ${token}`;
+    }
+    return h;
+  }
+  async json(opts) {
+    const mode = opts.auth ?? "bearer";
+    let res = await this.fetchOnce(opts, "application/json");
+    if (res.status === 401 && mode === "bearer" && this.cfg.auth.invalidate) {
+      await this.cfg.auth.invalidate();
+      res = await this.fetchOnce(opts, "application/json");
+    }
+    if (!res.ok)
+      throw await parseErrorResponse(res);
+    const ct = res.headers.get("content-type") ?? "";
+    if (ct.includes("application/json")) {
+      return await res.json();
+    }
+    return await res.text();
+  }
+  async fetchOnce(opts, accept) {
+    const timeoutMs = opts.timeoutMs ?? this.cfg.timeoutMs;
+    const timeoutCtrl = new AbortController;
+    const timer = timeoutMs > 0 ? setTimeout(() => timeoutCtrl.abort(new Error(`timeout ${timeoutMs}ms`)), timeoutMs) : null;
+    const url = this.buildUrl(opts);
+    const headers = await this.buildHeaders(opts, accept);
+    const fetchFn = this.getFetch();
+    try {
+      return await fetchFn(url, {
+        method: opts.method ?? "GET",
+        headers,
+        body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined,
+        signal: composeSignals(opts.signal, timeoutCtrl.signal)
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new EX7NetworkError("network_error", `cannot reach ${url}: ${msg}`);
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+    }
+  }
+  async* sse(opts) {
+    const url = this.buildUrl(opts);
+    const headers = await this.buildHeaders(opts, "text/event-stream");
+    const fetchFn = this.getFetch();
+    let res;
+    try {
+      res = await fetchFn(url, {
+        method: opts.method ?? "GET",
+        headers,
+        body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined,
+        signal: opts.signal
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new EX7NetworkError("network_error", `cannot reach ${url}: ${msg}`);
+    }
+    if (!res.ok)
+      throw await parseErrorResponse(res);
+    if (!res.body) {
+      throw new EX7Error(res.status, "no_body", "SSE response has no body");
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder("utf-8");
+    let buf = "";
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done)
+        break;
+      buf += decoder.decode(value, { stream: true });
+      let idx;
+      while ((idx = buf.search(/\r?\n\r?\n/)) !== -1) {
+        const block = buf.slice(0, idx);
+        const match = buf.slice(idx).match(/^\r?\n\r?\n/);
+        buf = buf.slice(idx + (match?.[0].length ?? 2));
+        const ev = parseSseBlock(block);
+        if (ev)
+          yield ev;
+      }
+    }
+  }
+}
+function composeSignals(a, b) {
+  if (!a)
+    return b;
+  const ctrl = new AbortController;
+  const onAbort = () => ctrl.abort();
+  a.addEventListener("abort", onAbort, { once: true });
+  b.addEventListener("abort", onAbort, { once: true });
+  return ctrl.signal;
+}
+function parseSseBlock(block) {
+  if (!block.trim())
+    return null;
+  let event = null;
+  const dataLines = [];
+  for (const line of block.split(/\r?\n/)) {
+    if (line.startsWith(":"))
+      continue;
+    const colon = line.indexOf(":");
+    const field = colon === -1 ? line : line.slice(0, colon);
+    const value = colon === -1 ? "" : line.slice(colon + 1).replace(/^ /, "");
+    if (field === "event")
+      event = value;
+    else if (field === "data")
+      dataLines.push(value);
+  }
+  if (dataLines.length === 0 && event === null)
+    return null;
+  const raw = dataLines.join(`
+`);
+  let data = raw;
+  if (raw.length > 0 && (raw.startsWith("{") || raw.startsWith("["))) {
+    try {
+      data = JSON.parse(raw);
+    } catch {}
+  }
+  return { event, data, raw };
+}
+
+// ../sdk/src/graph/schema.ts
+var BUCKET_OF = {
+  indicator: "indicator",
+  analysis: "analysis",
+  filter: "filter",
+  order: "order",
+  bollinger_bands: "indicator",
+  macd: "indicator",
+  stochastic: "indicator",
+  vwap_node: "indicator",
+  delta_divergence: "analysis",
+  time_of_day_filter: "filter",
+  volatility_regime_filter: "filter",
+  trailing_stop_order: "order",
+  breakeven_stop: "order",
+  partial_exit: "order",
+  hedge_order: "order"
+};
+var ALL_GRAPH_NODE_TYPES = Object.keys(BUCKET_OF);
+var GRAPH_VERSION = 1;
+
+// ../sdk/src/graph/validator.ts
+var MAX_NODES = 500;
+var MAX_EDGES = 1000;
+var MAX_BYTES = 1 * 1024 * 1024;
+var VALID_NODE_TYPES = new Set(ALL_GRAPH_NODE_TYPES);
+var BUCKET_COMPATIBILITY = {
+  indicator: new Set(["indicator", "analysis", "filter", "order"]),
+  analysis: new Set(["analysis", "filter", "order"]),
+  filter: new Set(["filter", "order"]),
+  order: new Set(["order"])
+};
+function validateStrategyGraph(input) {
+  const issues = [];
+  if (typeof input === "string" && input.length > MAX_BYTES) {
+    return fail([
+      {
+        path: "$",
+        expected: `≤ ${MAX_BYTES} bytes`,
+        got: String(input.length),
+        message: `Strategy graph is too large: ${input.length} bytes (cap ${MAX_BYTES} = 1 MiB)`
+      }
+    ]);
+  }
+  let raw = input;
+  if (typeof input === "string") {
+    try {
+      raw = JSON.parse(input);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      return fail([
+        {
+          path: "$",
+          expected: "valid JSON",
+          got: msg,
+          message: `Strategy graph is not valid JSON: ${msg}`
+        }
+      ]);
+    }
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return fail([
+      {
+        path: "$",
+        expected: "JSON object",
+        got: Array.isArray(raw) ? "array" : typeof raw,
+        message: "Strategy graph must be a JSON object"
+      }
+    ]);
+  }
+  const obj = raw;
+  if (obj.version !== undefined && obj.version !== GRAPH_VERSION) {
+    return fail([
+      {
+        path: "version",
+        expected: String(GRAPH_VERSION),
+        got: JSON.stringify(obj.version),
+        message: `Graph version must be ${GRAPH_VERSION}, got ${JSON.stringify(obj.version)} (this client may be outdated)`
+      }
+    ]);
+  }
+  if (!Array.isArray(obj.nodes)) {
+    return fail([
+      {
+        path: "nodes",
+        expected: "array",
+        got: typeof obj.nodes,
+        message: "`nodes` must be an array of node objects"
+      }
+    ]);
+  }
+  if (!Array.isArray(obj.edges)) {
+    return fail([
+      {
+        path: "edges",
+        expected: "array",
+        got: typeof obj.edges,
+        message: "`edges` must be an array of edge objects"
+      }
+    ]);
+  }
+  if (obj.nodes.length > MAX_NODES) {
+    issues.push({
+      path: "nodes",
+      expected: `≤ ${MAX_NODES}`,
+      got: String(obj.nodes.length),
+      message: `Too many nodes: ${obj.nodes.length} exceeds cap of ${MAX_NODES}`
+    });
+  }
+  if (obj.edges.length > MAX_EDGES) {
+    issues.push({
+      path: "edges",
+      expected: `≤ ${MAX_EDGES}`,
+      got: String(obj.edges.length),
+      message: `Too many edges: ${obj.edges.length} exceeds cap of ${MAX_EDGES}`
+    });
+  }
+  if (issues.length > 0)
+    return fail(issues);
+  const nodes = [];
+  const seenNodeIds = new Set;
+  const nodeTypeById = new Map;
+  for (let i = 0;i < obj.nodes.length; i++) {
+    const r = validateNode(obj.nodes[i], i);
+    if (r.issue) {
+      issues.push(r.issue);
+      continue;
+    }
+    if (seenNodeIds.has(r.node.id)) {
+      issues.push({
+        path: `nodes[${i}].id`,
+        node_id: r.node.id,
+        expected: "unique within graph",
+        got: JSON.stringify(r.node.id),
+        message: `Node id '${r.node.id}' appears twice; ids must be unique`
+      });
+      continue;
+    }
+    seenNodeIds.add(r.node.id);
+    nodeTypeById.set(r.node.id, r.node.type);
+    nodes.push(r.node);
+  }
+  const edges = [];
+  const seenEdgeIds = new Set;
+  const adjacency = new Map;
+  for (let i = 0;i < obj.edges.length; i++) {
+    const r = validateEdge(obj.edges[i], i, nodeTypeById);
+    if (r.issue) {
+      issues.push(r.issue);
+      continue;
+    }
+    if (seenEdgeIds.has(r.edge.id)) {
+      issues.push({
+        path: `edges[${i}].id`,
+        expected: "unique within graph",
+        got: JSON.stringify(r.edge.id),
+        message: `Edge id '${r.edge.id}' appears twice; ids must be unique`
+      });
+      continue;
+    }
+    seenEdgeIds.add(r.edge.id);
+    edges.push(r.edge);
+    const outList = adjacency.get(r.edge.source) ?? [];
+    outList.push(r.edge.target);
+    adjacency.set(r.edge.source, outList);
+  }
+  if (edges.length > 0 && nodes.length > 0) {
+    const cycle = findCycle(nodes, adjacency);
+    if (cycle) {
+      issues.push({
+        path: "$",
+        expected: "directed acyclic graph",
+        got: cycle.join(" → "),
+        message: `Cycle detected: ${cycle.join(" → ")}. Strategy graphs must be DAGs.`
+      });
+    }
+  }
+  if (issues.length > 0)
+    return fail(issues);
+  return { ok: true, graph: { nodes, edges, version: GRAPH_VERSION } };
+}
+function extractGraphFromBody(body) {
+  if (body && typeof body === "object" && !Array.isArray(body)) {
+    const obj = body;
+    if ("graph_json" in obj)
+      return obj.graph_json;
+  }
+  return body;
+}
+function fail(issues) {
+  return { ok: false, errors: issues.map((i) => i.message), issues };
+}
+function validateNode(cand, i) {
+  const at = `nodes[${i}]`;
+  if (!cand || typeof cand !== "object" || Array.isArray(cand)) {
+    return {
+      issue: {
+        path: at,
+        expected: "object",
+        got: Array.isArray(cand) ? "array" : typeof cand,
+        message: `Node at index ${i} must be an object`
+      },
+      node: {}
+    };
+  }
+  const c = cand;
+  if (typeof c.id !== "string" || c.id.length === 0) {
+    return {
+      issue: {
+        path: `${at}.id`,
+        expected: "non-empty string",
+        got: typeof c.id === "string" ? '""' : typeof c.id,
+        message: `Node at index ${i} is missing 'id'`
+      },
+      node: {}
+    };
+  }
+  if (typeof c.type !== "string" || !VALID_NODE_TYPES.has(c.type)) {
+    return {
+      issue: {
+        path: `${at}.type`,
+        node_id: c.id,
+        expected: `one of: ${ALL_GRAPH_NODE_TYPES.join(", ")}`,
+        got: JSON.stringify(c.type),
+        message: `Node '${c.id}' has unknown type ${JSON.stringify(c.type)}. Valid: ${ALL_GRAPH_NODE_TYPES.join(", ")}`
+      },
+      node: {}
+    };
+  }
+  if (typeof c.subtype !== "string" || c.subtype.length === 0) {
+    return {
+      issue: {
+        path: `${at}.subtype`,
+        node_id: c.id,
+        expected: "non-empty string",
+        got: typeof c.subtype === "string" ? '""' : typeof c.subtype,
+        message: `Node '${c.id}' is missing 'subtype'`
+      },
+      node: {}
+    };
+  }
+  const pos = c.position;
+  if (!pos || typeof pos !== "object" || Array.isArray(pos) || typeof pos.x !== "number" || typeof pos.y !== "number" || !Number.isFinite(pos.x) || !Number.isFinite(pos.y)) {
+    return {
+      issue: {
+        path: `${at}.position`,
+        node_id: c.id,
+        expected: "{ x: finite number, y: finite number }",
+        got: JSON.stringify(pos),
+        message: `Node '${c.id}' position must be { x, y } with finite numbers`
+      },
+      node: {}
+    };
+  }
+  if (!c.params || typeof c.params !== "object" || Array.isArray(c.params)) {
+    return {
+      issue: {
+        path: `${at}.params`,
+        node_id: c.id,
+        expected: "plain object",
+        got: Array.isArray(c.params) ? "array" : typeof c.params,
+        message: `Node '${c.id}' params must be a plain object`
+      },
+      node: {}
+    };
+  }
+  return {
+    node: {
+      id: c.id,
+      type: c.type,
+      subtype: c.subtype,
+      position: { x: pos.x, y: pos.y },
+      params: c.params
+    }
+  };
+}
+function validateEdge(cand, i, nodeTypeById) {
+  const at = `edges[${i}]`;
+  if (!cand || typeof cand !== "object" || Array.isArray(cand)) {
+    return {
+      issue: {
+        path: at,
+        expected: "object",
+        got: Array.isArray(cand) ? "array" : typeof cand,
+        message: `Edge at index ${i} must be an object`
+      },
+      edge: {}
+    };
+  }
+  const c = cand;
+  if (typeof c.id !== "string" || c.id.length === 0) {
+    return {
+      issue: {
+        path: `${at}.id`,
+        expected: "non-empty string",
+        got: typeof c.id === "string" ? '""' : typeof c.id,
+        message: `Edge at index ${i} is missing 'id'`
+      },
+      edge: {}
+    };
+  }
+  if (typeof c.source !== "string" || c.source.length === 0) {
+    return {
+      issue: {
+        path: `${at}.source`,
+        expected: "non-empty string",
+        got: typeof c.source === "string" ? '""' : typeof c.source,
+        message: `Edge '${c.id}' is missing 'source'`
+      },
+      edge: {}
+    };
+  }
+  if (typeof c.target !== "string" || c.target.length === 0) {
+    return {
+      issue: {
+        path: `${at}.target`,
+        expected: "non-empty string",
+        got: typeof c.target === "string" ? '""' : typeof c.target,
+        message: `Edge '${c.id}' is missing 'target'`
+      },
+      edge: {}
+    };
+  }
+  if (c.source === c.target) {
+    return {
+      issue: {
+        path: at,
+        expected: "source ≠ target",
+        got: `${c.source} → ${c.source}`,
+        message: `Edge '${c.id}' is a self-loop on '${c.source}'; self-loops are not allowed`
+      },
+      edge: {}
+    };
+  }
+  const sType = nodeTypeById.get(c.source);
+  if (!sType) {
+    return {
+      issue: {
+        path: `${at}.source`,
+        expected: "id of a node in the graph",
+        got: JSON.stringify(c.source),
+        message: `Edge '${c.id}' source '${c.source}' is not a node in the graph`
+      },
+      edge: {}
+    };
+  }
+  const tType = nodeTypeById.get(c.target);
+  if (!tType) {
+    return {
+      issue: {
+        path: `${at}.target`,
+        expected: "id of a node in the graph",
+        got: JSON.stringify(c.target),
+        message: `Edge '${c.id}' target '${c.target}' is not a node in the graph`
+      },
+      edge: {}
+    };
+  }
+  const srcBucket = BUCKET_OF[sType];
+  const tgtBucket = BUCKET_OF[tType];
+  const allowed = BUCKET_COMPATIBILITY[srcBucket];
+  if (!allowed.has(tgtBucket)) {
+    const allowedList = Array.from(allowed).join(", ");
+    return {
+      issue: {
+        path: at,
+        expected: `${srcBucket} → one of: ${allowedList}`,
+        got: `${srcBucket} → ${tgtBucket}`,
+        message: `Edge '${c.id}' connects ${srcBucket} '${c.source}' to ${tgtBucket} '${c.target}'. Pipeline order is indicator → analysis → filter → order; allowed from ${srcBucket}: ${allowedList}.`
+      },
+      edge: {}
+    };
+  }
+  const out = { id: c.id, source: c.source, target: c.target };
+  if (typeof c.sourceHandle === "string")
+    out.sourceHandle = c.sourceHandle;
+  if (typeof c.targetHandle === "string")
+    out.targetHandle = c.targetHandle;
+  return { edge: out };
+}
+function findCycle(nodes, adjacency) {
+  const colour = new Map;
+  for (const n of nodes)
+    colour.set(n.id, 0);
+  const stack = [];
+  let cycle = null;
+  function dfs(id) {
+    colour.set(id, 1);
+    stack.push(id);
+    const out = adjacency.get(id) ?? [];
+    for (const next of out) {
+      const c = colour.get(next) ?? 0;
+      if (c === 1) {
+        const idx = stack.indexOf(next);
+        cycle = stack.slice(idx).concat(next);
+        return true;
+      }
+      if (c === 0 && dfs(next))
+        return true;
+    }
+    stack.pop();
+    colour.set(id, 2);
+    return false;
+  }
+  for (const n of nodes) {
+    if (colour.get(n.id) === 0) {
+      if (dfs(n.id))
+        return cycle;
+    }
+  }
+  return null;
+}
+
+// ../sdk/src/resources/strategies.ts
+var TERMINAL = new Set(["done", "error"]);
+
+class StrategiesResource {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  list(params = {}, o = {}) {
+    return this.http.json({
+      path: "api/backend/strategies",
+      query: {
+        limit: params.limit,
+        cursor: params.cursor,
+        instrument: params.instrument,
+        is_published: params.is_published,
+        q: params.q
+      },
+      ...o
+    });
+  }
+  async* listAll(params = {}, o = {}) {
+    let cursor = undefined;
+    do {
+      const page = await this.list({ ...params, cursor: cursor ?? undefined }, o);
+      for (const s of page.strategies)
+        yield s;
+      cursor = page.next_cursor;
+    } while (cursor);
+  }
+  get(id, o = {}) {
+    return this.http.json({
+      path: `api/backend/strategies/${encodeURIComponent(id)}`,
+      ...o
+    });
+  }
+  async create(input, o = {}) {
+    const { validate = true, ...callOpts } = o;
+    if (validate) {
+      const v = validateStrategyGraph(input.graph_json);
+      if (!v.ok) {
+        throw new EX7ValidationError(0, "invalid_graph", `graph failed validation: ${v.issues.length} issue(s)`, v.issues);
+      }
+    }
+    return this.http.json({
+      path: "api/backend/strategies",
+      method: "POST",
+      body: input,
+      ...callOpts
+    });
+  }
+  async delete(id, o = {}) {
+    await this.http.json({
+      path: `api/backend/strategies/${encodeURIComponent(id)}`,
+      method: "DELETE",
+      ...o
+    });
+    return { ok: true, id };
+  }
+  export(id, o = {}) {
+    return this.http.json({
+      path: `api/backend/strategies/${encodeURIComponent(id)}/export`,
+      ...o
+    });
+  }
+  async judge(id, o = {}) {
+    const path = `api/backend/strategies/${encodeURIComponent(id)}/judge`;
+    const maxTries = o.maxTries ?? 30;
+    const { signal, timeoutMs } = o;
+    let run = await this.http.json({ path, method: "POST", signal, timeoutMs });
+    o.onTick?.(run);
+    for (let i = 0;i < maxTries && !TERMINAL.has(run.status); i++) {
+      await sleep(o.intervalMs ?? Math.min(1000 + i * 250, 4000));
+      run = await this.http.json({ path, method: "GET", signal, timeoutMs });
+      o.onTick?.(run);
+    }
+    return run;
+  }
+  publish(id, o = {}) {
+    return this.setPublished(id, true, o);
+  }
+  unpublish(id, o = {}) {
+    return this.setPublished(id, false, o);
+  }
+  setPublished(id, publish, o = {}) {
+    return this.http.json({
+      path: `api/backend/strategies/${encodeURIComponent(id)}/${publish ? "publish" : "unpublish"}`,
+      method: "POST",
+      ...o
+    });
+  }
+  deployPlan(id, input = {}, o = {}) {
+    return this.http.json({
+      path: `api/backend/strategies/${encodeURIComponent(id)}/deploy-plan`,
+      method: "POST",
+      body: {
+        max_contracts: input.maxContracts ?? 1,
+        dd_limit: input.ddLimit ?? 2000,
+        single_day_bust_safe: input.bustSafe ?? false,
+        allow_promising: input.allowPromising ?? false
+      },
+      ...o
+    });
+  }
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// ../sdk/src/resources/judge.ts
+var TERMINAL2 = new Set(["done", "error", "failed"]);
+
+class JudgeResource {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  async* run(strategyId, o = {}) {
+    const metrics = {};
+    let verdict;
+    let tier;
+    let snapshot;
+    const stream = this.http.sse({
+      path: `api/judge/run/${encodeURIComponent(strategyId)}`,
+      method: "POST",
+      timeoutMs: 0,
+      ...o.signal ? { signal: o.signal } : {}
+    });
+    for await (const ev of stream) {
+      const data = ev.data && typeof ev.data === "object" ? ev.data : {};
+      if (data.metric && typeof data.metric.value === "number") {
+        metrics[data.metric.key] = data.metric.value;
+      }
+      if (data.verdict)
+        verdict = data.verdict;
+      if (data.tier)
+        tier = data.tier;
+      if (data.snapshot)
+        snapshot = data.snapshot;
+      yield data;
+    }
+    return buildSummary(verdict, tier, snapshot, metrics);
+  }
+  async runToEnd(strategyId, o = {}) {
+    const gen = this.run(strategyId, o);
+    let next = await gen.next();
+    while (!next.done) {
+      o.onPhase?.(next.value);
+      next = await gen.next();
+    }
+    return next.value;
+  }
+  runs = {
+    create: (graph, o = {}) => this.http.json({
+      path: "api/judge/runs",
+      method: "POST",
+      body: { graph },
+      ...o
+    }),
+    get: (runId, o = {}) => this.http.json({
+      path: `api/judge/runs/${encodeURIComponent(runId)}`,
+      ...o
+    })
+  };
+  async runFromGraph(graph, o = {}) {
+    const { signal, timeoutMs } = o;
+    const sub = await this.runs.create(graph, { signal, timeoutMs });
+    let run = sub;
+    o.onTick?.({ run_id: run.run_id, status: run.status });
+    const maxTries = o.maxTries ?? 30;
+    for (let i = 0;i < maxTries && !TERMINAL2.has(run.status); i++) {
+      await sleep2(o.intervalMs ?? Math.min(1000 + i * 250, 4000));
+      run = await this.runs.get(sub.run_id, { signal, timeoutMs });
+      o.onTick?.({ run_id: run.run_id, status: run.status });
+    }
+    return run;
+  }
+  health(o = {}) {
+    return this.http.json({ path: "api/judge/health", auth: "none", ...o });
+  }
+}
+function buildSummary(verdict, tier, snapshot, metrics) {
+  const summary = { metrics };
+  if (verdict)
+    summary.verdict = verdict;
+  if (tier)
+    summary.tier = tier;
+  if (snapshot)
+    summary.snapshot = snapshot;
+  return summary;
+}
+function sleep2(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// ../sdk/src/resources/vix.ts
+class VixResource {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  generate(input, o = {}) {
+    return this.http.json({
+      path: "api/backend/vix/generate",
+      method: "POST",
+      body: {
+        prompt: input.prompt,
+        ...input.currentGraph ? { current_graph: input.currentGraph } : {},
+        ...input.tone ? { tone: input.tone } : {}
+      },
+      ...o
+    });
+  }
+  generateStrategy(input, o = {}) {
+    return this.http.json({
+      path: "api/vix/generate-strategy",
+      method: "POST",
+      body: {
+        prompt: input.prompt,
+        ...input.instrument ? { instrument: input.instrument } : {},
+        ...input.timeframe ? { timeframe: input.timeframe } : {}
+      },
+      ...o
+    });
+  }
+  quota(o = {}) {
+    return this.http.json({ path: "api/vix/quota", ...o });
+  }
+}
+
+// ../sdk/src/resources/backtest.ts
+var TERMINAL3 = new Set(["succeeded", "failed", "cancelled"]);
+
+class BacktestResource {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  async run(strategyId, input, o = {}) {
+    const res = await this.http.json({
+      path: `api/backend/strategies/${encodeURIComponent(strategyId)}/backtest`,
+      method: "POST",
+      body: {
+        start_date: input.from,
+        end_date: input.to,
+        ...input.instrument ? { instrument: input.instrument } : {}
+      },
+      ...o
+    });
+    return res.job;
+  }
+  async list(strategyId, params = {}, o = {}) {
+    const res = await this.http.json({
+      path: `api/backend/strategies/${encodeURIComponent(strategyId)}/backtest`,
+      query: { limit: params.limit },
+      ...o
+    });
+    return res.jobs;
+  }
+  async get(strategyId, jobId, o = {}) {
+    const res = await this.http.json({
+      path: `api/backend/strategies/${encodeURIComponent(strategyId)}/backtest/${encodeURIComponent(jobId)}`,
+      ...o
+    });
+    return res.job;
+  }
+  async cancel(strategyId, jobId, o = {}) {
+    const res = await this.http.json({
+      path: `api/backend/strategies/${encodeURIComponent(strategyId)}/backtest/${encodeURIComponent(jobId)}`,
+      method: "DELETE",
+      ...o
+    });
+    return res.job;
+  }
+  async waitFor(strategyId, jobId, o = {}) {
+    const { signal } = o;
+    const maxWaitMs = o.maxWaitMs ?? 30 * 60000;
+    const started = Date.now();
+    let delay = o.intervalMs ?? 1500;
+    let job = await this.get(strategyId, jobId, { signal });
+    o.onTick?.(job);
+    while (!TERMINAL3.has(job.status)) {
+      if (Date.now() - started > maxWaitMs) {
+        throw new EX7Error(0, "backtest_timeout", `backtest ${jobId} did not finish within ${maxWaitMs}ms`);
+      }
+      await sleep3(delay, signal);
+      delay = Math.min(Math.round(delay * 1.4), 1e4);
+      job = await this.get(strategyId, jobId, { signal });
+      o.onTick?.(job);
+    }
+    if (job.status !== "succeeded") {
+      throw new EX7Error(0, `backtest_${job.status}`, job.error_message ?? `backtest ${jobId} ${job.status}`, job);
+    }
+    return job;
+  }
+  async runAndWait(strategyId, input, o = {}) {
+    const job = await this.run(strategyId, input, { signal: o.signal });
+    return this.waitFor(strategyId, job.id, o);
+  }
+}
+function sleep3(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted)
+      return reject(new Error("aborted"));
+    const t = setTimeout(resolve, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(t);
+      reject(new Error("aborted"));
+    }, { once: true });
+  });
+}
+
+// ../sdk/src/resources/signals.ts
+class SignalsResource {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  list(params = {}, o = {}) {
+    return this.http.json({
+      path: "api/backend/signals",
+      query: { limit: params.limit },
+      ...o
+    });
+  }
+  async* watch(o = {}) {
+    const reconnect = o.reconnect ?? true;
+    const minMs = o.backoff?.minMs ?? 1000;
+    const maxMs = o.backoff?.maxMs ?? 30000;
+    let delay = minMs;
+    for (;; ) {
+      try {
+        const stream = this.http.sse({
+          path: "api/backend/signals/stream",
+          timeoutMs: 0,
+          ...o.signal ? { signal: o.signal } : {}
+        });
+        for await (const ev of stream) {
+          if (ev.data && typeof ev.data === "object") {
+            yield ev.data;
+          }
+          delay = minMs;
+        }
+      } catch (err) {
+        if (!reconnect || o.signal?.aborted)
+          throw err;
+      }
+      if (!reconnect || o.signal?.aborted)
+        return;
+      await sleep4(delay, o.signal);
+      delay = Math.min(delay * 2, maxMs);
+    }
+  }
+}
+function sleep4(ms, signal) {
+  return new Promise((resolve) => {
+    const t = setTimeout(resolve, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(t);
+      resolve();
+    }, { once: true });
+  });
+}
+
+// ../sdk/src/resources/agents.ts
+class AgentsResource {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  spawn(input, o = {}) {
+    return this.http.json({
+      path: "api/agent/owner/spawn",
+      method: "POST",
+      body: {
+        orchestrator_provider: input.orchestratorProvider,
+        scopes: input.scopes,
+        ...input.ttlDays !== undefined ? { ttl_days: input.ttlDays } : {},
+        ...input.displayName !== undefined ? { display_name: input.displayName } : {},
+        ...input.orchestratorExternalId !== undefined ? { orchestrator_external_id: input.orchestratorExternalId } : {},
+        ...input.dailySpendingLimitCents !== undefined ? { daily_spending_limit_cents: input.dailySpendingLimitCents } : {}
+      },
+      ...o
+    });
+  }
+  list(o = {}) {
+    return this.http.json({ path: "api/agent/owner/agents", ...o });
+  }
+  revoke(agentId, o = {}) {
+    return this.http.json({
+      path: "api/agent/owner/revoke",
+      method: "POST",
+      body: { agent_id: agentId },
+      ...o
+    });
+  }
+}
+
+// ../sdk/src/resources/agent.ts
+class AgentScopedResource {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  vix(prompt, o = {}) {
+    return this.http.json({
+      path: "api/agent/vix/generate",
+      method: "POST",
+      body: { prompt },
+      auth: "agent",
+      ...o
+    });
+  }
+  judge(strategyId, o = {}) {
+    return this.http.json({
+      path: "api/agent/judge/run",
+      method: "POST",
+      body: { strategy_id: strategyId },
+      auth: "agent",
+      ...o
+    });
+  }
+}
+
+// ../sdk/src/graph/node-catalog.ts
+var NODE_CATALOG = {
+  rsi: { type: "indicator", defaultParams: { period: 14 } },
+  ema: { type: "indicator", defaultParams: { period: 20 } },
+  vwap: { type: "indicator", defaultParams: { anchor: "session" } },
+  bollinger: { type: "indicator", defaultParams: { period: 20, stdev: 2 } },
+  zscore: { type: "indicator", defaultParams: { period: 20 } },
+  atr: { type: "indicator", defaultParams: { period: 14 } },
+  volume: { type: "indicator", defaultParams: { mode: "raw" } },
+  bollinger_bands: { type: "bollinger_bands", defaultParams: { period: 20, stdev: 2 } },
+  macd: { type: "macd", defaultParams: { fast: 12, slow: 26, signal: 9 } },
+  stochastic: { type: "stochastic", defaultParams: { k_period: 14, d_period: 3, smoothing: 3 } },
+  vwap_node: { type: "vwap_node", defaultParams: { anchor: "session", bands: false } },
+  regime: { type: "analysis", defaultParams: { lookback: 60 } },
+  vix_filter: { type: "analysis", defaultParams: { allow: ["low_vol", "normal"] } },
+  delta_divergence: { type: "delta_divergence", defaultParams: { lookback: 30, min_delta: 0.5 } },
+  session: { type: "filter", defaultParams: { start: "09:50", end: "15:55", days: "mon-fri" } },
+  news_blackout: { type: "filter", defaultParams: { minutes_before: 5, minutes_after: 5 } },
+  volatility_gate: { type: "filter", defaultParams: { atr_min: 2, atr_max: 20 } },
+  time_of_day_filter: { type: "time_of_day_filter", defaultParams: { start: "09:50", end: "15:55" } },
+  volatility_regime_filter: {
+    type: "volatility_regime_filter",
+    defaultParams: { allow: ["low_vol", "normal"] }
+  },
+  entry_long: { type: "order", defaultParams: { size: 1, order_type: "market" } },
+  entry_short: { type: "order", defaultParams: { size: 1, order_type: "market" } },
+  stop_loss: { type: "order", defaultParams: { mode: "ticks", value: 8 } },
+  take_profit: { type: "order", defaultParams: { mode: "ticks", value: 12 } },
+  trailing_stop_order: { type: "trailing_stop_order", defaultParams: { mode: "ticks", distance: 8 } },
+  breakeven_stop: { type: "breakeven_stop", defaultParams: { trigger_ticks: 6, offset_ticks: 1 } },
+  partial_exit: { type: "partial_exit", defaultParams: { fraction: 0.5, target_ticks: 8 } },
+  hedge_order: { type: "hedge_order", defaultParams: { instrument: "MES", ratio: 1 } }
+};
+function resolveNodeType(subtype, fallbackBucket) {
+  return NODE_CATALOG[subtype]?.type ?? fallbackBucket;
+}
+function defaultParamsFor(subtype) {
+  const entry = NODE_CATALOG[subtype];
+  return entry ? { ...entry.defaultParams } : {};
+}
+
+// ../sdk/src/graph/builder.ts
+var BUCKET_COLUMN = {
+  indicator: 0,
+  analysis: 1,
+  filter: 2,
+  order: 3
+};
+var COLUMN_WIDTH = 320;
+var ROW_HEIGHT = 110;
+
+class GraphBuilder {
+  nodes = [];
+  edges = [];
+  subtypeCount = new Map;
+  columnFill = {
+    indicator: 0,
+    analysis: 0,
+    filter: 0,
+    order: 0
+  };
+  node(type, subtype, params, opts) {
+    const n = (this.subtypeCount.get(subtype) ?? 0) + 1;
+    this.subtypeCount.set(subtype, n);
+    const id = opts?.id ?? `${subtype}_${n}`;
+    const bucket = BUCKET_OF[type];
+    const position = opts?.position ?? this.nextPosition(bucket);
+    this.nodes.push({
+      id,
+      type,
+      subtype,
+      position,
+      params: params ?? defaultParamsFor(subtype)
+    });
+    return { id, type };
+  }
+  indicator(subtype, params) {
+    return this.node(resolveNodeType(subtype, "indicator"), subtype, params);
+  }
+  analysis(subtype, params) {
+    return this.node(resolveNodeType(subtype, "analysis"), subtype, params);
+  }
+  filter(subtype, params) {
+    return this.node(resolveNodeType(subtype, "filter"), subtype, params);
+  }
+  order(subtype, params) {
+    return this.node(resolveNodeType(subtype, "order"), subtype, params);
+  }
+  connect(from, to, opts) {
+    const base = `e_${from.id}__${to.id}`;
+    let id = base;
+    let dup = 1;
+    while (this.edges.some((e) => e.id === id))
+      id = `${base}_${++dup}`;
+    const edge = { id, source: from.id, target: to.id };
+    if (opts?.sourceHandle)
+      edge.sourceHandle = opts.sourceHandle;
+    if (opts?.targetHandle)
+      edge.targetHandle = opts.targetHandle;
+    this.edges.push(edge);
+    return this;
+  }
+  build() {
+    const result = this.tryBuild();
+    if (!result.ok) {
+      throw new EX7ValidationError(0, "invalid_graph", `graph failed validation: ${result.issues.length} issue(s)`, result.issues);
+    }
+    return result.graph;
+  }
+  tryBuild() {
+    const draft = {
+      nodes: this.nodes,
+      edges: this.edges,
+      version: GRAPH_VERSION
+    };
+    return validateStrategyGraph(draft);
+  }
+  nextPosition(bucket) {
+    const row = this.columnFill[bucket];
+    this.columnFill[bucket] = row + 1;
+    return { x: BUCKET_COLUMN[bucket] * COLUMN_WIDTH, y: row * ROW_HEIGHT };
+  }
+}
+function createGraphBuilder() {
+  return new GraphBuilder;
+}
+
+// ../sdk/src/workflow/engine.ts
+var TIER_RANK = {
+  PASS: 0,
+  PROMISING: 1,
+  INCONCLUSIVE: 2,
+  FAIL: 3
+};
+function effectiveMinTier(opts) {
+  if (opts.allowPromising)
+    return "PROMISING";
+  return opts.minTier ?? "PASS";
+}
+function satisfiesGate(tier, opts) {
+  if (!tier)
+    return false;
+  return TIER_RANK[tier] <= TIER_RANK[effectiveMinTier(opts)];
+}
+
+class WorkflowBuilderImpl {
+  client;
+  steps = [];
+  observers = [];
+  constructor(client) {
+    this.client = client;
+  }
+  fromPrompt(text, o = {}) {
+    const step = { kind: "source", via: "prompt", prompt: text };
+    if (o.instrument)
+      step.instrument = o.instrument;
+    if (o.timeframe)
+      step.timeframe = o.timeframe;
+    this.steps.push(step);
+    return this;
+  }
+  fromGraph(graph) {
+    this.steps.push({ kind: "source", via: "graph", graph });
+    return this;
+  }
+  fromFile(path) {
+    this.steps.push({ kind: "source", via: "file", path });
+    return this;
+  }
+  fromStrategy(id) {
+    this.steps.push({ kind: "source", via: "strategy", id });
+    return this;
+  }
+  validate() {
+    this.steps.push({ kind: "validate" });
+    return this;
+  }
+  create(meta) {
+    this.steps.push({ kind: "create", meta });
+    return this;
+  }
+  judge() {
+    this.steps.push({ kind: "judge" });
+    return this;
+  }
+  gate(opts = {}) {
+    this.steps.push({ kind: "gate", opts });
+    return this;
+  }
+  backtest(opts) {
+    this.steps.push({ kind: "backtest", opts });
+    return this;
+  }
+  deployPlan(opts = {}) {
+    this.steps.push({ kind: "deployPlan", opts });
+    return this;
+  }
+  publish() {
+    this.steps.push({ kind: "publish" });
+    return this;
+  }
+  onPhase(cb) {
+    this.observers.push(cb);
+    return this;
+  }
+  async run(o = {}) {
+    const signal = o.signal;
+    const steps = autoInjectGate(this.steps);
+    assertHasSource(steps);
+    const ctx = {};
+    const phases = [];
+    const startedAt = Date.now();
+    const emit = async (e) => {
+      for (const cb of this.observers)
+        await cb(e);
+    };
+    const runPhase = async (phase, exec) => {
+      const phaseStart = Date.now();
+      await emit({ phase, status: "start", startedAt: phaseStart });
+      const progress = async (data, p) => {
+        await emit({
+          phase,
+          status: "progress",
+          startedAt: phaseStart,
+          data,
+          ...p !== undefined ? { progress: p } : {}
+        });
+      };
+      try {
+        const out = await exec(progress);
+        const rec = {
+          phase,
+          ok: true,
+          output: out,
+          startedAt: phaseStart,
+          elapsedMs: Date.now() - phaseStart
+        };
+        phases.push(rec);
+        await emit({ phase, status: "done", startedAt: phaseStart, elapsedMs: rec.elapsedMs, data: out });
+        return out;
+      } catch (e) {
+        const err = toEX7(e);
+        const rec = {
+          phase,
+          ok: false,
+          error: err,
+          startedAt: phaseStart,
+          elapsedMs: Date.now() - phaseStart
+        };
+        phases.push(rec);
+        await emit({ phase, status: "failed", startedAt: phaseStart, elapsedMs: rec.elapsedMs, error: err });
+        throw err;
+      }
+    };
+    let failedPhase;
+    let error;
+    try {
+      for (const step of steps) {
+        await this.execStep(step, ctx, runPhase, signal);
+      }
+    } catch (e) {
+      error = toEX7(e);
+      failedPhase = phases.length > 0 ? phases[phases.length - 1].phase : undefined;
+    }
+    const result = {
+      ok: error === undefined,
+      phases,
+      startedAt,
+      elapsedMs: Date.now() - startedAt
+    };
+    if (ctx.graph)
+      result.graph = ctx.graph;
+    if (ctx.strategy)
+      result.strategy = ctx.strategy;
+    if (ctx.verdict)
+      result.verdict = ctx.verdict;
+    if (ctx.backtestJob)
+      result.backtestJob = ctx.backtestJob;
+    if (ctx.deploymentPlan)
+      result.deploymentPlan = ctx.deploymentPlan;
+    if (ctx.published !== undefined)
+      result.published = ctx.published;
+    if (failedPhase)
+      result.failedPhase = failedPhase;
+    if (error)
+      result.error = error;
+    return result;
+  }
+  async execStep(step, ctx, runPhase, signal) {
+    const client = this.client;
+    switch (step.kind) {
+      case "source":
+        await runPhase("source", async () => {
+          ctx.graph = await this.resolveSource(step, ctx, signal);
+          return step.via === "strategy" ? ctx.strategy : ctx.graph;
+        });
+        return;
+      case "validate":
+        await runPhase("validate", async () => {
+          const v = validateStrategyGraph(ctx.graph);
+          if (!v.ok) {
+            throw new EX7ValidationError(0, "invalid_graph", `graph failed validation: ${v.issues.length} issue(s)`, v.issues);
+          }
+          ctx.graph = v.graph;
+          return { nodes: v.graph.nodes.length, edges: v.graph.edges.length };
+        });
+        return;
+      case "create":
+        await runPhase("create", async () => {
+          if (!ctx.graph)
+            throw new EX7Error(0, "no_graph", "create requires a graph source");
+          const input = {
+            name: step.meta.name,
+            graph_json: ctx.graph
+          };
+          if (step.meta.description !== undefined)
+            input.description = step.meta.description;
+          if (step.meta.instrument !== undefined)
+            input.instrument = step.meta.instrument;
+          ctx.strategy = await client.strategies.create(input, signal ? { signal } : {});
+          return ctx.strategy;
+        });
+        return;
+      case "judge":
+        await runPhase("judge", async (progress) => {
+          if (!ctx.strategy)
+            throw new EX7Error(0, "no_strategy", "judge requires a created or sourced strategy");
+          const runResult = await client.strategies.judge(ctx.strategy.id, {
+            ...signal ? { signal } : {},
+            onTick: (r) => void progress(r)
+          });
+          const tier = runResult.tier ?? runResult.result?.tier ?? undefined;
+          ctx.verdict = { runResult, ...tier ? { tier } : {} };
+          return ctx.verdict;
+        });
+        return;
+      case "gate":
+        await runPhase("gate", async () => {
+          const tier = ctx.verdict?.tier;
+          if (!satisfiesGate(tier, step.opts)) {
+            const min = effectiveMinTier(step.opts);
+            throw new EX7GateError(0, "gate_unmet", tier ? `verdict tier ${tier} does not meet the gate (minimum ${min})` : "no judge verdict available; gate fails closed (validate first, operate second)");
+          }
+          return { tier, min: effectiveMinTier(step.opts) };
+        });
+        return;
+      case "backtest":
+        await runPhase("backtest", async (progress) => {
+          if (!ctx.strategy)
+            throw new EX7Error(0, "no_strategy", "backtest requires a strategy");
+          const pollOpts = { onTick: (j) => void progress(j) };
+          if (signal)
+            pollOpts.signal = signal;
+          if (step.opts.intervalMs !== undefined)
+            pollOpts.intervalMs = step.opts.intervalMs;
+          if (step.opts.maxWaitMs !== undefined)
+            pollOpts.maxWaitMs = step.opts.maxWaitMs;
+          const input = { from: step.opts.from, to: step.opts.to };
+          if (step.opts.instrument !== undefined)
+            input.instrument = step.opts.instrument;
+          ctx.backtestJob = await client.backtest.runAndWait(ctx.strategy.id, input, pollOpts);
+          return ctx.backtestJob;
+        });
+        return;
+      case "deployPlan":
+        await runPhase("deployPlan", async () => {
+          if (!ctx.strategy)
+            throw new EX7Error(0, "no_strategy", "deployPlan requires a strategy");
+          ctx.deploymentPlan = await client.strategies.deployPlan(ctx.strategy.id, step.opts, signal ? { signal } : {});
+          return ctx.deploymentPlan;
+        });
+        return;
+      case "publish":
+        await runPhase("publish", async () => {
+          if (!ctx.strategy)
+            throw new EX7Error(0, "no_strategy", "publish requires a strategy");
+          const s = await client.strategies.publish(ctx.strategy.id, signal ? { signal } : {});
+          ctx.strategy = s;
+          ctx.published = true;
+          return s;
+        });
+        return;
+    }
+  }
+  async resolveSource(step, ctx, signal) {
+    const client = this.client;
+    switch (step.via) {
+      case "prompt": {
+        const res = await client.vix.generateStrategy({
+          prompt: step.prompt,
+          ...step.instrument ? { instrument: step.instrument } : {},
+          ...step.timeframe ? { timeframe: step.timeframe } : {}
+        }, signal ? { signal } : {});
+        return res.graph;
+      }
+      case "graph":
+        return step.graph;
+      case "file": {
+        const fs = await import("node:fs/promises");
+        const raw = await fs.readFile(step.path, "utf8");
+        return extractGraphFromBody(JSON.parse(raw));
+      }
+      case "strategy": {
+        ctx.strategy = await client.strategies.get(step.id, signal ? { signal } : {});
+        return ctx.strategy.graph_json;
+      }
+    }
+  }
+}
+function autoInjectGate(steps) {
+  const hasDeploy = steps.some((s) => s.kind === "deployPlan");
+  const hasGate = steps.some((s) => s.kind === "gate");
+  if (!hasDeploy || hasGate)
+    return steps;
+  const idx = steps.findIndex((s) => s.kind === "deployPlan");
+  const out = steps.slice();
+  out.splice(idx, 0, { kind: "gate", opts: { minTier: "PASS" } });
+  return out;
+}
+function assertHasSource(steps) {
+  if (!steps.some((s) => s.kind === "source")) {
+    throw new EX7Error(0, "no_source", "workflow needs a source: fromPrompt(), fromGraph(), fromFile(), or fromStrategy()");
+  }
+}
+function toEX7(e) {
+  if (e instanceof EX7Error)
+    return e;
+  if (e instanceof Error)
+    return new EX7Error(0, "workflow_error", e.message);
+  return new EX7Error(0, "workflow_error", String(e));
+}
+async function runIterate(client, o) {
+  const attempts = [];
+  const signal = o.signal;
+  const emit = async (e) => {
+    if (o.onPhase)
+      await o.onPhase(e);
+  };
+  let next = o.prompt;
+  for (let attempt = 1;attempt <= o.maxAttempts; attempt++) {
+    try {
+      const graph = await produceGraph(client, next, o, signal, attempt, emit);
+      const v = validateStrategyGraph(graph);
+      if (!v.ok) {
+        const err = new EX7ValidationError(0, "invalid_graph", `attempt ${attempt}: graph failed validation`, v.issues);
+        attempts.push({ attempt, graph, passed: false, error: err });
+        if (!await advance(o, { attempt, graph, reason: "invalid_graph" }, (n) => next = n))
+          break;
+        continue;
+      }
+      const name = o.name?.(attempt) ?? `vix-iter-${attempt}`;
+      const createInput = {
+        name,
+        graph_json: v.graph
+      };
+      if (o.instrument)
+        createInput.instrument = o.instrument;
+      const at = { phase: "create", status: "start", startedAt: Date.now(), attempt };
+      await emit(at);
+      const strategy = await client.strategies.create(createInput, signal ? { signal } : {});
+      await emit({ phase: "judge", status: "start", startedAt: Date.now(), attempt });
+      const runResult = await client.strategies.judge(strategy.id, signal ? { signal } : {});
+      const tier = runResult.tier ?? runResult.result?.tier ?? undefined;
+      const passed = satisfiesGate(tier, o.gate);
+      const record = { attempt, graph: v.graph, strategy, passed };
+      if (tier)
+        record.tier = tier;
+      attempts.push(record);
+      await emit({
+        phase: "gate",
+        status: passed ? "done" : "failed",
+        startedAt: Date.now(),
+        attempt,
+        data: { tier }
+      });
+      if (passed) {
+        if (o.cleanupFailed)
+          await cleanup(client, attempts, strategy.id);
+        const out2 = { ok: true, attempts, passed: record };
+        if (tier)
+          out2.finalTier = tier;
+        return out2;
+      }
+      const failure = {
+        attempt,
+        graph: v.graph,
+        strategy,
+        result: runResult,
+        reason: tier ? `tier ${tier}` : "no verdict"
+      };
+      if (tier)
+        failure.tier = tier;
+      if (attempt < o.maxAttempts) {
+        if (!await advance(o, failure, (n) => next = n))
+          break;
+      }
+    } catch (e) {
+      const err = toEX7(e);
+      attempts.push({ attempt, graph: emptyishGraph(), passed: false, error: err });
+      break;
+    }
+  }
+  if (o.cleanupFailed)
+    await cleanup(client, attempts);
+  const last = attempts[attempts.length - 1];
+  const out = { ok: false, attempts };
+  if (last?.tier)
+    out.finalTier = last.tier;
+  return out;
+}
+async function produceGraph(client, input, o, signal, attempt, emit) {
+  if (typeof input !== "string")
+    return input;
+  await emit({ phase: "source", status: "start", startedAt: Date.now(), attempt });
+  const res = await client.vix.generateStrategy({
+    prompt: input,
+    ...o.instrument ? { instrument: o.instrument } : {},
+    ...o.timeframe ? { timeframe: o.timeframe } : {}
+  }, signal ? { signal } : {});
+  return res.graph;
+}
+async function advance(o, failure, setNext) {
+  if (!o.refine)
+    return false;
+  const next = await o.refine(failure);
+  setNext(next);
+  return true;
+}
+async function cleanup(client, attempts, keepId) {
+  for (const a of attempts) {
+    if (!a.strategy || a.strategy.id === keepId || a.passed)
+      continue;
+    try {
+      await client.strategies.delete(a.strategy.id);
+    } catch {}
+  }
+}
+function emptyishGraph() {
+  return { nodes: [], edges: [], version: 1 };
+}
+function createWorkflowFactory(client) {
+  const factory = () => new WorkflowBuilderImpl(client);
+  factory.iterate = (o) => runIterate(client, o);
+  return factory;
+}
+
+// ../sdk/src/client.ts
+function createClient(config = {}) {
+  const resolved = resolveConfig(config);
+  const httpCfg = {
+    baseUrl: resolved.baseUrl,
+    auth: resolved.auth,
+    timeoutMs: resolved.timeoutMs,
+    userAgent: resolved.userAgent,
+    agentToken: resolved.agentToken,
+    fetch: resolved.fetch,
+    defaultHeaders: resolved.headers
+  };
+  const http = new HttpClient(httpCfg);
+  const client = {
+    config: resolved,
+    http,
+    strategies: new StrategiesResource(http),
+    judge: new JudgeResource(http),
+    vix: new VixResource(http),
+    backtest: new BacktestResource(http),
+    signals: new SignalsResource(http),
+    agents: new AgentsResource(http),
+    agent: new AgentScopedResource(http),
+    workflow: undefined,
+    graph: () => createGraphBuilder(),
+    status: (o = {}) => http.json({ path: "api/health", auth: "none", ...o }),
+    asAgent: (agentToken) => createClient({ ...config, agentToken }),
+    request: (opts) => http.json(opts)
+  };
+  client.workflow = createWorkflowFactory(client);
+  return client;
+}
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+
+// src/tools.ts
+function reqString(args, key) {
+  const v = args[key];
+  if (typeof v !== "string" || v.length === 0) {
+    throw Object.assign(new Error(`missing required string '${key}'`), { code: "invalid_args", status: 400 });
+  }
+  return v;
+}
+function optNumber(args, key) {
+  const v = args[key];
+  return typeof v === "number" ? v : undefined;
+}
+function optString(args, key) {
+  const v = args[key];
+  return typeof v === "string" && v.length > 0 ? v : undefined;
+}
+var TOOLS = [
+  {
+    definition: {
+      name: "ex7_status",
+      description: "Readiness probe for the EX7 platform (db, backend, services). No auth required.",
+      inputSchema: { type: "object", properties: {}, additionalProperties: false }
+    },
+    handler: (ctx) => ctx.client.status()
+  },
+  {
+    definition: {
+      name: "ex7_vix_generate",
+      description: "Generate a strategy-graph delta (nodes_to_add/edges_to_add) from a natural-language idea. With an agent token this uses the deterministic, $0 agent pipeline.",
+      inputSchema: {
+        type: "object",
+        properties: { prompt: { type: "string", minLength: 1, maxLength: 4000 } },
+        required: ["prompt"],
+        additionalProperties: false
+      }
+    },
+    handler: (ctx, args) => {
+      const prompt = reqString(args, "prompt");
+      return ctx.agentMode ? ctx.client.agent.vix(prompt) : ctx.client.vix.generate({ prompt });
+    }
+  },
+  {
+    definition: {
+      name: "ex7_strategy_validate",
+      description: "Validate a strategy graph structurally, offline (no network). Accepts a bare graph or a { graph_json } wrapper.",
+      inputSchema: {
+        type: "object",
+        properties: { graph_json: { type: "object" } },
+        required: ["graph_json"],
+        additionalProperties: true
+      }
+    },
+    handler: async (_ctx, args) => {
+      const result = validateStrategyGraph(extractGraphFromBody(args.graph_json));
+      return result.ok ? { ok: true, nodes: result.graph.nodes.length, edges: result.graph.edges.length } : { ok: false, errors: result.errors, issues: result.issues };
+    }
+  },
+  {
+    definition: {
+      name: "ex7_strategy_create",
+      description: "Create (persist) a strategy from a graph. The graph is validated locally first.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string", minLength: 1 },
+          description: { type: "string" },
+          instrument: { type: "string", enum: ["NQ", "ES", "CL", "MNQ", "MES", "MCL"] },
+          graph_json: { type: "object" }
+        },
+        required: ["name", "graph_json"],
+        additionalProperties: false
+      }
+    },
+    handler: (ctx, args) => {
+      const input = {
+        name: reqString(args, "name"),
+        graph_json: args.graph_json
+      };
+      const desc = optString(args, "description");
+      if (desc)
+        input.description = desc;
+      const inst = optString(args, "instrument");
+      if (inst)
+        input.instrument = inst;
+      return ctx.client.strategies.create(input);
+    }
+  },
+  {
+    definition: {
+      name: "ex7_judge_run",
+      description: "Run The Judge on a saved strategy and return the terminal verdict (tier + metrics). With an agent token this is a deterministic $0 fixture lookup.",
+      inputSchema: {
+        type: "object",
+        properties: { strategy_id: { type: "string", minLength: 1 } },
+        required: ["strategy_id"],
+        additionalProperties: false
+      }
+    },
+    handler: (ctx, args) => {
+      const id = reqString(args, "strategy_id");
+      return ctx.agentMode ? ctx.client.agent.judge(id) : ctx.client.strategies.judge(id);
+    }
+  },
+  {
+    definition: {
+      name: "ex7_backtest_run",
+      description: "Enqueue a backtest and wait for the terminal job (metrics on success).",
+      inputSchema: {
+        type: "object",
+        properties: {
+          strategy_id: { type: "string", minLength: 1 },
+          from: { type: "string", description: "YYYY-MM-DD" },
+          to: { type: "string", description: "YYYY-MM-DD" },
+          instrument: { type: "string", enum: ["NQ", "ES", "CL", "MNQ", "MES", "MCL"] }
+        },
+        required: ["strategy_id", "from", "to"],
+        additionalProperties: false
+      }
+    },
+    handler: (ctx, args) => {
+      const input = {
+        from: reqString(args, "from"),
+        to: reqString(args, "to")
+      };
+      const inst = optString(args, "instrument");
+      if (inst)
+        input.instrument = inst;
+      return ctx.client.backtest.runAndWait(reqString(args, "strategy_id"), input);
+    }
+  },
+  {
+    definition: {
+      name: "ex7_deploy_plan",
+      description: "Compile a deployment plan for a PASS strategy. EX7 never executes orders: the result is a webhook TEMPLATE + disclaimer you wire to your own broker. Requires a passing Judge verdict.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          strategy_id: { type: "string", minLength: 1 },
+          max_contracts: { type: "number", minimum: 1, maximum: 50 },
+          dd_limit: { type: "number" },
+          bust_safe: { type: "boolean" },
+          allow_promising: { type: "boolean" }
+        },
+        required: ["strategy_id"],
+        additionalProperties: false
+      }
+    },
+    handler: (ctx, args) => {
+      const input = {};
+      const mc = optNumber(args, "max_contracts");
+      if (mc !== undefined)
+        input.maxContracts = mc;
+      const dd = optNumber(args, "dd_limit");
+      if (dd !== undefined)
+        input.ddLimit = dd;
+      if (typeof args.bust_safe === "boolean")
+        input.bustSafe = args.bust_safe;
+      if (typeof args.allow_promising === "boolean")
+        input.allowPromising = args.allow_promising;
+      return ctx.client.strategies.deployPlan(reqString(args, "strategy_id"), input);
+    }
+  },
+  {
+    definition: {
+      name: "ex7_strategy_publish",
+      description: "Publish a validated strategy (or unpublish it with { unpublish: true }).",
+      inputSchema: {
+        type: "object",
+        properties: {
+          strategy_id: { type: "string", minLength: 1 },
+          unpublish: { type: "boolean" }
+        },
+        required: ["strategy_id"],
+        additionalProperties: false
+      }
+    },
+    handler: (ctx, args) => {
+      const id = reqString(args, "strategy_id");
+      return args.unpublish === true ? ctx.client.strategies.unpublish(id) : ctx.client.strategies.publish(id);
+    }
+  },
+  {
+    definition: {
+      name: "ex7_signals_list",
+      description: "List recent live trading signals (one-shot read).",
+      inputSchema: {
+        type: "object",
+        properties: { limit: { type: "number", minimum: 1, maximum: 200 } },
+        additionalProperties: false
+      }
+    },
+    handler: (ctx, args) => {
+      const limit = optNumber(args, "limit");
+      return ctx.client.signals.list(limit !== undefined ? { limit } : {});
+    }
+  },
+  {
+    definition: {
+      name: "ex7_workflow_run",
+      description: "Run the full EX7 workflow from a prompt: generate -> validate -> create -> judge -> gate (PASS) and, optionally, backtest and a deploy-plan. Returns a per-phase summary. Operate steps run only on a real PASS.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          prompt: { type: "string", minLength: 1, maxLength: 4000 },
+          name: { type: "string", minLength: 1 },
+          instrument: { type: "string", enum: ["NQ", "ES", "CL", "MNQ", "MES", "MCL"] },
+          min_tier: { type: "string", enum: ["PASS", "PROMISING"] },
+          run_backtest: { type: "boolean" },
+          backtest_from: { type: "string" },
+          backtest_to: { type: "string" },
+          want_deploy_plan: { type: "boolean" },
+          deploy_max_contracts: { type: "number", minimum: 1, maximum: 50 }
+        },
+        required: ["prompt", "name"],
+        additionalProperties: false
+      }
+    },
+    handler: async (ctx, args) => {
+      const prompt = reqString(args, "prompt");
+      const name = reqString(args, "name");
+      const instrument = optString(args, "instrument");
+      const minTier = optString(args, "min_tier") ?? "PASS";
+      let wf = ctx.client.workflow().fromPrompt(prompt, instrument ? { instrument } : {}).validate().create(instrument ? { name, instrument } : { name }).judge().gate({ minTier });
+      if (args.run_backtest === true) {
+        const from = reqString(args, "backtest_from");
+        const to = reqString(args, "backtest_to");
+        wf = wf.backtest(instrument ? { from, to, instrument } : { from, to });
+      }
+      if (args.want_deploy_plan === true) {
+        const mc = optNumber(args, "deploy_max_contracts");
+        wf = wf.deployPlan(mc !== undefined ? { maxContracts: mc } : {});
+      }
+      const result = await wf.run();
+      return {
+        ok: result.ok,
+        strategy_id: result.strategy?.id,
+        judge_tier: result.verdict?.tier,
+        backtest_metrics: result.backtestJob?.metrics ?? undefined,
+        deploy_plan: result.deploymentPlan,
+        published: result.published,
+        failed_phase: result.failedPhase,
+        error: result.error ? { code: result.error.code, message: result.error.message } : undefined,
+        phases: result.phases.map((p) => ({ phase: p.phase, ok: p.ok, ms: p.elapsedMs }))
+      };
+    }
+  }
+];
+
+// src/server.ts
+var SERVER_NAME = "ex7";
+var SERVER_VERSION = "0.1.0";
+function createServer(deps) {
+  const ctx = {
+    client: deps.client,
+    agentMode: deps.agentMode ?? !!deps.client.config.agentToken
+  };
+  const server = new Server({ name: SERVER_NAME, version: SERVER_VERSION }, { capabilities: { tools: {} } });
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: TOOLS.map((t) => t.definition)
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const tool = TOOLS.find((t) => t.definition.name === req.params.name);
+    if (!tool) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: "unknown_tool", name: req.params.name }) }],
+        isError: true
+      };
+    }
+    try {
+      const args = req.params.arguments ?? {};
+      const result = await tool.handler(ctx, args);
+      return { content: [{ type: "text", text: JSON.stringify(result ?? null) }] };
+    } catch (e) {
+      const err = e;
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: err.code ?? "error",
+              status: err.status,
+              message: err.message ?? String(e)
+            })
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+  return server;
+}
+
+// src/index.ts
+async function main() {
+  const baseUrl = process.env.EX7_BASE_URL || process.env.EX7_API_URL || "https://ex7capital.com";
+  const config = { baseUrl, userAgent: "ex7-mcp/0.1.0" };
+  if (process.env.EX7_TOKEN)
+    config.token = process.env.EX7_TOKEN;
+  if (process.env.EX7_AGENT_TOKEN)
+    config.agentToken = process.env.EX7_AGENT_TOKEN;
+  const client = createClient(config);
+  const server = createServer({ client });
+  const transport = new StdioServerTransport;
+  await server.connect(transport);
+  process.stderr.write(`ex7-mcp ready (base ${baseUrl}${config.agentToken ? ", agent mode" : ""})
+`);
+}
+main().catch((e) => {
+  process.stderr.write(`ex7-mcp fatal: ${e instanceof Error ? e.message : String(e)}
+`);
+  process.exit(1);
+});