@exaudeus/workrail 3.17.0 → 3.18.1

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/mcp/output-schemas.d.ts

@@ -1368,7 +1368,7 @@ export declare const V2BindingDriftWarningSchema: z.ZodObject<{
     currentValue: string;
 }>;
 export declare const V2StepContextSchema: z.ZodObject<{
-    assessments: z.ZodOptional<z.ZodObject<{
+    assessments: z.ZodOptional<z.ZodArray<z.ZodObject<{
         assessmentId: z.ZodString;
         dimensions: z.ZodArray<z.ZodObject<{
             dimensionId: z.ZodString;
@@ -1400,7 +1400,7 @@ export declare const V2StepContextSchema: z.ZodObject<{
             rationale?: string | undefined;
         }[];
         normalizationNotes: readonly string[];
-    }>>;
+    }>, "many">>;
 }, "strip", z.ZodTypeAny, {
     assessments?: {
         assessmentId: string;
@@ -1410,7 +1410,7 @@ export declare const V2StepContextSchema: z.ZodObject<{
             rationale?: string | undefined;
         }[];
         normalizationNotes: readonly string[];
-    } | undefined;
+    }[] | undefined;
 }, {
     assessments?: {
         assessmentId: string;
@@ -1420,7 +1420,7 @@ export declare const V2StepContextSchema: z.ZodObject<{
             rationale?: string | undefined;
         }[];
         normalizationNotes: readonly string[];
-    } | undefined;
+    }[] | undefined;
 }>;
 export declare const V2ContinueWorkflowOutputSchema: z.ZodEffects<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
     kind: z.ZodLiteral<"ok">;
@@ -1491,7 +1491,7 @@ export declare const V2ContinueWorkflowOutputSchema: z.ZodEffects<z.ZodDiscrimin
         currentValue: string;
     }>, "many">>;
     stepContext: z.ZodOptional<z.ZodObject<{
-        assessments: z.ZodOptional<z.ZodObject<{
+        assessments: z.ZodOptional<z.ZodArray<z.ZodObject<{
             assessmentId: z.ZodString;
             dimensions: z.ZodArray<z.ZodObject<{
                 dimensionId: z.ZodString;
@@ -1523,7 +1523,7 @@ export declare const V2ContinueWorkflowOutputSchema: z.ZodEffects<z.ZodDiscrimin
                 rationale?: string | undefined;
             }[];
             normalizationNotes: readonly string[];
-        }>>;
+        }>, "many">>;
     }, "strip", z.ZodTypeAny, {
         assessments?: {
             assessmentId: string;
@@ -1533,7 +1533,7 @@ export declare const V2ContinueWorkflowOutputSchema: z.ZodEffects<z.ZodDiscrimin
                 rationale?: string | undefined;
             }[];
             normalizationNotes: readonly string[];
-        } | undefined;
+        }[] | undefined;
     }, {
         assessments?: {
             assessmentId: string;
@@ -1543,7 +1543,7 @@ export declare const V2ContinueWorkflowOutputSchema: z.ZodEffects<z.ZodDiscrimin
                 rationale?: string | undefined;
             }[];
             normalizationNotes: readonly string[];
-        } | undefined;
+        }[] | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
     kind: "ok";
@@ -1582,7 +1582,7 @@ export declare const V2ContinueWorkflowOutputSchema: z.ZodEffects<z.ZodDiscrimin
                 rationale?: string | undefined;
             }[];
             normalizationNotes: readonly string[];
-        } | undefined;
+        }[] | undefined;
     } | undefined;
 }, {
     kind: "ok";
@@ -1621,7 +1621,7 @@ export declare const V2ContinueWorkflowOutputSchema: z.ZodEffects<z.ZodDiscrimin
                 rationale?: string | undefined;
             }[];
             normalizationNotes: readonly string[];
-        } | undefined;
+        }[] | undefined;
     } | undefined;
 }>, z.ZodObject<{
     kind: z.ZodLiteral<"blocked">;
@@ -2058,7 +2058,7 @@ export declare const V2ContinueWorkflowOutputSchema: z.ZodEffects<z.ZodDiscrimin
                 rationale?: string | undefined;
             }[];
             normalizationNotes: readonly string[];
-        } | undefined;
+        }[] | undefined;
     } | undefined;
 } | {
     kind: "blocked";
@@ -2155,7 +2155,7 @@ export declare const V2ContinueWorkflowOutputSchema: z.ZodEffects<z.ZodDiscrimin
                 rationale?: string | undefined;
             }[];
             normalizationNotes: readonly string[];
