@darkhorseprojects/circuitry 0.3.1 → 0.3.3

package/dist/bundle.d.ts

@@ -16,13 +16,14 @@ type SceneElement = {
         elementId?: string;
     } | null;
 };
-export declare const BUNDLE_MIME = "application/vnd.circuitry.bundle+json";
+export declare const BUNDLE_MIME = "application/vnd.circuitry.bundle+yaml";
 export type CircuitryBundle = {
     version: 1;
     createdAt: string;
     elements: SceneElement[];
 };
 export declare const createBundleFromSelection: (elements: readonly SceneElement[], selectedIds: Readonly<Record<string, true>>) => CircuitryBundle | null;
+export declare const stringifyBundle: (bundle: CircuitryBundle) => string;
 export declare const parseBundleText: (text: string) => CircuitryBundle;
 export declare const importBundleElements: (bundle: CircuitryBundle, opts?: {
     offsetX?: number;

package/dist/cli.js

@@ -1,14 +1,18 @@
 #!/usr/bin/env node
 
+// src/cli.ts
+import { readFile as readFile2 } from "node:fs/promises";
+
 // src/node.ts
 import { access, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 
 // src/yaml.ts
-import YAML from "yaml";
+import YAML2 from "yaml";
 
 // src/graph.ts
-var CIRCUITRY_SPEC_VERSION = "0.3.1";
+import YAML from "yaml";
+var CIRCUITRY_SPEC_VERSION = "0.3.2";
 var DEFAULT_CIRCUITRY_VALIDATION_RULES = [
   "no-self-loops",
   "no-unknown-edge-endpoints",
@@ -21,25 +25,15 @@ var DEFAULT_CIRCUITRY_VALIDATION_STANDARD = {
   rules: DEFAULT_CIRCUITRY_VALIDATION_RULES,
   executableKinds: ["agent", "tool", "output"]
 };
-var executableKindsFromRules = (rules = []) => {
-  const executableRule = rules.find(
-    (entry) => typeof entry !== "string" && entry.rule === "require-executable-inputs"
-  );
-  return executableRule?.executableKinds;
-};
+var ruleName = (rule) => typeof rule === "string" ? rule : rule.rule;
+var executableKindsFromRules = (rules) => rules.find((rule) => typeof rule !== "string" && rule.rule === "require-executable-inputs")?.executableKinds;
 var createCircuitryValidationStandard = (standard = {}, graph) => {
-  const rules = [
-    ...DEFAULT_CIRCUITRY_VALIDATION_RULES,
-    ...graph?.validation?.rules || [],
-    ...standard.rules || []
-  ];
+  const rules = [...DEFAULT_CIRCUITRY_VALIDATION_RULES, ...graph?.validation?.rules || [], ...standard.rules || []];
   return {
     version: standard.version || DEFAULT_CIRCUITRY_VALIDATION_STANDARD.version,
     requireSpecVersion: standard.requireSpecVersion ?? DEFAULT_CIRCUITRY_VALIDATION_STANDARD.requireSpecVersion,
     rules,
-    executableKinds: standard.executableKinds || executableKindsFromRules(rules) || [
-      ...DEFAULT_CIRCUITRY_VALIDATION_STANDARD.executableKinds
-    ]
+    executableKinds: standard.executableKinds || executableKindsFromRules(rules) || [...DEFAULT_CIRCUITRY_VALIDATION_STANDARD.executableKinds]
   };
 };
 var expandResources = (resources) => {
@@ -47,12 +41,7 @@ var expandResources = (resources) => {
   const edges = [];
   for (const [id, resource] of Object.entries(resources)) {
     if (resource.type === "text") {
-      nodes.push({
-        id,
-        kind: "input",
-        label: resource.label || id,
-        input: { type: "text", value: resource.value }
-      });
+      nodes.push({ id, kind: "input", label: resource.label || id, input: { type: "text", value: resource.value } });
     } else if (resource.type === "agent") {
       const agent = resource;
       nodes.push({
@@ -62,7 +51,6 @@ var expandResources = (resources) => {
         agent: {
           identity: agent.identity || agent.label || id,
           model: agent.model,
-          thinkingLevel: agent.thinkingLevel,
           tools: agent.tools,
           instructions: agent.instructions,
           personality: agent.personality,
@@ -71,274 +59,131 @@ var expandResources = (resources) => {
         skills: agent.skills,
         expect: agent.expect
       });
-      for (const inputRef of agent.inputs || []) {
-        edges.push({ from: inputRef, to: id, kind: "dependency" });
-      }
+      for (const input of agent.inputs || []) edges.push({ from: input, to: id, kind: "dependency" });
     } else if (resource.type === "tool") {
       const tool = resource;
-      nodes.push({
-        id,
-        kind: "tool",
-        label: tool.label || id,
-        agent: { instructions: tool.instructions }
-      });
-      for (const inputRef of tool.inputs || []) {
-        edges.push({ from: inputRef, to: id, kind: "dependency" });
-      }
+      nodes.push({ id, kind: "tool", label: tool.label || id, agent: { instructions: tool.instructions } });
+      for (const input of tool.inputs || []) edges.push({ from: input, to: id, kind: "dependency" });
     } else {
       const input = resource;
-      nodes.push({
-        id,
-        kind: "input",
-        label: input.label || id,
-        input: {
-          type: input.type,
-          value: input.value,
-          uri: input.uri || input.path,
-          mimeType: input.mimeType,
-          data: input.data
-        }
-      });
+      nodes.push({ id, kind: "input", label: input.label || id, input: { type: input.type, value: input.value, uri: input.uri || input.path, mimeType: input.mimeType, data: input.data } });
     }
   }
   return { nodes, edges };
 };
 var normalizeCircuitryGraph = (graph) => {
-  if (!graph.resources || Object.keys(graph.resources).length === 0) return { ...graph };
-  const { nodes, edges } = expandResources(graph.resources);
-  return { ...graph, nodes, edges };
+  if (!graph.resources) return { ...graph };
+  return { ...graph, ...expandResources(graph.resources) };
 };
-var VALID_SPEC_VERSIONS = /* @__PURE__ */ new Set([CIRCUITRY_SPEC_VERSION]);
-var validateCircuitryGraphInternal = (graph, standard = {}, options) => {
-  const resolvedStandard = createCircuitryValidationStandard(
-    standard,
-    graph && typeof graph === "object" && !Array.isArray(graph) ? graph : void 0
-  );
+var validateCircuitryGraphInternal = (graph, standard = {}, source) => {
+  const resolved = createCircuitryValidationStandard(standard, graph && typeof graph === "object" && !Array.isArray(graph) ? graph : void 0);
   const errors = [];
-  const addError = (code, message, path3) => errors.push({ code, message, ...path3 ? { path: path3 } : {} });
-  if (!graph || typeof graph !== "object" || Array.isArray(graph)) {
-    addError("invalid_graph", "Circuitry graph must be an object");
-    return { ok: false, errors, standard: resolvedStandard };
+  const issue = (code, message = code, path2) => errors.push({ code, message, ...path2 ? { path: path2 } : {} });
+  if (!graph || typeof graph !== "object" || Array.isArray(graph)) return { ok: false, errors: [{ code: "invalid_graph", message: "invalid graph" }], standard: resolved };
+  const g = graph;
+  if (resolved.requireSpecVersion && g.circuitry !== resolved.version) issue("invalid_version", "invalid version", ["circuitry"]);
+  if (source) {
+    const raw = g;
+    if (!g.resources || Object.keys(g.resources).length === 0) issue("missing_resources", "missing resources", ["resources"]);
+    if (raw.agents) issue("forbidden_agents", "forbidden agents", ["agents"]);
+    if (raw.inputs) issue("forbidden_inputs", "forbidden inputs", ["inputs"]);
+    if (g.nodes?.length) issue("forbidden_nodes", "forbidden nodes", ["nodes"]);
+    if (g.edges?.length) issue("forbidden_edges", "forbidden edges", ["edges"]);
+    if (raw.links) issue("forbidden_links", "forbidden links", ["links"]);
   }
-  const graphObject = graph;
-  const rules = resolvedStandard.rules;
-  const hasRule = (name) => rules.some((entry) => (typeof entry === "string" ? entry : entry.rule) === name);
-  if (resolvedStandard.requireSpecVersion && !VALID_SPEC_VERSIONS.has(String(graphObject.circuitry))) {
-    addError(
-      "invalid_spec_version",
-      `Expected circuitry: "${CIRCUITRY_SPEC_VERSION}"`,
-      ["circuitry"]
-    );
-  }
-  if (options.sourceFormat) {
-    if (!graphObject.resources || Object.keys(graphObject.resources).length === 0) {
-      addError("missing_resources", "Circuitry graphs must use a resources: section", ["resources"]);
-    }
-    if (graphObject.agents && Object.keys(graphObject.agents).length > 0) {
-      addError("forbidden_agents", "Circuitry graph files must not use top-level agents:; use resources:", ["agents"]);
-    }
-    if (graphObject.inputs && Object.keys(graphObject.inputs).length > 0) {
-      addError("forbidden_inputs", "Circuitry graph files use args: for runtime arguments and resource inputs for edges", ["inputs"]);
-    }
-    if (graphObject.nodes && graphObject.nodes.length > 0) {
-      addError("forbidden_nodes", "Circuitry graph files must not use top-level nodes:; use resources:", ["nodes"]);
-    }
-    if (graphObject.edges && graphObject.edges.length > 0) {
-      addError("forbidden_edges", "Circuitry graph files must not use top-level edges:; use resource inputs:", ["edges"]);
-    }
-    if (graphObject.links && graphObject.links.length > 0) {
-      addError("forbidden_links", "Circuitry graph files use imports: for multi-file graphs", ["links"]);
-    }
-  }
-  const normalized = normalizeCircuitryGraph(graphObject);
+  const rules = new Set(resolved.rules.map(ruleName));
+  const normalized = normalizeCircuitryGraph(g);
   const ids = /* @__PURE__ */ new Set();
   for (const [index, node] of (normalized.nodes || []).entries()) {
     if (!node.id) {
-      addError("missing_node_id", "Node is missing id", ["nodes", index, "id"]);
+      issue("missing_node_id", "missing node id", ["nodes", index, "id"]);
       continue;
     }
-    if (ids.has(node.id)) {
-      addError("duplicate_node_id", `Duplicate node id: ${node.id}`, ["nodes", index, "id"]);
-    }
+    if (ids.has(node.id)) issue("duplicate_node_id", "duplicate node id", ["nodes", index, "id"]);
     ids.add(node.id);
-    if (!node.kind) {
-      addError("missing_node_kind", `Node ${node.id} is missing kind`, ["nodes", index, "kind"]);
-    }
+    if (!node.kind) issue("missing_node_kind", "missing node kind", ["nodes", index, "kind"]);
   }
   const adjacency = /* @__PURE__ */ new Map();
-  const incomingCount = /* @__PURE__ */ new Map();
+  const incoming = /* @__PURE__ */ new Map();
   for (const id of ids) {
     adjacency.set(id, []);
-    incomingCount.set(id, 0);
+    incoming.set(id, 0);
   }
   for (const [index, edge] of (normalized.edges || []).entries()) {
     if (!edge.from || !edge.to) {
-      addError("missing_edge_endpoint", "Edge is missing from/to", ["edges", index]);
+      issue("missing_edge_endpoint", "missing edge endpoint", ["edges", index]);
       continue;
     }
-    if (hasRule("no-self-loops") && edge.from === edge.to) {
-      addError("self_loop", `Edge creates self loop: ${edge.from} -> ${edge.to}`, ["edges", index]);
+    if (rules.has("no-self-loops") && edge.from === edge.to) {
+      issue("self_loop", "self loop", ["edges", index]);
       continue;
     }
-    if (hasRule("no-unknown-edge-endpoints") && !ids.has(edge.from)) {
-      addError("unknown_edge_source", `Edge references unknown source: ${edge.from}`, ["edges", index, "from"]);
+    const ok = ids.has(edge.from) && ids.has(edge.to);
+    if (rules.has("no-unknown-edge-endpoints")) {
+      if (!ids.has(edge.from)) issue("unknown_edge_source", "unknown edge source", ["edges", index, "from"]);
+      if (!ids.has(edge.to)) issue("unknown_edge_target", "unknown edge target", ["edges", index, "to"]);
     }
-    if (hasRule("no-unknown-edge-endpoints") && !ids.has(edge.to)) {
-      addError("unknown_edge_target", `Edge references unknown target: ${edge.to}`, ["edges", index, "to"]);
-    }
-    if (ids.has(edge.from) && ids.has(edge.to)) {
+    if (ok) {
       adjacency.get(edge.from).push(edge.to);
-      incomingCount.set(edge.to, (incomingCount.get(edge.to) || 0) + 1);
+      incoming.set(edge.to, (incoming.get(edge.to) || 0) + 1);
     }
   }
-  const executableKinds = new Set(resolvedStandard.executableKinds);
-  if (hasRule("require-executable-inputs")) {
+  if (rules.has("require-executable-inputs")) {
+    const executable = new Set(resolved.executableKinds);
     for (const [index, node] of (normalized.nodes || []).entries()) {
-      if (executableKinds.has(node.kind) && (incomingCount.get(node.id) || 0) === 0) {
-        addError("executable_without_inputs", `Executable node has no inputs: ${node.id}`, ["nodes", index]);
-      }
+      if (executable.has(node.kind) && (incoming.get(node.id) || 0) === 0) issue("missing_executable_input", "missing executable input", ["nodes", index]);
     }
   }
-  const visiting = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
-  const path2 = [];
-  let cycleMessage = "";
-  const visit = (id) => {
-    if (cycleMessage) return;
-    if (visiting.has(id)) {
-      cycleMessage = [...path2.slice(path2.indexOf(id)), id].join(" -> ");
-      return;
-    }
-    if (visited.has(id)) return;
-    visiting.add(id);
-    path2.push(id);
-    for (const next of adjacency.get(id) || []) visit(next);
-    path2.pop();
-    visiting.delete(id);
-    visited.add(id);
-  };
-  if (hasRule("no-cycles")) {
-    for (const id of ids) {
-      visit(id);
-      if (cycleMessage) {
-        addError("cycle", `Graph contains cycle: ${cycleMessage}`);
-        break;
-      }
-    }
-  }
-  const additionalRules = rules.filter((rule) => {
-    if (typeof rule === "string") return false;
-    return rule.rule === "require-graph-field" || rule.rule === "require-node-field" || rule.rule === "require-edge-field" || rule.rule === "require-string" || rule.rule === "reject-string";
-  });
-  const fieldPath = (field) => field.split(".").filter(Boolean);
-  const getField = (value, field) => fieldPath(field).reduce((current, key) => {
-    if (!current || typeof current !== "object") return void 0;
-    return current[key];
-  }, value);
-  const isPresent = (value) => value !== void 0 && value !== null && value !== "";
-  for (const rule of additionalRules) {
-    if (rule.rule === "require-graph-field") {
-      if (!isPresent(getField(normalized, rule.field))) {
-        addError("missing_required_graph_field", `Graph is missing required field: ${rule.field}`, fieldPath(rule.field));
-      }
-      continue;
-    }
-    if (rule.rule === "require-node-field") {
-      const nodeKinds = new Set(rule.nodeKinds || []);
-      for (const [index, node] of (normalized.nodes || []).entries()) {
-        if (nodeKinds.size > 0 && !nodeKinds.has(node.kind)) continue;
-        if (!isPresent(getField(node, rule.field))) {
-          addError("missing_required_node_field", `Node ${node.id || "<missing id>"} is missing required field: ${rule.field}`, ["nodes", index, ...fieldPath(rule.field)]);
-        }
-      }
-      continue;
-    }
-    if (rule.rule === "require-edge-field") {
-      const edgeKinds = new Set(rule.edgeKinds || []);
-      for (const [index, edge] of (normalized.edges || []).entries()) {
-        if (edgeKinds.size > 0 && (!edge.kind || !edgeKinds.has(edge.kind))) continue;
-        if (!isPresent(getField(edge, rule.field))) {
-          addError("missing_required_edge_field", `Edge ${edge.id || index} is missing required field: ${rule.field}`, ["edges", index, ...fieldPath(rule.field)]);
-        }
-      }
-      continue;
-    }
-    const checkString = (target, subject, id, match, path3) => {
-      const value = getField(subject, match.field);
-      const text = typeof value === "string" ? value : "";
-      const includes = text.includes(match.value);
-      if (rule.rule === "require-string" && !includes) {
-        addError("missing_required_string", `${target} ${id} field ${match.field} must include string: ${match.value}`, path3);
-      }
-      if (rule.rule === "reject-string" && includes) {
-        addError("rejected_string", `${target} ${id} field ${match.field} must not include string: ${match.value}`, path3);
-      }
+  if (rules.has("no-cycles")) {
+    const visiting = /* @__PURE__ */ new Set();
+    const visited = /* @__PURE__ */ new Set();
+    const visit = (id) => {
+      if (visiting.has(id)) return true;
+      if (visited.has(id)) return false;
+      visiting.add(id);
+      for (const next of adjacency.get(id) || []) if (visit(next)) return true;
+      visiting.delete(id);
+      visited.add(id);
+      return false;
     };
-    for (const match of rule.graph || []) checkString("graph", normalized, "<root>", match, fieldPath(match.field));
-    for (const match of rule.nodes || []) {
-      const nodeKinds = new Set(match.nodeKinds || []);
-      for (const [index, node] of (normalized.nodes || []).entries()) {
-        if (nodeKinds.size > 0 && !nodeKinds.has(node.kind)) continue;
-        checkString("node", node, node.id || "<missing id>", match, ["nodes", index, ...fieldPath(match.field)]);
-      }
-    }
-    for (const match of rule.edges || []) {
-      const edgeKinds = new Set(match.edgeKinds || []);
-      for (const [index, edge] of (normalized.edges || []).entries()) {
-        if (edgeKinds.size > 0 && (!edge.kind || !edgeKinds.has(edge.kind))) continue;
-        checkString("edge", edge, edge.id || String(index), match, ["edges", index, ...fieldPath(match.field)]);
-      }
+    for (const id of ids) if (visit(id)) {
+      issue("cycle", "cycle");
+      break;
     }
   }
-  return { ok: errors.length === 0, errors, standard: resolvedStandard };
-};
-var validateCircuitryGraphWithStandard = (graph, standard = {}) => validateCircuitryGraphInternal(graph, standard, { sourceFormat: true });
-var validateCircuitryExecutionGraphWithStandard = (graph, standard = {}) => validateCircuitryGraphInternal(graph, standard, { sourceFormat: false });
-var validateCircuitryGraph = (graph, standard = {}) => validateCircuitryGraphWithStandard(graph, standard).errors.map(
-  (error) => error.message
-);
-var parseCircuitryJson = (text, standard = {}, options = {}) => {
-  let graph;
-  try {
-    graph = JSON.parse(text);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Could not parse Circuitry JSON. Check commas, quotes, and braces.
-${message}`);
-  }
-  if (options.validate === false) return graph;
-  const errors = validateCircuitryGraph(graph, standard);
-  if (errors.length) {
-    throw new Error(`Invalid Circuitry graph:
-${errors.join("\n")}`);
-  }
-  return normalizeCircuitryGraph(graph);
+  return { ok: errors.length === 0, errors, standard: resolved };
 };
+var validateCircuitryGraphWithStandard = (graph, standard = {}) => validateCircuitryGraphInternal(graph, standard, true);
+var validateCircuitryExecutionGraphWithStandard = (graph, standard = {}) => validateCircuitryGraphInternal(graph, standard, false);
+var validateCircuitryGraph = (graph, standard = {}) => validateCircuitryGraphWithStandard(graph, standard).errors.map((error) => error.message);
 
 // src/yaml.ts
-var parseCircuitryYaml = (text, standard = {}, options = {}) => {
-  let graph;
+var parseYamlData = (text) => {
   try {
-    graph = YAML.parse(text);
+    return YAML2.parse(text);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Could not parse Circuitry YAML. Check indentation and quotes.
+    throw new Error(`Could not parse YAML.
 ${message}`);
   }
+};
+var stringifyYamlData = (value) => YAML2.stringify(value);
+var parseCircuitryYaml = (text, standard = {}, options = {}) => {
+  const graph = parseYamlData(text);
   if (!graph || typeof graph !== "object" || Array.isArray(graph)) {
-    throw new Error("Could not parse Circuitry YAML. Expected a graph object.");
+    throw new Error("Circuitry YAML must be a graph object.");
   }
-  if (options.validate === false) return graph;
-  const errors = validateCircuitryGraph(graph, standard);
-  if (errors.length) {
-    throw new Error(`Invalid Circuitry graph:
+  if (options.validate !== false) {
+    const errors = validateCircuitryGraph(graph, standard);
+    if (errors.length) throw new Error(`Invalid Circuitry graph:
 ${errors.join("\n")}`);
   }
-  return normalizeCircuitryGraph(graph);
-};
-var parseCircuitryText = (text, filename2 = "graph.circuitry.yaml", standard = {}, options = {}) => {
-  return filename2.endsWith(".json") ? parseCircuitryJson(text, standard, options) : parseCircuitryYaml(text, standard, options);
+  return graph;
 };
+var parseCircuitryText = (text, standard = {}, options = {}) => parseCircuitryYaml(text, standard, options);
+
+// src/scheduler.ts
+import YAML3 from "yaml";
 
 // src/node.ts
 var defaultFilename = "graph.circuitry.yaml";
@@ -396,30 +241,38 @@ ${validation.errors.map((e) => e.message).join("\n")}`);
 var loadCircuitryGraphFile = async (filename2 = defaultFilename, standard, stack = []) => {
   const graphFile = path.resolve(process.cwd(), filename2);
   const text = await readFile(graphFile, "utf8");
-  const parsed = parseCircuitryText(text, graphFile, standard, { validate: false });
+  const parsed = parseCircuitryText(text, standard, { validate: false });
   return resolveCircuitryGraph(parsed, graphFile, text, standard, stack);
 };
 
 // src/cli.ts
 var [, , command, filename] = process.argv;
 var usage = () => {
-  console.error("usage: circuitry <check|normalize> <graph.circuitry.yaml>");
+  console.error("usage: circuitry <check|normalize|normalize-json|parse> <file.yaml>");
   process.exit(2);
 };
 if (!command || !filename) usage();
 try {
-  const loaded = await loadCircuitryGraphFile(filename);
-  if (command === "check") {
-    const result = validateCircuitryExecutionGraphWithStandard(loaded.graph);
-    if (!result.ok) {
-      console.error(result.errors.map((error) => error.message).join("\n"));
-      process.exit(1);
-    }
-    console.log(`ok: ${loaded.filename}`);
-  } else if (command === "normalize") {
-    console.log(JSON.stringify({ graph: loaded.graph, origins: loaded.origins }, null, 2));
+  if (command === "parse") {
+    const text = await readFile2(filename, "utf8");
+    process.stdout.write(stringifyYamlData(parseYamlData(text)));
   } else {
-    usage();
+    const loaded = await loadCircuitryGraphFile(filename);
+    if (command === "check") {
+      const result = validateCircuitryExecutionGraphWithStandard(loaded.graph);
+      if (!result.ok) {
+        console.error(result.errors.map((error) => error.message).join("\n"));
+        process.exit(1);
+      }
+      console.log(`ok: ${loaded.filename}`);
+    } else if (command === "normalize") {
+      process.stdout.write(stringifyYamlData({ circuitryBundle: CIRCUITRY_SPEC_VERSION, graph: loaded.graph, origins: loaded.origins }));
+    } else if (command === "normalize-json") {
+      process.stdout.write(JSON.stringify({ circuitryBundle: CIRCUITRY_SPEC_VERSION, graph: loaded.graph, origins: loaded.origins }));
+      process.stdout.write("\n");
+    } else {
+      usage();
+    }
   }
 } catch (error) {
   console.error(error instanceof Error ? error.message : String(error));

package/dist/graph.d.ts

@@ -1,13 +1,12 @@
-export declare const CIRCUITRY_SPEC_VERSION: "0.3.1";
+export declare const CIRCUITRY_SPEC_VERSION: "0.3.2";
 export type CircuitrySpecVersion = typeof CIRCUITRY_SPEC_VERSION;
 export type CircuitryNodeKind = "agent" | "input" | "tool" | "output" | string;
-export type CircuitryEdgeKind = "context" | "dependency" | "message" | "control" | string;
+export type CircuitryEdgeKind = "dependency" | "context" | "message" | "control" | string;
 export type CircuitryInputKind = "text" | "file" | "url" | "image" | "uri" | "canvas" | "mcp" | string;
 export type CircuitryAgent = {
     uses?: string;
     model?: string;
     tools?: string[];
-    thinkingLevel?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
     identity?: string;
     personality?: string;
     instructions?: string;
@@ -51,9 +50,7 @@ export type CircuitryEdge = {
 export type CircuitryExpectFieldType = "str" | "int" | "float" | "bool" | "list" | "dict" | (string & {});
 export type CircuitryExpectField = {
     type: CircuitryExpectFieldType;
-    /** Optional substring that must appear in the string value. */
     contains?: string;
-    /** For list fields: shape of each item. */
     items?: CircuitryExpectSchema | CircuitryExpectFieldType;
     optional?: boolean;
 };
@@ -70,14 +67,9 @@ export type CircuitryResourceAgent = {
     identity?: string;
     label?: string;
     model?: string;
-    thinkingLevel?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
-    /** References to other resource ids that feed this agent. */
     inputs?: string[];
-    /** Per-resource tool whitelist. */
     tools?: string[];
-    /** Per-resource skill whitelist. */
     skills?: string[];
-    /** Expected output schema — stored as metadata, used for optional validation. */
     expect?: CircuitryExpectSchema;
     instructions?: string;
     personality?: string;
@@ -135,38 +127,10 @@ export type CircuitryRuntime = {
     permissions?: Record<string, unknown>;
 };
 export type CircuitryBuiltInValidationRule = "no-self-loops" | "no-unknown-edge-endpoints" | "require-executable-inputs" | "no-cycles";
-export type CircuitryStringValidationMatch = {
-    field: string;
-    value: string;
-    nodeKinds?: string[];
-    edgeKinds?: string[];
-};
-export type CircuitryAdditionalValidationRule = {
-    rule: "require-graph-field";
-    field: string;
-} | {
-    rule: "require-node-field";
-    field: string;
-    nodeKinds?: string[];
-} | {
-    rule: "require-edge-field";
-    field: string;
-    edgeKinds?: string[];
-} | {
-    rule: "require-string";
-    graph?: CircuitryStringValidationMatch[];
-    nodes?: CircuitryStringValidationMatch[];
-    edges?: CircuitryStringValidationMatch[];
-} | {
-    rule: "reject-string";
-    graph?: CircuitryStringValidationMatch[];
-    nodes?: CircuitryStringValidationMatch[];
-    edges?: CircuitryStringValidationMatch[];
-};
 export type CircuitryValidationRuleEntry = CircuitryBuiltInValidationRule | {
-    rule: CircuitryBuiltInValidationRule;
+    rule: "require-executable-inputs";
     executableKinds?: string[];
-} | CircuitryAdditionalValidationRule;
+};
 export type CircuitryGraphValidation = {
     rules?: CircuitryValidationRuleEntry[];
 };
@@ -179,44 +143,31 @@ export type CircuitryGraphArg = {
     mimeType?: string;
 };
 export type CircuitryRuntimeInputs = Record<string, unknown>;
-/**
- * Return a graph copy with runtime input values applied to existing text inputs.
- *
- * Runtime inputs are execution-time args for graph programs: small overlays on
- * declared text inputs. They must target declared input resources; this keeps
- * graph source stable and catches misspelled input names before execution.
- */
-export declare const applyCircuitryRuntimeInputs: (graph: CircuitryGraph, inputs?: CircuitryRuntimeInputs) => CircuitryGraph;
-/** Import declaration for bringing resources from another graph file. */
 export type CircuitryImport = {
-    /** Path to another .circuitry.yaml/.json file, resolved relative to this file. */
     path: string;
-    /** Import all resources, a resource list, or an old->new resource id map. */
     resources: "*" | string[] | Record<string, string>;
-    /** Optional namespace applied to imported resource ids and their internal refs. */
     prefix?: string;
 };
 export type CircuitryGraph = {
-    /** Spec version. */
     circuitry: CircuitrySpecVersion | string;
     id?: string;
     title?: string;
     description?: string;
-    /** Explicit imports of resources from other graph files. */
     imports?: CircuitryImport[];
-    /** Runtime call contract. Args bind to resources with matching ids. */
     args?: Record<string, CircuitryGraphArg>;
     resources?: Record<string, CircuitryResourceEntry>;
-    /** Internal normalized execution nodes. Authored graph files must not set this. */
     nodes?: CircuitryNode[];
-    /** Internal normalized execution edges. Authored graph files must not set this. */
     edges?: CircuitryEdge[];
-    /** Forbidden in authored graph files. */
     agents?: never;
     runtime?: CircuitryRuntime;
     validation?: CircuitryGraphValidation;
     metadata?: Record<string, unknown>;
 };
+export type LoadedCircuitryBundle = {
+    circuitryBundle: CircuitrySpecVersion;
+    graph: CircuitryGraph;
+    origins: Record<string, string>;
+};
 export type CircuitryAgentPreset = {
     name: string;
     description?: string;
@@ -243,18 +194,15 @@ export type CircuitryValidationResult = {
 };
 export declare const DEFAULT_CIRCUITRY_VALIDATION_RULES: CircuitryValidationRuleEntry[];
 export declare const DEFAULT_CIRCUITRY_VALIDATION_STANDARD: {
-    readonly version: "0.3.1";
+    readonly version: "0.3.2";
     readonly requireSpecVersion: true;
     readonly rules: CircuitryValidationRuleEntry[];
     readonly executableKinds: ["agent", "tool", "output"];
 };
+export declare const applyCircuitryRuntimeInputs: (graph: CircuitryGraph, inputs?: CircuitryRuntimeInputs) => CircuitryGraph;
 export declare const createCircuitryValidationStandard: (standard?: CircuitryValidationStandard, graph?: CircuitryGraph) => Required<CircuitryValidationStandard>;
 export declare const normalizeCircuitryGraph: (graph: CircuitryGraph) => CircuitryGraph;
 export declare const validateCircuitryGraphWithStandard: (graph: unknown, standard?: CircuitryValidationStandard) => CircuitryValidationResult;
 export declare const validateCircuitryExecutionGraphWithStandard: (graph: unknown, standard?: CircuitryValidationStandard) => CircuitryValidationResult;
 export declare const validateCircuitryGraph: (graph: unknown, standard?: CircuitryValidationStandard) => string[];
-export declare const parseCircuitryJson: (text: string, standard?: CircuitryValidationStandard, options?: {
-    validate?: boolean;
-}) => CircuitryGraph;
-export declare const stringifyCircuitryJson: (graph: CircuitryGraph) => string;
 export declare const isUriInput: (input: CircuitryInput | Omit<CircuitryInput, "id">) => boolean;