@exaudeus/workrail 3.10.0 → 3.11.0

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateAssessmentConsequences = evaluateAssessmentConsequences;
+exports.getDeclaredAssessmentConsequence = getDeclaredAssessmentConsequence;
+function evaluateAssessmentConsequences(args) {
+    if (!args.step?.assessmentConsequences || args.step.assessmentConsequences.length === 0)
+        return undefined;
+    if (!args.recordedAssessment)
+        return undefined;
+    const consequence = args.step.assessmentConsequences[0];
+    if (!consequence)
+        return undefined;
+    const matchedDimension = args.recordedAssessment.dimensions.find(dimension => dimension.dimensionId === consequence.when.dimensionId &&
+        dimension.level === consequence.when.equalsLevel);
+    if (!matchedDimension)
+        return undefined;
+    return {
+        kind: 'require_followup',
+        assessmentId: args.recordedAssessment.assessmentId,
+        triggerDimensionId: consequence.when.dimensionId,
+        triggerLevel: consequence.when.equalsLevel,
+        guidance: consequence.effect.guidance,
+    };
+}
+function getDeclaredAssessmentConsequence(step) {
+    return step?.assessmentConsequences?.[0];
+}

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

@@ -0,0 +1,16 @@
+import type { AssessmentDefinition, WorkflowStepDefinition } from '../../../types/workflow-definition.js';
+import type { ValidationResult } from '../../../types/validation.js';
+import { ASSESSMENT_CONTRACT_REF, type AssessmentArtifactV1 } from '../../../v2/durable-core/schemas/artifacts/index.js';
+import type { RecordedAssessmentV1 } from '../../../v2/durable-core/domain/assessment-record.js';
+export interface AssessmentValidationOutcome {
+    readonly contractRef: typeof ASSESSMENT_CONTRACT_REF;
+    readonly validation: ValidationResult;
+    readonly acceptedArtifact: AssessmentArtifactV1 | undefined;
+    readonly acceptedArtifactIndex: number | undefined;
+    readonly recordedAssessment: RecordedAssessmentV1 | undefined;
+}
+export declare function validateAssessmentForStep(args: {
+    readonly step: WorkflowStepDefinition;
+    readonly assessments: readonly AssessmentDefinition[] | undefined;
+    readonly artifacts: readonly unknown[];
+}): AssessmentValidationOutcome | undefined;

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

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAssessmentForStep = validateAssessmentForStep;
+const index_js_1 = require("../../../v2/durable-core/schemas/artifacts/index.js");
+function normalizeLevel(level, allowedLevels) {
+    const exact = allowedLevels.find((candidate) => candidate === level);
+    if (exact)
+        return { kind: 'exact', value: exact };
+    const normalizedInput = level.trim().toLowerCase();
+    const normalizedMatches = allowedLevels.filter((candidate) => candidate.toLowerCase() === normalizedInput);
+    if (normalizedMatches.length === 1) {
+        return {
+            kind: 'normalized',
+            value: normalizedMatches[0],
+            note: `Normalized level "${level}" to canonical value "${normalizedMatches[0]}".`,
+        };
+    }
+    if (normalizedMatches.length > 1) {
+        return {
+            kind: 'ambiguous',
+            message: `Level "${level}" is ambiguous for this dimension. Allowed levels: ${allowedLevels.join(', ')}.`,
+        };
+    }
+    return {
+        kind: 'invalid',
+        message: `Level "${level}" is not allowed. Allowed levels: ${allowedLevels.join(', ')}.`,
+    };
+}
+function extractSubmittedLevel(value) {
+    if (typeof value === 'string') {
+        return { level: value, hasRationale: false };
+    }
+    return { level: value.level, hasRationale: typeof value.rationale === 'string' && value.rationale.trim().length > 0 };
+}
+function extractSubmittedRationale(value) {
+    if (typeof value === 'string')
+        return undefined;
+    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) {
+        if (dimension.required !== false) {
+            issues.push(`Missing assessment dimension "${dimension.id}".`);
+            suggestions.push(`Provide a value for "${dimension.id}". Allowed levels: ${dimension.levels.join(', ')}.`);
+        }
+        return;
+    }
+    const { level } = extractSubmittedLevel(submitted);
+    const normalized = normalizeLevel(level, dimension.levels);
+    switch (normalized.kind) {
+        case 'exact':
+            recordedDimensions.push({
+                dimensionId: dimension.id,
+                level: normalized.value,
+                rationale: extractSubmittedRationale(submitted),
+                normalization: 'exact',
+            });
+            return;
+        case 'normalized':
+            warnings.push(normalized.note);
+            recordedDimensions.push({
+                dimensionId: dimension.id,
+                level: normalized.value,
+                rationale: extractSubmittedRationale(submitted),
+                normalization: 'normalized',
+            });
+            return;
+        case 'ambiguous':
+        case 'invalid':
+            issues.push(`Dimension "${dimension.id}": ${normalized.message}`);
+            suggestions.push(`Use one of the canonical levels for "${dimension.id}": ${dimension.levels.join(', ')}.`);
+            return;
+        default: {
+            const _exhaustive = normalized;
+            return _exhaustive;
+        }
+    }
+}
+function validateAssessmentForStep(args) {
+    if (!args.step.assessmentRefs || args.step.assessmentRefs.length === 0)
+        return undefined;
+    const lookup = buildDefinitionLookup(args.assessments, args.step);
+    if (!lookup.definition) {
+        return {
+            contractRef: index_js_1.ASSESSMENT_CONTRACT_REF,
+            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) {
+        return {
+            contractRef: index_js_1.ASSESSMENT_CONTRACT_REF,
+            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);
+    if (!parsed) {
+        return {
+            contractRef: index_js_1.ASSESSMENT_CONTRACT_REF,
+            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) {
+        return {
+            contractRef: index_js_1.ASSESSMENT_CONTRACT_REF,
+            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) {
+        validateDimension(dimension, parsed, issues, suggestions, warnings, recordedDimensions);
+    }
+    const allowedDimensionIds = new Set(lookup.definition.dimensions.map((dimension) => dimension.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(', ')}.`);
+        }
+    }
+    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
+            ? {
+                assessmentId: lookup.definition.id,
+                summary: parsed.summary,
+                dimensions: recordedDimensions,
+                normalizationNotes: warnings,
+            }
+            : undefined,
+        validation: {
+            valid: issues.length === 0,
+            issues,
+            suggestions,
+            warnings: warnings.length > 0 ? warnings : undefined,
+        },
+    };
+}

package/dist/mcp/handlers/v2-advance-core/event-builders.d.ts

@@ -25,6 +25,7 @@ type BuildAppendPlanArgs = {
     readonly kind: 'blocked';
     readonly blockers: import('../../../v2/durable-core/domain/reason-model.js').BlockerReportV1;
     readonly snapshotRef: import('../../../v2/durable-core/ids/index.js').SnapshotRef;
+    readonly outputsToAppend?: readonly OutputToAppend[];
 } | {
     readonly kind: 'advanced';
     readonly toNodeKind: 'step' | 'blocked_attempt' | undefined;

package/dist/mcp/handlers/v2-advance-core/event-builders.js

@@ -18,6 +18,7 @@ function buildAndAppendPlan(args) {
         const toNodeId = String(idFactory.mintNodeId());
         const evtNodeCreated = idFactory.mintEventId();
         const evtEdgeCreated = idFactory.mintEventId();
+        const outputEventIds = (args.outputsToAppend ?? []).map(() => idFactory.mintEventId());
         const hasChildren = truth.events.some((e) => e.kind === constants_js_1.EVENT_KIND.EDGE_CREATED && e.data.fromNodeId === String(currentNodeId));
         const causeKind = hasChildren ? constants_js_1.EDGE_CAUSE.NON_TIP_ADVANCE : constants_js_1.EDGE_CAUSE.INTENTIONAL_FORK;
         const planRes = (0, ack_advance_append_plan_js_1.buildAckAdvanceAppendPlanV1)({
@@ -37,9 +38,9 @@ function buildAndAppendPlan(args) {
                 advanceRecordedEventId: evtAdvanceRecorded,
                 nodeCreatedEventId: evtNodeCreated,
                 edgeCreatedEventId: evtEdgeCreated,
-                outputEventIds: [],
+                outputEventIds,
             },
-            outputsToAppend: [],
+            outputsToAppend: args.outputsToAppend ?? [],
         });
         if (planRes.isErr())
             return (0, neverthrow_1.errAsync)({ kind: 'invariant_violation', message: planRes.error.message });

package/dist/mcp/handlers/v2-advance-core/index.js

@@ -71,31 +71,46 @@ function executeAdvanceCore(args) {
             const ctx = { truth, sessionId, runId, currentNodeId, attemptId, workflowHash, inputOutput, pinnedWorkflow, engineState, pendingStep };
             const computed = { reasons: effectiveReasons, outputRequirement, validation: evalValidation };
             const portsLocal = { snapshotStore, sessionStore, sha256, idFactory };
-            return (0, outcome_blocked_js_1.buildBlockedOutcome)({ mode, snap, ctx, computed, lock, ports: portsLocal });
+            return (0, outcome_blocked_js_1.buildBlockedOutcome)({ mode, snap, ctx, computed, v, lock, ports: portsLocal });
         }
         const validation = phase.validation;
+        const effectiveValidation = v.assessmentValidation && !v.assessmentValidation.validation.valid
+            ? v.assessmentValidation.validation
+            : validation;
         const outputRequirement = (0, validation_criteria_validator_js_1.getOutputRequirementStatusWithArtifactsV1)({
             outputContract: v.outputContract,
             artifacts: v.artifacts,
             validationCriteria: v.validationCriteria,
+            assessmentValidation: v.assessmentValidation?.validation,
             notesMarkdown: v.notesMarkdown,
-            validation,
+            validation: effectiveValidation,
         });
         const missingNotes = !v.notesOptional && !v.notesMarkdown?.trim()
             ? { stepId: v.pendingStep.stepId }
             : undefined;
-        const rawReasonsRes = (0, blocking_decision_js_1.detectBlockingReasonsV1)({ outputRequirement, missingNotes });
-        if (rawReasonsRes.isErr()) {
-            return errAsync({ kind: 'invariant_violation', message: rawReasonsRes.error.message });
+        const rawReasonsWithAssessmentRes = (0, blocking_decision_js_1.detectBlockingReasonsV1)({
+            outputRequirement,
+            missingNotes,
+            assessmentFollowupRequired: v.triggeredAssessmentConsequence
+                ? {
+                    assessmentId: v.triggeredAssessmentConsequence.assessmentId,
+                    dimensionId: v.triggeredAssessmentConsequence.triggerDimensionId,
+                    level: v.triggeredAssessmentConsequence.triggerLevel,
+                    guidance: v.triggeredAssessmentConsequence.guidance,
+                }
+                : undefined,
+        });
+        if (rawReasonsWithAssessmentRes.isErr()) {
+            return errAsync({ kind: 'invariant_violation', message: rawReasonsWithAssessmentRes.error.message });
         }
-        const rawReasons = rawReasonsRes.value;
+        const rawReasons = rawReasonsWithAssessmentRes.value;
         const { blocking: reasons } = (0, risk_policy_guardrails_js_1.applyGuardrails)(v.riskPolicy, rawReasons);
         const shouldBlockNow = reasons.length > 0 && (0, reason_model_js_1.shouldBlock)(v.autonomy, reasons);
         const ctx = { truth, sessionId, runId, currentNodeId, attemptId, workflowHash, inputOutput, pinnedWorkflow, engineState, pendingStep };
-        const computed = { reasons, outputRequirement, validation };
+        const computed = { reasons, outputRequirement, validation: effectiveValidation };
         const ports = { snapshotStore, sessionStore, sha256, idFactory };
         if (shouldBlockNow) {
-            return (0, outcome_blocked_js_1.buildBlockedOutcome)({ mode, snap, ctx, computed, lock, ports });
+            return (0, outcome_blocked_js_1.buildBlockedOutcome)({ mode, snap, ctx, computed, v, lock, ports });
         }
         return (0, outcome_success_js_1.buildSuccessOutcome)({ mode, ctx, computed, v, lock, ports });
     });

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

@@ -3,8 +3,11 @@ import type { RunId, NodeId } from '../../../v2/durable-core/ids/index.js';
 import type { LoadedSessionTruthV2 } from '../../../v2/ports/session-event-log-store.port.js';
 import type { JsonValue, JsonObject } from '../../../v2/durable-core/canonical/json-types.js';
 import type { V2ContinueWorkflowInput } from '../../v2/tools.js';
-import type { OutputContract } from '../../../types/workflow-definition.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';
 export interface ValidatedAdvanceInputs {
     readonly pendingStep: {
@@ -17,9 +20,14 @@ export interface ValidatedAdvanceInputs {
     readonly mergedContext: Record<string, unknown>;
     readonly inputContextObj: JsonObject | undefined;
     readonly validationCriteria: ValidationCriteria | undefined;
+    readonly assessmentValidation: import('./assessment-validation.js').AssessmentValidationOutcome | undefined;
     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';
     readonly riskPolicy: 'conservative' | 'balanced' | 'aggressive';
     readonly effectivePrefs: {

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

@@ -7,6 +7,8 @@ const run_context_js_1 = require("../../../v2/projections/run-context.js");
 const preferences_js_1 = require("../../../v2/projections/preferences.js");
 const context_merge_js_1 = require("../../../v2/durable-core/domain/context-merge.js");
 const constants_js_1 = require("../../../v2/durable-core/constants.js");
+const assessment_validation_js_1 = require("./assessment-validation.js");
+const assessment_consequences_js_1 = require("./assessment-consequences.js");
 function validateAdvanceInputs(args) {
     const { truth, runId, currentNodeId, inputContext, inputOutput, pinnedWorkflow, pendingStep } = args;
     const storedContextRes = (0, run_context_js_1.projectRunContextV2)(truth.events);
@@ -19,8 +21,21 @@ function validateAdvanceInputs(args) {
         return (0, neverthrow_1.err)({ kind: 'invariant_violation', message: `Context merge failed: ${mergedContextRes.error.message}` });
     }
     const step = (0, workflow_js_1.getStepById)(pinnedWorkflow, pendingStep.stepId);
-    const validationCriteria = step?.validationCriteria;
-    const outputContract = step?.outputContract;
+    const typedStep = step && !('type' in step && step.type === 'loop') ? step : undefined;
+    const validationCriteria = typedStep?.validationCriteria;
+    const outputContract = typedStep?.outputContract;
+    const stepAssessments = (pinnedWorkflow.definition.assessments ?? []).filter((assessment) => typedStep?.assessmentRefs?.includes(assessment.id));
+    const assessmentValidation = typedStep
+        ? (0, assessment_validation_js_1.validateAssessmentForStep)({
+            step: typedStep,
+            assessments: pinnedWorkflow.definition.assessments,
+            artifacts: inputOutput?.artifacts ?? [],
+        })
+        : undefined;
+    const triggeredAssessmentConsequence = (0, assessment_consequences_js_1.evaluateAssessmentConsequences)({
+        step: typedStep,
+        recordedAssessment: assessmentValidation?.recordedAssessment,
+    });
     const notesOptional = outputContract !== undefined ||
         (step !== null && step !== undefined && 'notesOptional' in step && step.notesOptional === true);
     const parentByNodeId = {};
@@ -50,9 +65,14 @@ function validateAdvanceInputs(args) {
         mergedContext: mergedContextRes.value,
         inputContextObj,
         validationCriteria,
+        assessmentValidation,
         outputContract,
         notesMarkdown: inputOutput?.notesMarkdown,
         artifacts: inputOutput?.artifacts ?? [],
+        assessmentArtifact: assessmentValidation?.acceptedArtifact,
+        recordedAssessment: assessmentValidation?.recordedAssessment,
+        triggeredAssessmentConsequence,
+        stepAssessments,
         autonomy,
         riskPolicy,
         effectivePrefs,

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

@@ -6,11 +6,13 @@ import type { WithHealthySessionLock } from '../../../v2/durable-core/ids/with-h
 import type { InternalError } from '../v2-error-mapping.js';
 import type { AdvanceMode } from './index.js';
 import type { AdvanceContext, ComputedAdvanceResults, AdvanceCorePorts } from './index.js';
+import type { ValidatedAdvanceInputs } from './input-validation.js';
 export declare function buildBlockedOutcome(args: {
     readonly mode: AdvanceMode;
     readonly snap: ExecutionSnapshotFileV1;
     readonly ctx: AdvanceContext;
     readonly computed: ComputedAdvanceResults;
+    readonly v: ValidatedAdvanceInputs;
     readonly lock: WithHealthySessionLock;
     readonly ports: AdvanceCorePorts;
 }): RA<void, InternalError | SessionEventLogStoreError | SnapshotStoreError>;

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

@@ -5,6 +5,8 @@ const neverthrow_1 = require("neverthrow");
 const reason_model_js_1 = require("../../../v2/durable-core/domain/reason-model.js");
 const validation_event_builder_js_1 = require("../../../v2/durable-core/domain/validation-event-builder.js");
 const blocked_node_builder_js_1 = require("../../../v2/durable-core/domain/blocked-node-builder.js");
+const assessment_recorded_event_builder_js_1 = require("../../../v2/durable-core/domain/assessment-recorded-event-builder.js");
+const assessment_consequence_event_builder_js_1 = require("../../../v2/durable-core/domain/assessment-consequence-event-builder.js");
 const event_builders_js_1 = require("./event-builders.js");
 function buildBlockedOutcome(args) {
     const { mode, snap, lock, ports } = args;
@@ -15,26 +17,23 @@ function buildBlockedOutcome(args) {
     if (blockersRes.isErr()) {
         return errAsync({ kind: 'invariant_violation', message: blockersRes.error.message });
     }
-    const validationEventId = idFactory.mintEventId();
-    const validationId = `validation_${String(attemptId)}`;
-    const contractRefForEvent = (outputRequirement.kind !== 'not_required' && outputRequirement.kind !== 'satisfied') ? outputRequirement.contractRef : 'none';
-    const validationForEvent = validation ??
-        (outputRequirement.kind === 'missing'
-            ? { valid: false, issues: [`Missing required output for contractRef=${contractRefForEvent}`], suggestions: [], warnings: undefined }
-            : { valid: false, issues: ['Validation result missing'], suggestions: [], warnings: undefined });
-    const validationEventRes = (0, validation_event_builder_js_1.buildValidationPerformedEvent)({
-        sessionId: String(sessionId),
-        validationId,
-        attemptId: String(attemptId),
-        contractRef: contractRefForEvent,
-        scope: { runId: String(runId), nodeId: String(currentNodeId) },
-        minted: { eventId: validationEventId },
-        result: validationForEvent,
-    });
-    if (validationEventRes.isErr()) {
-        return errAsync({ kind: 'invariant_violation', message: validationEventRes.error.message });
+    const validationId = validation ? `validation_${String(attemptId)}` : undefined;
+    const extraEventsToAppend = [];
+    if (validation && outputRequirement.kind !== 'not_required' && outputRequirement.kind !== 'satisfied') {
+        const validationEventRes = (0, validation_event_builder_js_1.buildValidationPerformedEvent)({
+            sessionId: String(sessionId),
+            validationId: validationId,
+            attemptId: String(attemptId),
+            contractRef: outputRequirement.contractRef,
+            scope: { runId: String(runId), nodeId: String(currentNodeId) },
+            minted: { eventId: idFactory.mintEventId() },
+            result: validation,
+        });
+        if (validationEventRes.isErr()) {
+            return errAsync({ kind: 'invariant_violation', message: validationEventRes.error.message });
+        }
+        extraEventsToAppend.push(validationEventRes.value);
     }
-    const extraEventsToAppend = [validationEventRes.value];
     const primaryReason = reasons[0];
     if (!primaryReason) {
         return errAsync({ kind: 'invariant_violation', message: 'shouldBlockNow=true requires at least one effective reason (post-guardrails)' });
@@ -50,11 +49,62 @@ function buildBlockedOutcome(args) {
     if (blockedSnapshotRes.isErr()) {
         return errAsync({ kind: 'invariant_violation', message: blockedSnapshotRes.error.message });
     }
+    const outputAppendResult = args.ctx.inputOutput?.artifacts
+        ? (() => {
+            const outputsRes = (0, event_builders_js_1.buildArtifactOutputs)(args.ctx.inputOutput.artifacts, attemptId, sha256);
+            if (outputsRes.isErr()) {
+                return outputsRes;
+            }
+            return outputsRes;
+        })()
+        : undefined;
+    if (outputAppendResult?.isErr()) {
+        return errAsync(outputAppendResult.error);
+    }
+    const outputsToAppend = outputAppendResult && outputAppendResult.isOk()
+        ? outputAppendResult.value
+        : [];
+    const validated = args.v;
+    if (validated?.recordedAssessment && validated.assessmentValidation?.acceptedArtifactIndex !== undefined) {
+        const assessmentOutput = outputsToAppend[validated.assessmentValidation.acceptedArtifactIndex];
+        if (!assessmentOutput || assessmentOutput.outputChannel !== 'artifact') {
+            return errAsync({ kind: 'invariant_violation', message: 'Accepted assessment artifact did not produce a matching artifact output on blocked path.' });
+        }
+        const assessmentEventRes = (0, assessment_recorded_event_builder_js_1.buildAssessmentRecordedEvent)({
+            sessionId: String(sessionId),
+            attemptId: String(attemptId),
+            artifactOutputId: String(assessmentOutput.outputId),
+            scope: { runId: String(runId), nodeId: String(currentNodeId) },
+            assessment: validated.recordedAssessment,
+            minted: { eventId: idFactory.mintEventId() },
+        });
+        if (assessmentEventRes.isErr()) {
+            return errAsync({ kind: 'invariant_violation', message: assessmentEventRes.error.message });
+        }
+        extraEventsToAppend.push(assessmentEventRes.value);
+    }
+    if (validated?.triggeredAssessmentConsequence) {
+        const consequenceEventRes = (0, assessment_consequence_event_builder_js_1.buildAssessmentConsequenceAppliedEvent)({
+            sessionId: String(sessionId),
+            attemptId: String(attemptId),
+            scope: { runId: String(runId), nodeId: String(currentNodeId) },
+            assessmentId: validated.triggeredAssessmentConsequence.assessmentId,
+            dimensionId: validated.triggeredAssessmentConsequence.triggerDimensionId,
+            level: validated.triggeredAssessmentConsequence.triggerLevel,
+            guidance: validated.triggeredAssessmentConsequence.guidance,
+            minted: { eventId: idFactory.mintEventId() },
+        });
+        if (consequenceEventRes.isErr()) {
+            return errAsync({ kind: 'invariant_violation', message: consequenceEventRes.error.message });
+        }
+        extraEventsToAppend.push(consequenceEventRes.value);
+    }
     return snapshotStore.putExecutionSnapshotV1(blockedSnapshotRes.value).andThen((blockedSnapshotRef) => {
         return (0, event_builders_js_1.buildAndAppendPlan)({
             kind: 'blocked',
             truth, sessionId, runId, currentNodeId, attemptId, workflowHash,
             extraEventsToAppend, blockers: blockersRes.value, snapshotRef: blockedSnapshotRef,
+            outputsToAppend,
             sessionStore, idFactory, lock,
         });
     });

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

@@ -9,6 +9,7 @@ const v2_state_conversion_js_1 = require("../v2-state-conversion.js");
 const v2_context_budget_js_1 = require("../v2-context-budget.js");
 const v2_advance_events_js_1 = require("../v2-advance-events.js");
 const event_builders_js_1 = require("./event-builders.js");
+const assessment_recorded_event_builder_js_1 = require("../../../v2/durable-core/domain/assessment-recorded-event-builder.js");
 function successNodeKind(mode) {
     switch (mode.kind) {
         case 'fresh': return undefined;
@@ -124,6 +125,27 @@ 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];
+            if (!assessmentOutput || assessmentOutput.outputChannel !== 'artifact') {
+                return errAsync({
+                    kind: 'invariant_violation',
+                    message: 'Accepted assessment artifact did not produce a matching artifact output.',
+                });
+            }
+            const assessmentEventRes = (0, assessment_recorded_event_builder_js_1.buildAssessmentRecordedEvent)({
+                sessionId: String(sessionId),
+                attemptId: String(attemptId),
+                artifactOutputId: String(assessmentOutput.outputId),
+                scope: { runId: String(runId), nodeId: String(currentNodeId) },
+                assessment: v.recordedAssessment,
+                minted: { eventId: idFactory.mintEventId() },
+            });
+            if (assessmentEventRes.isErr()) {
+                return errAsync({ kind: 'invariant_violation', message: assessmentEventRes.error.message });
+            }
+            extraEventsToAppend.push(assessmentEventRes.value);
+        }
         const outputsToAppend = [...notesOutputs, ...artifactOutputsRes.value];
         return (0, event_builders_js_1.buildAndAppendPlan)({
             kind: 'advanced',

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

@@ -58,6 +58,12 @@ function buildAdvancedReplayResponse(args) {
                 .mapErr((failure) => ({ kind: 'token_signing_failed', cause: failure }))
             : (0, neverthrow_1.okAsync)(undefined);
         const validation = (0, validation_loader_js_1.loadValidationResultV1)(truth.events, String(blocked.validationRef)).unwrapOr(null) ?? undefined;
+        const assessmentFollowup = blocked.reason.kind === 'assessment_followup_required'
+            ? {
+                title: `Assessment follow-up matched ${blocked.reason.assessmentId}.${blocked.reason.dimensionId} == ${blocked.reason.level}`,
+                guidance: blocked.reason.guidance,
+            }
+            : undefined;
         let blockedMeta = null;
         if (pending) {
             const result = (0, prompt_renderer_js_1.renderPendingPrompt)({
@@ -89,6 +95,7 @@ function buildAdvancedReplayResponse(args) {
             retryable,
             retryContinueToken,
             validation,
+            assessmentFollowup,
         }))));
     }
     let okMeta = null;