@exaudeus/workrail 1.1.0 → 1.3.0

package/dist/application/services/validation-engine.d.ts

@@ -1,8 +1,22 @@
 import { ConditionContext } from '../../utils/condition-evaluator';
+import { type Result } from 'neverthrow';
 import type { LoopStepDefinition } from '../../types/workflow-definition';
 import type { Workflow } from '../../types/workflow';
 import { ValidationCriteria, ValidationResult } from '../../types/validation';
 import { EnhancedLoopValidator } from './enhanced-loop-validator';
+export type ValidationEngineError = {
+    readonly kind: 'schema_compilation_failed';
+    readonly message: string;
+    readonly details?: unknown;
+} | {
+    readonly kind: 'invalid_criteria_format';
+    readonly message: string;
+    readonly details?: unknown;
+} | {
+    readonly kind: 'evaluation_threw';
+    readonly message: string;
+    readonly details?: unknown;
+};
 export declare class ValidationEngine {
     private ajv;
     private schemaCache;
@@ -18,7 +32,7 @@ export declare class ValidationEngine {
     private evaluateSingleCriteria;
     private isValidationRule;
     private isValidationComposition;
-    validate(output: string, criteria: ValidationCriteria, context?: ConditionContext): Promise<ValidationResult>;
+    validate(output: string, criteria: ValidationCriteria, context?: ConditionContext): Promise<Result<ValidationResult, ValidationEngineError>>;
     private evaluateRule;
     private looksLikeQuotedJsonSnippet;
     private maybePushJsonObjectNotStringSuggestion;

package/dist/application/services/validation-engine.js

@@ -18,9 +18,9 @@ var ValidationEngine_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValidationEngine = void 0;
 const tsyringe_1 = require("tsyringe");
-const error_handler_1 = require("../../core/error-handler");
 const condition_evaluator_1 = require("../../utils/condition-evaluator");
 const ajv_1 = __importDefault(require("ajv"));
+const neverthrow_1 = require("neverthrow");
 const workflow_definition_1 = require("../../types/workflow-definition");
 const enhanced_loop_validator_1 = require("./enhanced-loop-validator");
 const step_output_decoder_1 = require("./step-output-decoder");
@@ -33,15 +33,19 @@ let ValidationEngine = ValidationEngine_1 = class ValidationEngine {
     compileSchema(schema) {
         const schemaKey = JSON.stringify(schema);
         if (this.schemaCache.has(schemaKey)) {
-            return this.schemaCache.get(schemaKey);
+            return (0, neverthrow_1.ok)(this.schemaCache.get(schemaKey));
         }
         try {
             const compiledSchema = this.ajv.compile(schema);
             this.schemaCache.set(schemaKey, compiledSchema);
-            return compiledSchema;
+            return (0, neverthrow_1.ok)(compiledSchema);
         }
         catch (error) {
-            throw new error_handler_1.ValidationError(`Invalid JSON schema: ${error}`);
+            return (0, neverthrow_1.err)({
+                kind: 'schema_compilation_failed',
+                message: 'Invalid JSON schema',
+                details: { error: String(error) },
+            });
         }
     }
     evaluateCriteria(output, criteria, context) {
@@ -51,20 +55,17 @@ let ValidationEngine = ValidationEngine_1 = class ValidationEngine {
             }
             if (this.isValidationComposition(criteria)) {
                 const compositionResult = this.evaluateComposition(output, criteria, context);
-                return {
-                    valid: compositionResult,
-                    issues: compositionResult ? [] : ['Validation composition failed'],
-                    suggestions: compositionResult ? [] : ['Review validation criteria and adjust output accordingly.'],
+                return compositionResult.map((okRes) => ({
+                    valid: okRes,
+                    issues: okRes ? [] : ['Validation composition failed'],
+                    suggestions: okRes ? [] : ['Review validation criteria and adjust output accordingly.'],
                     warnings: undefined,
-                };
+                }));
             }
-            throw new error_handler_1.ValidationError('Invalid validation criteria format');
+            return (0, neverthrow_1.err)({ kind: 'invalid_criteria_format', message: 'Invalid validation criteria format' });
         }
         catch (error) {
-            if (error instanceof error_handler_1.ValidationError) {
-                throw error;
-            }
-            throw new error_handler_1.ValidationError(`Error evaluating validation criteria: ${error}`);
+            return (0, neverthrow_1.err)({ kind: 'evaluation_threw', message: 'Error evaluating validation criteria', details: { error: String(error) } });
         }
     }
     evaluateRuleArray(output, rules, context) {
@@ -72,53 +73,69 @@ let ValidationEngine = ValidationEngine_1 = class ValidationEngine {
         const suggestions = [];
         const warnings = [];
         for (const rule of rules) {
-            try {
+            if (typeof rule === 'object' && rule && 'condition' in rule) {
                 if (rule.condition && !(0, condition_evaluator_1.evaluateCondition)(rule.condition, context)) {
                     continue;
                 }
-                this.evaluateRule(output, rule, issues, suggestions, warnings);
-            }
-            catch (error) {
-                if (error instanceof error_handler_1.ValidationError) {
-                    throw error;
-                }
-                throw new error_handler_1.ValidationError(`Error evaluating validation rule: ${error}`);
             }
+            const ruleRes = this.evaluateRule(output, rule, issues, suggestions, warnings);
+            if (ruleRes.isErr())
+                return (0, neverthrow_1.err)(ruleRes.error);
         }
-        return {
+        return (0, neverthrow_1.ok)({
             valid: issues.length === 0,
             issues,
             suggestions: issues.length > 0 ? this.uniqueSuggestions([...suggestions, ValidationEngine_1.DEFAULT_FAILURE_SUGGESTION]) : [],
             warnings: warnings.length > 0 ? this.uniqueSuggestions(warnings) : undefined,
-        };
+        });
     }
     evaluateComposition(output, composition, context) {
         if (composition.and) {
-            return composition.and.every(criteria => this.evaluateSingleCriteria(output, criteria, context));
+            for (const criteria of composition.and) {
+                const res = this.evaluateSingleCriteria(output, criteria, context);
+                if (res.isErr())
+                    return (0, neverthrow_1.err)(res.error);
+                if (!res.value)
+                    return (0, neverthrow_1.ok)(false);
+            }
+            return (0, neverthrow_1.ok)(true);
         }
         if (composition.or) {
-            return composition.or.some(criteria => this.evaluateSingleCriteria(output, criteria, context));
+            let sawTrue = false;
+            for (const criteria of composition.or) {
+                const res = this.evaluateSingleCriteria(output, criteria, context);
+                if (res.isErr())
+                    return (0, neverthrow_1.err)(res.error);
+                if (res.value) {
+                    sawTrue = true;
+                    break;
+                }
+            }
+            return (0, neverthrow_1.ok)(sawTrue);
         }
         if (composition.not) {
-            return !this.evaluateSingleCriteria(output, composition.not, context);
+            const res = this.evaluateSingleCriteria(output, composition.not, context);
+            return res.map((v) => !v);
         }
-        return true;
+        return (0, neverthrow_1.ok)(true);
     }
     evaluateSingleCriteria(output, criteria, context) {
         if (this.isValidationRule(criteria)) {
             if (criteria.condition && !(0, condition_evaluator_1.evaluateCondition)(criteria.condition, context)) {
-                return true;
+                return (0, neverthrow_1.ok)(true);
             }
             const issues = [];
             const suggestions = [];
             const warnings = [];
-            this.evaluateRule(output, criteria, issues, suggestions, warnings);
-            return issues.length === 0;
+            const res = this.evaluateRule(output, criteria, issues, suggestions, warnings);
+            if (res.isErr())
+                return (0, neverthrow_1.err)(res.error);
+            return (0, neverthrow_1.ok)(issues.length === 0);
         }
         if (this.isValidationComposition(criteria)) {
             return this.evaluateComposition(output, criteria, context);
         }
-        throw new error_handler_1.ValidationError('Invalid validation criteria type');
+        return (0, neverthrow_1.err)({ kind: 'invalid_criteria_format', message: 'Invalid validation criteria type' });
     }
     isValidationRule(criteria) {
         return typeof criteria === 'object' && 'type' in criteria;
@@ -135,23 +152,25 @@ let ValidationEngine = ValidationEngine_1 = class ValidationEngine {
             if (typeof output !== 'string' || output.trim().length === 0) {
                 issues.push('Output is empty or invalid.');
             }
-            return {
+            return (0, neverthrow_1.ok)({
                 valid: issues.length === 0,
                 issues,
                 suggestions: issues.length > 0 ? ['Provide valid output content.'] : []
-            };
+            });
         }
         const evaluation = this.evaluateCriteria(output, criteria, context || {});
-        if (!evaluation.valid) {
-            issues.push(...evaluation.issues);
+        if (evaluation.isErr())
+            return (0, neverthrow_1.err)(evaluation.error);
+        if (!evaluation.value.valid) {
+            issues.push(...evaluation.value.issues);
         }
         const valid = issues.length === 0;
-        return {
+        return (0, neverthrow_1.ok)({
             valid,
             issues,
-            suggestions: valid ? [] : this.uniqueSuggestions([...evaluation.suggestions, ValidationEngine_1.DEFAULT_FAILURE_SUGGESTION]),
-            warnings: evaluation.warnings,
-        };
+            suggestions: valid ? [] : this.uniqueSuggestions([...evaluation.value.suggestions, ValidationEngine_1.DEFAULT_FAILURE_SUGGESTION]),
+            warnings: evaluation.value.warnings,
+        });
     }
     evaluateRule(output, rule, issues, suggestions, warnings) {
         if (typeof rule === 'string') {
@@ -159,7 +178,7 @@ let ValidationEngine = ValidationEngine_1 = class ValidationEngine {
             if (!re.test(output)) {
                 issues.push(`Output does not match pattern: ${rule}`);
             }
-            return;
+            return (0, neverthrow_1.ok)(undefined);
         }
         if (rule && typeof rule === 'object') {
             switch (rule.type) {
@@ -183,8 +202,12 @@ let ValidationEngine = ValidationEngine_1 = class ValidationEngine {
                             }
                         }
                     }
-                    catch {
-                        throw new error_handler_1.ValidationError(`Invalid regex pattern in validationCriteria: ${rule.pattern}`);
+                    catch (error) {
+                        return (0, neverthrow_1.err)({
+                            kind: 'invalid_criteria_format',
+                            message: 'Invalid regex pattern in validationCriteria',
+                            details: { pattern: rule.pattern, error: String(error) },
+                        });
                     }
                     break;
                 }
@@ -228,7 +251,10 @@ let ValidationEngine = ValidationEngine_1 = class ValidationEngine {
                                 suggestions.push(ValidationEngine_1.JSON_STRING_CONTAINS_JSON_SUGGESTION);
                             }
                         }
-                        const validate = this.compileSchema(rule.schema);
+                        const validateRes = this.compileSchema(rule.schema);
+                        if (validateRes.isErr())
+                            return (0, neverthrow_1.err)(validateRes.error);
+                        const validate = validateRes.value;
                         const isValid = validate(decoded.value);
                         if (!isValid) {
                             const errorMessages = validate.errors?.map((error) => `Validation Error at '${error.instancePath}': ${error.message}`) || ['Schema validation failed'];
@@ -239,19 +265,23 @@ let ValidationEngine = ValidationEngine_1 = class ValidationEngine {
                         }
                     }
                     catch (error) {
-                        if (error instanceof error_handler_1.ValidationError) {
-                            throw error;
-                        }
-                        throw new error_handler_1.ValidationError(`Schema validation error: ${error}`);
+                        return (0, neverthrow_1.err)({
+                            kind: 'evaluation_threw',
+                            message: 'Schema validation error',
+                            details: { error: String(error) },
+                        });
                     }
                     break;
                 }
                 default:
-                    throw new error_handler_1.ValidationError(`Unsupported validation rule type: ${rule.type}`);
+                    return (0, neverthrow_1.err)({
+                        kind: 'invalid_criteria_format',
+                        message: `Unsupported validation rule type: ${rule.type}`,
+                    });
             }
-            return;
+            return (0, neverthrow_1.ok)(undefined);
         }
-        throw new error_handler_1.ValidationError('Invalid validationCriteria format.');
+        return (0, neverthrow_1.err)({ kind: 'invalid_criteria_format', message: 'Invalid validationCriteria format.' });
     }
     looksLikeQuotedJsonSnippet(message) {
         if (typeof message !== 'string')

package/dist/application/services/workflow-compiler.d.ts

@@ -1,9 +1,11 @@
 import { Workflow, WorkflowStepDefinition, LoopStepDefinition } from '../../types/workflow';
+import type { LoopConditionSource } from '../../types/workflow-definition';
 import type { Result } from 'neverthrow';
 import { type DomainError } from '../../domain/execution/error';
 export interface CompiledLoop {
     readonly loop: LoopStepDefinition;
     readonly bodySteps: readonly WorkflowStepDefinition[];
+    readonly conditionSource?: LoopConditionSource;
 }
 export interface CompiledWorkflow {
     readonly workflow: Workflow;
@@ -14,5 +16,6 @@ export interface CompiledWorkflow {
 }
 export declare class WorkflowCompiler {
     compile(workflow: Workflow): Result<CompiledWorkflow, DomainError>;
+    private deriveConditionSource;
     private resolveLoopBody;
 }

package/dist/application/services/workflow-compiler.js

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkflowCompiler = void 0;
 const tsyringe_1 = require("tsyringe");
 const workflow_1 = require("../../types/workflow");
+const index_1 = require("../../v2/durable-core/schemas/artifacts/index");
 const neverthrow_1 = require("neverthrow");
 const error_1 = require("../../domain/execution/error");
 let WorkflowCompiler = class WorkflowCompiler {
@@ -33,9 +34,11 @@ let WorkflowCompiler = class WorkflowCompiler {
             for (const bodyStep of bodyResolved.value) {
                 loopBodyStepIds.add(bodyStep.id);
             }
+            const conditionSource = this.deriveConditionSource(loop, bodyResolved.value);
             compiledLoops.set(loop.id, {
                 loop,
                 bodySteps: bodyResolved.value,
+                conditionSource,
             });
         }
         return (0, neverthrow_1.ok)({
@@ -46,6 +49,29 @@ let WorkflowCompiler = class WorkflowCompiler {
             loopBodyStepIds,
         });
     }
+    deriveConditionSource(loop, bodySteps) {
+        if (loop.loop.type !== 'while' && loop.loop.type !== 'until') {
+            return undefined;
+        }
+        if (loop.loop.conditionSource) {
+            return loop.loop.conditionSource;
+        }
+        const hasLoopControlContract = bodySteps.some((s) => s.outputContract?.contractRef === index_1.LOOP_CONTROL_CONTRACT_REF);
+        if (hasLoopControlContract) {
+            return {
+                kind: 'artifact_contract',
+                contractRef: index_1.LOOP_CONTROL_CONTRACT_REF,
+                loopId: loop.id,
+            };
+        }
+        if (loop.loop.condition) {
+            return {
+                kind: 'context_variable',
+                condition: loop.loop.condition,
+            };
+        }
+        return undefined;
+    }
     resolveLoopBody(loop, stepById, workflow) {
         if (Array.isArray(loop.body)) {
             for (const s of loop.body) {

package/dist/application/services/workflow-interpreter.d.ts

@@ -5,6 +5,7 @@ import { type DomainError } from '../../domain/execution/error';
 import { ExecutionState } from '../../domain/execution/state';
 import { WorkflowEvent } from '../../domain/execution/event';
 import { StepInstanceId } from '../../domain/execution/ids';
+import { type DecisionTraceEntry } from '../../v2/durable-core/domain/decision-trace-builder';
 export interface NextStep {
     readonly step: WorkflowStepDefinition;
     readonly stepInstanceId: StepInstanceId;
@@ -17,13 +18,15 @@ export interface InterpreterOutput {
     readonly state: ExecutionState;
     readonly next: NextStep | null;
     readonly isComplete: boolean;
+    readonly trace: readonly DecisionTraceEntry[];
 }
 export declare class WorkflowInterpreter {
     applyEvent(state: ExecutionState, event: WorkflowEvent): Result<ExecutionState, DomainError>;
-    next(compiled: CompiledWorkflow, state: ExecutionState, context?: Record<string, unknown>): Result<InterpreterOutput, DomainError>;
+    next(compiled: CompiledWorkflow, state: ExecutionState, context?: Record<string, unknown>, artifacts?: readonly unknown[]): Result<InterpreterOutput, DomainError>;
     private ensureRunning;
     private nextTopLevel;
     private nextInCurrentLoop;
+    private evaluateWhileUntilCondition;
     private projectLoopContextAtIteration;
     private projectLoopContext;
     private lookupStepInstance;

package/dist/application/services/workflow-interpreter.js

@@ -14,6 +14,8 @@ const neverthrow_1 = require("neverthrow");
 const error_1 = require("../../domain/execution/error");
 const ids_1 = require("../../domain/execution/ids");
 const loop_runtime_1 = require("../../v2/durable-core/domain/loop-runtime");
+const loop_control_evaluator_1 = require("../../v2/durable-core/domain/loop-control-evaluator");
+const decision_trace_builder_1 = require("../../v2/durable-core/domain/decision-trace-builder");
 let WorkflowInterpreter = class WorkflowInterpreter {
     applyEvent(state, event) {
         if (state.kind === 'complete')
@@ -44,14 +46,15 @@ let WorkflowInterpreter = class WorkflowInterpreter {
             }
         }
     }
-    next(compiled, state, context = {}) {
+    next(compiled, state, context = {}, artifacts = []) {
         if (state.kind === 'complete') {
-            return (0, neverthrow_1.ok)({ state, next: null, isComplete: true });
+            return (0, neverthrow_1.ok)({ state, next: null, isComplete: true, trace: [] });
         }
         const runningRes = this.ensureRunning(state);
         if (runningRes.isErr())
             return (0, neverthrow_1.err)(runningRes.error);
         let running = runningRes.value;
+        const trace = [];
         if (running.pendingStep) {
             const step = this.lookupStepInstance(compiled, running.pendingStep);
             if (step.isErr())
@@ -60,17 +63,19 @@ let WorkflowInterpreter = class WorkflowInterpreter {
                 state: running,
                 next: step.value,
                 isComplete: false,
+                trace,
             });
         }
         for (let guard = 0; guard < 10000; guard++) {
             if (running.loopStack.length > 0) {
-                const inLoop = this.nextInCurrentLoop(compiled, running, context);
+                const inLoop = this.nextInCurrentLoop(compiled, running, context, artifacts, trace);
                 if (inLoop.isErr())
                     return (0, neverthrow_1.err)(inLoop.error);
                 const result = inLoop.value;
                 running = result.state;
                 if (result.next) {
-                    return (0, neverthrow_1.ok)({ state: running, next: result.next, isComplete: false });
+                    trace.push((0, decision_trace_builder_1.traceSelectedNextStep)(result.next.stepInstanceId.stepId));
+                    return (0, neverthrow_1.ok)({ state: running, next: result.next, isComplete: false, trace });
                 }
                 if (running.loopStack.length > 0) {
                     continue;
@@ -82,12 +87,13 @@ let WorkflowInterpreter = class WorkflowInterpreter {
             const out = top.value;
             running = out.state;
             if (out.next) {
-                return (0, neverthrow_1.ok)({ state: running, next: out.next, isComplete: false });
+                trace.push((0, decision_trace_builder_1.traceSelectedNextStep)(out.next.stepInstanceId.stepId));
+                return (0, neverthrow_1.ok)({ state: running, next: out.next, isComplete: false, trace });
             }
             if (running.loopStack.length > 0) {
                 continue;
             }
-            return (0, neverthrow_1.ok)({ state: { kind: 'complete' }, next: null, isComplete: true });
+            return (0, neverthrow_1.ok)({ state: { kind: 'complete' }, next: null, isComplete: true, trace });
         }
         return (0, neverthrow_1.err)(error_1.Err.invalidState('Interpreter exceeded guard iterations (possible infinite loop)'));
     }
@@ -127,7 +133,7 @@ let WorkflowInterpreter = class WorkflowInterpreter {
         }
         return (0, neverthrow_1.ok)({ state, next: null });
     }
-    nextInCurrentLoop(compiled, state, context) {
+    nextInCurrentLoop(compiled, state, context, artifacts, trace) {
         const frame = state.loopStack[state.loopStack.length - 1];
         const loopCompiled = compiled.compiledLoops.get(frame.loopId);
         if (!loopCompiled) {
@@ -142,7 +148,10 @@ let WorkflowInterpreter = class WorkflowInterpreter {
                     case 'for': {
                         const count = loopCompiled.loop.loop.count;
                         if (typeof count === 'number') {
-                            return (0, neverthrow_1.ok)(iteration < count);
+                            const shouldEnter = iteration < count;
+                            if (shouldEnter && iteration === 0)
+                                trace.push((0, decision_trace_builder_1.traceEnteredLoop)(frame.loopId, iteration));
+                            return (0, neverthrow_1.ok)(shouldEnter);
                         }
                         if (typeof count === 'string') {
                             const raw = context[count];
@@ -153,7 +162,10 @@ let WorkflowInterpreter = class WorkflowInterpreter {
                                     message: `for loop '${loopCompiled.loop.id}' requires numeric context['${count}']`,
                                 });
                             }
-                            return (0, neverthrow_1.ok)(iteration < raw);
+                            const shouldEnter = iteration < raw;
+                            if (shouldEnter && iteration === 0)
+                                trace.push((0, decision_trace_builder_1.traceEnteredLoop)(frame.loopId, iteration));
+                            return (0, neverthrow_1.ok)(shouldEnter);
                         }
                         return (0, neverthrow_1.err)({
                             code: 'LOOP_INVALID_CONFIG',
@@ -178,27 +190,34 @@ let WorkflowInterpreter = class WorkflowInterpreter {
                                 message: `forEach loop '${loopCompiled.loop.id}' requires array context['${itemsVar}']`,
                             });
                         }
-                        return (0, neverthrow_1.ok)(iteration < raw.length);
+                        const shouldEnter = iteration < raw.length;
+                        if (shouldEnter && iteration === 0)
+                            trace.push((0, decision_trace_builder_1.traceEnteredLoop)(frame.loopId, iteration));
+                        return (0, neverthrow_1.ok)(shouldEnter);
                     }
                     case 'while': {
-                        if (!loopCompiled.loop.loop.condition) {
-                            return (0, neverthrow_1.err)({
-                                code: 'LOOP_INVALID_CONFIG',
-                                loopId: loopCompiled.loop.id,
-                                message: `while loop '${loopCompiled.loop.id}' missing condition`,
-                            });
+                        const res = this.evaluateWhileUntilCondition(loopCompiled, iteration, context, artifacts, frame, false);
+                        if (res.isOk()) {
+                            const source = loopCompiled.conditionSource?.kind === 'artifact_contract' ? 'artifact'
+                                : loopCompiled.conditionSource?.kind === 'context_variable' ? 'context'
+                                    : 'legacy';
+                            trace.push((0, decision_trace_builder_1.traceEvaluatedCondition)(frame.loopId, iteration, res.value, source));
+                            if (res.value && iteration === 0)
+                                trace.push((0, decision_trace_builder_1.traceEnteredLoop)(frame.loopId, iteration));
                         }
-                        return (0, neverthrow_1.ok)((0, condition_evaluator_1.evaluateCondition)(loopCompiled.loop.loop.condition, this.projectLoopContextAtIteration(loopCompiled.loop, iteration, context)));
+                        return res;
                     }
                     case 'until': {
-                        if (!loopCompiled.loop.loop.condition) {
-                            return (0, neverthrow_1.err)({
-                                code: 'LOOP_INVALID_CONFIG',
-                                loopId: loopCompiled.loop.id,
-                                message: `until loop '${loopCompiled.loop.id}' missing condition`,
-                            });
+                        const res = this.evaluateWhileUntilCondition(loopCompiled, iteration, context, artifacts, frame, true);
+                        if (res.isOk()) {
+                            const source = loopCompiled.conditionSource?.kind === 'artifact_contract' ? 'artifact'
+                                : loopCompiled.conditionSource?.kind === 'context_variable' ? 'context'
+                                    : 'legacy';
+                            trace.push((0, decision_trace_builder_1.traceEvaluatedCondition)(frame.loopId, iteration, res.value, source));
+                            if (res.value && iteration === 0)
+                                trace.push((0, decision_trace_builder_1.traceEnteredLoop)(frame.loopId, iteration));
                         }
-                        return (0, neverthrow_1.ok)(!(0, condition_evaluator_1.evaluateCondition)(loopCompiled.loop.loop.condition, this.projectLoopContextAtIteration(loopCompiled.loop, iteration, context)));
+                        return res;
                     }
                     default:
                         return (0, neverthrow_1.err)({
@@ -247,6 +266,7 @@ let WorkflowInterpreter = class WorkflowInterpreter {
         }
         switch (decision.value.kind) {
             case 'exit_loop': {
+                trace.push((0, decision_trace_builder_1.traceExitedLoop)(frame.loopId, `Condition no longer met after ${frame.iteration} iteration(s)`));
                 const popped = state.loopStack.slice(0, -1);
                 return (0, neverthrow_1.ok)({
                     state: {
@@ -283,6 +303,47 @@ let WorkflowInterpreter = class WorkflowInterpreter {
                 return (0, neverthrow_1.err)(error_1.Err.invalidState('Non-exhaustive loop decision'));
         }
     }
+    evaluateWhileUntilCondition(loopCompiled, iteration, context, artifacts, frame, invertForUntil) {
+        const source = loopCompiled.conditionSource;
+        if (!source) {
+            if (!loopCompiled.loop.loop.condition) {
+                return (0, neverthrow_1.err)({
+                    code: 'LOOP_INVALID_CONFIG',
+                    loopId: loopCompiled.loop.id,
+                    message: `${loopCompiled.loop.loop.type} loop '${loopCompiled.loop.id}' missing condition and conditionSource`,
+                });
+            }
+            const raw = (0, condition_evaluator_1.evaluateCondition)(loopCompiled.loop.loop.condition, this.projectLoopContextAtIteration(loopCompiled.loop, iteration, context));
+            return (0, neverthrow_1.ok)(invertForUntil ? !raw : raw);
+        }
+        switch (source.kind) {
+            case 'artifact_contract': {
+                const result = (0, loop_control_evaluator_1.evaluateLoopControlFromArtifacts)(artifacts, source.loopId);
+                if (result.kind === 'found') {
+                    return (0, neverthrow_1.ok)(result.decision === 'continue');
+                }
+                return (0, neverthrow_1.err)({
+                    code: 'LOOP_MISSING_CONTEXT',
+                    loopId: loopCompiled.loop.id,
+                    message: result.kind === 'not_found'
+                        ? `Loop '${source.loopId}' requires a wr.loop_control artifact but none was provided`
+                        : `Loop '${source.loopId}' has an invalid loop control artifact: ${result.reason}`,
+                });
+            }
+            case 'context_variable': {
+                const raw = (0, condition_evaluator_1.evaluateCondition)(source.condition, this.projectLoopContextAtIteration(loopCompiled.loop, iteration, context));
+                return (0, neverthrow_1.ok)(invertForUntil ? !raw : raw);
+            }
+            default: {
+                const _exhaustive = source;
+                return (0, neverthrow_1.err)({
+                    code: 'LOOP_INVALID_CONFIG',
+                    loopId: loopCompiled.loop.id,
+                    message: `Unknown conditionSource kind: ${_exhaustive.kind}`,
+                });
+            }
+        }
+    }
     projectLoopContextAtIteration(loop, iteration, base) {
         const out = { ...base };
         const iterationVar = loop.loop.iterationVar || 'currentIteration';

package/dist/application/services/workflow-service.js

@@ -65,13 +65,30 @@ let DefaultWorkflowService = class DefaultWorkflowService {
         if (!step) {
             return { valid: false, issues: [`Step '${stepId}' not found in workflow '${workflowId}'`], suggestions: [], warnings: undefined };
         }
+        const outputContract = step.outputContract;
+        if (outputContract) {
+            return {
+                valid: false,
+                issues: [`Step '${stepId}' uses outputContract (artifact validation); validate via v2 continue_workflow path, not v1 validateStepOutput`],
+                suggestions: ['Use the v2 continue_workflow tool with output.artifacts[] to validate against the artifact contract.'],
+                warnings: undefined,
+            };
+        }
         const criteria = step.validationCriteria;
         if (!criteria)
             return { valid: true, issues: [], suggestions: [], warnings: undefined };
         const result = await this.validationEngine.validate(output, criteria);
-        const contextualizedWarnings = result.warnings?.map(w => `Step '${workflowId}/${stepId}': ${w}`);
+        if (result.isErr()) {
+            return {
+                valid: false,
+                issues: [`Validation engine error: ${result.error.kind} (${result.error.message})`],
+                suggestions: ['Check validationCriteria for invalid schema/format, and retry.'],
+                warnings: undefined,
+            };
+        }
+        const contextualizedWarnings = result.value.warnings?.map((w) => `Step '${workflowId}/${stepId}': ${w}`);
         return {
-            ...result,
+            ...result.value,
             warnings: contextualizedWarnings,
         };
     }