@exaudeus/workrail 3.10.0 → 3.11.0

package/dist/mcp/output-schemas.js

@@ -144,6 +144,11 @@ const V2BlockerPointerSchema = zod_1.z.discriminatedUnion('kind', [
     zod_1.z.object({ kind: zod_1.z.literal('context_budget') }),
     zod_1.z.object({ kind: zod_1.z.literal('output_contract'), contractRef: zod_1.z.string().min(1) }),
     zod_1.z.object({ kind: zod_1.z.literal('capability'), capability: zod_1.z.enum(['delegation', 'web_browsing']) }),
+    zod_1.z.object({
+        kind: zod_1.z.literal('assessment_dimension'),
+        assessmentId: zod_1.z.string().min(1),
+        dimensionId: zod_1.z.string().min(1).regex(DELIMITER_SAFE_ID_PATTERN, 'dimensionId must be delimiter-safe: [a-z0-9_-]+'),
+    }),
     zod_1.z.object({
         kind: zod_1.z.literal('workflow_step'),
         stepId: zod_1.z.string().min(1).regex(DELIMITER_SAFE_ID_PATTERN, 'stepId must be delimiter-safe: [a-z0-9_-]+'),
@@ -154,6 +159,7 @@ const V2BlockerSchema = zod_1.z.object({
         'USER_ONLY_DEPENDENCY',
         'MISSING_REQUIRED_OUTPUT',
         'INVALID_REQUIRED_OUTPUT',
+        'ASSESSMENT_FOLLOWUP_REQUIRED',
         'MISSING_REQUIRED_NOTES',
         'MISSING_CONTEXT_KEY',
         'CONTEXT_BUDGET_EXCEEDED',
@@ -195,6 +201,9 @@ exports.V2BlockerReportSchema = zod_1.z
             case 'capability':
                 ptrStable = p.capability;
                 break;
+            case 'assessment_dimension':
+                ptrStable = `${p.assessmentId}|${p.dimensionId}`;
+                break;
             case 'workflow_step':
                 ptrStable = p.stepId;
                 break;
@@ -252,6 +261,12 @@ const V2ContinueWorkflowBlockedSchema = zod_1.z.object({
         suggestions: zod_1.z.array(zod_1.z.string()),
     })
         .optional(),
+    assessmentFollowup: zod_1.z
+        .object({
+        title: zod_1.z.string().min(1),
+        guidance: zod_1.z.string().min(1),
+    })
+        .optional(),
 });
 exports.V2ContinueWorkflowOutputSchema = zod_1.z.discriminatedUnion('kind', [
     V2ContinueWorkflowOkSchema,

package/dist/mcp/v2-response-formatter.js

@@ -126,7 +126,13 @@ function formatBlockedRetryable(data) {
             lines.push('');
         }
     }
-    lines.push('Retry with corrected output:');
+    if (data.assessmentFollowup) {
+        lines.push('**Follow-up required before retrying this step:**');
+        lines.push(`- ${data.assessmentFollowup.title}`);
+        lines.push(`- ${data.assessmentFollowup.guidance}`);
+        lines.push('');
+    }
+    lines.push('Retry the same step with improved output:');
     lines.push('');
     lines.push(formatTokenBlock(data));
     return lines.join('\n');

package/dist/types/workflow-definition.d.ts

@@ -11,6 +11,29 @@ export interface PromptFragment {
     readonly when?: Condition;
     readonly text: string;
 }
+export interface AssessmentDimensionDefinition {
+    readonly id: string;
+    readonly purpose: string;
+    readonly levels: readonly string[];
+    readonly required?: boolean;
+}
+export interface AssessmentDefinition {
+    readonly id: string;
+    readonly purpose: string;
+    readonly dimensions: readonly AssessmentDimensionDefinition[];
+}
+export interface AssessmentConsequenceTriggerDefinition {
+    readonly dimensionId: string;
+    readonly equalsLevel: string;
+}
+export interface AssessmentFollowupRequiredEffectDefinition {
+    readonly kind: 'require_followup';
+    readonly guidance: string;
+}
+export interface AssessmentConsequenceDefinition {
+    readonly when: AssessmentConsequenceTriggerDefinition;
+    readonly effect: AssessmentFollowupRequiredEffectDefinition;
+}
 export interface WorkflowStepDefinition {
     readonly id: string;
     readonly title: string;
@@ -23,6 +46,8 @@ export interface WorkflowStepDefinition {
     readonly runCondition?: Readonly<Record<string, unknown>>;
     readonly validationCriteria?: ValidationCriteria;
     readonly outputContract?: OutputContract;
+    readonly assessmentRefs?: readonly string[];
+    readonly assessmentConsequences?: readonly AssessmentConsequenceDefinition[];
     readonly notesOptional?: boolean;
     readonly templateCall?: TemplateCall;
     readonly promptFragments?: readonly PromptFragment[];
@@ -106,6 +131,7 @@ export interface WorkflowDefinition {
     readonly functionDefinitions?: readonly FunctionDefinition[];
     readonly recommendedPreferences?: WorkflowRecommendedPreferences;
     readonly features?: readonly string[];
+    readonly assessments?: readonly AssessmentDefinition[];
     readonly extensionPoints?: readonly ExtensionPoint[];
     readonly references?: readonly WorkflowReference[];
 }

package/dist/types/workflow-definition.js

@@ -28,11 +28,26 @@ function hasWorkflowDefinitionShape(obj) {
 function createWorkflowDefinition(definition) {
     return Object.freeze({
         ...definition,
-        steps: Object.freeze(definition.steps.map(step => Object.freeze({ ...step }))),
+        steps: Object.freeze(definition.steps.map(step => Object.freeze({
+            ...step,
+            assessmentConsequences: 'assessmentConsequences' in step && step.assessmentConsequences
+                ? Object.freeze(step.assessmentConsequences.map(consequence => Object.freeze({
+                    ...consequence,
+                    when: Object.freeze({ ...consequence.when }),
+                    effect: Object.freeze({ ...consequence.effect }),
+                })))
+                : undefined,
+        }))),
         preconditions: definition.preconditions ? Object.freeze([...definition.preconditions]) : undefined,
         clarificationPrompts: definition.clarificationPrompts ? Object.freeze([...definition.clarificationPrompts]) : undefined,
         metaGuidance: definition.metaGuidance ? Object.freeze([...definition.metaGuidance]) : undefined,
         functionDefinitions: definition.functionDefinitions ? Object.freeze([...definition.functionDefinitions]) : undefined,
+        assessments: definition.assessments
+            ? Object.freeze(definition.assessments.map(assessment => Object.freeze({
+                ...assessment,
+                dimensions: Object.freeze(assessment.dimensions.map(dimension => Object.freeze({ ...dimension }))),
+            })))
+            : undefined,
         extensionPoints: definition.extensionPoints ? Object.freeze([...definition.extensionPoints]) : undefined,
         references: definition.references ? Object.freeze(definition.references.map(ref => Object.freeze({ ...ref }))) : undefined,
     });

package/dist/v2/durable-core/constants.d.ts

@@ -28,6 +28,8 @@ export declare const EVENT_KIND: {
     readonly ADVANCE_RECORDED: "advance_recorded";
     readonly VALIDATION_PERFORMED: "validation_performed";
     readonly NODE_OUTPUT_APPENDED: "node_output_appended";
+    readonly ASSESSMENT_RECORDED: "assessment_recorded";
+    readonly ASSESSMENT_CONSEQUENCE_APPLIED: "assessment_consequence_applied";
     readonly PREFERENCES_CHANGED: "preferences_changed";
     readonly CAPABILITY_OBSERVED: "capability_observed";
     readonly GAP_RECORDED: "gap_recorded";

package/dist/v2/durable-core/constants.js

@@ -31,6 +31,8 @@ exports.EVENT_KIND = {
     ADVANCE_RECORDED: 'advance_recorded',
     VALIDATION_PERFORMED: 'validation_performed',
     NODE_OUTPUT_APPENDED: 'node_output_appended',
+    ASSESSMENT_RECORDED: 'assessment_recorded',
+    ASSESSMENT_CONSEQUENCE_APPLIED: 'assessment_consequence_applied',
     PREFERENCES_CHANGED: 'preferences_changed',
     CAPABILITY_OBSERVED: 'capability_observed',
     GAP_RECORDED: 'gap_recorded',

package/dist/v2/durable-core/domain/assessment-consequence-event-builder.d.ts

@@ -0,0 +1,23 @@
+import { type Result } from 'neverthrow';
+import type { DomainEventV1 } from '../schemas/session/index.js';
+type EventToAppendV1 = Omit<DomainEventV1, 'eventIndex' | 'sessionId'>;
+export type AssessmentConsequenceEventError = {
+    readonly code: 'ASSESSMENT_CONSEQUENCE_EVENT_INVARIANT_VIOLATION';
+    readonly message: string;
+};
+export declare function buildAssessmentConsequenceAppliedEvent(args: {
+    readonly sessionId: string;
+    readonly attemptId: string;
+    readonly scope: {
+        readonly runId: string;
+        readonly nodeId: string;
+    };
+    readonly assessmentId: string;
+    readonly dimensionId: string;
+    readonly level: string;
+    readonly guidance: string;
+    readonly minted: {
+        readonly eventId: string;
+    };
+}): Result<EventToAppendV1, AssessmentConsequenceEventError>;
+export {};

package/dist/v2/durable-core/domain/assessment-consequence-event-builder.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAssessmentConsequenceAppliedEvent = buildAssessmentConsequenceAppliedEvent;
+const neverthrow_1 = require("neverthrow");
+const constants_js_1 = require("../constants.js");
+function buildAssessmentConsequenceAppliedEvent(args) {
+    if (!args.sessionId)
+        return (0, neverthrow_1.err)({ code: 'ASSESSMENT_CONSEQUENCE_EVENT_INVARIANT_VIOLATION', message: 'sessionId is required' });
+    if (!args.attemptId)
+        return (0, neverthrow_1.err)({ code: 'ASSESSMENT_CONSEQUENCE_EVENT_INVARIANT_VIOLATION', message: 'attemptId is required' });
+    if (!args.scope.runId || !args.scope.nodeId) {
+        return (0, neverthrow_1.err)({ code: 'ASSESSMENT_CONSEQUENCE_EVENT_INVARIANT_VIOLATION', message: 'scope.runId and scope.nodeId are required' });
+    }
+    if (!args.assessmentId || !args.dimensionId || !args.level || !args.guidance) {
+        return (0, neverthrow_1.err)({ code: 'ASSESSMENT_CONSEQUENCE_EVENT_INVARIANT_VIOLATION', message: 'assessment consequence fields are required' });
+    }
+    return (0, neverthrow_1.ok)({
+        v: 1,
+        eventId: args.minted.eventId,
+        kind: constants_js_1.EVENT_KIND.ASSESSMENT_CONSEQUENCE_APPLIED,
+        dedupeKey: `assessment_consequence_applied:${args.sessionId}:${args.scope.nodeId}:${args.attemptId}`,
+        scope: { runId: args.scope.runId, nodeId: args.scope.nodeId },
+        data: {
+            attemptId: args.attemptId,
+            assessmentId: args.assessmentId,
+            trigger: {
+                dimensionId: args.dimensionId,
+                level: args.level,
+            },
+            effect: {
+                kind: 'require_followup',
+                guidance: args.guidance,
+            },
+        },
+    });
+}

package/dist/v2/durable-core/domain/assessment-record.d.ts

@@ -0,0 +1,12 @@
+export interface RecordedAssessmentDimensionV1 {
+    readonly dimensionId: string;
+    readonly level: string;
+    readonly rationale?: string;
+    readonly normalization: 'exact' | 'normalized';
+}
+export interface RecordedAssessmentV1 {
+    readonly assessmentId: string;
+    readonly summary?: string;
+    readonly dimensions: readonly RecordedAssessmentDimensionV1[];
+    readonly normalizationNotes: readonly string[];
+}

package/dist/v2/durable-core/domain/assessment-record.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/v2/durable-core/domain/assessment-recorded-event-builder.d.ts

@@ -0,0 +1,22 @@
+import { type Result } from 'neverthrow';
+import type { DomainEventV1 } from '../schemas/session/index.js';
+import type { RecordedAssessmentV1 } from './assessment-record.js';
+type EventToAppendV1 = Omit<DomainEventV1, 'eventIndex' | 'sessionId'>;
+export type AssessmentRecordedEventError = {
+    readonly code: 'ASSESSMENT_EVENT_INVARIANT_VIOLATION';
+    readonly message: string;
+};
+export declare function buildAssessmentRecordedEvent(args: {
+    readonly sessionId: string;
+    readonly attemptId: string;
+    readonly artifactOutputId: string;
+    readonly scope: {
+        readonly runId: string;
+        readonly nodeId: string;
+    };
+    readonly assessment: RecordedAssessmentV1;
+    readonly minted: {
+        readonly eventId: string;
+    };
+}): Result<EventToAppendV1, AssessmentRecordedEventError>;
+export {};

package/dist/v2/durable-core/domain/assessment-recorded-event-builder.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAssessmentRecordedEvent = buildAssessmentRecordedEvent;
+const neverthrow_1 = require("neverthrow");
+const constants_js_1 = require("../constants.js");
+function buildAssessmentRecordedEvent(args) {
+    if (!args.sessionId)
+        return (0, neverthrow_1.err)({ code: 'ASSESSMENT_EVENT_INVARIANT_VIOLATION', message: 'sessionId is required' });
+    if (!args.attemptId)
+        return (0, neverthrow_1.err)({ code: 'ASSESSMENT_EVENT_INVARIANT_VIOLATION', message: 'attemptId is required' });
+    if (!args.artifactOutputId)
+        return (0, neverthrow_1.err)({ code: 'ASSESSMENT_EVENT_INVARIANT_VIOLATION', message: 'artifactOutputId is required' });
+    if (!args.scope.runId || !args.scope.nodeId) {
+        return (0, neverthrow_1.err)({ code: 'ASSESSMENT_EVENT_INVARIANT_VIOLATION', message: 'scope.runId and scope.nodeId are required' });
+    }
+    if (!args.minted.eventId)
+        return (0, neverthrow_1.err)({ code: 'ASSESSMENT_EVENT_INVARIANT_VIOLATION', message: 'minted.eventId is required' });
+    return (0, neverthrow_1.ok)({
+        v: 1,
+        eventId: args.minted.eventId,
+        kind: constants_js_1.EVENT_KIND.ASSESSMENT_RECORDED,
+        dedupeKey: `assessment_recorded:${args.sessionId}:${args.scope.nodeId}:${args.attemptId}`,
+        scope: { runId: args.scope.runId, nodeId: args.scope.nodeId },
+        data: {
+            assessmentId: args.assessment.assessmentId,
+            attemptId: args.attemptId,
+            artifactOutputId: args.artifactOutputId,
+            summary: args.assessment.summary,
+            normalizationNotes: [...args.assessment.normalizationNotes],
+            dimensions: args.assessment.dimensions.map((dimension) => ({
+                dimensionId: dimension.dimensionId,
+                level: dimension.level,
+                normalization: dimension.normalization,
+                ...(dimension.rationale ? { rationale: dimension.rationale } : {}),
+            })),
+        },
+    });
+}

package/dist/v2/durable-core/domain/blocked-node-builder.d.ts

@@ -14,7 +14,7 @@ export declare function buildBlockedNodeSnapshot(args: {
     readonly priorSnapshot: ExecutionSnapshotFileV1;
     readonly primaryReason: ReasonV1;
     readonly attemptId: AttemptId;
-    readonly validationRef: string;
+    readonly validationRef?: string;
     readonly blockers: BlockerReportV1;
     readonly sha256: Sha256PortV2;
 }): Result<ExecutionSnapshotFileV1, BlockedNodeBuildError>;

package/dist/v2/durable-core/domain/blocked-node-builder.js

@@ -9,6 +9,14 @@ function toContractViolationReason(reason) {
             return { kind: 'invalid_required_output', contractRef: reason.contractRef };
         case 'missing_required_output':
             return { kind: 'missing_required_output', contractRef: reason.contractRef };
+        case 'assessment_followup_required':
+            return {
+                kind: 'assessment_followup_required',
+                assessmentId: reason.assessmentId,
+                dimensionId: reason.dimensionId,
+                level: reason.level,
+                guidance: reason.guidance,
+            };
         case 'missing_context_key':
             return { kind: 'missing_context_key', key: reason.key };
         case 'context_budget_exceeded':

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

@@ -34,4 +34,10 @@ export declare function detectBlockingReasonsV1(args: {
     readonly missingNotes?: {
         readonly stepId: string;
     };
+    readonly assessmentFollowupRequired?: {
+        readonly assessmentId: string;
+        readonly dimensionId: string;
+        readonly level: string;
+        readonly guidance: string;
+    };
 }): Result<readonly ReasonV1[], BlockingDecisionError>;

package/dist/v2/durable-core/domain/blocking-decision.js

@@ -63,5 +63,20 @@ function detectBlockingReasonsV1(args) {
         }
         reasons.push({ kind: 'missing_notes', stepId: args.missingNotes.stepId });
     }
+    if (args.assessmentFollowupRequired) {
+        if (!constants_js_1.DELIMITER_SAFE_ID_PATTERN.test(args.assessmentFollowupRequired.dimensionId)) {
+            return (0, neverthrow_1.err)({
+                code: 'INVALID_DELIMITER_SAFE_ID',
+                message: `assessment dimension ID must be delimiter-safe: [a-z0-9_-]+ (got: ${args.assessmentFollowupRequired.dimensionId})`,
+            });
+        }
+        reasons.push({
+            kind: 'assessment_followup_required',
+            assessmentId: args.assessmentFollowupRequired.assessmentId,
+            dimensionId: args.assessmentFollowupRequired.dimensionId,
+            level: args.assessmentFollowupRequired.level,
+            guidance: args.assessmentFollowupRequired.guidance,
+        });
+    }
     return (0, neverthrow_1.ok)(reasons);
 }

package/dist/v2/durable-core/domain/prompt-renderer.js

@@ -181,6 +181,18 @@ function formatOutputContractRequirements(outputContract) {
             ];
     }
 }
+function formatAssessmentRequirements(assessments) {
+    if (assessments.length === 0)
+        return [];
+    const requirements = [];
+    for (const assessment of assessments) {
+        requirements.push('Provide an artifact with kind: "wr.assessment"');
+        requirements.push(`Assessment target: "${assessment.id}"`);
+        requirements.push(`Dimensions: ${assessment.dimensions.map((dimension) => `${dimension.id} (${dimension.levels.join(' | ')})`).join(', ')}`);
+        requirements.push('Use only canonical dimension levels. If the engine rejects the artifact, correct the submitted levels instead of inventing new ones.');
+    }
+    return requirements;
+}
 function assembleFragmentedPrompt(fragments, context) {
     return fragments
         .filter(f => (0, condition_evaluator_js_1.evaluateCondition)(f.when, context))
@@ -217,6 +229,12 @@ function renderPendingPrompt(args) {
     const outputContract = 'outputContract' in step
         ? step.outputContract
         : undefined;
+    const stepAssessmentRefs = 'assessmentRefs' in step
+        ? step.assessmentRefs
+        : undefined;
+    const stepAssessments = stepAssessmentRefs && stepAssessmentRefs.length > 0
+        ? (args.workflow.definition.assessments ?? []).filter((assessment) => stepAssessmentRefs.includes(assessment.id))
+        : [];
     const isExitStep = outputContract?.contractRef === index_js_2.LOOP_CONTROL_CONTRACT_REF;
     const loopStep = resolveParentLoopStep(args.workflow, args.stepId);
     const maxIterations = loopStep?.loop.maxIterations;
@@ -247,6 +265,12 @@ function renderPendingPrompt(args) {
             ? `\n\n${contractRequirements.map(r => `- ${r}`).join('\n')}`
             : `\n\n**OUTPUT REQUIREMENTS (System):**\n${contractRequirements.map(r => `- ${r}`).join('\n')}`
         : '';
+    const assessmentRequirements = formatAssessmentRequirements(stepAssessments);
+    const assessmentSection = assessmentRequirements.length > 0
+        ? cleanResponseFormat
+            ? `\n\n${assessmentRequirements.map(r => `- ${r}`).join('\n')}`
+            : `\n\n**ASSESSMENT REQUIREMENTS (System):**\n${assessmentRequirements.map(r => `- ${r}`).join('\n')}`
+        : '';
     const isNotesOptional = outputContract !== undefined ||
         ('notesOptional' in step && step.notesOptional === true);
     const notesSection = (() => {
@@ -297,7 +321,7 @@ function renderPendingPrompt(args) {
     const fragmentSuffix = promptFragments && promptFragments.length > 0
         ? assembleFragmentedPrompt(promptFragments, renderContext)
         : '';
-    const enhancedPrompt = loopBanner + basePrompt + requirementsSection + contractSection + notesSection
+    const enhancedPrompt = loopBanner + basePrompt + requirementsSection + contractSection + assessmentSection + notesSection
         + (fragmentSuffix ? '\n\n' + fragmentSuffix : '');
     if (!args.rehydrateOnly) {
         return (0, neverthrow_1.ok)({ stepId: args.stepId, title: baseTitle, prompt: enhancedPrompt, agentRole, requireConfirmation });

package/dist/v2/durable-core/domain/reason-model.d.ts

@@ -8,7 +8,7 @@ export type GapReasonV1 = {
     readonly detail: UserOnlyDependencyReasonV1;
 } | {
     readonly category: 'contract_violation';
-    readonly detail: 'missing_required_output' | 'invalid_required_output' | 'missing_required_notes';
+    readonly detail: 'missing_required_output' | 'invalid_required_output' | 'missing_required_notes' | 'assessment_followup_required';
 } | {
     readonly category: 'capability_missing';
     readonly detail: 'required_capability_unavailable' | 'required_capability_unknown';
@@ -16,7 +16,7 @@ export type GapReasonV1 = {
     readonly category: 'unexpected';
     readonly detail: 'invariant_violation' | 'storage_corruption_detected' | 'evaluation_error';
 };
-export type BlockerCodeV1 = 'USER_ONLY_DEPENDENCY' | 'MISSING_REQUIRED_OUTPUT' | 'INVALID_REQUIRED_OUTPUT' | 'MISSING_REQUIRED_NOTES' | 'MISSING_CONTEXT_KEY' | 'CONTEXT_BUDGET_EXCEEDED' | 'REQUIRED_CAPABILITY_UNKNOWN' | 'REQUIRED_CAPABILITY_UNAVAILABLE' | 'INVARIANT_VIOLATION' | 'STORAGE_CORRUPTION_DETECTED';
+export type BlockerCodeV1 = 'USER_ONLY_DEPENDENCY' | 'MISSING_REQUIRED_OUTPUT' | 'INVALID_REQUIRED_OUTPUT' | 'ASSESSMENT_FOLLOWUP_REQUIRED' | 'MISSING_REQUIRED_NOTES' | 'MISSING_CONTEXT_KEY' | 'CONTEXT_BUDGET_EXCEEDED' | 'REQUIRED_CAPABILITY_UNKNOWN' | 'REQUIRED_CAPABILITY_UNAVAILABLE' | 'INVARIANT_VIOLATION' | 'STORAGE_CORRUPTION_DETECTED';
 export type BlockerPointerV1 = {
     readonly kind: 'context_key';
     readonly key: string;
@@ -28,6 +28,10 @@ export type BlockerPointerV1 = {
 } | {
     readonly kind: 'capability';
     readonly capability: CapabilityV2;
+} | {
+    readonly kind: 'assessment_dimension';
+    readonly assessmentId: string;
+    readonly dimensionId: string;
 } | {
     readonly kind: 'workflow_step';
     readonly stepId: string;
@@ -52,6 +56,12 @@ export type ReasonV1 = {
 } | {
     readonly kind: 'invalid_required_output';
     readonly contractRef: string;
+} | {
+    readonly kind: 'assessment_followup_required';
+    readonly assessmentId: string;
+    readonly dimensionId: string;
+    readonly level: string;
+    readonly guidance: string;
 } | {
     readonly kind: 'missing_notes';
     readonly stepId: string;

package/dist/v2/durable-core/domain/reason-model.js

@@ -8,6 +8,7 @@ exports.shouldBlock = shouldBlock;
 const constants_js_1 = require("../constants.js");
 const neverthrow_1 = require("neverthrow");
 const utf8_byte_length_js_1 = require("../schemas/lib/utf8-byte-length.js");
+const index_js_1 = require("../schemas/artifacts/index.js");
 function ensureDelimiterSafeId(label, value) {
     if (!constants_js_1.DELIMITER_SAFE_ID_PATTERN.test(value)) {
         return (0, neverthrow_1.err)({
@@ -58,6 +59,12 @@ function reasonToGap(reason) {
                 reason: { category: 'contract_violation', detail: 'invalid_required_output' },
                 summary: `Invalid required output for contractRef=${reason.contractRef}`,
             };
+        case 'assessment_followup_required':
+            return {
+                severity: 'critical',
+                reason: { category: 'contract_violation', detail: 'assessment_followup_required' },
+                summary: `Assessment follow-up required: ${reason.assessmentId}.${reason.dimensionId} == ${reason.level}`,
+            };
         case 'missing_notes':
             return {
                 severity: 'critical',
@@ -125,6 +132,9 @@ function blockerSortKey(b) {
         case 'capability':
             ptrStable = p.capability;
             break;
+        case 'assessment_dimension':
+            ptrStable = `${p.assessmentId}|${p.dimensionId}`;
+            break;
         case 'workflow_step':
             ptrStable = p.stepId;
             break;
@@ -162,7 +172,9 @@ function reasonToBlocker(reason) {
                 code: 'MISSING_REQUIRED_OUTPUT',
                 pointer: { kind: 'output_contract', contractRef },
                 message: `Missing required output (contractRef=${contractRef}).`,
-                suggestedFix: 'Call continue_workflow without output to rehydrate the current step, then retry with output.notesMarkdown that satisfies the step output requirements.',
+                suggestedFix: contractRef === index_js_1.ASSESSMENT_CONTRACT_REF
+                    ? 'Call continue_workflow without output to rehydrate the current step, then retry with an assessment artifact under output.artifacts using kind "wr.assessment" and the required canonical dimension levels.'
+                    : 'Call continue_workflow without output to rehydrate the current step, then retry with output.notesMarkdown that satisfies the step output requirements.',
             }))
                 .andThen(ensureBlockerTextBudgets);
         case 'invalid_required_output':
@@ -171,9 +183,22 @@ function reasonToBlocker(reason) {
                 code: 'INVALID_REQUIRED_OUTPUT',
                 pointer: { kind: 'output_contract', contractRef },
                 message: `Invalid output for contractRef=${contractRef}.`,
-                suggestedFix: 'Update output.notesMarkdown to satisfy validation. Then call continue_workflow without output to rehydrate the current step and retry advance with the corrected output. Replaying the same invalid advance will keep returning this blocked result.',
+                suggestedFix: contractRef === index_js_1.ASSESSMENT_CONTRACT_REF
+                    ? 'Update the assessment artifact in output.artifacts so it uses the expected assessment ID and canonical dimension levels. Then call continue_workflow without output to rehydrate the current step and retry with the corrected artifact.'
+                    : 'Update output.notesMarkdown to satisfy validation. Then call continue_workflow without output to rehydrate the current step and retry advance with the corrected output. Replaying the same invalid advance will keep returning this blocked result.',
             }))
                 .andThen(ensureBlockerTextBudgets);
+        case 'assessment_followup_required':
+            return ensureBlockerTextBudgets({
+                code: 'ASSESSMENT_FOLLOWUP_REQUIRED',
+                pointer: {
+                    kind: 'assessment_dimension',
+                    assessmentId: reason.assessmentId,
+                    dimensionId: reason.dimensionId,
+                },
+                message: `Follow-up required before this step can proceed: ${reason.assessmentId}.${reason.dimensionId} matched "${reason.level}".`,
+                suggestedFix: `Stay on this step, address this follow-up, and retry with updated output: ${reason.guidance}`,
+            });
         case 'missing_notes':
             return ensureDelimiterSafeId('workflow_step.stepId', reason.stepId)
                 .map((stepId) => ({

package/dist/v2/durable-core/domain/risk-policy-guardrails.js

@@ -6,6 +6,7 @@ function isNeverDowngradable(reason) {
     switch (reason.kind) {
         case 'missing_required_output':
         case 'invalid_required_output':
+        case 'assessment_followup_required':
         case 'missing_notes':
             return true;
         case 'user_only_dependency':

package/dist/v2/durable-core/domain/validation-criteria-validator.d.ts

@@ -11,6 +11,7 @@ export declare function getOutputRequirementStatusWithArtifactsV1(args: {
     readonly outputContract: OutputContract | undefined;
     readonly artifacts: readonly unknown[];
     readonly validationCriteria: ValidationCriteria | undefined;
+    readonly assessmentValidation?: ValidationResult;
     readonly notesMarkdown: string | undefined;
     readonly validation: ValidationResult | undefined;
 }): OutputRequirementStatus;

package/dist/v2/durable-core/domain/validation-criteria-validator.js

@@ -4,6 +4,7 @@ exports.VALIDATION_CRITERIA_CONTRACT_REF = void 0;
 exports.getOutputRequirementStatusV1 = getOutputRequirementStatusV1;
 exports.getOutputRequirementStatusWithArtifactsV1 = getOutputRequirementStatusWithArtifactsV1;
 const artifact_contract_validator_js_1 = require("./artifact-contract-validator.js");
+const index_js_1 = require("../schemas/artifacts/index.js");
 exports.VALIDATION_CRITERIA_CONTRACT_REF = 'wr.validationCriteria';
 function getOutputRequirementStatusV1(args) {
     if (!args.validationCriteria)
@@ -38,6 +39,16 @@ function getOutputRequirementStatusWithArtifactsV1(args) {
         }
         return { kind: 'satisfied' };
     }
+    if (args.assessmentValidation) {
+        if (!args.assessmentValidation.valid) {
+            return {
+                kind: 'invalid',
+                contractRef: index_js_1.ASSESSMENT_CONTRACT_REF,
+                validation: args.assessmentValidation,
+            };
+        }
+        return { kind: 'satisfied' };
+    }
     return getOutputRequirementStatusV1({
         validationCriteria: args.validationCriteria,
         notesMarkdown: args.notesMarkdown,

package/dist/v2/durable-core/schemas/artifacts/assessment.d.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+export declare const ASSESSMENT_CONTRACT_REF: "wr.contracts.assessment";
+export declare const AssessmentDimensionSubmissionSchema: z.ZodUnion<[z.ZodString, z.ZodObject<{
+    level: z.ZodString;
+    rationale: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    level: string;
+    rationale?: string | undefined;
+}, {
+    level: string;
+    rationale?: string | undefined;
+}>]>;
+export type AssessmentDimensionSubmission = z.infer<typeof AssessmentDimensionSubmissionSchema>;
+export declare const AssessmentArtifactV1Schema: z.ZodObject<{
+    kind: z.ZodLiteral<"wr.assessment">;
+    assessmentId: z.ZodOptional<z.ZodString>;
+    dimensions: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodObject<{
+        level: z.ZodString;
+        rationale: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        level: string;
+        rationale?: string | undefined;
+    }, {
+        level: string;
+        rationale?: string | undefined;
+    }>]>>, Record<string, string | {
+        level: string;
+        rationale?: string | undefined;
+    }>, Record<string, string | {
+        level: string;
+        rationale?: string | undefined;
+    }>>;
+    summary: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    kind: "wr.assessment";
+    dimensions: Record<string, string | {
+        level: string;
+        rationale?: string | undefined;
+    }>;
+    assessmentId?: string | undefined;
+    summary?: string | undefined;
+}, {
+    kind: "wr.assessment";
+    dimensions: Record<string, string | {
+        level: string;
+        rationale?: string | undefined;
+    }>;
+    assessmentId?: string | undefined;
+    summary?: string | undefined;
+}>;
+export type AssessmentArtifactV1 = z.infer<typeof AssessmentArtifactV1Schema>;
+export declare function isAssessmentArtifact(artifact: unknown): artifact is {
+    readonly kind: 'wr.assessment';
+};
+export declare function parseAssessmentArtifact(artifact: unknown): AssessmentArtifactV1 | null;

package/dist/v2/durable-core/schemas/artifacts/assessment.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssessmentArtifactV1Schema = exports.AssessmentDimensionSubmissionSchema = exports.ASSESSMENT_CONTRACT_REF = void 0;
+exports.isAssessmentArtifact = isAssessmentArtifact;
+exports.parseAssessmentArtifact = parseAssessmentArtifact;
+const zod_1 = require("zod");
+const MAX_ASSESSMENT_SUMMARY_LENGTH = 1024;
+const MAX_DIMENSION_RATIONALE_LENGTH = 512;
+exports.ASSESSMENT_CONTRACT_REF = 'wr.contracts.assessment';
+exports.AssessmentDimensionSubmissionSchema = zod_1.z.union([
+    zod_1.z.string().min(1),
+    zod_1.z.object({
+        level: zod_1.z.string().min(1),
+        rationale: zod_1.z.string().min(1).max(MAX_DIMENSION_RATIONALE_LENGTH).optional(),
+    }).strict(),
+]);
+exports.AssessmentArtifactV1Schema = zod_1.z.object({
+    kind: zod_1.z.literal('wr.assessment'),
+    assessmentId: zod_1.z.string().min(1).max(64).optional(),
+    dimensions: zod_1.z.record(exports.AssessmentDimensionSubmissionSchema).refine((value) => Object.keys(value).length > 0, 'dimensions must contain at least one entry'),
+    summary: zod_1.z.string().max(MAX_ASSESSMENT_SUMMARY_LENGTH).optional(),
+}).strict();
+function isAssessmentArtifact(artifact) {
+    return typeof artifact === 'object' && artifact !== null && artifact.kind === 'wr.assessment';
+}
+function parseAssessmentArtifact(artifact) {
+    const result = exports.AssessmentArtifactV1Schema.safeParse(artifact);
+    return result.success ? result.data : null;
+}