@sweny-ai/core 0.1.213 → 0.1.215

package/dist/executor.d.ts

@@ -12,7 +12,7 @@
  *
  * This replaces ~8k lines of engine + recipe step code.
  */
-import type { Workflow, Node, Skill, Tool, Claude, Observer, NodeResult, Logger, ExecutionResult, JSONSchema, EvalResult, Evaluator, ToolCall } from "./types.js";
+import type { Workflow, Node, Skill, Tool, Claude, Observer, NodeResult, Logger, ExecutionResult, EvalResult, Evaluator, ToolCall } from "./types.js";
 import type { ToolAliases } from "./eval/index.js";
 import type { HarnessPolicyMode } from "./harness/policy.js";
 import type { AgentHarness } from "./harness/types.js";
@@ -20,6 +20,7 @@ import type { DeciderOperatorConfig } from "./decider.js";
 import type { Budget } from "./budget.js";
 import { type ActorInfo } from "./safe-outputs.js";
 import { type ExecutionJournal } from "./journal.js";
+import { COUNT_OF_KEYWORD, outputContractProblems } from "./output-contract.js";
 export interface ExecuteOptions {
     /** Registered skills (id → Skill) */
     skills: Map<string, Skill>;
@@ -175,22 +176,8 @@ export declare function deciderRoutingState(workflow: Workflow, current: string,
  * @internal
  */
 export declare function buildBoundedContext(workflow: Workflow, nodeId: string, results: Map<string, NodeResult>, input: unknown, instruction: string): Record<string, unknown>;
-/** One way a node's emitted data breaks its declared output contract. */
-export interface ContractProblem {
-    field: string;
-    kind: "missing" | "invalid";
-    problem: string;
-}
-/** Keyword on an integer output property: the count sweny cross-checks against an array in the same output. */
-export declare const COUNT_OF_KEYWORD = "x-sweny-count-of";
-/**
- * Check emitted data against the declared output contract (#357): every
- * `required` field present; every present top-level property of its declared
- * `type` and inside its `enum`; and every `x-sweny-count-of` integer equal to
- * the count it declares over its array. Not full JSON Schema: formats,
- * nested shapes and additionalProperties stay the author's concern.
- */
-export declare function outputContractProblems(data: unknown, output: JSONSchema | undefined): ContractProblem[];
+export { COUNT_OF_KEYWORD, outputContractProblems };
+export type { ContractProblem } from "./output-contract.js";
 /**
  * Required tools the agent never called, when that is the only reason a node
  * failed its evals and another turn could call them: every failure is a
@@ -216,4 +203,3 @@ export declare function isReadTool(tool: Pick<Tool, "access">): boolean;
  * any side effect.
  */
 export declare function guardStagedWrite(tool: Pick<Tool, "name" | "access">, staged: boolean): void;
-export {};

package/dist/executor.js

@@ -37,6 +37,7 @@ import { redact, runSecretValues } from "./journal.js";
 import { buildNodePolicy, hasNodePolicy, resolveNodePermissions } from "./node-policy.js";
 import { applySafeOutputs, createEmitOutputTool, createWriteStageState, resolveActor, safeOutputsInstruction, unresolvedOutputs, SAFE_OUTPUT_SCREEN_INSTRUCTION, } from "./safe-outputs.js";
 import { JournalWriteError } from "./journal.js";
+import { COUNT_OF_KEYWORD, checkOutputContract, contractFailureMessage, contractPaths, listContractProblems, outputContractProblems, } from "./output-contract.js";
 /**
  * Default workflow-level step budget. Counts total node executions across the
  * whole run (loop iterations included). Generous enough for legitimate deep
@@ -119,7 +120,7 @@ async function executeRun(workflow, input, options, results, trace, at) {
     const nodeRunCounts = new Map(); // node → times executed
     const maxSteps = options.max_steps ?? DEFAULT_MAX_STEPS;
     let stepCount = 0; // total node executions across the run (loop iterations included)
-    validate(workflow, skills);
+    validate(workflow, skills, logger);
     // Safe outputs (#365): run-wide caps and dedupe, the staged switch and the
     // triggering actor, resolved once per run.
     const writeState = createWriteStageState();
@@ -768,6 +769,8 @@ async function executeRun(workflow, input, options, results, trace, at) {
                     context,
                     tools: trackedTools,
                     outputSchema: harnessSchema(node.output),
+                    // The executor checks the output and asks for one repair itself, the same on every harness.
+                    ...(node.output ? { callerRepairsOutput: true } : {}),
                     maxTurns: node.max_turns,
                     disallowedTools: node.disallowed_tools,
                     ...(denyClasses.length > 0 ? { deny: denyClasses } : {}),
@@ -854,73 +857,69 @@ async function executeRun(workflow, input, options, results, trace, at) {
                 agentRunFailed = true;
                 break;
             }
-            // Required-field gate: if the source node's declared output schema
-            // marks fields as `required`, those fields are the routing contract.
-            // An agent that omits a required field has violated the contract; we
-            // fail the node loudly rather than letting routing guess against a
-            // half-built data view. See the offload release-notes field bug:
-            // an optional quality_retry_count was declared in the schema but
-            // omitted by the agent, the route view silently dropped the key,
-            // and an "is 0 OR is undefined" condition ghost-matched.
-            //
-            // We only check declared `required` fields, not full JSON Schema
-            // validation. Type mismatches, formats, additionalProperties, etc.
-            // stay the workflow author's problem and don't have the same
-            // routing-correctness blast radius.
-            // A missing required field is a contract violation handled on the same
-            // footing as an eval failure: an otherwise-recoverable one-off omission
-            // should self-heal on a second attempt when the node has `retry`
-            // configured. We synthesize an eval-shaped failure so the retry preamble
-            // and trace bookkeeping below treat it identically. When no retry is
-            // configured (or the budget is exhausted), it still hard-fails the node.
-            // Output contract (#357): required fields present, declared types and
-            // enums respected, declared counts consistent. One repair round trip
-            // first, for every harness: the agent is told exactly what is wrong.
-            const contract = outputContractProblems(result.data, node.output);
+            // Output contract (#357, #573): the emitted data is checked against the
+            // node's declared `output` JSON Schema at every depth (nested objects,
+            // arrays of objects, enums, `required` at any depth,
+            // additionalProperties), plus `x-sweny-count-of` counts. The check runs
+            // here, on the data every harness returns, so a violation reads the same
+            // whichever harness ran the node, each problem with its exact path and
+            // never the emitted value. One repair round trip first, for every
+            // harness: the agent is told exactly what is wrong. A check that cannot
+            // run (it threw) fails this node, never the run, and gets no repair.
+            const checked = checkOutputContract(result.data, node.output);
+            const contract = "problems" in checked ? checked.problems : [];
             if (contract.length > 0 && !repaired) {
                 // Part of this node visit, like a retry of the same call: no extra
                 // max_steps slot. Its spend still counts (budget, journal usage).
                 repaired = true;
-                const listed = contract.map((p) => `- ${p.field}: ${p.problem}`).join("\n");
-                logger.warn(`  output contract: ${contract.map((p) => p.field).join(", ")}; asking the agent once to fix it`, {
+                const listed = listContractProblems(contract)
+                    .map((line) => `- ${line}`)
+                    .join("\n");
+                logger.warn(`  output contract: ${contractPaths(contract).join(", ")}; asking the agent once to fix it`, {
                     node: currentId,
                 });
                 safeObserve(observer, {
                     type: "node:warning",
                     node: currentId,
                     reason: "output contract violated; one repair attempt",
-                    fields: contract.map((p) => p.field),
+                    fields: contractPaths(contract),
                 }, logger);
                 currentInstruction =
                     `Your previous output did not match this step's declared output schema:\n${listed}\n\n` +
-                        `Do the step again and return the complete output with every listed field present and of the declared type.` +
+                        `Do the step again and return the complete output, with every listed field present and matching the declared schema.` +
                         `\n\n---\n\n${currentInstruction}`;
                 continue;
             }
-            // Still wrong after the repair. A field an expression routes on is not a
-            // node failure: routes that read it fall through to the next rung
-            // (decider or agent) at routing time. Other missing required fields keep
-            // failing the node, as before.
+            // Still wrong after the repair. A problem under a field an expression
+            // routes on is not a node failure: routes that read it fall through to
+            // the next rung (decider or agent) at routing time. Every other problem
+            // fails the node, on the same footing as an eval failure: with `retry`
+            // configured, the reflection and retry path below gets another attempt.
+            // A schema that does not compile keeps the pre-#573 rule (deprecated):
+            // only a missing field fails the node.
             const routedOn = routingFieldsOf(workflow, currentId);
             const tolerated = contract.filter((p) => routedOn.has(p.field));
             if (tolerated.length > 0) {
-                logger.warn(`  output contract still violated for routing field(s) ${tolerated.map((p) => p.field).join(", ")}; ` +
+                logger.warn(`  output contract still violated for routing field(s) ${contractPaths(tolerated).join(", ")}; ` +
                     `routes that read them fall through to the next rung`, { node: currentId });
                 safeObserve(observer, {
                     type: "node:warning",
                     node: currentId,
                     reason: "routing fields missing or invalid after repair; their routes fall through",
-                    fields: tolerated.map((p) => p.field),
+                    fields: contractPaths(tolerated),
                 }, logger);
             }
-            const missingRequired = contract
-                .filter((p) => p.kind === "missing" && !routedOn.has(p.field))
-                .map((p) => p.field);
+            const broken = contract.filter((p) => !routedOn.has(p.field) && (p.kind === "missing" || !p.fallback));
+            const contractError = "error" in checked
+                ? `output validation error: ${checked.error}`
+                : broken.length > 0
+                    ? contractFailureMessage(broken)
+                    : undefined;
             let outcome;
-            if (missingRequired.length > 0) {
-                const msg = `output schema violation: required field(s) missing from emitted data: ${missingRequired.join(", ")}`;
-                const failure = { name: "output_required", kind: "value", pass: false, reasoning: msg };
-                outcome = { pass: false, error: msg, failures: [failure] };
+            if (contractError !== undefined) {
+                const name = broken.some((p) => p.kind === "missing") ? "output_required" : "output_schema";
+                const failure = { name, kind: "value", pass: false, reasoning: contractError };
+                outcome = { pass: false, error: contractError, failures: [failure] };
                 // Still record the synthesized failure as the node's eval result so
                 // observers and downstream context see the contract violation.
                 result.evals = [failure];
@@ -1408,9 +1407,12 @@ export function deciderRoutingState(workflow, current, results, conditions, secr
         const fields = fieldsOf(id);
         if (fields.size > 0 && r.status === "success") {
             const data = (r.data ?? {});
+            // A field that breaks the node's contract by any rule (#573) is sent as null, like a mistyped one.
+            const broken = invalidOutputFields(r, hasOwn(workflow.nodes, id) ? workflow.nodes[id] : undefined);
             const output = Object.create(null);
-            for (const [k, spec] of fields)
-                output[k] = projectValue(spec, hasOwn(data, k) ? data[k] : undefined);
+            for (const [k, spec] of fields) {
+                output[k] = broken.has(k) ? null : projectValue(spec, hasOwn(data, k) ? data[k] : undefined);
+            }
             entry.output = output;
         }
         if (r.evals && r.evals.length > 0) {
@@ -1518,114 +1520,19 @@ export function buildBoundedContext(workflow, nodeId, results, input, instructio
             .map(([k, v]) => [k, buildBoundedNodeEntry(v, workflow.nodes[k])])),
     };
 }
+// The output contract (#357, #573) lives in output-contract.ts; re-exported for existing importers.
+export { COUNT_OF_KEYWORD, outputContractProblems };
 /**
- * Return the declared `required` field names for a node's output schema,
- * or an empty array when no required block is declared. Tolerant of
- * malformed schemas (mirrors getDeclaredOutputProperties).
+ * The top-level output fields of a node's result that are present but break
+ * its contract (#573), at any depth and by any rule. Routing reads them as
+ * unknown and the decider never sees their values. A check that cannot run
+ * (it threw) marks every declared field, so nothing unchecked routes.
  */
-function getDeclaredRequiredFields(output) {
-    if (!output || typeof output !== "object")
-        return [];
-    const required = output.required;
-    if (!Array.isArray(required))
-        return [];
-    return required.filter((r) => typeof r === "string");
-}
-/** Keyword on an integer output property: the count sweny cross-checks against an array in the same output. */
-export const COUNT_OF_KEYWORD = "x-sweny-count-of";
-function typeMatches(t, v) {
-    switch (t) {
-        case "string":
-            return typeof v === "string";
-        case "number":
-            return typeof v === "number" && Number.isFinite(v);
-        case "integer":
-            return typeof v === "number" && Number.isInteger(v);
-        case "boolean":
-            return typeof v === "boolean";
-        case "array":
-            return Array.isArray(v);
-        case "object":
-            return typeof v === "object" && v !== null && !Array.isArray(v);
-        case "null":
-            return v === null;
-        default:
-            return true; // unknown or absent type: not checked
-    }
-}
-function countOf(spec, data) {
-    const items = hasOwn(data, spec.array) ? data[spec.array] : undefined;
-    if (!Array.isArray(items))
-        return undefined;
-    let n = 0;
-    for (const item of items) {
-        if (!item || typeof item !== "object")
-            continue;
-        const it = item;
-        const whereOk = Object.entries(spec.where ?? {}).every(([k, allowed]) => hasOwn(it, k) && Array.isArray(allowed) && allowed.some((a) => a === it[k]));
-        const nonEmptyOk = (spec.non_empty ?? []).every((k) => hasOwn(it, k) && typeof it[k] === "string" && it[k].trim() !== "");
-        if (whereOk && nonEmptyOk)
-            n++;
-    }
-    return n;
-}
-/**
- * Check emitted data against the declared output contract (#357): every
- * `required` field present; every present top-level property of its declared
- * `type` and inside its `enum`; and every `x-sweny-count-of` integer equal to
- * the count it declares over its array. Not full JSON Schema: formats,
- * nested shapes and additionalProperties stay the author's concern.
- */
-export function outputContractProblems(data, output) {
-    if (!output || typeof output !== "object")
-        return [];
-    const obj = (data && typeof data === "object" ? data : {});
-    const problems = [];
-    for (const k of getDeclaredRequiredFields(output)) {
-        if (!hasOwn(obj, k))
-            problems.push({ field: k, kind: "missing", problem: "required but missing" });
-    }
-    const props = output.properties;
-    if (!props || typeof props !== "object")
-        return problems;
-    for (const [k, raw] of Object.entries(props)) {
-        if (!hasOwn(obj, k) || !raw || typeof raw !== "object")
-            continue;
-        const p = raw;
-        const v = obj[k];
-        const types = Array.isArray(p.type) ? p.type : p.type === undefined ? [] : [p.type];
-        if (types.length > 0 && !types.some((t) => typeMatches(t, v))) {
-            problems.push({ field: k, kind: "invalid", problem: `expected ${types.join(" or ")}, got ${JSON.stringify(v)}` });
-            continue;
-        }
-        if (Array.isArray(p.enum) && !p.enum.some((e) => e === v)) {
-            problems.push({
-                field: k,
-                kind: "invalid",
-                problem: `expected one of ${JSON.stringify(p.enum)}, got ${JSON.stringify(v)}`,
-            });
-            continue;
-        }
-        const spec = p[COUNT_OF_KEYWORD];
-        if (spec && typeof spec === "object" && typeof spec.array === "string") {
-            const want = countOf(spec, obj);
-            if (want === undefined) {
-                problems.push({
-                    field: k,
-                    kind: "invalid",
-                    problem: `cannot be checked: '${spec.array}' is not a list`,
-                });
-            }
-            else if (v !== want) {
-                problems.push({
-                    field: k,
-                    kind: "invalid",
-                    problem: `is ${JSON.stringify(v)} but '${spec.array}' has ${want} matching item(s)`,
-                });
-            }
-        }
-    }
-    return problems;
+function invalidOutputFields(result, node) {
+    const checked = checkOutputContract(result.data, node?.output);
+    if ("error" in checked)
+        return getDeclaredOutputProperties(node?.output) ?? new Set();
+    return new Set(checked.problems.filter((p) => p.kind === "invalid").map((p) => p.field));
 }
 /**
  * Required tools the agent never called, when that is the only reason a node
@@ -2300,9 +2207,8 @@ function resolveByExpressions(workflow, current, results, conditionalEdges, defa
         if (r.status !== "success")
             continue;
         const node = hasOwn(workflow.nodes, id) ? workflow.nodes[id] : undefined;
-        for (const p of outputContractProblems(r.data, node?.output))
-            if (p.kind === "invalid")
-                invalid.add(`${id}.${p.field}`);
+        for (const f of invalidOutputFields(r, node))
+            invalid.add(`${id}.${f}`);
         scope[id] = buildPriorNodeContext(r);
     }
     const problems = [];
@@ -2368,7 +2274,7 @@ function resolveByExpressions(workflow, current, results, conditionalEdges, defa
 /**
  * Validate a workflow definition before execution.
  */
-function validate(workflow, skills) {
+function validate(workflow, skills, logger) {
     for (const [id, def] of Object.entries(workflow.skills ?? {})) {
         if (!def.instruction?.trim()) {
             throw new Error(`Inline skill "${id}" must provide a non-empty instruction`);
@@ -2392,10 +2298,14 @@ function validate(workflow, skills) {
     // reach execute() without the loader, so without this they got none of it
     // (#326). Runs once per execute() call, before any node runs. Skill
     // availability stays a warning below, so no knownSkills here.
-    const structural = validateWorkflow(workflow);
+    const loadWarnings = [];
+    const structural = validateWorkflow(workflow, undefined, { warnings: loadWarnings });
     if (structural.length > 0) {
         throw new Error(`Invalid workflow "${workflow.id}":\n${structural.map((e) => `  ${e.code}: ${e.message}`).join("\n")}`);
     }
+    // Deprecated but still loading (#573): said once per run, never silently.
+    for (const w of loadWarnings)
+        logger.warn(`  ${w.code}: ${w.message}`, { node: w.nodeId });
     // Check that each node has at least one available skill (if it lists any)
     for (const [nodeId, node] of Object.entries(workflow.nodes)) {
         if (node.skills.length === 0)

package/dist/harness/acp.js

@@ -53,7 +53,8 @@ import { policyGate, resolveHarnessPolicy, TOOL_CLASSES } from "./policy.js";
 import { gitCredentialPolicy } from "../git-credentials.js";
 import { buildNodePrompt, reportCompletionUsage } from "./prompts.js";
 import { makeAbort } from "./abort.js";
-import { parseToolResultContent, schemaMismatches, summarizeToolError, tryParseJSON } from "./parse.js";
+import { parseToolResultContent, summarizeToolError, tryParseJSON } from "./parse.js";
+import { checkOutputContract, listContractProblems } from "../output-contract.js";
 import { startToolBridge } from "./tool-bridge/server.js";
 import { defaultSandboxWrapper, prepareAgentSpawn, wrappersFrom, } from "./sandbox-wrapper.js";
 import { TOKEN_ENV } from "./tool-bridge/protocol.js";
@@ -775,18 +776,25 @@ export class AcpHarness {
             const basePrompt = buildNodePrompt(req.instruction, req.context, req.outputSchema);
             const schema = req.outputSchema;
             const retry = { asked: false };
-            // One correction turn when the answer does not match the declared output.
+            // The same check, at every depth, that sweny's executor applies to every
+            // harness's output (output-contract.ts). A check that cannot run asks nothing.
+            const mismatches = (text) => {
+                const checked = checkOutputContract(tryParseJSON(text, schema, { warn() { } }), schema);
+                return "problems" in checked ? listContractProblems(checked.problems) : [];
+            };
+            // One correction turn when the answer does not match the declared output,
+            // unless the caller (sweny's executor) runs the one repair itself: one repair loop on every harness.
             const followUp = (turn) => {
-                if (!schema || retry.asked)
+                if (!schema || retry.asked || req.callerRepairsOutput)
                     return undefined;
-                const parsed = tryParseJSON(turn.text, schema, { warn() { } });
-                const problems = schemaMismatches(parsed, schema);
+                const problems = mismatches(turn.text);
                 if (problems.length === 0)
                     return undefined;
                 retry.asked = true;
                 this.logger.info(`  acp: the answer does not match the output shape (${problems.join("; ")}); asking once more`);
                 return [
-                    `Your last reply did not match the required output: ${problems.join("; ")}.`,
+                    "Your last reply did not match the required output:",
+                    ...problems.map((line) => `- ${line}`),
                     "Reply again, ending with ONLY a JSON object that matches this schema:",
                     "```json",
                     JSON.stringify(schema, null, 2),
@@ -838,8 +846,7 @@ export class AcpHarness {
             const result = this.toResult(conv, schema, req.timeoutMs);
             if (result.status === "success" && schema && retry.asked) {
                 const last = conv.turns.at(-1)?.text ?? "";
-                const left = schemaMismatches(tryParseJSON(last, schema, { warn() { } }), schema);
-                if (left.length > 0) {
+                if (mismatches(last).length > 0) {
                     extraDegraded.push(`structured_output: the answer still did not match the declared output after one retry`);
                 }
             }

package/dist/loader.js

@@ -13,7 +13,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { parse as parseYaml } from "yaml";
 import { ZodError } from "zod";
-import { workflowZ, validateWorkflow, preflightLegacyVerify } from "./schema.js";
+import { workflowZ, validateWorkflow, preflightLegacyVerify, } from "./schema.js";
 import { approveDirectiveWarnings } from "./node-policy.js";
 import { DEFAULT_MIGRATION_CONFIG, migrateWorkflow, migrationWarning, } from "./migrations.js";
 /**
@@ -90,13 +90,15 @@ export function validateParsed(raw, options = {}) {
         const msg = err instanceof Error ? err.message : String(err);
         return { ok: false, errors: [{ message: msg, code: "SCHEMA" }] };
     }
-    const structural = validateWorkflow(parsed, options.knownSkills);
+    const schemaWarnings = [];
+    const structural = validateWorkflow(parsed, options.knownSkills, { warnings: schemaWarnings });
     if (structural.length > 0) {
         return {
             ok: false,
             errors: structural.map((e) => ({ message: e.message, code: e.code, nodeId: e.nodeId })),
         };
     }
+    warnings.push(...schemaWarnings.map((w) => `${w.code}: ${w.message}`));
     warnings.push(...approveDirectiveWarnings(parsed));
     return warnings.length > 0 ? { ok: true, workflow: parsed, warnings } : { ok: true, workflow: parsed };
 }

package/dist/output-contract-draft06.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The JSON Schema draft-06 meta-schema, as ajv ships it in
+ * `ajv/dist/refs/json-schema-draft-06.json` (ajv 8 adds it with
+ * `addMetaSchema` to support draft-06). Kept here as a module because core
+ * cannot import JSON files; a spec asserts it deep-equals ajv's copy.
+ */
+export declare const DRAFT_06_META_SCHEMA: Record<string, unknown>;

package/dist/output-contract-draft06.js

@@ -0,0 +1,210 @@
+/**
+ * The JSON Schema draft-06 meta-schema, as ajv ships it in
+ * `ajv/dist/refs/json-schema-draft-06.json` (ajv 8 adds it with
+ * `addMetaSchema` to support draft-06). Kept here as a module because core
+ * cannot import JSON files; a spec asserts it deep-equals ajv's copy.
+ */
+export const DRAFT_06_META_SCHEMA = {
+    $schema: "http://json-schema.org/draft-06/schema#",
+    $id: "http://json-schema.org/draft-06/schema#",
+    title: "Core schema meta-schema",
+    definitions: {
+        schemaArray: {
+            type: "array",
+            minItems: 1,
+            items: {
+                $ref: "#",
+            },
+        },
+        nonNegativeInteger: {
+            type: "integer",
+            minimum: 0,
+        },
+        nonNegativeIntegerDefault0: {
+            allOf: [
+                {
+                    $ref: "#/definitions/nonNegativeInteger",
+                },
+                {
+                    default: 0,
+                },
+            ],
+        },
+        simpleTypes: {
+            enum: ["array", "boolean", "integer", "null", "number", "object", "string"],
+        },
+        stringArray: {
+            type: "array",
+            items: {
+                type: "string",
+            },
+            uniqueItems: true,
+            default: [],
+        },
+    },
+    type: ["object", "boolean"],
+    properties: {
+        $id: {
+            type: "string",
+            format: "uri-reference",
+        },
+        $schema: {
+            type: "string",
+            format: "uri",
+        },
+        $ref: {
+            type: "string",
+            format: "uri-reference",
+        },
+        title: {
+            type: "string",
+        },
+        description: {
+            type: "string",
+        },
+        default: {},
+        examples: {
+            type: "array",
+            items: {},
+        },
+        multipleOf: {
+            type: "number",
+            exclusiveMinimum: 0,
+        },
+        maximum: {
+            type: "number",
+        },
+        exclusiveMaximum: {
+            type: "number",
+        },
+        minimum: {
+            type: "number",
+        },
+        exclusiveMinimum: {
+            type: "number",
+        },
+        maxLength: {
+            $ref: "#/definitions/nonNegativeInteger",
+        },
+        minLength: {
+            $ref: "#/definitions/nonNegativeIntegerDefault0",
+        },
+        pattern: {
+            type: "string",
+            format: "regex",
+        },
+        additionalItems: {
+            $ref: "#",
+        },
+        items: {
+            anyOf: [
+                {
+                    $ref: "#",
+                },
+                {
+                    $ref: "#/definitions/schemaArray",
+                },
+            ],
+            default: {},
+        },
+        maxItems: {
+            $ref: "#/definitions/nonNegativeInteger",
+        },
+        minItems: {
+            $ref: "#/definitions/nonNegativeIntegerDefault0",
+        },
+        uniqueItems: {
+            type: "boolean",
+            default: false,
+        },
+        contains: {
+            $ref: "#",
+        },
+        maxProperties: {
+            $ref: "#/definitions/nonNegativeInteger",
+        },
+        minProperties: {
+            $ref: "#/definitions/nonNegativeIntegerDefault0",
+        },
+        required: {
+            $ref: "#/definitions/stringArray",
+        },
+        additionalProperties: {
+            $ref: "#",
+        },
+        definitions: {
+            type: "object",
+            additionalProperties: {
+                $ref: "#",
+            },
+            default: {},
+        },
+        properties: {
+            type: "object",
+            additionalProperties: {
+                $ref: "#",
+            },
+            default: {},
+        },
+        patternProperties: {
+            type: "object",
+            additionalProperties: {
+                $ref: "#",
+            },
+            default: {},
+        },
+        dependencies: {
+            type: "object",
+            additionalProperties: {
+                anyOf: [
+                    {
+                        $ref: "#",
+                    },
+                    {
+                        $ref: "#/definitions/stringArray",
+                    },
+                ],
+            },
+        },
+        propertyNames: {
+            $ref: "#",
+        },
+        const: {},
+        enum: {
+            type: "array",
+            minItems: 1,
+            uniqueItems: true,
+        },
+        type: {
+            anyOf: [
+                {
+                    $ref: "#/definitions/simpleTypes",
+                },
+                {
+                    type: "array",
+                    items: {
+                        $ref: "#/definitions/simpleTypes",
+                    },
+                    minItems: 1,
+                    uniqueItems: true,
+                },
+            ],
+        },
+        format: {
+            type: "string",
+        },
+        allOf: {
+            $ref: "#/definitions/schemaArray",
+        },
+        anyOf: {
+            $ref: "#/definitions/schemaArray",
+        },
+        oneOf: {
+            $ref: "#/definitions/schemaArray",
+        },
+        not: {
+            $ref: "#",
+        },
+    },
+    default: {},
+};

package/dist/output-contract.d.ts

@@ -0,0 +1,92 @@
+/**
+ * The node output contract (#357, #573): a node's emitted data checked
+ * against its declared `output` JSON Schema, at every depth.
+ *
+ * One standard validator (ajv) does the checking, so nested objects, arrays
+ * of objects, enums, `required` at any depth, `additionalProperties`,
+ * `oneOf` and the rest mean what JSON Schema says they mean. The check runs
+ * in the executor on the data every harness returns, so a violation reads
+ * the same whichever harness ran the node. Each problem carries the exact
+ * path of the value that broke the schema (`findings[1].severity`) and the
+ * rule it broke, never the value itself: output can carry secrets.
+ *
+ * Dialect: JSON Schema 2020-12, or the draft a schema names in `$schema`
+ * (draft-04, draft-06, draft-07, 2019-09). `format` is an annotation, as
+ * 2020-12 defines it by default, and is not asserted. Keywords ajv does not
+ * know (sweny's `x-` keywords among them) are ignored by ajv;
+ * `x-sweny-count-of` is checked here after the schema itself.
+ *
+ * A schema ajv cannot compile (deprecated, see {@link outputSchemaError})
+ * keeps the check sweny ran before #573: top-level `required`, and the
+ * `type` and `enum` of each top-level property.
+ *
+ * Output nested deeper than {@link MAX_OUTPUT_DEPTH} levels, or holding more
+ * than {@link MAX_OUTPUT_VALUES} values, is not checked: it is a problem in
+ * itself.
+ *
+ * No harness or skill imports.
+ */
+import type { JSONSchema } from "./types.js";
+/** One way a node's emitted data breaks its declared output contract. */
+export interface ContractProblem {
+    /**
+     * The top-level output field the problem sits under, or {@link ROOT_PATH}
+     * for the output object itself. Routing tolerance keys on it: a route that
+     * reads this field falls through instead of failing the node.
+     */
+    field: string;
+    /** Where the broken value is, e.g. `findings[1].severity` ({@link ROOT_PATH} for the object itself). */
+    path: string;
+    /**
+     * `missing`: a top-level `required` field is absent. `invalid`: any other
+     * break, a `required` field missing at depth included.
+     */
+    kind: "missing" | "invalid";
+    /** The rule that broke and what it expects. Never the emitted value. */
+    problem: string;
+    /**
+     * Found by the pre-#573 top-level check, because the schema does not
+     * compile. As before #573, only a missing field fails the node.
+     */
+    fallback?: true;
+}
+/** The path that names the output object itself. */
+export declare const ROOT_PATH = "(output)";
+/** Keyword on an integer output property: the count sweny cross-checks against an array in the same output. */
+export declare const COUNT_OF_KEYWORD = "x-sweny-count-of";
+/** Deepest nesting checked: the output object is level 0. */
+export declare const MAX_OUTPUT_DEPTH = 64;
+/** Most values (objects, arrays and scalars together) checked in one output. */
+export declare const MAX_OUTPUT_VALUES = 100000;
+/**
+ * Why a declared output schema cannot be compiled, or undefined when it
+ * compiles (or there is none). Such a schema is deprecated: the node keeps
+ * the pre-#573 top-level check, and a future minor will refuse to load it.
+ */
+export declare function outputSchemaError(output: JSONSchema | undefined): string | undefined;
+/**
+ * Check emitted data against the declared output contract: the whole JSON
+ * Schema at every depth, then every `x-sweny-count-of` integer against the
+ * count it declares over its array. One problem per broken path, in schema
+ * order. Empty when the node declares no schema or the data conforms. A
+ * schema that does not compile gets the pre-#573 top-level check instead.
+ * Can throw (a hostile getter, an ajv fault): callers use
+ * {@link checkOutputContract}.
+ */
+export declare function outputContractProblems(data: unknown, output: JSONSchema | undefined): ContractProblem[];
+/** The contract check that never throws: its problems, or why it could not run. */
+export declare function checkOutputContract(data: unknown, output: JSONSchema | undefined): {
+    problems: ContractProblem[];
+} | {
+    error: string;
+};
+/** The problems' paths, at most {@link MAX_LISTED} of them, for log lines and events. */
+export declare function contractPaths(problems: ContractProblem[]): string[];
+/** The problems as `path: problem` lines, at most {@link MAX_LISTED} of them. */
+export declare function listContractProblems(problems: ContractProblem[]): string[];
+/**
+ * The node error for a contract still broken after the repair request.
+ * Missing top-level fields are named together, the way the required-field
+ * gate always has; every other problem follows as `path: problem`.
+ */
+export declare function contractFailureMessage(problems: ContractProblem[]): string;

package/dist/output-contract.js

@@ -0,0 +1,374 @@
+/**
+ * The node output contract (#357, #573): a node's emitted data checked
+ * against its declared `output` JSON Schema, at every depth.
+ *
+ * One standard validator (ajv) does the checking, so nested objects, arrays
+ * of objects, enums, `required` at any depth, `additionalProperties`,
+ * `oneOf` and the rest mean what JSON Schema says they mean. The check runs
+ * in the executor on the data every harness returns, so a violation reads
+ * the same whichever harness ran the node. Each problem carries the exact
+ * path of the value that broke the schema (`findings[1].severity`) and the
+ * rule it broke, never the value itself: output can carry secrets.
+ *
+ * Dialect: JSON Schema 2020-12, or the draft a schema names in `$schema`
+ * (draft-04, draft-06, draft-07, 2019-09). `format` is an annotation, as
+ * 2020-12 defines it by default, and is not asserted. Keywords ajv does not
+ * know (sweny's `x-` keywords among them) are ignored by ajv;
+ * `x-sweny-count-of` is checked here after the schema itself.
+ *
+ * A schema ajv cannot compile (deprecated, see {@link outputSchemaError})
+ * keeps the check sweny ran before #573: top-level `required`, and the
+ * `type` and `enum` of each top-level property.
+ *
+ * Output nested deeper than {@link MAX_OUTPUT_DEPTH} levels, or holding more
+ * than {@link MAX_OUTPUT_VALUES} values, is not checked: it is a problem in
+ * itself.
+ *
+ * No harness or skill imports.
+ */
+import { Ajv } from "ajv";
+import { Ajv2019 } from "ajv/dist/2019.js";
+import { Ajv2020 } from "ajv/dist/2020.js";
+import Ajv04Module from "ajv-draft-04";
+import { DRAFT_06_META_SCHEMA } from "./output-contract-draft06.js";
+/** The path that names the output object itself. */
+export const ROOT_PATH = "(output)";
+/** Keyword on an integer output property: the count sweny cross-checks against an array in the same output. */
+export const COUNT_OF_KEYWORD = "x-sweny-count-of";
+/** Deepest nesting checked: the output object is level 0. */
+export const MAX_OUTPUT_DEPTH = 64;
+/** Most values (objects, arrays and scalars together) checked in one output. */
+export const MAX_OUTPUT_VALUES = 100_000;
+/**
+ * Prose every harness puts in `data.summary` next to the parsed output. It is
+ * not the agent's structured answer, so it is checked only when the schema
+ * names it (a declared or required `summary`).
+ */
+const HARNESS_SUMMARY_KEY = "summary";
+/** Problems listed in one message, log line or event before the rest are counted. */
+const MAX_LISTED = 20;
+const hasOwn = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
+// ─── Compilation ─────────────────────────────────────────────────
+/**
+ * `strict: false`: unknown keywords (descriptions, `x-` keywords) are not
+ * errors. `validateFormats: false`: `format` is an annotation (2020-12
+ * default), so no format plugin is needed. `allErrors`: report every
+ * problem at once, so one repair request names them all.
+ */
+const AJV_OPTIONS = { allErrors: true, strict: false, validateFormats: false, logger: false };
+// ajv-draft-04 is CommonJS with only a default export; `.default` is the class under Node and bundlers alike.
+const Ajv04 = Ajv04Module.default;
+const DRAFT_04 = new Ajv04(AJV_OPTIONS);
+const DRAFT_07 = new Ajv(AJV_OPTIONS).addMetaSchema(DRAFT_06_META_SCHEMA);
+const DRAFT_2019 = new Ajv2019(AJV_OPTIONS);
+const DRAFT_2020 = new Ajv2020(AJV_OPTIONS);
+/** The validator for the dialect the schema names in `$schema`; 2020-12 when it names none. */
+function validatorFor(schema) {
+    const dialect = String(schema.$schema);
+    if (/draft-04/.test(dialect))
+        return DRAFT_04;
+    if (/draft-0[67]/.test(dialect))
+        return DRAFT_07;
+    return /2019-09/.test(dialect) ? DRAFT_2019 : DRAFT_2020;
+}
+const INVALID_SCHEMA = "schema is invalid: ";
+/** ajv repeats a meta-schema complaint once per branch it tried: say each once. */
+function oneEach(message) {
+    const head = message.startsWith(INVALID_SCHEMA) ? INVALID_SCHEMA : "";
+    return head + [...new Set(message.slice(head.length).split(", "))].join(", ");
+}
+const compiled = new WeakMap();
+/** Compile once per schema object. The schema is released from ajv afterwards, so two schemas may share an `$id`. */
+function compile(schema) {
+    const hit = compiled.get(schema);
+    if (hit)
+        return hit;
+    const v = validatorFor(schema);
+    let out;
+    try {
+        out = { validate: v.compile(schema) };
+    }
+    catch (err) {
+        out = { error: oneEach(err.message) };
+    }
+    finally {
+        v.removeSchema(schema);
+    }
+    compiled.set(schema, out);
+    return out;
+}
+/**
+ * Why a declared output schema cannot be compiled, or undefined when it
+ * compiles (or there is none). Such a schema is deprecated: the node keeps
+ * the pre-#573 top-level check, and a future minor will refuse to load it.
+ */
+export function outputSchemaError(output) {
+    if (!output || typeof output !== "object")
+        return undefined;
+    const c = compile(output);
+    return "error" in c ? c.error : undefined;
+}
+// ─── Paths and messages ──────────────────────────────────────────
+function pointerSegments(pointer) {
+    if (pointer === "")
+        return [];
+    return pointer
+        .slice(1)
+        .split("/")
+        .map((s) => s.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+/** One step down the data. Every segment but a final missing or extra key exists, since ajv found it there. */
+const step = (cur, seg) => cur[seg];
+/**
+ * `["findings", "1", "severity"]` over the data -> `findings[1].severity`.
+ * `[n]` only where the value is an array; a key that is not an identifier is
+ * quoted (`["odd key"]`, `byIndex["0"]`).
+ */
+function renderPath(segments, data) {
+    if (segments.length === 0)
+        return ROOT_PATH;
+    let out = "";
+    let cur = data;
+    for (const seg of segments) {
+        if (Array.isArray(cur))
+            out += `[${seg}]`;
+        else if (/^[A-Za-z_$][\w$-]*$/.test(seg))
+            out += out === "" ? seg : `.${seg}`;
+        else
+            out += `[${JSON.stringify(seg)}]`;
+        cur = step(cur, seg);
+    }
+    return out;
+}
+/** A schema value (an enum list, a const) as JSON, cut to 80 characters. Never used on output data. */
+function preview(v) {
+    const s = String(JSON.stringify(v));
+    return s.length > 80 ? `${s.slice(0, 77)}...` : s;
+}
+function toProblem(e, data) {
+    const segs = pointerSegments(e.instancePath);
+    const p = e.params;
+    let problem;
+    switch (e.keyword) {
+        case "required":
+            segs.push(String(p.missingProperty));
+            problem = "required but missing";
+            break;
+        case "dependentRequired":
+        case "dependencies":
+            segs.push(String(p.missingProperty));
+            problem = `required when '${String(p.property)}' is present, but missing`;
+            break;
+        case "additionalProperties":
+            segs.push(String(p.additionalProperty));
+            problem = "not allowed (additionalProperties: false)";
+            break;
+        case "unevaluatedProperties":
+            segs.push(String(p.unevaluatedProperty));
+            problem = "not allowed (unevaluatedProperties: false)";
+            break;
+        case "type":
+            problem = `expected ${[p.type].flat().join(" or ")}`;
+            break;
+        case "enum":
+            problem = `expected one of ${preview(p.allowedValues)}`;
+            break;
+        case "const":
+            problem = `expected ${preview(p.allowedValue)}`;
+            break;
+        default:
+            // ajv's wording names the rule and its limit, never the value.
+            problem = `${e.message}`;
+    }
+    const missingTopLevel = e.keyword === "required" && segs.length === 1;
+    return {
+        field: segs.length === 0 ? ROOT_PATH : segs[0],
+        path: renderPath(segs, data),
+        kind: missingTopLevel ? "missing" : "invalid",
+        problem,
+    };
+}
+// ─── The pre-#573 top-level check (schemas that do not compile) ──
+function typeMatches(t, v) {
+    switch (t) {
+        case "string":
+            return typeof v === "string";
+        case "number":
+            return Number.isFinite(v);
+        case "integer":
+            return Number.isInteger(v);
+        case "boolean":
+            return typeof v === "boolean";
+        case "array":
+            return Array.isArray(v);
+        case "object":
+            return typeof v === "object" && v !== null && !Array.isArray(v);
+        case "null":
+            return v === null;
+        default:
+            return true; // unknown or absent type: not checked, as before
+    }
+}
+/** Every `required` field present; every present top-level property of its declared `type` and in its `enum`. */
+function topLevelProblems(output, data) {
+    const problems = [];
+    const required = Array.isArray(output.required) ? output.required : [];
+    for (const k of required) {
+        if (typeof k === "string" && !hasOwn(data, k)) {
+            problems.push({ field: k, path: k, kind: "missing", problem: "required but missing", fallback: true });
+        }
+    }
+    // This schema did not compile, so any part of it may be malformed: read it defensively.
+    for (const [k, raw] of Object.entries(output.properties ?? {})) {
+        if (!hasOwn(data, k))
+            continue;
+        const p = (raw ?? {});
+        // An absent or unknown type matches anything, as before #573.
+        const types = [p.type].flat();
+        let problem;
+        if (!types.some((t) => typeMatches(t, data[k])))
+            problem = `expected ${types.join(" or ")}`;
+        else if (Array.isArray(p.enum) && !p.enum.some((e) => e === data[k]))
+            problem = `expected one of ${preview(p.enum)}`;
+        if (problem)
+            problems.push({ field: k, path: renderPath([k], data), kind: "invalid", problem, fallback: true });
+    }
+    return problems;
+}
+function countOf(spec, data) {
+    const items = data[spec.array];
+    if (!Array.isArray(items))
+        return undefined;
+    let n = 0;
+    for (const item of items) {
+        if (!item || typeof item !== "object")
+            continue;
+        const it = item;
+        const whereOk = Object.entries(spec.where ?? {}).every(([k, allowed]) => Array.isArray(allowed) && allowed.some((a) => a === it[k]));
+        const nonEmptyOk = (spec.non_empty ?? []).every((k) => typeof it[k] === "string" && it[k].trim() !== "");
+        if (whereOk && nonEmptyOk)
+            n++;
+    }
+    return n;
+}
+function countProblems(output, data, alreadyBroken, fallback) {
+    const problems = [];
+    for (const [k, raw] of Object.entries(output.properties ?? {})) {
+        if (!hasOwn(data, k) || alreadyBroken.has(k))
+            continue;
+        const spec = raw?.[COUNT_OF_KEYWORD];
+        if (typeof spec?.array !== "string")
+            continue;
+        const want = countOf(spec, data);
+        const problem = want === undefined
+            ? `cannot be checked: '${spec.array}' is not a list`
+            : data[k] !== want
+                ? `does not match the count: '${spec.array}' has ${want} matching item(s)`
+                : undefined;
+        if (problem) {
+            problems.push({
+                field: k,
+                path: renderPath([k], data),
+                kind: "invalid",
+                problem,
+                ...(fallback ? { fallback: true } : {}),
+            });
+        }
+    }
+    return problems;
+}
+// ─── The check ───────────────────────────────────────────────────
+/** The data the schema is checked against: the harness's `summary` prose left out unless the schema names it. */
+function structuredView(output, data) {
+    const declared = hasOwn(Object(output.properties), HARNESS_SUMMARY_KEY) ||
+        (Array.isArray(output.required) && output.required.includes(HARNESS_SUMMARY_KEY));
+    if (declared)
+        return data;
+    const { [HARNESS_SUMMARY_KEY]: _summary, ...rest } = data;
+    return rest;
+}
+/** Why the output is too big to check, without recursion, or undefined. */
+function tooBig(data) {
+    const stack = [[data, 0]];
+    let values = 0;
+    while (stack.length > 0) {
+        const [v, depth] = stack.pop();
+        if (depth > MAX_OUTPUT_DEPTH)
+            return `not checked: the output nests deeper than ${MAX_OUTPUT_DEPTH} levels`;
+        if (++values > MAX_OUTPUT_VALUES)
+            return `not checked: the output holds more than ${MAX_OUTPUT_VALUES} values`;
+        if (v !== null && typeof v === "object")
+            for (const c of Object.values(v))
+                stack.push([c, depth + 1]);
+    }
+    return undefined;
+}
+/**
+ * Check emitted data against the declared output contract: the whole JSON
+ * Schema at every depth, then every `x-sweny-count-of` integer against the
+ * count it declares over its array. One problem per broken path, in schema
+ * order. Empty when the node declares no schema or the data conforms. A
+ * schema that does not compile gets the pre-#573 top-level check instead.
+ * Can throw (a hostile getter, an ajv fault): callers use
+ * {@link checkOutputContract}.
+ */
+export function outputContractProblems(data, output) {
+    if (!output || typeof output !== "object")
+        return [];
+    const obj = structuredView(output, (data && typeof data === "object" ? data : {}));
+    const big = tooBig(obj);
+    if (big)
+        return [{ field: ROOT_PATH, path: ROOT_PATH, kind: "invalid", problem: big }];
+    const c = compile(output);
+    if ("error" in c) {
+        const problems = topLevelProblems(output, obj);
+        return [...problems, ...countProblems(output, obj, new Set(problems.map((p) => p.field)), true)];
+    }
+    const problems = [];
+    const seen = new Set();
+    c.validate(obj);
+    for (const e of c.validate.errors ?? []) {
+        const p = toProblem(e, obj);
+        if (seen.has(p.path))
+            continue;
+        seen.add(p.path);
+        problems.push(p);
+    }
+    return [...problems, ...countProblems(output, obj, new Set(problems.map((p) => p.field)), false)];
+}
+/** The contract check that never throws: its problems, or why it could not run. */
+export function checkOutputContract(data, output) {
+    try {
+        return { problems: outputContractProblems(data, output) };
+    }
+    catch (err) {
+        return { error: err instanceof Error ? err.message : String(err) };
+    }
+}
+function capped(lines) {
+    if (lines.length <= MAX_LISTED)
+        return lines;
+    return [...lines.slice(0, MAX_LISTED), `and ${lines.length - MAX_LISTED} more`];
+}
+/** The problems' paths, at most {@link MAX_LISTED} of them, for log lines and events. */
+export function contractPaths(problems) {
+    return capped(problems.map((p) => p.path));
+}
+/** The problems as `path: problem` lines, at most {@link MAX_LISTED} of them. */
+export function listContractProblems(problems) {
+    return capped(problems.map((p) => `${p.path}: ${p.problem}`));
+}
+/**
+ * The node error for a contract still broken after the repair request.
+ * Missing top-level fields are named together, the way the required-field
+ * gate always has; every other problem follows as `path: problem`.
+ */
+export function contractFailureMessage(problems) {
+    const missing = problems.filter((p) => p.kind === "missing").map((p) => p.path);
+    const rest = problems.filter((p) => p.kind !== "missing");
+    const parts = [
+        ...(missing.length > 0 ? [`required field(s) missing from emitted data: ${capped(missing).join(", ")}`] : []),
+        ...listContractProblems(rest),
+    ];
+    return `output schema violation: ${parts.join("; ")}`;
+}

package/dist/schema.d.ts

@@ -1047,6 +1047,21 @@ export interface WorkflowError {
     message: string;
     nodeId?: string;
 }
+/**
+ * A finding that does not stop the workflow loading (#573): something that
+ * works today and is deprecated. `OUTPUT_SCHEMA_FALLBACK`: a node's `output`
+ * schema does not compile, so its output keeps the pre-#573 top-level check;
+ * a future minor will refuse to load it.
+ */
+export interface WorkflowWarning {
+    code: "OUTPUT_SCHEMA_FALLBACK";
+    message: string;
+    nodeId: string;
+}
+export interface ValidateWorkflowOptions {
+    /** Receives warning-level findings. They never appear in the returned errors. */
+    warnings?: WorkflowWarning[];
+}
 /**
  * Validate a workflow's graph structure.
  *
@@ -1061,7 +1076,7 @@ export interface WorkflowError {
  * Note: nodes with no outgoing edges are valid terminal nodes — the executor
  * returns null when it reaches one, ending the workflow cleanly.
  */
-export declare function validateWorkflow(workflow: Workflow | z.infer<typeof workflowZ>, knownSkills?: Set<string>): WorkflowError[];
+export declare function validateWorkflow(workflow: Workflow | z.infer<typeof workflowZ>, knownSkills?: Set<string>, options?: ValidateWorkflowOptions): WorkflowError[];
 export declare const workflowJsonSchema: {
     readonly $schema: "https://json-schema.org/draft/2020-12/schema";
     readonly $id: "https://spec.sweny.ai/schemas/workflow.json";

package/dist/schema.js

@@ -12,6 +12,7 @@ import { sourceZ } from "./sources.js";
 import { resolveNodePermissions } from "./node-policy.js";
 import { workflowInputsZ, WORKFLOW_INPUT_TYPES } from "./inputs.js";
 import { checkExpression, isWhenExpression, WHEN_EXPR_MAX_LENGTH } from "./when.js";
+import { outputSchemaError } from "./output-contract.js";
 // Studio and other schema-only consumers label edges without importing the root entry.
 export { isWhenExpression, whenLabel } from "./when.js";
 export { sourceZ };
@@ -455,7 +456,7 @@ export function parseWorkflow(raw) {
  * Note: nodes with no outgoing edges are valid terminal nodes — the executor
  * returns null when it reaches one, ending the workflow cleanly.
  */
-export function validateWorkflow(workflow, knownSkills) {
+export function validateWorkflow(workflow, knownSkills, options = {}) {
     const errors = [];
     const nodeIds = new Set(Object.keys(workflow.nodes));
     const entryExists = nodeIds.has(workflow.entry);
@@ -693,6 +694,21 @@ export function validateWorkflow(workflow, knownSkills) {
             });
         }
     }
+    // Output schemas compile with the validator the executor checks outputs
+    // with (#573). One that does not compile still loads, as it did before: a
+    // warning, and the node keeps the pre-#573 top-level check. Deprecated.
+    for (const [nodeId, node] of Object.entries(workflow.nodes)) {
+        const why = outputSchemaError(node.output);
+        if (why !== undefined) {
+            options.warnings?.push({
+                code: "OUTPUT_SCHEMA_FALLBACK",
+                message: `Node "${nodeId}" declares an output schema the validator cannot compile (${why}). ` +
+                    `Its output gets only the old top-level check (required fields, top-level types and enums). ` +
+                    `Deprecated: a future minor will refuse to load this workflow; fix the schema or name its draft in $schema.`,
+                nodeId,
+            });
+        }
+    }
     // Reject eval policies that are reserved in the vocabulary but not yet
     // implemented. The Zod schema accepts the whole EVAL_POLICIES enum (the
     // published JSON schema advertises them as reserved), but only `all_pass`

package/dist/types.d.ts

@@ -1003,6 +1003,12 @@ export interface Claude {
         context: Record<string, unknown>;
         tools: Tool[];
         outputSchema?: JSONSchema;
+        /**
+         * The caller checks the output against `outputSchema` and asks for one
+         * repair itself (sweny's executor, #573), so the harness must not run a
+         * correction turn of its own: one repair loop on every harness.
+         */
+        callerRepairsOutput?: boolean;
         /** Called with status messages while Claude is working (tool name, etc.) */
         onProgress?: (message: string) => void;
         /** MCP servers declared by this node's resolved skills. Explicit client configs win. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sweny-ai/core",
-  "version": "0.1.213",
+  "version": "0.1.215",
   "type": "module",
   "bin": {
     "sweny": "./dist/cli/main.js"
@@ -66,6 +66,8 @@
     "@anthropic-ai/claude-agent-sdk": "^0.3.314",
     "@clack/prompts": "^1.8.1",
     "@modelcontextprotocol/sdk": "^1.32.2",
+    "ajv": "^8.20.0",
+    "ajv-draft-04": "^1.0.0",
     "chalk": "^5",
     "commander": "^13",
     "yaml": "^2.9.1",
@@ -75,7 +77,6 @@
     "@anthropic-ai/claude-code": "^2.1.314",
     "@stryker-mutator/core": "^10.1.1",
     "@stryker-mutator/vitest-runner": "^10.1.1",
-    "ajv": "^8.20.0",
     "esbuild": "^0.28.2",
     "fast-check": "^3.23.2",
     "prettier": "^3.9.10",