@exaudeus/workrail 3.9.2 → 3.11.0

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/retrieval-contract.d.ts

@@ -0,0 +1,105 @@
+export type RetrievalPackSurface = 'rehydrate';
+export type ResumePreviewSurface = 'resume_preview';
+export type RetrievalPackTier = 'structural_context' | 'durable_recap' | 'reference_material';
+export type ResumePreviewTier = 'identity_context' | 'durable_recap';
+export interface RetrievalPackTierDefinition {
+    readonly tier: RetrievalPackTier;
+    readonly purpose: string;
+    readonly priority: number;
+    readonly retention: 'core' | 'tail';
+}
+export interface ResumePreviewTierDefinition {
+    readonly tier: ResumePreviewTier;
+    readonly purpose: string;
+    readonly priority: number;
+    readonly maxBytes: number;
+}
+export interface RetrievalPackTruncationPolicy {
+    readonly mode: 'drop_lower_tiers_then_global_utf8_trim';
+    readonly budgetScope: 'shared_recovery_prompt';
+    readonly antiReconstructionRule: 'select_order_and_compress_explicit_facts_only';
+}
+export interface RetrievalPackContract {
+    readonly surface: RetrievalPackSurface;
+    readonly tiers: readonly RetrievalPackTierDefinition[];
+    readonly truncation: RetrievalPackTruncationPolicy;
+}
+export interface ResumePreviewContract {
+    readonly surface: ResumePreviewSurface;
+    readonly tiers: readonly ResumePreviewTierDefinition[];
+    readonly budgetBytes: number;
+}
+export interface BranchSummarySegment {
+    readonly kind: 'branch_summary';
+    readonly tier: 'structural_context';
+    readonly source: 'deterministic_structure';
+    readonly title: 'Branch Summary';
+    readonly body: string;
+}
+export interface DownstreamRecapSegment {
+    readonly kind: 'downstream_recap';
+    readonly tier: 'structural_context';
+    readonly source: 'explicit_durable_fact';
+    readonly title: 'Downstream Recap (Preferred Branch)';
+    readonly body: string;
+}
+export interface AncestryRecapSegment {
+    readonly kind: 'ancestry_recap';
+    readonly tier: 'durable_recap';
+    readonly source: 'explicit_durable_fact';
+    readonly title: 'Ancestry Recap';
+    readonly body: string;
+}
+export interface FunctionDefinitionsSegment {
+    readonly kind: 'function_definitions';
+    readonly tier: 'reference_material';
+    readonly source: 'workflow_definition';
+    readonly title: 'Function Definitions';
+    readonly body: string;
+}
+export type RetrievalPackSegment = BranchSummarySegment | DownstreamRecapSegment | AncestryRecapSegment | FunctionDefinitionsSegment;
+export interface RetrievalPackRenderResult {
+    readonly text: string;
+    readonly includedTiers: readonly RetrievalPackTier[];
+    readonly omittedTierCount: number;
+    readonly truncatedWithinTier: boolean;
+}
+export interface SessionTitlePreviewSegment {
+    readonly kind: 'session_title_preview';
+    readonly tier: 'identity_context';
+    readonly source: 'persisted_context';
+    readonly body: string;
+}
+export interface RecapPreviewSegment {
+    readonly kind: 'recap_preview';
+    readonly tier: 'durable_recap';
+    readonly source: 'explicit_durable_fact';
+    readonly body: string;
+}
+export type ResumePreviewSegment = SessionTitlePreviewSegment | RecapPreviewSegment;
+export type ResumePreviewText = string & {
+    readonly __brand: 'ResumePreviewText';
+};
+export interface ResumePreviewRenderResult {
+    readonly text: ResumePreviewText;
+    readonly includedTiers: readonly ResumePreviewTier[];
+}
+export declare const REHYDRATE_RETRIEVAL_CONTRACT: RetrievalPackContract;
+export declare const RESUME_PREVIEW_CONTRACT: ResumePreviewContract;
+export declare function createBranchSummarySegment(body: string): BranchSummarySegment | null;
+export declare function createDownstreamRecapSegment(body: string): DownstreamRecapSegment | null;
+export declare function createAncestryRecapSegment(body: string): AncestryRecapSegment | null;
+export declare function createFunctionDefinitionsSegment(body: string): FunctionDefinitionsSegment | null;
+export declare function createSessionTitlePreviewSegment(body: string): SessionTitlePreviewSegment | null;
+export declare function createRecapPreviewSegment(body: string): RecapPreviewSegment | null;
+export declare function compareRetrievalPackSegments(a: RetrievalPackSegment, b: RetrievalPackSegment): number;
+export declare function orderRetrievalPackSegments(segments: readonly RetrievalPackSegment[]): readonly RetrievalPackSegment[];
+export declare function renderRetrievalPackSections(segments: readonly RetrievalPackSegment[]): readonly string[];
+export declare function renderBudgetedResumePreview(args: {
+    readonly segments: readonly ResumePreviewSegment[];
+    readonly focusTerms?: readonly string[];
+}): ResumePreviewRenderResult;
+export declare function renderBudgetedRehydrateRecovery(args: {
+    readonly header: string;
+    readonly segments: readonly RetrievalPackSegment[];
+}): RetrievalPackRenderResult;