-        } | undefined;
+        }[] | undefined;
     } | undefined;
 } | {
     kind: "blocked";

package/dist/mcp/output-schemas.js

@@ -288,18 +288,17 @@ exports.V2BindingDriftWarningSchema = zod_1.z.object({
     pinnedValue: zod_1.z.string().min(1),
     currentValue: zod_1.z.string().min(1),
 });
+const V2StepContextAssessmentSchema = zod_1.z.object({
+    assessmentId: zod_1.z.string().min(1),
+    dimensions: zod_1.z.array(zod_1.z.object({
+        dimensionId: zod_1.z.string().min(1),
+        level: zod_1.z.string().min(1),
+        rationale: zod_1.z.string().optional(),
+    })),
+    normalizationNotes: zod_1.z.array(zod_1.z.string()).readonly(),
+});
 exports.V2StepContextSchema = zod_1.z.object({
-    assessments: zod_1.z
-        .object({
-        assessmentId: zod_1.z.string().min(1),
-        dimensions: zod_1.z.array(zod_1.z.object({
-            dimensionId: zod_1.z.string().min(1),
-            level: zod_1.z.string().min(1),
-            rationale: zod_1.z.string().optional(),
-        })),
-        normalizationNotes: zod_1.z.array(zod_1.z.string()).readonly(),
-    })
-        .optional(),
+    assessments: zod_1.z.array(V2StepContextAssessmentSchema).optional(),
 });
 const V2ContinueWorkflowOkSchema = zod_1.z.object({
     kind: zod_1.z.literal('ok'),

package/dist/types/workflow-source.js

@@ -75,7 +75,7 @@ function assertNever(x) {
 function getSourceDisplayName(source) {
     switch (source.kind) {
         case 'bundled':
-            return 'Built-in';
+            return 'WorkRail';
         case 'user':
             return 'User Library';
         case 'project':

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

@@ -10,9 +10,6 @@ export interface ObservationEventData {
     } | {
         readonly type: 'sha256';
         readonly value: string;
-    } | {
-        readonly type: 'path';
-        readonly value: string;
     };
     readonly confidence: 'low' | 'med' | 'high';
 }

package/dist/v2/durable-core/domain/observation-builder.js

@@ -34,11 +34,9 @@ function anchorsToObservations(anchors) {
                 });
                 break;
             case 'repo_root':
-                if (anchor.value.length > constants_js_1.MAX_OBSERVATION_PATH_LENGTH)
-                    break;
                 observations.push({
                     key: 'repo_root',
-                    value: { type: 'path', value: anchor.value },
+                    value: { type: 'short_string', value: anchor.value },
                     confidence: 'high',
                 });
                 break;

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

@@ -177,11 +177,19 @@ function formatOutputContractRequirements(outputContract) {
 function formatAssessmentRequirements(assessments) {
     if (assessments.length === 0)
         return [];
+    const multiRef = assessments.length > 1;
     const requirements = [];
     for (const assessment of assessments) {
         requirements.push('Provide an artifact with kind: "wr.assessment"');
+        if (multiRef) {
+            requirements.push(`Set assessmentId: "${assessment.id}" on the artifact so the engine can match it to the correct assessment.`);
+        }
         requirements.push(`Assessment target: "${assessment.id}"`);
-        requirements.push(`Dimensions: ${assessment.dimensions.map((dimension) => `${dimension.id} (${dimension.levels.join(' | ')})`).join(', ')}`);
+        requirements.push(`Purpose: ${assessment.purpose}`);
+        requirements.push('Dimensions:');
+        for (const dimension of assessment.dimensions) {
+            requirements.push(`  ${dimension.id} (${dimension.levels.join(' | ')}): ${dimension.purpose}`);
+        }
         requirements.push('Use only canonical dimension levels. If the engine rejects the artifact, correct the submitted levels instead of inventing new ones.');
     }
     return requirements;

package/dist/v2/infra/local/session-summary-provider/index.js

@@ -18,7 +18,6 @@ const EMPTY_OBSERVATIONS = {
     gitHeadSha: null,
     gitBranch: null,
     repoRootHash: null,
-    repoRoot: null,
 };
 const TITLE_CONTEXT_KEYS = ['goal', 'taskDescription', 'mrTitle', 'prTitle', 'ticketTitle', 'problem'];
 class LocalSessionSummaryProviderV2 {
@@ -137,7 +136,7 @@ function extractObservations(events) {
             case 'git_head_sha': return { ...acc, gitHeadSha: e.data.value.value };
             case 'git_branch': return { ...acc, gitBranch: e.data.value.value };
             case 'repo_root_hash': return { ...acc, repoRootHash: e.data.value.value };
-            case 'repo_root': return { ...acc, repoRoot: e.data.value.value };
+            case 'repo_root': return acc;
         }
     }, EMPTY_OBSERVATIONS);
 }

package/dist/v2/projections/resume-ranking.d.ts

@@ -8,7 +8,6 @@ export interface SessionObservations {
     readonly gitHeadSha: string | null;
     readonly gitBranch: string | null;
     readonly repoRootHash: string | null;
-    readonly repoRoot: string | null;
 }
 export type WorkflowIdentity = {
     readonly kind: 'unknown';