@exaudeus/workrail 3.16.0 → 3.18.0

package/dist/mcp/handlers/shared/request-workflow-reader.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearWalkCacheForTesting = clearWalkCacheForTesting;
 exports.hasRequestWorkspaceSignal = hasRequestWorkspaceSignal;
 exports.resolveRequestWorkspaceDirectory = resolveRequestWorkspaceDirectory;
 exports.toProjectWorkflowDirectory = toProjectWorkflowDirectory;
@@ -13,6 +14,27 @@ const path_1 = __importDefault(require("path"));
 const url_1 = require("url");
 const enhanced_multi_source_workflow_storage_js_1 = require("../../../infrastructure/storage/enhanced-multi-source-workflow-storage.js");
 const schema_validating_workflow_storage_js_1 = require("../../../infrastructure/storage/schema-validating-workflow-storage.js");
+const with_timeout_js_1 = require("./with-timeout.js");
+const SKIP_DIRS = new Set([
+    '.git', 'node_modules',
+    'build', 'dist', 'out', 'target',
+    '.gradle', '.gradle-cache', '.cache',
+    'DerivedData', 'Pods',
+    'vendor',
+    '__pycache__', '.venv', 'venv',
+    '.next', '.nuxt', '.turbo', '.parcel-cache',
+    '.claude', '.claude-worktrees', '.firebender',
+    'coverage', '.nyc_output',
+]);
+const MAX_WALK_DEPTH = 5;
+const WALK_CACHE_TTL_MS = 300000;
+const walkCache = new Map();
+const walkInFlight = new Map();
+function clearWalkCacheForTesting() {
+    walkCache.clear();
+    walkInFlight.clear();
+}
+const DISCOVERY_TIMEOUT_MS = 10000;
 function hasRequestWorkspaceSignal(options) {
     return Boolean(options.workspacePath) || (options.resolvedRootUris?.length ?? 0) > 0;
 }
@@ -34,18 +56,38 @@ function toProjectWorkflowDirectory(workspaceDirectory) {
         ? workspaceDirectory
         : path_1.default.join(workspaceDirectory, 'workflows');
 }
