@sweny-ai/core 0.1.156 → 0.1.157

package/dist/eval/index.js

@@ -35,42 +35,42 @@ function resolveJudgeModel(evaluator, node, workflow, harnessDefault) {
 export async function evaluateAll(evaluators, result, opts = {}) {
     if (!evaluators || evaluators.length === 0)
         return [];
+    // A judge with no client is a wiring error: refuse before any model call.
+    const orphanJudge = evaluators.find((e) => e.kind === "judge" && !opts.claude);
+    if (orphanJudge) {
+        throw new Error(`evaluator '${orphanJudge.name}' is kind: judge but no Claude client was provided to evaluateAll`);
+    }
+    // Evaluators are independent, so they run concurrently (#337): N judges on
+    // a node cost one round-trip of wall time, not N. Results keep declaration
+    // order. Every evaluator settles before an error surfaces, and the first
+    // rejection in declaration order is rethrown, so the outcome never depends
+    // on which call finishes first.
+    const settled = await Promise.allSettled(evaluators.map((e) => evaluateOne(e, result, opts)));
     const out = [];
-    for (const e of evaluators) {
-        if (e.kind === "value") {
-            const verdict = evaluateValueRule(e.rule ?? {}, result.data);
-            out.push({
-                name: e.name,
-                kind: "value",
-                pass: verdict.pass,
-                reasoning: capReasoning(verdict.reasoning),
-            });
-        }
-        else if (e.kind === "function") {
-            const verdict = evaluateFunctionRule(e.rule ?? {}, result.toolCalls, opts.aliases);
-            out.push({
-                name: e.name,
-                kind: "function",
-                pass: verdict.pass,
-                reasoning: capReasoning(verdict.reasoning),
-            });
-        }
-        else if (e.kind === "judge") {
-            if (!opts.claude) {
-                throw new Error(`evaluator '${e.name}' is kind: judge but no Claude client was provided to evaluateAll`);
-            }
-            const model = resolveJudgeModel(e, opts.node, opts.workflow, opts.claude.defaultJudgeModel);
-            const verdict = await evaluateJudge(e, result, opts.claude, { model });
-            out.push({
-                name: e.name,
-                kind: "judge",
-                pass: verdict.pass,
-                reasoning: capReasoning(verdict.reasoning),
-            });
-        }
+    for (const s of settled) {
+        if (s.status === "rejected")
+            throw s.reason;
+        if (s.value)
+            out.push(s.value);
     }
     return out;
 }
+async function evaluateOne(e, result, opts) {
+    if (e.kind === "value") {
+        const verdict = evaluateValueRule(e.rule ?? {}, result.data);
+        return { name: e.name, kind: "value", pass: verdict.pass, reasoning: capReasoning(verdict.reasoning) };
+    }
+    if (e.kind === "function") {
+        const verdict = evaluateFunctionRule(e.rule ?? {}, result.toolCalls, opts.aliases);
+        return { name: e.name, kind: "function", pass: verdict.pass, reasoning: capReasoning(verdict.reasoning) };
+    }
+    if (e.kind === "judge" && opts.claude) {
+        const model = resolveJudgeModel(e, opts.node, opts.workflow, opts.claude.defaultJudgeModel);
+        const verdict = await evaluateJudge(e, result, opts.claude, { model });
+        return { name: e.name, kind: "judge", pass: verdict.pass, reasoning: capReasoning(verdict.reasoning) };
+    }
+    return null;
+}
 /**
  * Collapse a list of {@link EvalResult}s into a single pass/fail under the
  * node's `eval_policy`. v1 implements `all_pass`. Other policies are

package/dist/executor.js

@@ -206,14 +206,22 @@ export async function execute(workflow, input, options) {
         // (a Record<name, EvalResult> for downstream lookup like
         // `priorNode.evals.tests_run_clean.pass`). This namespace is reserved
         // for runtime verdicts; an agent-provided `data.evals` never overrides it.
-        const context = {
+        // `requires` always reads this full map: it is a deterministic gate, not
+        // a prompt, so it costs no tokens and keeps every declared path working.
+        const requiresContext = {
             input,
             ...Object.fromEntries([...results.entries()].map(([k, v]) => [k, buildPriorNodeContext(v)])),
         };
+        // What the model sees (#337): only nodes this one can depend on, and a
+        // schema'd node's declared fields instead of its prose. `context_mode:
+        // full` keeps the old everything-prior map.
+        const context = workflow.context_mode === "full"
+            ? requiresContext
+            : buildBoundedContext(workflow, currentId, results, input, resolvedInstruction);
         // Pre-condition gate: evaluate `requires` against the cross-node context
         // BEFORE invoking the LLM. Failure either marks the node failed (on_fail
         // default) or skipped (on_fail: "skip") and skips execution entirely.
-        const requiresError = evaluateRequires(node.requires, context);
+        const requiresError = evaluateRequires(node.requires, requiresContext);
         if (requiresError) {
             const onFail = node.requires?.on_fail ?? "fail";
             const result = onFail === "skip"
@@ -653,9 +661,9 @@ function buildPriorNodeContext(result) {
  * evaluator. When no schema is declared we fall back to the full data
  * (back-compat for workflows without structured outputs).
  *
- * The downstream node prompt is untouched: nodes still see the full prior
- * `data` including any prose `summary`, so workflows that consume the
- * narrative in subsequent steps keep working.
+ * Downstream node prompts get a similar projection (see
+ * `buildBoundedNodeEntry`), minus the null-fill, unless the workflow sets
+ * `context_mode: full`.
  */
 function buildRouteEvalEntry(result, sourceNode) {
     const fullData = (result.data ?? {});
@@ -714,6 +722,77 @@ function getDeclaredOutputProperties(output) {
         return null;
     return new Set(keys);
 }
+// ─── Bounded node context (#337) ─────────────────────────────────
+//
+// Full mode hands every node the whole results map: node N re-sends nodes
+// 1..N-1 including each one's prose `summary`, so prompt bytes per run grow
+// quadratically and one verbose node inflates every later prompt. Bounded
+// mode (the default) keeps the same keys a node can depend on, and sends a
+// schema'd node's declared fields only.
+/** Keys the executor itself writes into data; kept when a view is projected. */
+const RUNTIME_DATA_KEYS = ["error", "fail_soft", "skipped_reason"];
+/**
+ * The prompt-context entry for one prior node in bounded mode. A successful
+ * node with a declared `output.properties` block contributes those fields
+ * (plus executor-written error/fail_soft keys); everything else, including
+ * the free-text `summary`, is dropped. Nodes without a schema, and nodes
+ * that did not succeed, keep the full `buildPriorNodeContext` entry. The
+ * trusted `evals` and `safe_outputs` namespaces always come from the runtime.
+ */
+function buildBoundedNodeEntry(result, sourceNode) {
+    const full = buildPriorNodeContext(result);
+    const declared = getDeclaredOutputProperties(sourceNode?.output);
+    if (!declared || result.status !== "success")
+        return full;
+    const keep = new Set([...declared, ...RUNTIME_DATA_KEYS, "evals", "safe_outputs"]);
+    return Object.fromEntries(Object.entries(full).filter(([k]) => keep.has(k)));
+}
+/** First segment of a requires path (`any:triage.findings[*].x` -> `triage`). */
+function pathRoot(path) {
+    return /^(?:all:|any:)?([^.[\]]+)/.exec(path)?.[1];
+}
+function mentionsNode(text, nodeId) {
+    const escaped = nodeId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`(?<![A-Za-z0-9_-])${escaped}(?![A-Za-z0-9_-])`).test(text);
+}
+/**
+ * Node ids whose results `nodeId` may read: its graph ancestors (every node
+ * with an edge path into it, itself included when it sits on a cycle), any
+ * node a `requires` path names, and any node id its instruction mentions.
+ */
+function contextDependencies(workflow, nodeId, instruction = "") {
+    const deps = new Set();
+    const stack = [nodeId];
+    for (let id = stack.pop(); id !== undefined; id = stack.pop()) {
+        for (const e of workflow.edges) {
+            if (e.to === id && !deps.has(e.from)) {
+                deps.add(e.from);
+                stack.push(e.from);
+            }
+        }
+    }
+    const requires = workflow.nodes[nodeId]?.requires;
+    for (const p of [...(requires?.output_required ?? []), ...(requires?.output_matches ?? []).map((m) => m.path)]) {
+        const root = pathRoot(p);
+        if (root && root !== "input")
+            deps.add(root);
+    }
+    for (const id of Object.keys(workflow.nodes)) {
+        if (id !== nodeId && mentionsNode(instruction, id))
+            deps.add(id);
+    }
+    return deps;
+}
+/** The bounded prompt context for one node: `input` plus its dependencies' entries. */
+function buildBoundedContext(workflow, nodeId, results, input, instruction) {
+    const deps = contextDependencies(workflow, nodeId, instruction);
+    return {
+        input,
+        ...Object.fromEntries([...results.entries()]
+            .filter(([k]) => deps.has(k))
+            .map(([k, v]) => [k, buildBoundedNodeEntry(v, workflow.nodes[k])])),
+    };
+}
 /**
  * Return the declared `required` field names for a node's output schema,
  * or an empty array when no required block is declared. Tolerant of

package/dist/schema.d.ts

@@ -2547,6 +2547,7 @@ export declare const workflowZ: z.ZodObject<{
     judge_model: z.ZodOptional<z.ZodString>;
     model: z.ZodOptional<z.ZodString>;
     judge_budget: z.ZodOptional<z.ZodNumber>;
+    context_mode: z.ZodOptional<z.ZodEnum<["bounded", "full"]>>;
     inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodObject<{
         type: z.ZodEnum<["string", "number", "boolean", "string[]"]>;
         description: z.ZodOptional<z.ZodString>;
@@ -2785,6 +2786,7 @@ export declare const workflowZ: z.ZodObject<{
     judge_model?: string | undefined;
     workflow_type?: "pr_review" | "e2e_test" | "content_generation" | "monitor" | "data_sync" | "generic" | undefined;
     judge_budget?: number | undefined;
+    context_mode?: "full" | "bounded" | undefined;
     inputs?: Record<string, {
         type: "string" | "number" | "boolean" | "string[]";
         description?: string | undefined;
@@ -2964,6 +2966,7 @@ export declare const workflowZ: z.ZodObject<{
     judge_model?: string | undefined;
     workflow_type?: "pr_review" | "e2e_test" | "content_generation" | "monitor" | "data_sync" | "generic" | undefined;
     judge_budget?: number | undefined;
+    context_mode?: "full" | "bounded" | undefined;
     inputs?: Record<string, {
         type: "string" | "number" | "boolean" | "string[]";
         description?: string | undefined;
@@ -3157,6 +3160,7 @@ export declare function parseWorkflow(raw: unknown): {
     judge_model?: string | undefined;
     workflow_type?: "pr_review" | "e2e_test" | "content_generation" | "monitor" | "data_sync" | "generic" | undefined;
     judge_budget?: number | undefined;
+    context_mode?: "full" | "bounded" | undefined;
     inputs?: Record<string, {
         type: "string" | "number" | "boolean" | "string[]";
         description?: string | undefined;
@@ -3610,6 +3614,11 @@ export declare const workflowJsonSchema: {
             readonly minimum: 0;
             readonly description: "Soft cap on expected judge calls per workflow run. Executor warns at load time if exceeded; not a hard runtime cap in v1.";
         };
+        readonly context_mode: {
+            readonly type: "string";
+            readonly enum: readonly ["bounded", "full"];
+            readonly description: "What prior results a node's prompt receives. bounded (default): only nodes it can depend on, and a schema'd node's declared fields instead of its free-text summary. full: every prior node's complete data.";
+        };
         readonly inputs: {
             readonly type: "object";
             readonly description: "Declared per-run input contract. Each entry names a parameter the caller may supply via --input. The CLI validates against this declaration, applies defaults for omitted optional fields, and rejects unknown types before the executor runs. Optional; workflows without an inputs block accept any JSON object (back-compat).";

package/dist/schema.js

@@ -7,7 +7,7 @@
  * parsing untrusted input (JSON/YAML import, Studio editor).
  */
 import { z } from "zod";
-import { AUTHOR_ASSOCIATIONS, EVALUATOR_KINDS, EVAL_POLICIES, MCP_TRANSPORTS, NODE_ACCESS, NODE_ON_FAIL, REQUIRES_ON_FAIL, SAFE_OUTPUT_APPLIERS, SAFE_OUTPUT_EXPIRES_PATTERN, SAFE_OUTPUT_MAX_CEILING, SAFE_OUTPUT_STATES, SAFE_OUTPUT_TYPES, SKILL_CATEGORIES, SKILL_ID_MAX_LENGTH, SKILL_ID_PATTERN, TOOL_ACCESS, TOOL_CLASSES, WORKFLOW_TYPES, } from "./types.js";
+import { AUTHOR_ASSOCIATIONS, CONTEXT_MODES, EVALUATOR_KINDS, EVAL_POLICIES, MCP_TRANSPORTS, NODE_ACCESS, NODE_ON_FAIL, REQUIRES_ON_FAIL, SAFE_OUTPUT_APPLIERS, SAFE_OUTPUT_EXPIRES_PATTERN, SAFE_OUTPUT_MAX_CEILING, SAFE_OUTPUT_STATES, SAFE_OUTPUT_TYPES, SKILL_CATEGORIES, SKILL_ID_MAX_LENGTH, SKILL_ID_PATTERN, TOOL_ACCESS, TOOL_CLASSES, WORKFLOW_TYPES, } from "./types.js";
 import { sourceZ } from "./sources.js";
 import { workflowInputsZ, WORKFLOW_INPUT_TYPES } from "./inputs.js";
 export { sourceZ };
@@ -353,6 +353,7 @@ export const workflowZ = z.object({
     judge_model: z.string().min(1).optional(),
     model: z.string().min(1).optional(),
     judge_budget: z.number().int().min(0).optional(),
+    context_mode: z.enum(CONTEXT_MODES).optional(),
     inputs: workflowInputsZ.optional(),
     permissions: nodePermissionsZ.optional(),
     safe_outputs: safeOutputsPolicyZ.optional(),
@@ -983,6 +984,11 @@ export const workflowJsonSchema = {
             // applies the soft-cap default at use-time. See judge_model above.
             description: "Soft cap on expected judge calls per workflow run. Executor warns at load time if exceeded; not a hard runtime cap in v1.",
         },
+        context_mode: {
+            type: "string",
+            enum: [...CONTEXT_MODES],
+            description: "What prior results a node's prompt receives. bounded (default): only nodes it can depend on, and a schema'd node's declared fields instead of its free-text summary. full: every prior node's complete data.",
+        },
         inputs: {
             type: "object",
             description: "Declared per-run input contract. Each entry names a parameter the caller may supply via --input. The CLI validates against this declaration, applies defaults for omitted optional fields, and rejects unknown types before the executor runs. Optional; workflows without an inputs block accept any JSON object (back-compat).",

package/dist/types.d.ts

@@ -137,6 +137,9 @@ export type EvaluatorKind = (typeof EVALUATOR_KINDS)[number];
 /** Aggregation policy for a node's evaluator results. v1 implements `all_pass`. */
 export declare const EVAL_POLICIES: readonly ["all_pass", "any_pass", "weighted"];
 export type EvalPolicy = (typeof EVAL_POLICIES)[number];
+/** What prior results a node's prompt receives (#337). See {@link Workflow.context_mode}. */
+export declare const CONTEXT_MODES: readonly ["bounded", "full"];
+export type ContextMode = (typeof CONTEXT_MODES)[number];
 /** Action when a `requires` precondition fails. */
 export declare const REQUIRES_ON_FAIL: readonly ["fail", "skip"];
 export type RequiresOnFail = (typeof REQUIRES_ON_FAIL)[number];
@@ -520,6 +523,13 @@ export interface Workflow {
     model?: string;
     /** Soft cap on expected judge calls per workflow run. Warning at load time when exceeded. */
     judge_budget?: number;
+    /**
+     * What prior results a node's prompt receives (#337). `bounded` (default):
+     * only nodes it can depend on (graph ancestors, nodes named by `requires`
+     * or its instruction), and a schema'd node's declared fields instead of its
+     * free-text `summary`. `full`: every prior node's complete data.
+     */
+    context_mode?: ContextMode;
     /**
      * Declared per-run input contract. When present, the CLI validates the
      * caller-provided `--input` JSON against this declaration, applies defaults

package/dist/types.js

@@ -51,6 +51,8 @@ export function isValidSkillId(id) {
 export const EVALUATOR_KINDS = ["value", "function", "judge"];
 /** Aggregation policy for a node's evaluator results. v1 implements `all_pass`. */
 export const EVAL_POLICIES = ["all_pass", "any_pass", "weighted"];
+/** What prior results a node's prompt receives (#337). See {@link Workflow.context_mode}. */
+export const CONTEXT_MODES = ["bounded", "full"];
 /** Action when a `requires` precondition fails. */
 export const REQUIRES_ON_FAIL = ["fail", "skip"];
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sweny-ai/core",
-  "version": "0.1.156",
+  "version": "0.1.157",
   "type": "module",
   "bin": {
     "sweny": "./dist/cli/main.js"