package/dist/v2/durable-core/domain/retrieval-contract.js

@@ -0,0 +1,310 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESUME_PREVIEW_CONTRACT = exports.REHYDRATE_RETRIEVAL_CONTRACT = void 0;
+exports.createBranchSummarySegment = createBranchSummarySegment;
+exports.createDownstreamRecapSegment = createDownstreamRecapSegment;
+exports.createAncestryRecapSegment = createAncestryRecapSegment;
+exports.createFunctionDefinitionsSegment = createFunctionDefinitionsSegment;
+exports.createSessionTitlePreviewSegment = createSessionTitlePreviewSegment;
+exports.createRecapPreviewSegment = createRecapPreviewSegment;
+exports.compareRetrievalPackSegments = compareRetrievalPackSegments;
+exports.orderRetrievalPackSegments = orderRetrievalPackSegments;
+exports.renderRetrievalPackSections = renderRetrievalPackSections;
+exports.renderBudgetedResumePreview = renderBudgetedResumePreview;
+exports.renderBudgetedRehydrateRecovery = renderBudgetedRehydrateRecovery;
+const constants_js_1 = require("../constants.js");
+const REHYDRATE_TIER_DEFINITIONS = [
+    {
+        tier: 'structural_context',
+        purpose: 'Orient the agent to branch shape and preferred continuation path.',
+        priority: 0,
+        retention: 'core',
+    },
+    {
+        tier: 'durable_recap',
+        purpose: 'Surface durable notes captured from explicit recap outputs.',
+        priority: 1,
+        retention: 'core',
+    },
+    {
+        tier: 'reference_material',
+        purpose: 'Surface authored workflow definitions referenced by the current step.',
+        priority: 2,
+        retention: 'tail',
+    },
+];
+exports.REHYDRATE_RETRIEVAL_CONTRACT = {
+    surface: 'rehydrate',
+    tiers: REHYDRATE_TIER_DEFINITIONS,
+    truncation: {
+        mode: 'drop_lower_tiers_then_global_utf8_trim',
+        budgetScope: 'shared_recovery_prompt',
+        antiReconstructionRule: 'select_order_and_compress_explicit_facts_only',
+    },
+};
+const RESUME_PREVIEW_TIER_DEFINITIONS = [
+    {
+        tier: 'identity_context',
+        purpose: 'Surface the best concise identity hint for the session.',
+        priority: 0,
+        maxBytes: 320,
+    },
+    {
+        tier: 'durable_recap',
+        purpose: 'Surface durable recap text, focused around the user query when possible.',
+        priority: 1,
+        maxBytes: 1600,
+    },
+];
+exports.RESUME_PREVIEW_CONTRACT = {
+    surface: 'resume_preview',
+    tiers: RESUME_PREVIEW_TIER_DEFINITIONS,
+    budgetBytes: constants_js_1.MAX_RESUME_PREVIEW_BYTES,
+};
+const encoder = new TextEncoder();
+const decoder = new TextDecoder('utf-8');
+function getTierPriority(tier) {
+    return exports.REHYDRATE_RETRIEVAL_CONTRACT.tiers.find((candidate) => candidate.tier === tier)?.priority ?? Number.MAX_SAFE_INTEGER;
+}
+function getTierRetention(tier) {
+    return exports.REHYDRATE_RETRIEVAL_CONTRACT.tiers.find((candidate) => candidate.tier === tier)?.retention ?? 'tail';
+}
+function getResumePreviewTierPriority(tier) {
+    return exports.RESUME_PREVIEW_CONTRACT.tiers.find((candidate) => candidate.tier === tier)?.priority ?? Number.MAX_SAFE_INTEGER;
+}
+function getResumePreviewTierMaxBytes(tier) {
+    return exports.RESUME_PREVIEW_CONTRACT.tiers.find((candidate) => candidate.tier === tier)?.maxBytes ?? exports.RESUME_PREVIEW_CONTRACT.budgetBytes;
+}
+function compareAscii(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+function trimToUtf8Boundary(bytes) {
+    const n = bytes.length;
+    if (n === 0)
+        return bytes;
+    let cont = 0;
+    for (let i = n - 1; i >= 0 && i >= n - 4; i--) {
+        const b = bytes[i];
+        if ((b & 192) === 128) {
+            cont++;
+        }
+        else {
+            break;
+        }
+    }
+    if (cont === 0)
+        return bytes;
+    const leadByteIndex = n - cont - 1;
+    if (leadByteIndex < 0) {
+        return new Uint8Array(0);
+    }
+    const leadByte = bytes[leadByteIndex];
+    const expectedLen = (leadByte & 128) === 0 ? 1 :
+        (leadByte & 224) === 192 ? 2 :
+            (leadByte & 240) === 224 ? 3 :
+                (leadByte & 248) === 240 ? 4 :
+                    0;
+    const actualLen = cont + 1;
+    if (expectedLen === 0 || expectedLen !== actualLen) {
+        return bytes.subarray(0, leadByteIndex);
+    }
+    return bytes;
+}
+function truncateUtf8(text, maxBytes) {
+    const bytes = encoder.encode(text);
+    if (bytes.length <= maxBytes) {
+        return text;
+    }
+    return decoder.decode(trimToUtf8Boundary(bytes.subarray(0, Math.max(0, maxBytes))));
+}
+function buildOmissionSuffix(omittedTierCount) {
+    const omissionLine = omittedTierCount > 0
+        ? `\nOmitted ${omittedTierCount} lower-priority tier${omittedTierCount === 1 ? '' : 's'} due to budget constraints.`
+        : '\nOmitted recovery content due to budget constraints.';
+    return `${constants_js_1.TRUNCATION_MARKER}${omissionLine}`;
+}
+function trimFinalRecoveryText(text, omittedTierCount) {
+    const suffix = buildOmissionSuffix(omittedTierCount);
+    const maxContentBytes = constants_js_1.RECOVERY_BUDGET_BYTES - encoder.encode(suffix).length;
+    const truncated = truncateUtf8(text, maxContentBytes);
+    return truncated + suffix;
+}
+function normalizePreviewFocusTerms(focusTerms) {
+    return [...new Set(focusTerms.map((term) => term.trim().toLowerCase()).filter((term) => term.length >= 3))];
+}
+function findFocusIndex(text, focusTerms) {
+    if (focusTerms.length === 0)
+        return -1;
+    const lower = text.toLowerCase();
+    return focusTerms.reduce((bestIndex, term) => {
+        const idx = lower.indexOf(term);
+        if (idx === -1)
+            return bestIndex;
+        if (bestIndex === -1)
+            return idx;
+        return Math.min(bestIndex, idx);
+    }, -1);
+}
+function excerptAroundFocus(text, maxBytes, focusTerms) {
+    const focusIndex = findFocusIndex(text, focusTerms);
+    if (focusIndex === -1) {
+        const truncated = truncateUtf8(text, maxBytes);
+        return truncated.length < text.length ? `${truncated}...` : truncated;
+    }
+    const contextChars = Math.max(80, Math.floor(maxBytes / 4));
+    const start = Math.max(0, focusIndex - contextChars);
+    const end = Math.min(text.length, focusIndex + contextChars * 2);
+    const slice = text.slice(start, end).trim();
+    const prefix = start > 0 ? '...' : '';
+    const suffix = end < text.length ? '...' : '';
+    const excerpt = `${prefix}${slice}${suffix}`;
+    return truncateUtf8(excerpt, maxBytes);
+}
+function createBranchSummarySegment(body) {
+    const trimmed = body.trim();
+    return trimmed.length === 0
+        ? null
+        : {
+            kind: 'branch_summary',
+            tier: 'structural_context',
+            source: 'deterministic_structure',
+            title: 'Branch Summary',
+            body: trimmed,
+        };
+}
+function createDownstreamRecapSegment(body) {
+    const trimmed = body.trim();
+    return trimmed.length === 0
+        ? null
+        : {
+            kind: 'downstream_recap',
+            tier: 'structural_context',
+            source: 'explicit_durable_fact',
+            title: 'Downstream Recap (Preferred Branch)',
+            body: trimmed,
+        };
+}
+function createAncestryRecapSegment(body) {
+    const trimmed = body.trim();
+    return trimmed.length === 0
+        ? null
+        : {
+            kind: 'ancestry_recap',
+            tier: 'durable_recap',
+            source: 'explicit_durable_fact',
+            title: 'Ancestry Recap',
+            body: trimmed,
+        };
+}
+function createFunctionDefinitionsSegment(body) {
+    const trimmed = body.trim();
+    return trimmed.length === 0
+        ? null
+        : {
+            kind: 'function_definitions',
+            tier: 'reference_material',
+            source: 'workflow_definition',
+            title: 'Function Definitions',
+            body: trimmed,
+        };
+}
+function createSessionTitlePreviewSegment(body) {
+    const trimmed = body.trim();
+    return trimmed.length === 0
+        ? null
+        : {
+            kind: 'session_title_preview',
+            tier: 'identity_context',
+            source: 'persisted_context',
+            body: trimmed,
+        };
+}
+function createRecapPreviewSegment(body) {
+    const trimmed = body.trim();
+    return trimmed.length === 0
+        ? null
+        : {
+            kind: 'recap_preview',
+            tier: 'durable_recap',
+            source: 'explicit_durable_fact',
+            body: trimmed,
+        };
+}
+function compareRetrievalPackSegments(a, b) {
+    const tierDiff = getTierPriority(a.tier) - getTierPriority(b.tier);
+    if (tierDiff !== 0)
+        return tierDiff;
+    const titleDiff = compareAscii(a.title, b.title);
+    if (titleDiff !== 0)
+        return titleDiff;
+    return compareAscii(a.body, b.body);
+}
+function orderRetrievalPackSegments(segments) {
+    return [...segments].sort(compareRetrievalPackSegments);
+}
+function renderRetrievalPackSections(segments) {
+    return orderRetrievalPackSegments(segments).map((segment) => `### ${segment.title}\n${segment.body}`);
+}
+function compareResumePreviewSegments(a, b) {
+    const tierDiff = getResumePreviewTierPriority(a.tier) - getResumePreviewTierPriority(b.tier);
+    if (tierDiff !== 0)
+        return tierDiff;
+    return compareAscii(a.body, b.body);
+}
+function renderBudgetedResumePreview(args) {
+    const ordered = [...args.segments].sort(compareResumePreviewSegments);
+    if (ordered.length === 0) {
+        return { text: '', includedTiers: [] };
+    }
+    const focusTerms = normalizePreviewFocusTerms(args.focusTerms ?? []);
+    const tierTexts = ordered.map((segment) => {
+        const maxBytes = getResumePreviewTierMaxBytes(segment.tier);
+        return {
+            tier: segment.tier,
+            text: excerptAroundFocus(segment.body, maxBytes, focusTerms),
+        };
+    });
+    const joined = tierTexts.map((entry) => entry.text).filter((text) => text.length > 0).join('\n\n');
+    const finalText = truncateUtf8(joined, exports.RESUME_PREVIEW_CONTRACT.budgetBytes);
+    const includedTiers = [...new Set(tierTexts.filter((entry) => entry.text.length > 0).map((entry) => entry.tier))];
+    return { text: finalText, includedTiers };
+}
+function renderBudgetedRehydrateRecovery(args) {
+    const ordered = orderRetrievalPackSegments(args.segments);
+    if (ordered.length === 0) {
+        return { text: '', includedTiers: [], omittedTierCount: 0, truncatedWithinTier: false };
+    }
+    const tiersInOrder = exports.REHYDRATE_RETRIEVAL_CONTRACT.tiers.map((tier) => tier.tier);
+    const sectionsByTier = new Map(tiersInOrder.map((tier) => [tier, ordered.filter((segment) => segment.tier === tier).map((segment) => `### ${segment.title}\n${segment.body}`)]));
+    const renderFromTiers = (tiers) => {
+        const sections = tiers.flatMap((tier) => sectionsByTier.get(tier) ?? []);
+        return sections.length === 0 ? '' : `${args.header}\n\n${sections.join('\n\n')}`;
+    };
+    const initiallyIncludedTiers = tiersInOrder.filter((tier) => (sectionsByTier.get(tier) ?? []).length > 0);
+    let includedTiers = initiallyIncludedTiers;
+    let recoveryText = renderFromTiers(includedTiers);
+    while (encoder.encode(recoveryText).length > constants_js_1.RECOVERY_BUDGET_BYTES) {
+        const droppableTierIndex = [...includedTiers]
+            .reverse()
+            .findIndex((tier) => getTierRetention(tier) === 'tail');
+        if (droppableTierIndex === -1) {
+            break;
+        }
+        const actualIndex = includedTiers.length - 1 - droppableTierIndex;
+        includedTiers = includedTiers.filter((_, index) => index !== actualIndex);
+        recoveryText = renderFromTiers(includedTiers);
+    }
+    const omittedTierCount = initiallyIncludedTiers.length - includedTiers.length;
+    const needsSuffix = omittedTierCount > 0 || encoder.encode(recoveryText).length > constants_js_1.RECOVERY_BUDGET_BYTES || includedTiers.length === 0;
+    const finalText = recoveryText.length === 0
+        ? trimFinalRecoveryText(args.header, initiallyIncludedTiers.length)
+        : !needsSuffix
+            ? recoveryText
+            : trimFinalRecoveryText(recoveryText, omittedTierCount);
+    return {
+        text: finalText,
+        includedTiers,
+        omittedTierCount,
+        truncatedWithinTier: encoder.encode(recoveryText).length > constants_js_1.RECOVERY_BUDGET_BYTES || includedTiers.length === 0,
+    };
+}

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;
+}

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

@@ -1,4 +1,5 @@
+export { ASSESSMENT_CONTRACT_REF, AssessmentArtifactV1Schema, AssessmentDimensionSubmissionSchema, isAssessmentArtifact, parseAssessmentArtifact, type AssessmentArtifactV1, type AssessmentDimensionSubmission, } from './assessment.js';
 export { LOOP_CONTROL_CONTRACT_REF, LoopControlDecisionSchema, LoopControlMetadataV1Schema, LoopControlArtifactV1Schema, isLoopControlArtifact, parseLoopControlArtifact, findLoopControlArtifact, type LoopControlDecision, type LoopControlMetadataV1, type LoopControlArtifactV1, } from './loop-control.js';
-export declare const ARTIFACT_CONTRACT_REFS: readonly ["wr.contracts.loop_control"];
+export declare const ARTIFACT_CONTRACT_REFS: readonly ["wr.contracts.assessment", "wr.contracts.loop_control"];
 export type ArtifactContractRef = (typeof ARTIFACT_CONTRACT_REFS)[number];
 export declare function isValidContractRef(ref: string): ref is ArtifactContractRef;