@exaudeus/workrail 3.17.0 → 3.18.0

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

@@ -685,24 +685,24 @@ let ValidationEngine = ValidationEngine_1 = class ValidationEngine {
                 issues.push(`${stepLabel}: assessmentConsequences must not be empty when declared`);
                 return;
             }
-            if (!step.assessmentRefs || step.assessmentRefs.length !== 1) {
-                issues.push(`${stepLabel}: assessmentConsequences require exactly one assessmentRef on the same step`);
-                suggestions.push(`Add exactly one assessmentRef to ${stepLabel} before declaring assessmentConsequences`);
+            if (!step.assessmentRefs || step.assessmentRefs.length === 0) {
+                issues.push(`${stepLabel}: assessmentConsequences require at least one assessmentRef on the same step`);
+                suggestions.push(`Add at least one assessmentRef to ${stepLabel} before declaring assessmentConsequences`);
                 return;
             }
             if (step.assessmentConsequences.length > 1) {
                 issues.push(`${stepLabel}: v1 assessment support allows exactly one assessment consequence per step`);
                 suggestions.push(`Reduce assessmentConsequences on ${stepLabel} to a single declaration`);
             }
-            const assessmentDefinition = assessments.find(assessment => assessment.id === step.assessmentRefs?.[0]);
-            if (!assessmentDefinition)
+            const referencedDefinitions = assessments.filter(assessment => step.assessmentRefs.includes(assessment.id));
+            if (referencedDefinitions.length === 0)
                 return;
             for (const consequence of step.assessmentConsequences) {
                 const trigger = consequence.when;
                 const effect = consequence.effect;
-                const allLevels = assessmentDefinition.dimensions.flatMap(d => d.levels);
+                const allLevels = referencedDefinitions.flatMap(def => def.dimensions.flatMap(d => d.levels));
                 if (!allLevels.includes(trigger.anyEqualsLevel)) {
-                    issues.push(`${stepLabel}: assessment consequence anyEqualsLevel '${trigger.anyEqualsLevel}' is not declared in any dimension of assessment '${assessmentDefinition.id}'`);
+                    issues.push(`${stepLabel}: assessment consequence anyEqualsLevel '${trigger.anyEqualsLevel}' is not declared in any dimension of any referenced assessment`);
                     suggestions.push(`Use a level declared in one of the dimensions: ${[...new Set(allLevels)].join(', ')}`);
                 }
                 if (effect.kind !== 'require_followup') {
@@ -776,10 +776,6 @@ let ValidationEngine = ValidationEngine_1 = class ValidationEngine {
                     }
                 }
                 validateAssessmentRefsForStep(typedStep, `Step '${step.id}'`);
-                if (typedStep.assessmentRefs !== undefined && typedStep.assessmentRefs.length > 1) {
-                    issues.push(`Step '${step.id}': v1 assessment support allows exactly one assessmentRef per step`);
-                    suggestions.push(`Reduce assessmentRefs on step '${step.id}' to a single assessment id`);
-                }
                 validateAssessmentConsequencesForStep(typedStep, `Step '${step.id}'`);
                 const callValidation = this.validateStepFunctionCalls(step, workflow.definition.functionDefinitions || []);
                 if (!callValidation.valid) {

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

@@ -140,21 +140,19 @@ let WorkflowCompiler = class WorkflowCompiler {
             const assessmentConsequences = typedStep.assessmentConsequences;
             if (!assessmentConsequences)
                 continue;
-            if (!typedStep.assessmentRefs || typedStep.assessmentRefs.length !== 1) {
-                return (0, neverthrow_1.err)(error_1.Err.invalidState(`Step '${step.id}' declares assessmentConsequences but does not declare exactly one assessmentRef`));
-            }
-            const assessment = (workflow.definition.assessments ?? []).find(candidate => candidate.id === typedStep.assessmentRefs?.[0]);
-            if (!assessment) {
-                return (0, neverthrow_1.err)(error_1.Err.invalidState(`Step '${step.id}' declares assessmentConsequences for unknown assessmentRef '${typedStep.assessmentRefs[0]}'`));
+            if (!typedStep.assessmentRefs || typedStep.assessmentRefs.length === 0) {
+                return (0, neverthrow_1.err)(error_1.Err.invalidState(`Step '${step.id}' declares assessmentConsequences but declares no assessmentRefs`));
             }
             if (assessmentConsequences.length > 1) {
                 return (0, neverthrow_1.err)(error_1.Err.invalidState(`Step '${step.id}' declares ${assessmentConsequences.length} assessment consequences. V1 supports exactly one assessment consequence per step.`));
             }
+            const allLevelsAcrossRefs = (workflow.definition.assessments ?? [])
+                .filter(candidate => typedStep.assessmentRefs.includes(candidate.id))
+                .flatMap(assessment => assessment.dimensions.flatMap(d => d.levels));
             for (const consequence of assessmentConsequences) {
                 const trigger = consequence.when;
-                const allLevels = assessment.dimensions.flatMap(d => d.levels);
-                if (!allLevels.includes(trigger.anyEqualsLevel)) {
-                    return (0, neverthrow_1.err)(error_1.Err.invalidState(`Step '${step.id}' declares consequence with anyEqualsLevel '${trigger.anyEqualsLevel}' that is not declared in any dimension of assessment '${assessment.id}'`));
+                if (!allLevelsAcrossRefs.includes(trigger.anyEqualsLevel)) {
+                    return (0, neverthrow_1.err)(error_1.Err.invalidState(`Step '${step.id}' declares consequence with anyEqualsLevel '${trigger.anyEqualsLevel}' that is not declared in any dimension of any referenced assessment`));
                 }
                 if (consequence.effect.kind !== 'require_followup') {
                     return (0, neverthrow_1.err)(error_1.Err.invalidState(`Step '${step.id}' declares unsupported assessment consequence effect '${String(consequence.effect.kind)}'`));
@@ -187,8 +185,8 @@ let WorkflowCompiler = class WorkflowCompiler {
                     }
                 }
                 if (bodyStep.assessmentConsequences) {
-                    if (!bodyStep.assessmentRefs || bodyStep.assessmentRefs.length !== 1) {
-                        return (0, neverthrow_1.err)(error_1.Err.invalidState(`Loop body step '${bodyStep.id}' in loop '${loop.id}' declares assessmentConsequences but does not declare exactly one assessmentRef`));
+                    if (!bodyStep.assessmentRefs || bodyStep.assessmentRefs.length === 0) {
+                        return (0, neverthrow_1.err)(error_1.Err.invalidState(`Loop body step '${bodyStep.id}' in loop '${loop.id}' declares assessmentConsequences but declares no assessmentRefs`));
                     }
                 }
             }

package/dist/manifest.json

@@ -126,16 +126,16 @@
       "bytes": 2122
     },
     "application/services/validation-engine.js": {
-      "sha256": "15e195411394b3c4d2cf86e7f41137fc211fba8677dcd8bc55b1c7eead9c5996",
-      "bytes": 49153
+      "sha256": "6231bc1fe0a130ca9771f24da7e5b661d7ceba5839e2867aab6a47b4e50e1a99",
+      "bytes": 48831
     },
     "application/services/workflow-compiler.d.ts": {
       "sha256": "f51443e1c3e8e079a972dd032e8de3bcde7b82d891e9a3621a6357cc4fc0e30d",
       "bytes": 1718
     },
     "application/services/workflow-compiler.js": {
-      "sha256": "8bd40b8b1bf29e4037bc7884a1c798a001d53b91f3f43ead18bf9df7a12ddf50",
-      "bytes": 14396
+      "sha256": "61d09a365540d49865f3d9a1b80eb5f21bad1bd4ccfe2950af63302dd4048dcf",
+      "bytes": 14175
     },
     "application/services/workflow-interpreter.d.ts": {
       "sha256": "56b5b5ad06d42096deba9f0abe7642c18a355a1e598749aab1730df4e9847674",
@@ -766,20 +766,20 @@
       "bytes": 306
     },
     "mcp/handlers/v2-advance-core/assessment-consequences.d.ts": {
-      "sha256": "d9d460f9164037a8f7804b37d6e0f821ee55858affaccb11001362acceb429c0",
+      "sha256": "69323678acf77575569b66a0444aa38578f392b5bfd3aa8f013ff6a463967f66",
       "bytes": 836
     },
     "mcp/handlers/v2-advance-core/assessment-consequences.js": {
-      "sha256": "87ff5f2ab7476d0790db70c8c8047a2cc30eb9fede7c7ba1694bd5ab8b15d1a8",
-      "bytes": 1088
+      "sha256": "b5f920c648fd8ffd4bf37df57f40e15eb85a84c606a050b0336f71ad15e9a039",
+      "bytes": 1203
     },
     "mcp/handlers/v2-advance-core/assessment-validation.d.ts": {
-      "sha256": "5721ca106bbbdddef33db1d392bbcfcaccd7c158c61255a8e578611b30d0efb9",
-      "bytes": 996
+      "sha256": "57c4e1cda1f7006d8cbcab19a7c2d0f6418aff128f0237265a200388ee378772",
+      "bytes": 1020
     },
     "mcp/handlers/v2-advance-core/assessment-validation.js": {
-      "sha256": "351461f5c0396e1164c31510b6447b341f8fab67cd5b222afb7cc53a7a9ab83f",
-      "bytes": 9229
+      "sha256": "9bf6b000610afcfc97b6f769574ed27b734baf1be2e52978534486bb453d23c4",
+      "bytes": 10270
     },
     "mcp/handlers/v2-advance-core/event-builders.d.ts": {
       "sha256": "64502bdfc33901fdb9f9d0d676c9762497bc03f17f0f9a68959a460b270b13b2",
@@ -798,28 +798,28 @@
       "bytes": 8087
     },
     "mcp/handlers/v2-advance-core/input-validation.d.ts": {
-      "sha256": "2fe0195dd0040968cb18c2cff07b1cf59f55fb5fe2675f6e46320eb0c98a9c53",
-      "bytes": 2910
+      "sha256": "4e057b4496c0d0b263a1296f313df6583df3b5fb34855c1e26d38cbdd39536ea",
+      "bytes": 2581
     },
     "mcp/handlers/v2-advance-core/input-validation.js": {
-      "sha256": "cc2cbc001a4135884ce3ccc526f26d47b3f9d92fcc28b99c52cf72a6aeb10cb7",
-      "bytes": 5405
+      "sha256": "6f690863bc61eec4cd9632b75d2bf6dc6b37fdaca445aded371715f351df673e",
+      "bytes": 5275
     },
     "mcp/handlers/v2-advance-core/outcome-blocked.d.ts": {
       "sha256": "837a6515ba8a1b5de8627c44e5f639a4b8e95d99833a784121539beb262cd96d",
       "bytes": 1242
     },
     "mcp/handlers/v2-advance-core/outcome-blocked.js": {
-      "sha256": "8cf22d664017e26cc5f368da2216a369065a9bbb3fddb4412e492438bbf9c354",
-      "bytes": 6126
+      "sha256": "3f13d7672c182ecaaf7ca44a616b2a358d27f7826a297fea6ea2afdb4d32d2c1",
+      "bytes": 6313
     },
     "mcp/handlers/v2-advance-core/outcome-success.d.ts": {
       "sha256": "09ddde83767b1a997cc20933d62bac89a83937be331bf021555d9e661b97cfa6",
       "bytes": 1055
     },
     "mcp/handlers/v2-advance-core/outcome-success.js": {
-      "sha256": "05560245b5bc844056c8787aa1fdd466e717d9a960d769af7a7dde76406f4e02",
-      "bytes": 7554
+      "sha256": "ebb8c7e942d915f479e456c01bf42a3f27a2b0502c24e3d924fbbc426d4cc422",
+      "bytes": 7752
     },
     "mcp/handlers/v2-advance-events.d.ts": {
       "sha256": "02cdb52a2c16dd619645b5496caf0880e57937bf21ea9efe44e6cd195cd43b94",
@@ -906,8 +906,8 @@
       "bytes": 2808
     },
     "mcp/handlers/v2-execution/replay.js": {
-      "sha256": "3accfc82c460fd9365e0d5e40a43a92029fc677cbe119e3ed65fca4fab103d92",
-      "bytes": 11371
+      "sha256": "5c0f7456db8862538103d876f00ff4c06533045c9f0dbe25e5ed4f53baf83e79",
+      "bytes": 11397
     },
     "mcp/handlers/v2-execution/start.d.ts": {
       "sha256": "2deb05345e125667576ede3bb20756a1b22ec86f18028d242b5d9b54dd25afaf",
@@ -998,12 +998,12 @@
       "bytes": 7991
     },
     "mcp/output-schemas.d.ts": {
-      "sha256": "ce4c18f491ca9c7409b5ab4e2f4e0a3467bfc77f4ebf360858594cf2dab66360",
-      "bytes": 93120
+      "sha256": "291a605a38ca41a6a6849ae6325b2541694a547d02cc231951fb6438f781b316",
+      "bytes": 93176
     },
     "mcp/output-schemas.js": {
-      "sha256": "e9b5cdfccec05f7756b5952af691f647f08708b53fbea92715dd167603d17a07",
-      "bytes": 22177
+      "sha256": "b9901935144a7842dd237a869b51fdd72153ce2970225da1e83cc22193bd1293",
+      "bytes": 22211
     },
     "mcp/render-envelope.d.ts": {
       "sha256": "22e83e1aba52968a7136cf289125a217b5f462a5a66a1eebe4669006e3326fdb",
@@ -1682,8 +1682,8 @@
       "bytes": 1295
     },
     "v2/durable-core/domain/prompt-renderer.js": {
-      "sha256": "75a37c32d8525171595bc75b22cd67118b9121c5c11d8f4446e5594630e20743",
-      "bytes": 18717
+      "sha256": "b4e6b9683d05eb63b86b346996ead259157882bcb1e6a70834a919c90c6007f9",
+      "bytes": 18937
     },
     "v2/durable-core/domain/reason-model.d.ts": {
       "sha256": "a944e7e0d9b3c73468488263cb0aa1e446c023f8084fd2af53cbda3f3bfcd37a",

package/dist/mcp/handlers/v2-advance-core/assessment-consequences.d.ts

@@ -9,6 +9,6 @@ export interface TriggeredAssessmentConsequenceV1 {
 }
 export declare function evaluateAssessmentConsequences(args: {
     readonly step: WorkflowStepDefinition | undefined;
-    readonly recordedAssessment: RecordedAssessmentV1 | undefined;
+    readonly recordedAssessments: readonly RecordedAssessmentV1[];
 }): TriggeredAssessmentConsequenceV1 | undefined;
 export declare function getDeclaredAssessmentConsequence(step: WorkflowStepDefinition | undefined): AssessmentConsequenceDefinition | undefined;

package/dist/mcp/handlers/v2-advance-core/assessment-consequences.js

@@ -5,21 +5,24 @@ exports.getDeclaredAssessmentConsequence = getDeclaredAssessmentConsequence;
 function evaluateAssessmentConsequences(args) {
     if (!args.step?.assessmentConsequences || args.step.assessmentConsequences.length === 0)
         return undefined;
-    if (!args.recordedAssessment)
+    if (args.recordedAssessments.length === 0)
         return undefined;
     const consequence = args.step.assessmentConsequences[0];
     if (!consequence)
         return undefined;
-    const matched = args.recordedAssessment.dimensions.find(d => d.level === consequence.when.anyEqualsLevel);
-    if (!matched)
-        return undefined;
-    return {
-        kind: 'require_followup',
-        assessmentId: args.recordedAssessment.assessmentId,
-        firstMatchedDimensionId: matched.dimensionId,
-        triggerLevel: consequence.when.anyEqualsLevel,
-        guidance: consequence.effect.guidance,
-    };
+    for (const recorded of args.recordedAssessments) {
+        const matched = recorded.dimensions.find(d => d.level === consequence.when.anyEqualsLevel);
+        if (matched) {
+            return {
+                kind: 'require_followup',
+                assessmentId: recorded.assessmentId,
+                firstMatchedDimensionId: matched.dimensionId,
+                triggerLevel: consequence.when.anyEqualsLevel,
+                guidance: consequence.effect.guidance,
+            };
+        }
+    }
+    return undefined;
 }
 function getDeclaredAssessmentConsequence(step) {
     return step?.assessmentConsequences?.[0];

package/dist/mcp/handlers/v2-advance-core/assessment-validation.d.ts

@@ -5,9 +5,11 @@ import type { RecordedAssessmentV1 } from '../../../v2/durable-core/domain/asses
 export interface AssessmentValidationOutcome {
     readonly contractRef: typeof ASSESSMENT_CONTRACT_REF;
     readonly validation: ValidationResult;
-    readonly acceptedArtifact: AssessmentArtifactV1 | undefined;
-    readonly acceptedArtifactIndex: number | undefined;
-    readonly recordedAssessment: RecordedAssessmentV1 | undefined;
+    readonly recordedAssessments: readonly RecordedAssessmentV1[];
+    readonly acceptedArtifacts: ReadonlyArray<{
+        readonly artifact: AssessmentArtifactV1;
+        readonly artifactIndex: number;
+    }>;
 }
 export declare function validateAssessmentForStep(args: {
     readonly step: WorkflowStepDefinition;

package/dist/mcp/handlers/v2-advance-core/assessment-validation.js

@@ -38,39 +38,6 @@ function extractSubmittedRationale(value) {
     const trimmed = value.rationale?.trim();
     return trimmed && trimmed.length > 0 ? trimmed : undefined;
 }
-function buildDefinitionLookup(assessments, step) {
-    const refs = step.assessmentRefs ?? [];
-    if (refs.length === 0) {
-        return {
-            definition: undefined,
-            issues: [],
-            suggestions: [],
-        };
-    }
-    if (!assessments || assessments.length === 0) {
-        return {
-            definition: undefined,
-            issues: [`Step "${step.id}" expects assessment input, but the workflow declares no assessments.`],
-            suggestions: ['Update the workflow definition to declare the assessments referenced by this step.'],
-        };
-    }
-    if (refs.length > 1) {
-        return {
-            definition: undefined,
-            issues: [`Step "${step.id}" declares multiple assessmentRefs. Assessment boundary validation currently supports exactly one assessment per step.`],
-            suggestions: ['Reduce assessmentRefs to a single assessment for this step in v1.'],
-        };
-    }
-    const definition = assessments.find((assessment) => assessment.id === refs[0]);
-    if (!definition) {
-        return {
-            definition: undefined,
-            issues: [`Step "${step.id}" references undeclared assessment "${refs[0]}".`],
-            suggestions: [`Declare assessment "${refs[0]}" on the workflow or remove the step reference.`],
-        };
-    }
-    return { definition, issues: [], suggestions: [] };
-}
 function validateDimension(dimension, artifact, issues, suggestions, warnings, recordedDimensions) {
     const submitted = artifact.dimensions[dimension.id];
     if (submitted === undefined) {
@@ -111,103 +78,158 @@ function validateDimension(dimension, artifact, issues, suggestions, warnings, r
         }
     }
 }
-function validateAssessmentForStep(args) {
-    if (!args.step.assessmentRefs || args.step.assessmentRefs.length === 0)
-        return undefined;
-    const lookup = buildDefinitionLookup(args.assessments, args.step);
-    if (!lookup.definition) {
+function validateSingleAssessment(args) {
+    const assessmentArtifacts = args.artifacts
+        .map((artifact, index) => ({ artifact, index }))
+        .filter(({ artifact }) => typeof artifact === 'object' && artifact !== null && artifact.kind === 'wr.assessment');
+    if (assessmentArtifacts.length === 0) {
         return {
-            contractRef: index_js_1.ASSESSMENT_CONTRACT_REF,
+            issues: [`This step requires an assessment submission for "${args.definition.id}".`],
+            suggestions: [
+                `Provide an artifact with kind "wr.assessment" for assessment "${args.definition.id}".`,
+                `Include dimension values for: ${args.definition.dimensions.map((dimension) => `${dimension.id} (${dimension.levels.join(' | ')})`).join(', ')}.`,
+            ],
+            warnings: [],
             acceptedArtifact: undefined,
             acceptedArtifactIndex: undefined,
             recordedAssessment: undefined,
-            validation: {
-                valid: false,
-                issues: [...lookup.issues],
-                suggestions: [...lookup.suggestions],
-            },
         };
     }
-    const assessmentArtifacts = args.artifacts
-        .map((artifact, index) => ({ artifact, index }))
-        .filter(({ artifact }) => typeof artifact === 'object' && artifact !== null && artifact.kind === 'wr.assessment');
-    if (assessmentArtifacts.length === 0) {
+    const candidateEntry = args.isSingleRef
+        ? assessmentArtifacts[0]
+        : assessmentArtifacts.find(({ artifact }) => {
+            const parsed = (0, index_js_1.parseAssessmentArtifact)(artifact);
+            return parsed?.assessmentId === args.definition.id;
+        });
+    if (!candidateEntry) {
         return {
-            contractRef: index_js_1.ASSESSMENT_CONTRACT_REF,
+            issues: [`Missing assessment artifact for "${args.definition.id}". Provide an artifact with kind "wr.assessment" and assessmentId "${args.definition.id}".`],
+            suggestions: [
+                `Include dimension values for: ${args.definition.dimensions.map((d) => `${d.id} (${d.levels.join(' | ')})`).join(', ')}.`,
+            ],
+            warnings: [],
             acceptedArtifact: undefined,
             acceptedArtifactIndex: undefined,
             recordedAssessment: undefined,
-            validation: {
-                valid: false,
-                issues: [`This step requires an assessment submission for "${lookup.definition.id}".`],
-                suggestions: [
-                    `Provide an artifact with kind "wr.assessment" for assessment "${lookup.definition.id}".`,
-                    `Include dimension values for: ${lookup.definition.dimensions.map((dimension) => `${dimension.id} (${dimension.levels.join(' | ')})`).join(', ')}.`,
-                ],
-            },
         };
     }
-    const acceptedCandidate = assessmentArtifacts[0];
-    const parsed = (0, index_js_1.parseAssessmentArtifact)(acceptedCandidate.artifact);
+    const parsed = (0, index_js_1.parseAssessmentArtifact)(candidateEntry.artifact);
     if (!parsed) {
         return {
-            contractRef: index_js_1.ASSESSMENT_CONTRACT_REF,
+            issues: ['Assessment artifact is malformed or does not match the expected shape.'],
+            suggestions: [
+                `Use an artifact with kind "wr.assessment", a dimensions object, and canonical dimension values for assessment "${args.definition.id}".`,
+            ],
+            warnings: [],
             acceptedArtifact: undefined,
             acceptedArtifactIndex: undefined,
             recordedAssessment: undefined,
-            validation: {
-                valid: false,
-                issues: ['Assessment artifact is malformed or does not match the expected shape.'],
-                suggestions: [
-                    `Use an artifact with kind "wr.assessment", a dimensions object, and canonical dimension values for assessment "${lookup.definition.id}".`,
-                ],
-            },
         };
     }
-    if (parsed.assessmentId && parsed.assessmentId !== lookup.definition.id) {
+    if (parsed.assessmentId && parsed.assessmentId !== args.definition.id) {
         return {
-            contractRef: index_js_1.ASSESSMENT_CONTRACT_REF,
+            issues: [`Assessment artifact targets "${parsed.assessmentId}", but this step expects "${args.definition.id}".`],
+            suggestions: [`Set assessmentId to "${args.definition.id}" or omit it and provide the correct dimensions.`],
+            warnings: [],
             acceptedArtifact: undefined,
             acceptedArtifactIndex: undefined,
             recordedAssessment: undefined,
-            validation: {
-                valid: false,
-                issues: [`Assessment artifact targets "${parsed.assessmentId}", but this step expects "${lookup.definition.id}".`],
-                suggestions: [`Set assessmentId to "${lookup.definition.id}" or omit it and provide the correct dimensions.`],
-            },
         };
     }
     const issues = [];
     const suggestions = [];
     const warnings = [];
     const recordedDimensions = [];
-    for (const dimension of lookup.definition.dimensions) {
+    for (const dimension of args.definition.dimensions) {
         validateDimension(dimension, parsed, issues, suggestions, warnings, recordedDimensions);
     }
-    const allowedDimensionIds = new Set(lookup.definition.dimensions.map((dimension) => dimension.id));
+    const allowedDimensionIds = new Set(args.definition.dimensions.map((d) => d.id));
     for (const submittedDimensionId of Object.keys(parsed.dimensions)) {
         if (!allowedDimensionIds.has(submittedDimensionId)) {
-            issues.push(`Unknown assessment dimension "${submittedDimensionId}" for assessment "${lookup.definition.id}".`);
-            suggestions.push(`Remove "${submittedDimensionId}" and use only: ${lookup.definition.dimensions.map((dimension) => dimension.id).join(', ')}.`);
+            issues.push(`Unknown assessment dimension "${submittedDimensionId}" for assessment "${args.definition.id}".`);
+            suggestions.push(`Remove "${submittedDimensionId}" and use only: ${args.definition.dimensions.map((d) => d.id).join(', ')}.`);
         }
     }
+    const valid = issues.length === 0;
     return {
-        contractRef: index_js_1.ASSESSMENT_CONTRACT_REF,
-        acceptedArtifact: issues.length === 0 ? parsed : undefined,
-        acceptedArtifactIndex: issues.length === 0 ? acceptedCandidate.index : undefined,
-        recordedAssessment: issues.length === 0
+        issues,
+        suggestions,
+        warnings,
+        acceptedArtifact: valid ? parsed : undefined,
+        acceptedArtifactIndex: valid ? candidateEntry.index : undefined,
+        recordedAssessment: valid
             ? {
-                assessmentId: lookup.definition.id,
+                assessmentId: args.definition.id,
                 summary: parsed.summary,
                 dimensions: recordedDimensions,
                 normalizationNotes: warnings,
             }
             : undefined,
+    };
+}
+function validateAssessmentForStep(args) {
+    if (!args.step.assessmentRefs || args.step.assessmentRefs.length === 0)
+        return undefined;
+    const refs = args.step.assessmentRefs;
+    if (!args.assessments || args.assessments.length === 0) {
+        return {
+            contractRef: index_js_1.ASSESSMENT_CONTRACT_REF,
+            recordedAssessments: [],
+            acceptedArtifacts: [],
+            validation: {
+                valid: false,
+                issues: refs.map((ref) => `Step expects assessment input for "${ref}", but the workflow declares no assessments.`),
+                suggestions: ['Update the workflow definition to declare the assessments referenced by this step.'],
+            },
+        };
+    }
+    const allIssues = [];
+    const allSuggestions = [];
+    const definitions = [];
+    for (const ref of refs) {
+        const definition = args.assessments.find((a) => a.id === ref);
+        if (!definition) {
+            allIssues.push(`Step references undeclared assessment "${ref}".`);
+            allSuggestions.push(`Declare assessment "${ref}" on the workflow or remove the step reference.`);
+        }
+        else {
+            definitions.push(definition);
+        }
+    }
+    if (allIssues.length > 0) {
+        return {
+            contractRef: index_js_1.ASSESSMENT_CONTRACT_REF,
+            recordedAssessments: [],
+            acceptedArtifacts: [],
+            validation: { valid: false, issues: allIssues, suggestions: allSuggestions },
+        };
+    }
+    const isSingleRef = refs.length === 1;
+    const perRefResults = definitions.map((definition) => validateSingleAssessment({ definition, artifacts: args.artifacts, isSingleRef }));
+    const combinedIssues = perRefResults.flatMap((r) => r.issues);
+    const combinedSuggestions = perRefResults.flatMap((r) => r.suggestions);
+    const combinedWarnings = perRefResults.flatMap((r) => r.warnings);
+    const allValid = combinedIssues.length === 0;
+    const recordedAssessments = [];
+    const acceptedArtifacts = [];
+    if (allValid) {
+        for (const result of perRefResults) {
+            if (result.recordedAssessment)
+                recordedAssessments.push(result.recordedAssessment);
+            if (result.acceptedArtifact !== undefined && result.acceptedArtifactIndex !== undefined) {
+                acceptedArtifacts.push({ artifact: result.acceptedArtifact, artifactIndex: result.acceptedArtifactIndex });
+            }
+        }
+    }
+    return {
+        contractRef: index_js_1.ASSESSMENT_CONTRACT_REF,
+        recordedAssessments,
+        acceptedArtifacts,
         validation: {
-            valid: issues.length === 0,
-            issues,
-            suggestions,
-            warnings: warnings.length > 0 ? warnings : undefined,
+            valid: allValid,
+            issues: combinedIssues,
+            suggestions: combinedSuggestions,
+            ...(combinedWarnings.length > 0 ? { warnings: combinedWarnings } : {}),
         },
     };
 }

package/dist/mcp/handlers/v2-advance-core/input-validation.d.ts

@@ -5,8 +5,6 @@ import type { JsonValue, JsonObject } from '../../../v2/durable-core/canonical/j
 import type { V2ContinueWorkflowInput } from '../../v2/tools.js';
 import type { AssessmentDefinition, OutputContract } from '../../../types/workflow-definition.js';
 import type { ValidationCriteria } from '../../../types/validation.js';
-import type { AssessmentArtifactV1 } from '../../../v2/durable-core/schemas/artifacts/index.js';
-import type { RecordedAssessmentV1 } from '../../../v2/durable-core/domain/assessment-record.js';
 import type { TriggeredAssessmentConsequenceV1 } from './assessment-consequences.js';
 import type { InternalError } from '../v2-error-mapping.js';
 import type { SessionIndex } from '../../../v2/durable-core/session-index.js';
@@ -25,8 +23,6 @@ export interface ValidatedAdvanceInputs {
     readonly outputContract: OutputContract | undefined;
     readonly notesMarkdown: string | undefined;
     readonly artifacts: readonly unknown[];
-    readonly assessmentArtifact: AssessmentArtifactV1 | undefined;
-    readonly recordedAssessment: RecordedAssessmentV1 | undefined;
     readonly triggeredAssessmentConsequence: TriggeredAssessmentConsequenceV1 | undefined;
     readonly stepAssessments: readonly AssessmentDefinition[];
     readonly autonomy: 'guided' | 'full_auto_stop_on_user_deps' | 'full_auto_never_stop';

package/dist/mcp/handlers/v2-advance-core/input-validation.js

@@ -48,7 +48,7 @@ function validateAdvanceInputs(args) {
         : undefined;
     const triggeredAssessmentConsequence = (0, assessment_consequences_js_1.evaluateAssessmentConsequences)({
         step: typedStep,
-        recordedAssessment: assessmentValidation?.recordedAssessment,
+        recordedAssessments: assessmentValidation?.recordedAssessments ?? [],
     });
     const notesOptional = outputContract !== undefined ||
         (step !== null && step !== undefined && 'notesOptional' in step && step.notesOptional === true);
@@ -92,8 +92,6 @@ function validateAdvanceInputs(args) {
         outputContract,
         notesMarkdown: inputOutput?.notesMarkdown,
         artifacts: inputOutput?.artifacts ?? [],
-        assessmentArtifact: assessmentValidation?.acceptedArtifact,
-        recordedAssessment: assessmentValidation?.recordedAssessment,
         triggeredAssessmentConsequence,
         stepAssessments,
         autonomy,

package/dist/mcp/handlers/v2-advance-core/outcome-blocked.js

@@ -65,8 +65,13 @@ function buildBlockedOutcome(args) {
         ? outputAppendResult.value
         : [];
     const validated = args.v;
-    if (validated?.recordedAssessment && validated.assessmentValidation?.acceptedArtifactIndex !== undefined) {
-        const assessmentOutput = outputsToAppend[validated.assessmentValidation.acceptedArtifactIndex];
+    const acceptedArtifacts = validated?.assessmentValidation?.acceptedArtifacts ?? [];
+    for (let i = 0; i < acceptedArtifacts.length; i++) {
+        const { artifactIndex } = acceptedArtifacts[i];
+        const recordedAssessment = validated?.assessmentValidation?.recordedAssessments[i];
+        if (!recordedAssessment)
+            continue;
+        const assessmentOutput = outputsToAppend[artifactIndex];
         if (!assessmentOutput || assessmentOutput.outputChannel !== 'artifact') {
             return errAsync({ kind: 'invariant_violation', message: 'Accepted assessment artifact did not produce a matching artifact output on blocked path.' });
         }
@@ -75,7 +80,7 @@ function buildBlockedOutcome(args) {
             attemptId: String(attemptId),
             artifactOutputId: String(assessmentOutput.outputId),
             scope: { runId: String(runId), nodeId: String(currentNodeId) },
-            assessment: validated.recordedAssessment,
+            assessment: recordedAssessment,
             minted: { eventId: idFactory.mintEventId() },
         });
         if (assessmentEventRes.isErr()) {

package/dist/mcp/handlers/v2-advance-core/outcome-success.js

@@ -125,8 +125,13 @@ function buildSuccessOutcome(args) {
         if (artifactOutputsRes.isErr()) {
             return errAsync(artifactOutputsRes.error);
         }
-        if (v.recordedAssessment && v.assessmentArtifact && v.assessmentValidation?.acceptedArtifactIndex !== undefined) {
-            const assessmentOutput = artifactOutputsRes.value[v.assessmentValidation.acceptedArtifactIndex];
+        const acceptedArtifacts = v.assessmentValidation?.acceptedArtifacts ?? [];
+        for (let i = 0; i < acceptedArtifacts.length; i++) {
+            const { artifactIndex } = acceptedArtifacts[i];
+            const recordedAssessment = v.assessmentValidation?.recordedAssessments[i];
+            if (!recordedAssessment)
+                continue;
+            const assessmentOutput = artifactOutputsRes.value[artifactIndex];
             if (!assessmentOutput || assessmentOutput.outputChannel !== 'artifact') {
                 return errAsync({
                     kind: 'invariant_violation',
@@ -138,7 +143,7 @@ function buildSuccessOutcome(args) {
                 attemptId: String(attemptId),
                 artifactOutputId: String(assessmentOutput.outputId),
                 scope: { runId: String(runId), nodeId: String(currentNodeId) },
-                assessment: v.recordedAssessment,
+                assessment: recordedAssessment,
                 minted: { eventId: idFactory.mintEventId() },
             });
             if (assessmentEventRes.isErr()) {

package/dist/mcp/handlers/v2-execution/replay.js

@@ -153,11 +153,11 @@ function buildStepContext(events, completedNodeId) {
         console.warn(`[workrail:replay] stepContext projection failed for node '${String(completedNodeId)}' — stepContext will be absent: ${projection.error.message}`);
         return undefined;
     }
-    const recorded = (0, assessments_js_1.getLatestAssessmentForNode)(projection.value, String(completedNodeId));
-    if (!recorded)
+    const allRecorded = projection.value.byNodeId[String(completedNodeId)];
+    if (!allRecorded || allRecorded.length === 0)
         return undefined;
     return {
-        assessments: {
+        assessments: allRecorded.map((recorded) => ({
             assessmentId: recorded.assessmentId,
             dimensions: recorded.dimensions.map((d) => ({
                 dimensionId: d.dimensionId,
@@ -165,7 +165,7 @@ function buildStepContext(events, completedNodeId) {
                 ...(d.rationale !== undefined ? { rationale: d.rationale } : {}),
             })),
             normalizationNotes: recorded.normalizationNotes,
-        },
+        })),
     };
 }
 function replayFromRecordedAdvance(args) {