@exaudeus/workrail 3.22.0 → 3.23.0

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

@@ -81,13 +81,17 @@ let WorkflowInterpreter = class WorkflowInterpreter {
                     continue;
                 }
             }
-            const top = this.nextTopLevel(compiled, running, context);
+            const top = this.nextTopLevel(compiled, running, context, trace);
             if (top.isErr())
                 return (0, neverthrow_1.err)(top.error);
             const out = top.value;
             running = out.state;
             if (out.next) {
-                trace.push((0, decision_trace_builder_1.traceSelectedNextStep)(out.next.stepInstanceId.stepId, out.next.step.title));
+                const selectedStep = out.next.step;
+                const label = selectedStep.runCondition
+                    ? selectedStep.title ?? out.next.stepInstanceId.stepId
+                    : `Selected (no condition): ${selectedStep.title ?? out.next.stepInstanceId.stepId}`;
+                trace.push((0, decision_trace_builder_1.traceSelectedNextStep)(out.next.stepInstanceId.stepId, label));
                 return (0, neverthrow_1.ok)({ state: running, next: out.next, isComplete: false, trace });
             }
             if (running.loopStack.length > 0) {
@@ -106,14 +110,19 @@ let WorkflowInterpreter = class WorkflowInterpreter {
         }
         return (0, neverthrow_1.ok)(state);
     }
