@sweny-ai/core 0.1.101 → 0.1.103

package/dist/executor.js

@@ -17,7 +17,15 @@ import { resolveSources } from "./source-resolver.js";
 import { evaluateAll, aggregateEval } from "./eval/index.js";
 import { evaluateRequires } from "./requires.js";
 import { buildRetryPreamble } from "./retry.js";
+import { resolveExecutionModel } from "./model.js";
 import { buildToolAliases } from "./skills/index.js";
+/**
+ * Default workflow-level step budget. Counts total node executions across the
+ * whole run (loop iterations included). Generous enough for legitimate deep
+ * workflows with controlled cycles, tight enough to terminate a runaway loop
+ * before it burns meaningful model spend.
+ */
+export const DEFAULT_MAX_STEPS = 200;
 /**
  * Execute a workflow from entry to completion.
  *
@@ -31,11 +39,13 @@ export async function execute(workflow, input, options) {
     // Inline skills (instruction/mcp only) become Skill objects with empty tools/config.
     // The caller's skill map takes precedence — inline skills only fill gaps.
     const skills = mergeInlineSkills(options.skills, workflow.skills);
-    const config = resolveConfig(skills, options.config);
+    const config = resolveConfig(skills, options.config, options.env ?? process.env);
     const logger = options.logger ?? consoleLogger;
     const results = new Map();
     const edgeCounts = new Map(); // "from→to" → times followed
     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)
     const trace = { steps: [], edges: [], sources: {} };
     validate(workflow, skills);
     // Build an eval-time alias table from the loaded skills. Each skill owns
@@ -86,6 +96,17 @@ export async function execute(workflow, input, options) {
         const node = workflow.nodes[currentId];
         if (!node)
             throw new Error(`Unknown node: "${currentId}"`);
+        // Workflow-level hard cap. Per-edge max_iterations bounds individual
+        // back-edges, but a self-loop (or LLM route) with no max_iterations is
+        // otherwise unbounded. This budget terminates the run loudly instead of
+        // hanging CI / the action and burning model spend.
+        stepCount++;
+        if (stepCount > maxSteps) {
+            throw new Error(`step budget exceeded: workflow '${workflow.id}' ran ${stepCount} steps (max_steps: ${maxSteps}). ` +
+                `This usually means an unbounded cycle, e.g. a back-edge with no 'max_iterations' or a route that keeps ` +
+                `looping. Add 'max_iterations' to the offending edge or raise 'max_steps' if the workflow legitimately ` +
+                `needs more steps.`);
+        }
         const iteration = (nodeRunCounts.get(currentId) ?? 0) + 1;
         nodeRunCounts.set(currentId, iteration);
         const resolvedInstruction = resolvedSources[`nodes.${currentId}.instruction`].content;
@@ -159,6 +180,9 @@ export async function execute(workflow, input, options) {
         let result;
         let currentInstruction = instruction;
         const retry = node.retry;
+        // Per-node execution model: node.model ?? workflow.model. When undefined,
+        // claude.run falls back to its own client default (then Claude Code's).
+        const nodeModel = resolveExecutionModel(node, workflow);
         while (true) {
             result = await claude.run({
                 instruction: currentInstruction,
@@ -167,6 +191,7 @@ export async function execute(workflow, input, options) {
                 outputSchema: node.output,
                 maxTurns: node.max_turns,
                 disallowedTools: node.disallowed_tools,
+                model: nodeModel,
                 onProgress: (message) => {
                     safeObserve(observer, { type: "node:progress", node: currentId, message }, logger);
                 },
@@ -174,17 +199,48 @@ export async function execute(workflow, input, options) {
             // Retry only triggers on eval failure. Bail on tool/API errors.
             if (result.status !== "success")
                 break;
-            const evalResults = await evaluateAll(node.eval, result, {
-                aliases: toolAliases,
-                claude,
-                node,
-                workflow,
-            });
-            result.evals = evalResults;
-            const outcome = aggregateEval(evalResults, node.eval_policy ?? "all_pass");
+            // 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.
+            const missingRequired = findMissingRequiredFields(result.data, node.output);
+            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] };
+                // Still record the synthesized failure as the node's eval result so
+                // observers and downstream context see the contract violation.
+                result.evals = [failure];
+            }
+            else {
+                const evalResults = await evaluateAll(node.eval, result, {
+                    aliases: toolAliases,
+                    claude,
+                    node,
+                    workflow,
+                });
+                result.evals = evalResults;
+                outcome = aggregateEval(evalResults, node.eval_policy ?? "all_pass");
+            }
             if (outcome.pass)
                 break;
-            // Apply eval failure to the result.
+            // Apply the failure to the result.
             result.status = "failed";
             result.data = { ...result.data, error: outcome.error };
             if (!retry || attempt >= retry.max) {
@@ -204,6 +260,7 @@ export async function execute(workflow, input, options) {
                 claude,
                 logger,
                 context,
+                model: nodeModel,
             });
             currentInstruction = `${preamble}\n\n---\n\n${instruction}`;
             safeObserve(observer, { type: "node:retry", node: currentId, attempt: attempt + 1, reason: outcome.error ?? "eval failed", preamble }, logger);
@@ -344,16 +401,44 @@ function buildPriorNodeContext(result) {
 function buildRouteEvalEntry(result, sourceNode) {
     const fullData = (result.data ?? {});
     const declaredProps = getDeclaredOutputProperties(sourceNode?.output);
-    const dataView = declaredProps ? pickKeys(fullData, declaredProps) : fullData;
+    // When the source node declared an `output.properties` block, the routing
+    // view is contract-shaped: every declared property is present in the
+    // view, with an explicit `null` when the agent did not emit it. The
+    // alternative (silently dropping the key) lets the LLM evaluator
+    // ghost-match conditions like "is 0", "is N", or "is undefined" against
+    // a structurally-absent field. That was the offload release-notes field
+    // bug: an optional `quality_retry_count` declared in the schema but
+    // omitted by the agent, evaluated against a condition like
+    // `quality_retry_count is 0 OR is undefined`, took the wrong branch.
+    //
+    // Returning `missing` separately lets the caller emit a loud warning so
+    // operators see the contract violation in the log stream.
+    let dataView;
+    const missing = [];
+    if (declaredProps) {
+        dataView = {};
+        for (const k of declaredProps) {
+            if (k in fullData) {
+                dataView[k] = fullData[k];
+            }
+            else {
+                dataView[k] = null;
+                missing.push(k);
+            }
+        }
+    }
+    else {
+        dataView = fullData;
+    }
     const evals = result.evals ?? [];
     if (evals.length === 0)
-        return dataView;
+        return { view: dataView, missing };
     const evalsByName = {};
     for (const e of evals) {
         evalsByName[e.name] = e;
     }
     // Spread evals first so a data-side `evals` key shadows it (back-compat).
-    return { evals: evalsByName, ...dataView };
+    return { view: { evals: evalsByName, ...dataView }, missing };
 }
 /**
  * Return the declared output property names for a node, or null when the
@@ -375,13 +460,34 @@ function getDeclaredOutputProperties(output) {
         return null;
     return new Set(keys);
 }
-function pickKeys(obj, keys) {
-    const out = {};
-    for (const k of keys) {
-        if (k in obj)
-            out[k] = obj[k];
-    }
-    return out;
+/**
+ * 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).
+ */
+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");
+}
+/**
+ * Validate a node's emitted data against the declared output schema's
+ * required fields. Returns the list of required-but-missing field names.
+ *
+ * This is intentionally narrow: we do NOT do full JSON Schema validation.
+ * The routing impact comes from required fields being absent, so that's
+ * what we check. Type mismatches, format violations, additionalProperties
+ * etc. stay the workflow author's problem.
+ */
+function findMissingRequiredFields(data, output) {
+    const required = getDeclaredRequiredFields(output);
+    if (required.length === 0)
+        return [];
+    const obj = (data ?? {});
+    return required.filter((k) => !(k in obj));
 }
 function nodeSourcesToArray(ns) {
     if (!ns)
@@ -492,13 +598,18 @@ function resolveSkillInstructions(skillIds, skills) {
 /**
  * Resolve config values: check explicit overrides first, then env vars.
  * Throws if a required field is missing.
+ *
+ * `env` is the environment map to read `field.env` from. Callers thread
+ * `options.env ?? process.env` so an explicit env map is honored consistently
+ * with Source resolution (which reads the same map). Defaults to
+ * `process.env` when omitted.
  */
-function resolveConfig(skills, overrides) {
+function resolveConfig(skills, overrides, env = process.env) {
     const config = {};
     const missing = [];
     for (const skill of skills.values()) {
         for (const [key, field] of Object.entries(skill.config)) {
-            const value = overrides?.[key] ?? (field.env ? process.env[field.env] : undefined);
+            const value = overrides?.[key] ?? (field.env ? env[field.env] : undefined);
             if (value) {
                 config[key] = value;
             }
@@ -587,10 +698,28 @@ async function resolveNext(workflow, current, results, input, claude, observer,
     // always-injected `summary` prose from the reference Claude client) can
     // sway the natural-language route evaluator and override the actual
     // structured result. See `buildRouteEvalEntry` for the full rationale.
-    const context = {
-        input,
-        ...Object.fromEntries([...results.entries()].map(([k, v]) => [k, buildRouteEvalEntry(v, workflow.nodes[k])])),
-    };
+    const context = { input };
+    for (const [k, v] of results.entries()) {
+        const { view, missing } = buildRouteEvalEntry(v, workflow.nodes[k]);
+        context[k] = view;
+        if (missing.length > 0) {
+            // Loud signal for the operator. The view itself already replaces the
+            // missing keys with explicit `null`, so the LLM evaluator cannot
+            // ghost-match "is N" or "is undefined" against a structurally-absent
+            // field. The warning surfaces the contract violation in the log
+            // stream and to observer-based telemetry.
+            logger?.warn(`  route eval: source node '${k}' declared properties not in emitted data: ${missing.join(", ")}`, {
+                node: k,
+                fields: missing,
+            });
+            safeObserve(observer, {
+                type: "node:warning",
+                node: k,
+                reason: `declared output properties missing from emitted data; routing view filled them with null`,
+                fields: missing,
+            }, logger);
+        }
+    }
     const choices = conditionalEdges.map((e) => ({
         id: e.to,
         description: e.when,
@@ -603,14 +732,36 @@ async function resolveNext(workflow, current, results, input, claude, observer,
         context,
         choices,
     });
-    // Validate that Claude returned a valid target
+    // Validate that Claude returned a valid target.
     const validTargets = new Set(outEdges.map((e) => e.to));
-    const resolved = validTargets.has(chosen) ? chosen : (defaultEdge?.to ?? outEdges[0].to); // fall back to default or first edge
+    if (!validTargets.has(chosen)) {
+        // The evaluator returned a target that is not a live out-edge. If there's
+        // an explicit default (unconditional) edge, take it as the documented
+        // fallback. Otherwise this is a hard error: silently jumping to
+        // `outEdges[0]` (often the loop-back edge) launders garbage model output
+        // into a plausible-looking route and, combined with an unbounded cycle,
+        // produces an infinite loop. Stop loudly instead.
+        if (!defaultEdge) {
+            logger?.warn(`  route eval: evaluator returned invalid target '${chosen}' for node '${current}' and there is no ` +
+                `default (unconditional) edge; terminating this branch. Valid targets: ${[...validTargets].join(", ")}`, { node: current, chosen, validTargets: [...validTargets] });
+            safeObserve(observer, {
+                type: "route",
+                from: current,
+                to: "(end)",
+                reason: `invalid route target '${chosen}' with no default edge`,
+            }, logger);
+            return null;
+        }
+    }
+    const resolved = validTargets.has(chosen) ? chosen : defaultEdge.to;
     // Track edge usage for max_iterations
     if (edgeCounts) {
         const key = `${current}→${resolved}`;
         edgeCounts.set(key, (edgeCounts.get(key) ?? 0) + 1);
     }
+    // Report the matched choice's description. The `?? "default"` fallback now
+    // only fires when a default edge genuinely exists (the no-default invalid
+    // case returned null above), so it can no longer mislabel a garbage route.
     safeObserve(observer, {
         type: "route",
         from: current,

package/dist/index.d.ts

@@ -21,18 +21,22 @@
  * })
  * ```
  */
-export type { Skill, SkillCategory, SkillDefinition, Tool, ToolContext, ConfigField, JSONSchema, Workflow, Node, Edge, NodeResult, ToolCall, ExecutionEvent, Observer, Claude, Logger, TraceStep, TraceEdge, ExecutionTrace, ExecutionResult, Source, ResolvedSource, SourceKind, SourceResolutionMap, WorkflowInputs, WorkflowInputField, WorkflowInputType, InputValidationError, InputValidationResult, } from "./types.js";
+export type { Skill, SkillCategory, SkillDefinition, Tool, ToolContext, ConfigField, JSONSchema, Workflow, Node, Edge, NodeResult, ToolCall, ExecutionEvent, Observer, Claude, Logger, TraceStep, TraceEdge, ExecutionTrace, ExecutionResult, Source, ResolvedSource, SourceKind, SourceResolutionMap, WorkflowInputs, WorkflowInputField, WorkflowInputType, InputValidationError, InputValidationResult, Evaluator, EvaluatorRule, EvalResult, EvaluatorKind, NodeRequires, NodeRetry, OutputMatch, NodeSources, EvalPolicy, RequiresOnFail, McpTransport, WorkflowType, SkillHarnessKey, } from "./types.js";
 export { WORKFLOW_INPUT_TYPES } from "./types.js";
+export { EVALUATOR_KINDS, EVAL_POLICIES, REQUIRES_ON_FAIL, MCP_TRANSPORTS, SKILL_CATEGORIES, SKILL_HARNESSES, SKILL_ID_PATTERN, SKILL_ID_MAX_LENGTH, isValidSkillId, } from "./types.js";
 export { consoleLogger } from "./types.js";
 export { execute } from "./executor.js";
 export type { ExecuteOptions } from "./executor.js";
-export { ClaudeClient } from "./claude.js";
-export type { ClaudeClientOptions } from "./claude.js";
+export { ClaudeClient, resolveAuthEnv } from "./claude.js";
+export type { ClaudeClientOptions, SwenyAuthMode, ResolveAuthEnvOpts } from "./claude.js";
+export { resolveExecutionModel } from "./model.js";
 export { github, linear, slack, sentry, datadog, notification, supabase, builtinSkills, createSkillMap, allSkills, isSkillConfigured, configuredBuiltinSkills, validateWorkflowSkills, } from "./skills/index.js";
 export type { SkillValidationResult } from "./skills/index.js";
 export { loadCustomSkills, discoverSkills, configuredSkills } from "./skills/custom-loader.js";
-export { workflowZ, nodeZ, edgeZ, skillZ, mcpServerConfigZ, skillDefinitionZ, sourceZ, workflowInputsZ, parseWorkflow, validateWorkflow, workflowJsonSchema, } from "./schema.js";
+export { workflowZ, nodeZ, edgeZ, skillZ, mcpServerConfigZ, skillDefinitionZ, sourceZ, workflowInputsZ, parseWorkflow, validateWorkflow, workflowJsonSchema, skillJsonSchema, } from "./schema.js";
 export type { WorkflowError } from "./schema.js";
+export { loadAndValidateWorkflow, validateParsed } from "./loader.js";
+export type { LoaderResult, LoaderError, LoaderOptions } from "./loader.js";
 export { validateRuntimeInput, summarizeInputShape } from "./inputs.js";
 export { buildAutoMcpServers, buildSkillMcpServers, buildProviderContext } from "./mcp.js";
 export type { ProviderContextOptions, SkillMcpOptions } from "./mcp.js";

package/dist/index.js

@@ -22,17 +22,25 @@
  * ```
  */
 export { WORKFLOW_INPUT_TYPES } from "./types.js";
+// Runtime enum constants + skill-id helpers
+export { EVALUATOR_KINDS, EVAL_POLICIES, REQUIRES_ON_FAIL, MCP_TRANSPORTS, SKILL_CATEGORIES, SKILL_HARNESSES, SKILL_ID_PATTERN, SKILL_ID_MAX_LENGTH, isValidSkillId, } from "./types.js";
 export { consoleLogger } from "./types.js";
 // Executor
 export { execute } from "./executor.js";
 // Claude client
-export { ClaudeClient } from "./claude.js";
+export { ClaudeClient, resolveAuthEnv } from "./claude.js";
+// Execution model resolution
+export { resolveExecutionModel } from "./model.js";
 // Skills
 export { github, linear, slack, sentry, datadog, notification, supabase, builtinSkills, createSkillMap, allSkills, isSkillConfigured, configuredBuiltinSkills, validateWorkflowSkills, } from "./skills/index.js";
 // Node-only skill discovery (filesystem-based)
 export { loadCustomSkills, discoverSkills, configuredSkills } from "./skills/custom-loader.js";
 // Schema & validation
-export { workflowZ, nodeZ, edgeZ, skillZ, mcpServerConfigZ, skillDefinitionZ, sourceZ, workflowInputsZ, parseWorkflow, validateWorkflow, workflowJsonSchema, } from "./schema.js";
+export { workflowZ, nodeZ, edgeZ, skillZ, mcpServerConfigZ, skillDefinitionZ, sourceZ, workflowInputsZ, parseWorkflow, validateWorkflow, workflowJsonSchema, skillJsonSchema, } from "./schema.js";
+// Loader — canonical read → parse → structural-validate pipeline (the path
+// the CLI uses for `workflow run`, `workflow validate`, and `publish`).
+// Node-only: loader.ts imports `node:fs`, so this is NOT mirrored in browser.ts.
+export { loadAndValidateWorkflow, validateParsed } from "./loader.js";
 // Workflow input validation
 export { validateRuntimeInput, summarizeInputShape } from "./inputs.js";
 // MCP auto-injection

package/dist/inputs.js

@@ -161,7 +161,16 @@ export function validateRuntimeInput(declared, raw) {
     // and the cascade `rules`/`context` mechanism inject extra keys into
     // the input bag. The declaration narrows the contract for documented
     // fields without locking down the whole object.
+    //
+    // Prototype-pollution guard: `raw` is `unknown` and callers (Studio,
+    // programmatic scripts) may hand us hand-built objects, or `JSON.parse`
+    // output containing an enumerable own `__proto__` key. Writing such a
+    // key with `out[k] = v` would reassign the result's prototype. Skip the
+    // three dangerous keys so untrusted input can never touch the prototype
+    // chain. `out` stays a normal object literal for downstream consumers.
     for (const [k, v] of Object.entries(provided)) {
+        if (isUnsafeKey(k))
+            continue;
         if (!Object.prototype.hasOwnProperty.call(declared, k)) {
             out[k] = v;
         }
@@ -195,6 +204,15 @@ export function summarizeInputShape(declared, resolved) {
     return shape;
 }
 // ─── Internals ──────────────────────────────────────────────────
+/**
+ * Keys that must never be copied from untrusted input onto a plain object,
+ * because assigning them mutates the prototype chain rather than adding an
+ * own property. `JSON.parse('{"__proto__":{...}}')` produces an enumerable
+ * own `__proto__` key that `Object.entries` surfaces.
+ */
+function isUnsafeKey(key) {
+    return key === "__proto__" || key === "constructor" || key === "prototype";
+}
 function checkValueType(value, type) {
     switch (type) {
         case "string":

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 } from "./schema.js";
+import { workflowZ, validateWorkflow, preflightLegacyVerify } from "./schema.js";
 /**
  * Load a workflow YAML or JSON file, parse with the canonical Zod schema,
  * and run structural validation. All three phases contribute to `errors`.
@@ -47,6 +47,20 @@ export function validateParsed(raw, options = {}) {
         const kind = raw === null ? "null" : Array.isArray(raw) ? "array" : typeof raw;
         return { ok: false, errors: [{ message: `Expected a workflow object, got ${kind}`, code: "SCHEMA" }] };
     }
+    // Detect legacy `verify:` blocks (renamed to `eval:` in v0.2.0) before the
+    // Zod parse. workflowZ is intentionally non-strict at the top level, so a
+    // top-level `verify:` would be silently STRIPPED instead of surfacing the
+    // migration message. parseWorkflow runs this preflight already; validateParsed
+    // (the entrypoint for loadAndValidateWorkflow / Studio import) must too. The
+    // loader contract is "return errors, do not throw", so map the throw to a
+    // SCHEMA LoaderError rather than letting it propagate.
+    try {
+        preflightLegacyVerify(raw);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { ok: false, errors: [{ message: msg, code: "SCHEMA" }] };
+    }
     let parsed;
     try {
         parsed = workflowZ.parse(raw);

package/dist/model.d.ts

@@ -0,0 +1,11 @@
+import type { Node, Workflow } from "./types.js";
+/**
+ * Resolve the execution model for a node: `node.model ?? workflow.model`.
+ *
+ * Returns `undefined` when neither is set. The client default (if any) is
+ * applied one layer down, inside `ClaudeClient.run` (`model ?? this.model`),
+ * so the full three-layer cascade is node → workflow → client default →
+ * Claude Code default. Callers SHOULD pass `undefined` through to `run`
+ * rather than substituting a hardcoded model.
+ */
+export declare function resolveExecutionModel(node: Node | undefined, workflow: Workflow | undefined): string | undefined;

package/dist/model.js

@@ -0,0 +1,19 @@
+// ─── Execution model resolution ─────────────────────────────────────
+//
+// Mirrors the judge-model cascade in eval/index.ts, but for the model that
+// executes a node (not the model that evaluates it). Unlike the judge
+// resolver, there is NO package-level default: when no layer specifies a
+// model, this returns undefined so the executor emits no SDK `model` option
+// and Claude Code's own default applies.
+/**
+ * Resolve the execution model for a node: `node.model ?? workflow.model`.
+ *
+ * Returns `undefined` when neither is set. The client default (if any) is
+ * applied one layer down, inside `ClaudeClient.run` (`model ?? this.model`),
+ * so the full three-layer cascade is node → workflow → client default →
+ * Claude Code default. Callers SHOULD pass `undefined` through to `run`
+ * rather than substituting a hardcoded model.
+ */
+export function resolveExecutionModel(node, workflow) {
+    return node?.model ?? workflow?.model;
+}

package/dist/retry.d.ts

@@ -12,6 +12,11 @@ export interface BuildRetryPreambleOptions {
     claude: Claude;
     logger: Logger;
     context: Record<string, unknown>;
+    /**
+     * Per-node execution model. The reflection reasons about this node, so it
+     * runs on the node's model. When undefined, the client default applies.
+     */
+    model?: string;
 }
 /**
  * Build the retry preamble for a single retry attempt.

package/dist/retry.js

@@ -21,7 +21,7 @@ const DEFAULT_PREAMBLE_HEADER = "## Previous attempt failed evaluation";
  * default static preamble and logs a warning.
  */
 export async function buildRetryPreamble(opts) {
-    const { retry, evalFailures, toolCalls, nodeInstruction, claude, logger, context } = opts;
+    const { retry, evalFailures, toolCalls, nodeInstruction, claude, logger, context, model } = opts;
     const failureList = formatEvalFailures(evalFailures);
     const inst = retry.instruction;
     if (typeof inst === "string") {
@@ -31,7 +31,7 @@ export async function buildRetryPreamble(opts) {
         const reflectPrompt = "reflect" in inst && typeof inst.reflect === "string" ? inst.reflect : DEFAULT_REFLECTION_PROMPT;
         const askInstruction = buildReflectionPrompt(reflectPrompt, nodeInstruction, failureList, toolCalls);
         try {
-            const diagnosis = await claude.ask({ instruction: askInstruction, context });
+            const diagnosis = await claude.ask({ instruction: askInstruction, context, model });
             const trimmed = diagnosis.trim();
             if (trimmed.length > 0) {
                 return `## Reflection on previous attempt\n\n${trimmed}\n\n${DEFAULT_PREAMBLE_HEADER}\n\n${failureList}`;