-async function discoverRootedWorkflowDirectories(roots) {
+function discoverRootedWorkflowDirectories(roots) {
+    const cacheKey = roots.map((r) => path_1.default.resolve(r)).sort().join('\0');
+    const now = Date.now();
+    const cached = walkCache.get(cacheKey);
+    if (cached && cached.expiresAt > now) {
+        return Promise.resolve(cached.result);
+    }
+    const inFlight = walkInFlight.get(cacheKey);
+    if (inFlight)
+        return inFlight;
+    const promise = _doWalk(cacheKey, roots, now);
+    walkInFlight.set(cacheKey, promise);
+    promise.then(() => walkInFlight.delete(cacheKey), () => walkInFlight.delete(cacheKey));
+    return promise;
+}
+async function _doWalk(cacheKey, roots, now) {
     const discoveredByPath = new Set();
     const discoveredPaths = [];
     const stalePaths = [];
-    for (const root of roots) {
-        const rootPath = path_1.default.resolve(root);
-        const result = await discoverWorkflowDirectoriesUnderRoot(rootPath);
-        if (result.stale) {
+    const resolvedRoots = roots.map((r) => path_1.default.resolve(r));
+    const rootResults = await Promise.allSettled(resolvedRoots.map((rootPath) => discoverWorkflowDirectoriesUnderRoot(rootPath)));
+    for (let i = 0; i < resolvedRoots.length; i++) {
+        const rootPath = resolvedRoots[i];
+        const rootResult = rootResults[i];
+        if (rootResult.status === 'rejected') {
+            throw rootResult.reason;
+        }
+        if (rootResult.value.stale) {
             stalePaths.push(rootPath);
             continue;
         }
-        for (const nextPath of result.discovered) {
+        for (const nextPath of rootResult.value.discovered) {
             const normalizedPath = path_1.default.resolve(nextPath);
             if (discoveredByPath.has(normalizedPath))
                 continue;
@@ -53,13 +95,22 @@ async function discoverRootedWorkflowDirectories(roots) {
             discoveredPaths.push(normalizedPath);
         }
     }
-    return { discovered: discoveredPaths, stale: stalePaths };
+    const result = { discovered: discoveredPaths, stale: stalePaths };
+    walkCache.set(cacheKey, { result, expiresAt: now + WALK_CACHE_TTL_MS });
+    return result;
 }
 async function createWorkflowReaderForRequest(options) {
     const workspaceDirectory = resolveRequestWorkspaceDirectory(options);
     const projectWorkflowDirectory = toProjectWorkflowDirectory(workspaceDirectory);
     const rememberedRoots = await listRememberedRoots(options.rememberedRootsStore);
-    const { discovered: rootedWorkflowDirectories, stale: stalePaths } = await discoverRootedWorkflowDirectories(rememberedRoots);
+    let discoveryResult;
+    try {
+        discoveryResult = await (0, with_timeout_js_1.withTimeout)(discoverRootedWorkflowDirectories(rememberedRoots), DISCOVERY_TIMEOUT_MS, 'workflow_root_discovery');
+    }
+    catch {
+        discoveryResult = { discovered: [], stale: [] };
+    }
+    const { discovered: rootedWorkflowDirectories, stale: stalePaths } = discoveryResult;
     const rootedCustomPaths = rootedWorkflowDirectories.filter((directory) => directory !== projectWorkflowDirectory);
     const { records: allManagedRecords, storeError: managedStoreError } = await listManagedSourceRecords(options.managedSourceStore);
     const envCustomPaths = parseWorkflowStoragePathEnv();
@@ -70,17 +121,30 @@ async function createWorkflowReaderForRequest(options) {
     const additionalManagedPaths = [];
     const activeManagedRecords = [];
     const staleManagedRecords = [];
+    const alreadyCovered = [];
+    const needsStatCheck = [];
     for (const record of allManagedRecords) {
         if (normalizedCustom.has(path_1.default.resolve(record.path))) {
-            activeManagedRecords.push(record);
-            continue;
-        }
-        if (await isDirectory(record.path)) {
-            additionalManagedPaths.push(record.path);
-            activeManagedRecords.push(record);
+            alreadyCovered.push(record);
         }
         else {
-            staleManagedRecords.push(record);
+            needsStatCheck.push(record);
+        }
+    }
+    activeManagedRecords.push(...alreadyCovered);
+    if (needsStatCheck.length > 0) {
+        const statResults = await (0, with_timeout_js_1.withTimeout)(Promise.allSettled(needsStatCheck.map((record) => isDirectory(record.path))), DISCOVERY_TIMEOUT_MS, 'managed_source_stat').catch(() => null);
+        for (let i = 0; i < needsStatCheck.length; i++) {
+            const record = needsStatCheck[i];
+            const result = statResults?.[i];
+            const isDir = result?.status === 'fulfilled' && result.value === true;
+            if (isDir) {
+                additionalManagedPaths.push(record.path);
+                activeManagedRecords.push(record);
+            }
+            else {
+                staleManagedRecords.push(record);
+            }
         }
     }
     const customPaths = [...rootedCustomPaths, ...additionalManagedPaths];
@@ -118,8 +182,8 @@ async function listRememberedRoots(rememberedRootsStore) {
         return [];
     const result = await rememberedRootsStore.listRoots();
     if (result.isErr()) {
-        const error = result.error;
-        throw new Error(`Failed to load remembered workflow roots: ${error.code}: ${error.message}`);
+        console.error(`[workrail] Failed to load remembered workflow roots: ${result.error.code}: ${result.error.message}`);
+        return [];
     }
     return result.value.map((root) => path_1.default.resolve(root));
 }
@@ -136,7 +200,7 @@ async function discoverWorkflowDirectoriesUnderRoot(rootPath) {
     }
     return { discovered: discoveredPaths, stale: false };
 }
-async function walkForRootedWorkflowDirectories(currentDirectory, discoveredPaths) {
+async function walkForRootedWorkflowDirectories(currentDirectory, discoveredPaths, depth = 0) {
     const entries = await promises_1.default.readdir(currentDirectory, { withFileTypes: true });
     const sortedEntries = [...entries].sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of sortedEntries) {
@@ -152,14 +216,20 @@ async function walkForRootedWorkflowDirectories(currentDirectory, discoveredPath
             }
             continue;
         }
-        await walkForRootedWorkflowDirectories(entryPath, discoveredPaths).catch((err) => {
+        if (depth >= MAX_WALK_DEPTH) {
+            if (process.env['WORKRAIL_DEV'] === '1') {
+                console.error(`[workrail] walk depth limit (${MAX_WALK_DEPTH}) reached at: ${entryPath}`);
+            }
+            continue;
+        }
+        await walkForRootedWorkflowDirectories(entryPath, discoveredPaths, depth + 1).catch((err) => {
             if (err.code !== 'ENOENT')
                 throw err;
         });
     }
 }
 function shouldSkipDirectory(name) {
-    return name === '.git' || name === 'node_modules';
+    return SKIP_DIRS.has(name);
 }
 async function isDirectory(targetPath) {
     try {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/mcp/handlers/v2-execution/continue-advance.d.ts

@@ -28,4 +28,5 @@ export declare function handleAdvanceIntent(args: {
     readonly sha256: Sha256PortV2;
     readonly aliasStore: import('../../../v2/ports/token-alias-store.port.js').TokenAliasStorePortV2;
     readonly entropy: import('../../../v2/ports/random-entropy.port.js').RandomEntropyPortV2;
+    readonly cleanResponseFormat?: boolean;
 }): RA<z.infer<typeof V2ContinueWorkflowOutputSchema>, ContinueWorkflowError>;

package/dist/mcp/handlers/v2-execution/continue-advance.js

@@ -11,7 +11,7 @@ const advance_js_1 = require("./advance.js");
 const sorted_event_log_js_1 = require("../../../v2/durable-core/sorted-event-log.js");
 const session_index_js_1 = require("../../../v2/durable-core/session-index.js");
 function handleAdvanceIntent(args) {
-    const { input, sessionId, runId, nodeId, attemptId, workflowHashRef, truth, gate, sessionStore, snapshotStore, pinnedStore, tokenCodecPorts, idFactory, sha256, aliasStore, entropy } = args;
+    const { input, sessionId, runId, nodeId, attemptId, workflowHashRef, truth, gate, sessionStore, snapshotStore, pinnedStore, tokenCodecPorts, idFactory, sha256, aliasStore, entropy, cleanResponseFormat } = args;
     const dedupeKey = `advance_recorded:${sessionId}:${nodeId}:${attemptId}`;
     const preLockSortedResult = (0, sorted_event_log_js_1.asSortedEventLog)(truth.events);
     if (preLockSortedResult.isErr()) {
@@ -101,6 +101,7 @@ function handleAdvanceIntent(args) {
                 tokenCodecPorts,
                 aliasStore,
                 entropy,
+                cleanResponseFormat,
             });
         }
         return gate
@@ -198,6 +199,7 @@ function handleAdvanceIntent(args) {
                 tokenCodecPorts,
                 aliasStore,
                 entropy,
+                cleanResponseFormat,
             });
         });
     });

package/dist/mcp/handlers/v2-execution/continue-rehydrate.d.ts

@@ -27,4 +27,5 @@ export declare function handleRehydrateIntent(args: {
     readonly aliasStore: import('../../../v2/ports/token-alias-store.port.js').TokenAliasStorePortV2;
     readonly entropy: import('../../../v2/ports/random-entropy.port.js').RandomEntropyPortV2;
     readonly resolvedRootUris?: readonly string[];
+    readonly cleanResponseFormat?: boolean;
 }): RA<RehydrateResult, ContinueWorkflowError>;

package/dist/mcp/handlers/v2-execution/continue-rehydrate.js

@@ -20,7 +20,7 @@ const index_js_2 = require("./index.js");
 const step_content_envelope_js_1 = require("../../step-content-envelope.js");
 const assert_output_js_1 = require("../../assert-output.js");
 function handleRehydrateIntent(args) {
-    const { input, sessionId, runId, nodeId, workflowHashRef, truth, tokenCodecPorts, pinnedStore, snapshotStore, idFactory, aliasStore, entropy, resolvedRootUris } = args;
+    const { input, sessionId, runId, nodeId, workflowHashRef, truth, tokenCodecPorts, pinnedStore, snapshotStore, idFactory, aliasStore, entropy, resolvedRootUris, cleanResponseFormat } = args;
     const runStarted = truth.events.find((e) => e.kind === constants_js_1.EVENT_KIND.RUN_STARTED && e.scope.runId === String(runId));
     const workflowId = runStarted?.data.workflowId;
     if (!runStarted || typeof workflowId !== 'string' || workflowId.trim() === '') {
@@ -124,6 +124,7 @@ function handleRehydrateIntent(args) {
                     runId: (0, index_js_1.asRunId)(String(runId)),
                     nodeId: (0, index_js_1.asNodeId)(String(nodeId)),
                     rehydrateOnly: true,
+                    cleanResponseFormat,
                 });
                 if (metaRes.isErr()) {
                     return (0, neverthrow_1.errAsync)({