-    nextTopLevel(compiled, state, context) {
+    nextTopLevel(compiled, state, context, trace = []) {
         for (const step of compiled.steps) {
             if (compiled.loopBodyStepIds.has(step.id))
                 continue;
             if (state.completed.includes(step.id))
                 continue;
-            if (step.runCondition && !(0, condition_evaluator_1.evaluateCondition)(step.runCondition, context)) {
-                continue;
+            if (step.runCondition) {
+                const conditionPassed = (0, condition_evaluator_1.evaluateCondition)(step.runCondition, context);
+                if (!conditionPassed) {
+                    trace.push((0, decision_trace_builder_1.traceStepRunConditionSkipped)(step.id, step.title, step.runCondition, context));
+                    continue;
+                }
+                trace.push((0, decision_trace_builder_1.traceStepRunConditionPassed)(step.id, step.title, step.runCondition, context));
             }
             if ((0, workflow_1.isLoopStepDefinition)(step)) {
                 const entered = { loopId: step.id, iteration: 0, bodyIndex: 0 };

package/dist/manifest.json

@@ -142,8 +142,8 @@
       "bytes": 1507
     },
     "application/services/workflow-interpreter.js": {
-      "sha256": "ba498a0d1fd7a2f415c993e8a11b32002afca18f0cee932936331b7c4a079a66",
-      "bytes": 21475
+      "sha256": "860a147051cb6cf36720c18a30c5c6f62c7868c4dd9a0f98e413fda0b0d205a5",
+      "bytes": 22145
     },
     "application/services/workflow-service.d.ts": {
       "sha256": "c9c9e2ab4396c46da0f12af93133ca1e7da94bdc88f67a074d8f6c43ef0a5b3b",
@@ -1622,12 +1622,12 @@
       "bytes": 962
     },
     "v2/durable-core/domain/decision-trace-builder.d.ts": {
-      "sha256": "17383d46067f3941b7a4c391a74a9d4c6cfb55d98edec5b40cd954831c4a2428",
-      "bytes": 1762
+      "sha256": "f897dd17019bb094c72b1b19d7e731d535f66256ae38a0b08646d2604be0663d",
+      "bytes": 2314
     },
     "v2/durable-core/domain/decision-trace-builder.js": {
-      "sha256": "4b34913677a333f78f739ba2ca95845dcc610364ca5d3eb7af9866ed889545ce",
-      "bytes": 4398
+      "sha256": "478a50a6b530248a46359d589611c640683fd3f754c2412341b7affa61f4d95b",
+      "bytes": 7910
     },
     "v2/durable-core/domain/function-definition-expander.d.ts": {
       "sha256": "2720e7c4dfbd9ec0cdf75eb4384fdbea18d4430aeae7f13d9215f0e5e4980468",

package/dist/v2/durable-core/domain/decision-trace-builder.d.ts

@@ -1,5 +1,6 @@
 import type { Result } from 'neverthrow';
 import type { LoopControlEvaluationResult } from './loop-control-evaluator.js';
+import type { Condition } from '../../../utils/condition-evaluator.js';
 export type DecisionTraceEntryKind = 'selected_next_step' | 'evaluated_condition' | 'entered_loop' | 'exited_loop' | 'detected_non_tip_advance';
 export type DecisionTraceRef = {
     readonly kind: 'step_id';
@@ -23,6 +24,9 @@ export declare function traceEnteredLoop(loopId: string, iteration: number): Dec
 export declare function traceEvaluatedCondition(loopId: string, iteration: number, result: boolean, source: 'artifact' | 'context' | 'legacy'): DecisionTraceEntry;
 export declare function traceExitedLoop(loopId: string, reason: string): DecisionTraceEntry;
 export declare function traceSelectedNextStep(stepId: string, stepTitle?: string): DecisionTraceEntry;
+export declare function formatConditionTrace(condition: Condition, context: Record<string, unknown>, passed: boolean): string;
+export declare function traceStepRunConditionSkipped(stepId: string, stepTitle: string | undefined, condition: Condition, context: Record<string, unknown>): DecisionTraceEntry;
+export declare function traceStepRunConditionPassed(stepId: string, stepTitle: string | undefined, condition: Condition, context: Record<string, unknown>): DecisionTraceEntry;
 export declare function traceArtifactMatchResult(loopId: string, iteration: number, result: LoopControlEvaluationResult): DecisionTraceEntry;
 export declare function applyTraceBudget(entries: readonly DecisionTraceEntry[]): readonly DecisionTraceEntry[];
 export declare function buildDecisionTraceEventData(traceId: string, entries: readonly DecisionTraceEntry[]): Result<{

package/dist/v2/durable-core/domain/decision-trace-builder.js

@@ -4,6 +4,9 @@ exports.traceEnteredLoop = traceEnteredLoop;
 exports.traceEvaluatedCondition = traceEvaluatedCondition;
 exports.traceExitedLoop = traceExitedLoop;
 exports.traceSelectedNextStep = traceSelectedNextStep;
+exports.formatConditionTrace = formatConditionTrace;
+exports.traceStepRunConditionSkipped = traceStepRunConditionSkipped;
+exports.traceStepRunConditionPassed = traceStepRunConditionPassed;
 exports.traceArtifactMatchResult = traceArtifactMatchResult;
 exports.applyTraceBudget = applyTraceBudget;
 exports.buildDecisionTraceEventData = buildDecisionTraceEventData;
@@ -40,6 +43,100 @@ function traceSelectedNextStep(stepId, stepTitle) {
         refs: [{ kind: 'step_id', stepId }],
     };
 }
+function formatConditionTrace(condition, context, passed) {
+    const prefix = passed ? 'PASS' : 'SKIP';
+    if (condition.and !== undefined) {
+        return passed ? 'PASS: and-condition met' : 'SKIP: and-condition not met';
+    }
+    if (condition.or !== undefined) {
+        return passed ? 'PASS: or-condition met' : 'SKIP: or-condition not met';
+    }
+    if (condition.not !== undefined) {
+        return passed ? 'PASS: not-condition met' : 'SKIP: not-condition not met';
+    }
+    const varName = condition.var;
+    if (!varName) {
+        return `${prefix}: condition ${passed ? 'met' : 'not met'}`;
+    }
+    const op = getOperatorLabel(condition);
+    if (passed) {
+        const contextValue = context[varName];
+        const contextStr = contextValue === undefined ? '(unset)' : String(contextValue);
+        const expectedStr = getExpectedValueLabel(condition);
+        return expectedStr !== null
+            ? `PASS: ${varName}=${contextStr} (${op}: ${expectedStr})`
+            : `PASS: ${varName}=${contextStr} (${op})`;
+    }
+    else {
+        return `SKIP: ${varName} (${op})`;
+    }
+}
+function getOperatorLabel(condition) {
+    if (condition.var === undefined)
+        return 'condition';
+    if ('equals' in condition)
+        return 'equals';
+    if ('not_equals' in condition)
+        return 'not_equals';
+    if (condition.gt !== undefined)
+        return 'gt';
+    if (condition.gte !== undefined)
+        return 'gte';
+    if (condition.lt !== undefined)
+        return 'lt';
+    if (condition.lte !== undefined)
+        return 'lte';
+    if (condition.contains !== undefined)
+        return 'contains';
+    if (condition.startsWith !== undefined)
+        return 'startsWith';
+    if (condition.endsWith !== undefined)
+        return 'endsWith';
+    if (condition.matches !== undefined)
+        return 'matches';
+    if (condition.in !== undefined)
+        return 'in';
+    return 'condition';
+}
+function getExpectedValueLabel(condition) {
+    if ('equals' in condition)
+        return String(condition.equals);
+    if ('not_equals' in condition)
+        return String(condition.not_equals);
+    if (condition.gt !== undefined)
+        return String(condition.gt);
+    if (condition.gte !== undefined)
+        return String(condition.gte);
+    if (condition.lt !== undefined)
+        return String(condition.lt);
+    if (condition.lte !== undefined)
+        return String(condition.lte);
+    if (condition.contains !== undefined)
+        return condition.contains;
+    if (condition.startsWith !== undefined)
+        return condition.startsWith;
+    if (condition.endsWith !== undefined)
+        return condition.endsWith;
+    if (condition.matches !== undefined)
+        return condition.matches;
+    if (condition.in !== undefined)
+        return JSON.stringify(condition.in);
+    return null;
+}
+function traceStepRunConditionSkipped(stepId, stepTitle, condition, context) {
+    return {
+        kind: 'evaluated_condition',
+        summary: formatConditionTrace(condition, context, false),
+        refs: [{ kind: 'step_id', stepId }],
+    };
+}
+function traceStepRunConditionPassed(stepId, stepTitle, condition, context) {
+    return {
+        kind: 'evaluated_condition',
+        summary: formatConditionTrace(condition, context, true),
+        refs: [{ kind: 'step_id', stepId }],
+    };
+}
 function traceArtifactMatchResult(loopId, iteration, result) {
     const detail = (() => {
         switch (result.kind) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exaudeus/workrail",
-  "version": "3.22.0",
+  "version": "3.23.0",
   "description": "Step-by-step workflow enforcement for AI agents via MCP",
   "license": "MIT",
   "repository": {