@sweny-ai/core 0.1.102 → 0.1.103

package/dist/schema.d.ts

@@ -7,7 +7,7 @@
  * parsing untrusted input (JSON/YAML import, Studio editor).
  */
 import { z } from "zod";
-import type { Workflow } from "./types.js";
+import type { Workflow, WorkflowType } from "./types.js";
 import { sourceZ } from "./sources.js";
 import { workflowInputsZ } from "./inputs.js";
 export { sourceZ };
@@ -239,7 +239,7 @@ export declare const skillZ: z.ZodEffects<z.ZodObject<{
         args?: string[] | undefined;
     }>>;
     mcpAliases: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
-}, "strip", z.ZodTypeAny, {
+}, "strict", z.ZodTypeAny, {
     description: string;
     name: string;
     id: string;
@@ -1089,6 +1089,7 @@ export declare const nodeZ: z.ZodObject<{
     }>, "many">>;
     eval_policy: z.ZodOptional<z.ZodEnum<["all_pass", "any_pass", "weighted"]>>;
     judge_model: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
     requires: z.ZodOptional<z.ZodEffects<z.ZodObject<{
         output_required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         output_matches: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
@@ -1196,6 +1197,7 @@ export declare const nodeZ: z.ZodObject<{
         type?: string | undefined;
     };
     skills: string[];
+    model?: string | undefined;
     output?: Record<string, unknown> | undefined;
     max_turns?: number | undefined;
     disallowed_tools?: string[] | undefined;
@@ -1284,6 +1286,7 @@ export declare const nodeZ: z.ZodObject<{
         url: string;
         type?: string | undefined;
     };
+    model?: string | undefined;
     skills?: string[] | undefined;
     output?: Record<string, unknown> | undefined;
     max_turns?: number | undefined;
@@ -1393,7 +1396,7 @@ export declare const edgeZ: z.ZodObject<{
  * cloud renderer + metric schema. Don't extend casually.
  */
 export declare const workflowTypeZ: z.ZodEnum<["pr_review", "e2e_test", "content_generation", "monitor", "data_sync", "generic"]>;
-export type WorkflowType = z.infer<typeof workflowTypeZ>;
+export type { WorkflowType };
 export declare const workflowZ: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;
@@ -1716,6 +1719,7 @@ export declare const workflowZ: z.ZodObject<{
         }>, "many">>;
         eval_policy: z.ZodOptional<z.ZodEnum<["all_pass", "any_pass", "weighted"]>>;
         judge_model: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
         requires: z.ZodOptional<z.ZodEffects<z.ZodObject<{
             output_required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
             output_matches: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
@@ -1823,6 +1827,7 @@ export declare const workflowZ: z.ZodObject<{
             type?: string | undefined;
         };
         skills: string[];
+        model?: string | undefined;
         output?: Record<string, unknown> | undefined;
         max_turns?: number | undefined;
         disallowed_tools?: string[] | undefined;
@@ -1911,6 +1916,7 @@ export declare const workflowZ: z.ZodObject<{
             url: string;
             type?: string | undefined;
         };
+        model?: string | undefined;
         skills?: string[] | undefined;
         output?: Record<string, unknown> | undefined;
         max_turns?: number | undefined;
@@ -2142,6 +2148,7 @@ export declare const workflowZ: z.ZodObject<{
         type?: string | undefined;
     }>]>, "many">>;
     judge_model: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
     judge_budget: z.ZodOptional<z.ZodNumber>;
     inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodObject<{
         type: z.ZodEnum<["string", "number", "boolean", "string[]"]>;
@@ -2202,6 +2209,7 @@ export declare const workflowZ: z.ZodObject<{
             type?: string | undefined;
         };
         skills: string[];
+        model?: string | undefined;
         output?: Record<string, unknown> | undefined;
         max_turns?: number | undefined;
         disallowed_tools?: string[] | undefined;
@@ -2288,6 +2296,7 @@ export declare const workflowZ: z.ZodObject<{
         max_iterations?: number | undefined;
     }[];
     entry: string;
+    model?: string | undefined;
     rules?: (string | {
         inline: string;
     } | {
@@ -2327,6 +2336,7 @@ export declare const workflowZ: z.ZodObject<{
             url: string;
             type?: string | undefined;
         };
+        model?: string | undefined;
         skills?: string[] | undefined;
         output?: Record<string, unknown> | undefined;
         max_turns?: number | undefined;
@@ -2415,6 +2425,7 @@ export declare const workflowZ: z.ZodObject<{
     }[];
     entry: string;
     description?: string | undefined;
+    model?: string | undefined;
     skills?: Record<string, {
         description?: string | undefined;
         name?: string | undefined;
@@ -2455,6 +2466,18 @@ export declare const workflowZ: z.ZodObject<{
         enum?: unknown[] | undefined;
     }> | undefined;
 }>;
+/**
+ * Detect legacy `verify:` blocks before parse and throw a clear migration
+ * error. Without this preflight, the user gets Zod's generic "Unrecognized
+ * key(s)" message at the node level (and silent passthrough at the
+ * workflow level, since workflowZ allows extra top-level fields for
+ * marketplace metadata).
+ *
+ * Catches:
+ *   - Top-level `workflow.verify` (typo / wrong scope).
+ *   - Per-node `nodes[*].verify` (the most common shape pre-rename).
+ */
+export declare function preflightLegacyVerify(raw: unknown): void;
 /** Parse + validate a raw object as a Workflow. Throws on invalid input. */
 export declare function parseWorkflow(raw: unknown): {
     description: string;
@@ -2484,6 +2507,7 @@ export declare function parseWorkflow(raw: unknown): {
             type?: string | undefined;
         };
         skills: string[];
+        model?: string | undefined;
         output?: Record<string, unknown> | undefined;
         max_turns?: number | undefined;
         disallowed_tools?: string[] | undefined;
@@ -2570,6 +2594,7 @@ export declare function parseWorkflow(raw: unknown): {
         max_iterations?: number | undefined;
     }[];
     entry: string;
+    model?: string | undefined;
     rules?: (string | {
         inline: string;
     } | {
@@ -2802,6 +2827,15 @@ export declare const workflowJsonSchema: {
                 };
                 readonly then: {
                     readonly required: readonly ["rule"];
+                    readonly not: {
+                        readonly anyOf: readonly [{
+                            readonly required: readonly ["rubric"];
+                        }, {
+                            readonly required: readonly ["pass_when"];
+                        }, {
+                            readonly required: readonly ["model"];
+                        }];
+                    };
                 };
             }, {
                 readonly if: {
@@ -2813,6 +2847,9 @@ export declare const workflowJsonSchema: {
                 };
                 readonly then: {
                     readonly required: readonly ["rubric"];
+                    readonly not: {
+                        readonly required: readonly ["rule"];
+                    };
                 };
             }];
         };
@@ -2856,13 +2893,16 @@ export declare const workflowJsonSchema: {
         readonly judge_model: {
             readonly type: "string";
             readonly minLength: 1;
-            readonly default: "claude-haiku-4-5";
             readonly description: "Default model for judge evaluators across the workflow. Overridable per-node and per-evaluator.";
         };
+        readonly model: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly description: "Default execution model for every node. Overridable per-node. Free-text passthrough (no registry); resolved as node.model ?? workflow.model ?? executor default.";
+        };
         readonly judge_budget: {
             readonly type: "integer";
             readonly minimum: 0;
-            readonly default: 50;
             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 inputs: {
@@ -2896,6 +2936,102 @@ export declare const workflowJsonSchema: {
                         readonly description: "Optional set of allowed values. Validated after the type check.";
                     };
                 };
+                readonly not: {
+                    readonly type: "object";
+                    readonly required: readonly ["required", "default"];
+                    readonly properties: {
+                        readonly required: {
+                            readonly const: true;
+                        };
+                    };
+                };
+                readonly allOf: readonly [{
+                    readonly if: {
+                        readonly properties: {
+                            readonly type: {
+                                readonly const: "string";
+                            };
+                        };
+                    };
+                    readonly then: {
+                        readonly properties: {
+                            readonly default: {
+                                readonly type: "string";
+                            };
+                            readonly enum: {
+                                readonly items: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    readonly if: {
+                        readonly properties: {
+                            readonly type: {
+                                readonly const: "number";
+                            };
+                        };
+                    };
+                    readonly then: {
+                        readonly properties: {
+                            readonly default: {
+                                readonly type: "number";
+                            };
+                            readonly enum: {
+                                readonly items: {
+                                    readonly type: "number";
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    readonly if: {
+                        readonly properties: {
+                            readonly type: {
+                                readonly const: "boolean";
+                            };
+                        };
+                    };
+                    readonly then: {
+                        readonly properties: {
+                            readonly default: {
+                                readonly type: "boolean";
+                            };
+                            readonly enum: {
+                                readonly items: {
+                                    readonly type: "boolean";
+                                };
+                            };
+                        };
+                    };
+                }, {
+                    readonly if: {
+                        readonly properties: {
+                            readonly type: {
+                                readonly const: "string[]";
+                            };
+                        };
+                    };
+                    readonly then: {
+                        readonly properties: {
+                            readonly default: {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "string";
+                                };
+                            };
+                            readonly enum: {
+                                readonly items: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "string";
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }];
             };
         };
         readonly nodes: {
@@ -2956,7 +3092,6 @@ export declare const workflowJsonSchema: {
                     readonly eval_policy: {
                         readonly type: "string";
                         readonly enum: readonly ["all_pass", "any_pass", "weighted"];
-                        readonly default: "all_pass";
                         readonly description: "How evaluator results aggregate. v1 implements all_pass; the others are reserved.";
                     };
                     readonly judge_model: {
@@ -2964,6 +3099,11 @@ export declare const workflowJsonSchema: {
                         readonly minLength: 1;
                         readonly description: "Default model for judge evaluators on this node. Overrides workflow-level judge_model.";
                     };
+                    readonly model: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "Execution model for this node's AI invocation. Overrides the workflow-level model. Free-text passthrough (no registry).";
+                    };
                     readonly requires: {
                         readonly type: "object";
                         readonly description: "Pre-condition checks evaluated before the LLM runs.";
@@ -3151,6 +3291,11 @@ export declare const skillJsonSchema: {
     readonly required: readonly ["id", "name", "description", "category", "config"];
     readonly anyOf: readonly [{
         readonly required: readonly ["tools"];
+        readonly properties: {
+            readonly tools: {
+                readonly minItems: 1;
+            };
+        };
     }, {
         readonly required: readonly ["instruction"];
     }, {
@@ -3201,6 +3346,18 @@ export declare const skillJsonSchema: {
             readonly $ref: "#/$defs/McpServerConfig";
             readonly description: "External MCP server definition wired for nodes referencing this skill.";
         };
+        readonly mcpAliases: {
+            readonly type: "object";
+            readonly description: "Maps a logical MCP server name to the tool-name aliases nodes use to reference it. Each entry is a non-empty list of non-empty strings.";
+            readonly additionalProperties: {
+                readonly type: "array";
+                readonly minItems: 1;
+                readonly items: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+            };
+        };
     };
     readonly $defs: {
         readonly ConfigField: {

package/dist/schema.js

@@ -7,7 +7,7 @@
  * parsing untrusted input (JSON/YAML import, Studio editor).
  */
 import { z } from "zod";
-import { EVALUATOR_KINDS, EVAL_POLICIES, MCP_TRANSPORTS, REQUIRES_ON_FAIL, SKILL_CATEGORIES, SKILL_ID_MAX_LENGTH, SKILL_ID_PATTERN, } from "./types.js";
+import { EVALUATOR_KINDS, EVAL_POLICIES, MCP_TRANSPORTS, REQUIRES_ON_FAIL, SKILL_CATEGORIES, SKILL_ID_MAX_LENGTH, SKILL_ID_PATTERN, WORKFLOW_TYPES, } from "./types.js";
 import { sourceZ } from "./sources.js";
 import { workflowInputsZ, WORKFLOW_INPUT_TYPES } from "./inputs.js";
 export { sourceZ };
@@ -66,6 +66,13 @@ export const skillZ = z
     mcp: mcpServerConfigZ.optional(),
     mcpAliases: z.record(z.array(z.string().min(1)).min(1)).optional(),
 })
+    // Strict to match the published skill JSON Schema's
+    // `additionalProperties: false`. Without this an unknown top-level key was
+    // silently STRIPPED by Zod but REJECTED by ajv (the one remaining
+    // Zod<->ajv skill divergence #214 flagged). custom-loader.ts builds Skill
+    // objects from frontmatter directly and never runs skillZ, so nothing
+    // downstream relies on extra keys passing through.
+    .strict()
     .refine((s) => s.tools.length > 0 || s.instruction || s.mcp, {
     message: "Skill must provide at least one of: tools, instruction, or mcp",
 });
@@ -200,6 +207,7 @@ export const nodeZ = z
     eval: z.array(evaluatorZ).min(1).optional(),
     eval_policy: evalPolicyZ.optional(),
     judge_model: z.string().min(1).optional(),
+    model: z.string().min(1).optional(),
     requires: nodeRequiresZ.optional(),
     retry: nodeRetryZ.optional(),
 })
@@ -224,7 +232,7 @@ export const edgeZ = z
  * Adding a new value here is a deliberate spec change: it requires a new
  * cloud renderer + metric schema. Don't extend casually.
  */
-export const workflowTypeZ = z.enum(["pr_review", "e2e_test", "content_generation", "monitor", "data_sync", "generic"]);
+export const workflowTypeZ = z.enum(WORKFLOW_TYPES);
 // Fix #4 gap — workflowZ is intentionally NOT .strict(). The published
 // JSON Schema's `additionalProperties: false` only scopes the properties
 // block, but marketplace workflows routinely carry top-level metadata
@@ -243,6 +251,7 @@ export const workflowZ = z.object({
     rules: z.array(sourceZ).optional(),
     context: z.array(sourceZ).optional(),
     judge_model: z.string().min(1).optional(),
+    model: z.string().min(1).optional(),
     judge_budget: z.number().int().min(0).optional(),
     inputs: workflowInputsZ.optional(),
 });
@@ -259,7 +268,7 @@ const LEGACY_VERIFY_MESSAGE = "uses the legacy 'verify:' field. It was renamed t
  *   - Top-level `workflow.verify` (typo / wrong scope).
  *   - Per-node `nodes[*].verify` (the most common shape pre-rename).
  */
-function preflightLegacyVerify(raw) {
+export function preflightLegacyVerify(raw) {
     if (!raw || typeof raw !== "object")
         return;
     const wf = raw;
@@ -532,14 +541,28 @@ export const workflowJsonSchema = {
                     description: "judge only. Override the judge model for this evaluator.",
                 },
             },
+            // The `then` branches mirror evaluatorZ.superRefine exactly: each kind
+            // requires its own field AND forbids the other kind's fields. Without
+            // the `not` clauses ajv only checked presence, so a `value` evaluator
+            // carrying a `rubric` passed ajv but threw under Zod (cross-kind drift).
             allOf: [
                 {
                     if: { properties: { kind: { enum: ["value", "function"] } } },
-                    then: { required: ["rule"] },
+                    then: {
+                        required: ["rule"],
+                        // judge-only fields are illegal on value / function evaluators.
+                        not: {
+                            anyOf: [{ required: ["rubric"] }, { required: ["pass_when"] }, { required: ["model"] }],
+                        },
+                    },
                 },
                 {
                     if: { properties: { kind: { const: "judge" } } },
-                    then: { required: ["rubric"] },
+                    then: {
+                        required: ["rubric"],
+                        // `rule` is value / function only.
+                        not: { required: ["rule"] },
+                    },
                 },
             ],
         },
@@ -561,19 +584,27 @@ export const workflowJsonSchema = {
         },
         workflow_type: {
             type: "string",
-            enum: ["pr_review", "e2e_test", "content_generation", "monitor", "data_sync", "generic"],
+            enum: [...WORKFLOW_TYPES],
             description: "Workflow type discriminator. Cloud uses this to route runs to a type-specific renderer. Optional; absence defaults to 'generic'.",
         },
         judge_model: {
             type: "string",
             minLength: 1,
-            default: "claude-haiku-4-5",
+            // No JSON `default` here: the Zod parser leaves this undefined and the
+            // executor applies the effective judge-model default at use-time. A
+            // documented JSON default that Zod never writes back is misleading.
             description: "Default model for judge evaluators across the workflow. Overridable per-node and per-evaluator.",
         },
+        model: {
+            type: "string",
+            minLength: 1,
+            description: "Default execution model for every node. Overridable per-node. Free-text passthrough (no registry); resolved as node.model ?? workflow.model ?? executor default.",
+        },
         judge_budget: {
             type: "integer",
             minimum: 0,
-            default: 50,
+            // No JSON `default` here: Zod leaves this undefined; the executor
+            // 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.",
         },
         inputs: {
@@ -607,6 +638,61 @@ export const workflowJsonSchema = {
                         description: "Optional set of allowed values. Validated after the type check.",
                     },
                 },
+                // The combination `required: true` together with a `default` is incoherent:
+                // a default would either silently satisfy the required check (making it
+                // vestigial) or never fire (making the default dead code). Reject the
+                // combination at JSON-Schema validation time so external validators agree
+                // with the Zod parser. See workflowInputFieldZ.superRefine in inputs.ts.
+                not: {
+                    type: "object",
+                    required: ["required", "default"],
+                    properties: {
+                        required: { const: true },
+                    },
+                },
+                // Per-type checks on `default` and each `enum` element, mirroring
+                // workflowInputFieldZ.superRefine -> checkValueType in inputs.ts.
+                // Without these, a `type: number` field with `default: "x"` passed
+                // ajv but threw under Zod (default/enum type drift). One if/then per
+                // primitive in WORKFLOW_INPUT_TYPES.
+                allOf: [
+                    {
+                        if: { properties: { type: { const: "string" } } },
+                        then: {
+                            properties: {
+                                default: { type: "string" },
+                                enum: { items: { type: "string" } },
+                            },
+                        },
+                    },
+                    {
+                        if: { properties: { type: { const: "number" } } },
+                        then: {
+                            properties: {
+                                default: { type: "number" },
+                                enum: { items: { type: "number" } },
+                            },
+                        },
+                    },
+                    {
+                        if: { properties: { type: { const: "boolean" } } },
+                        then: {
+                            properties: {
+                                default: { type: "boolean" },
+                                enum: { items: { type: "boolean" } },
+                            },
+                        },
+                    },
+                    {
+                        if: { properties: { type: { const: "string[]" } } },
+                        then: {
+                            properties: {
+                                default: { type: "array", items: { type: "string" } },
+                                enum: { items: { type: "array", items: { type: "string" } } },
+                            },
+                        },
+                    },
+                ],
             },
         },
         nodes: {
@@ -654,7 +740,10 @@ export const workflowJsonSchema = {
                     eval_policy: {
                         type: "string",
                         enum: [...EVAL_POLICIES],
-                        default: "all_pass",
+                        // No JSON `default` here: evalPolicyZ is `.optional()` with no
+                        // `.default()`, so Zod leaves this undefined and the executor
+                        // applies `?? "all_pass"` at use-time (executor.ts aggregateEval).
+                        // Matches the judge_model / judge_budget treatment (issue #214 #6).
                         description: "How evaluator results aggregate. v1 implements all_pass; the others are reserved.",
                     },
                     judge_model: {
@@ -662,6 +751,11 @@ export const workflowJsonSchema = {
                         minLength: 1,
                         description: "Default model for judge evaluators on this node. Overrides workflow-level judge_model.",
                     },
+                    model: {
+                        type: "string",
+                        minLength: 1,
+                        description: "Execution model for this node's AI invocation. Overrides the workflow-level model. Free-text passthrough (no registry).",
+                    },
                     requires: {
                         type: "object",
                         description: "Pre-condition checks evaluated before the LLM runs.",
@@ -784,7 +878,15 @@ export const skillJsonSchema = {
     description: "A composable tool bundle that provides capabilities to workflow nodes.",
     type: "object",
     required: ["id", "name", "description", "category", "config"],
-    anyOf: [{ required: ["tools"] }, { required: ["instruction"] }, { required: ["mcp"] }],
+    // Mirror skillZ.refine: a skill must provide at least one of NON-EMPTY
+    // tools, instruction, or mcp. `required: ["tools"]` alone is satisfied by
+    // `tools: []` (presence, not non-emptiness), so the tools branch pins
+    // minItems: 1 to match Zod (which checks `s.tools.length > 0`).
+    anyOf: [
+        { required: ["tools"], properties: { tools: { minItems: 1 } } },
+        { required: ["instruction"] },
+        { required: ["mcp"] },
+    ],
     additionalProperties: false,
     properties: {
         id: {
@@ -826,6 +928,19 @@ export const skillJsonSchema = {
             $ref: "#/$defs/McpServerConfig",
             description: "External MCP server definition wired for nodes referencing this skill.",
         },
+        // Mirror skillZ.mcpAliases: a record mapping a logical MCP server name
+        // to a non-empty list of non-empty tool-name aliases. Omitting this from
+        // the published schema (which is additionalProperties: false) caused ajv
+        // to REJECT valid skills that Zod accepts.
+        mcpAliases: {
+            type: "object",
+            description: "Maps a logical MCP server name to the tool-name aliases nodes use to reference it. Each entry is a non-empty list of non-empty strings.",
+            additionalProperties: {
+                type: "array",
+                minItems: 1,
+                items: { type: "string", minLength: 1 },
+            },
+        },
     },
     $defs: {
         ConfigField: {

package/dist/skills/custom-loader.d.ts

@@ -15,7 +15,7 @@ import type { Skill } from "../types.js";
  * can inspect `kind` to decide whether to surface, ignore, or fail.
  */
 export interface SkillDiagnostic {
-    kind: "invalid-frontmatter" | "missing-name" | "invalid-id" | "unreadable-file" | "duplicate-id";
+    kind: "invalid-frontmatter" | "missing-name" | "invalid-id" | "unreadable-file" | "duplicate-id" | "stdio-command-declared";
     path: string;
     message: string;
 }
@@ -30,14 +30,14 @@ export interface SkillDiscoveryResult {
  * to users. `discoverSkills` stays as a backward-compatible wrapper for
  * callers that only want the happy-path skill list.
  */
-export declare function discoverSkillsWithDiagnostics(cwd?: string): SkillDiscoveryResult;
+export declare function discoverSkillsWithDiagnostics(cwd?: string, env?: Record<string, string | undefined>): SkillDiscoveryResult;
 /**
  * Discover custom skills from all known harness directories.
  *
  * Backwards-compatible wrapper that drops diagnostics. Use
  * `discoverSkillsWithDiagnostics` when you want to surface warnings.
  */
-export declare function discoverSkills(cwd?: string): Skill[];
+export declare function discoverSkills(cwd?: string, env?: Record<string, string | undefined>): Skill[];
 /**
  * Legacy API — load custom skills from `.claude/skills/` only.
  * @deprecated Use `discoverSkills` for multi-directory support.