@exaudeus/workrail 3.14.0 → 3.16.0

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

@@ -0,0 +1,37 @@
+export declare function assertOutput<T>(data: T, check: (data: T) => void): T;
+type BlockerPointer = {
+    readonly kind: 'context_key';
+    readonly key: string;
+} | {
+    readonly kind: 'context_budget';
+} | {
+    readonly kind: 'output_contract';
+    readonly contractRef: string;
+} | {
+    readonly kind: 'capability';
+    readonly capability: string;
+} | {
+    readonly kind: 'assessment_dimension';
+    readonly assessmentId: string;
+    readonly dimensionId: string;
+} | {
+    readonly kind: 'workflow_step';
+    readonly stepId: string;
+};
+type BlockerLike = {
+    readonly code: string;
+    readonly pointer: BlockerPointer;
+};
+type BlockerReportLike = {
+    readonly blockers: readonly BlockerLike[];
+};
+export declare function assertBlockerReportInvariants(report: BlockerReportLike): void;
+type PendingLike = {
+    readonly stepId: string;
+} | null;
+type ContinueTokenHolder = {
+    readonly continueToken?: string | null | undefined;
+    readonly pending: PendingLike;
+};
+export declare function assertContinueTokenPresence(data: ContinueTokenHolder): void;
+export {};

package/dist/mcp/assert-output.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertOutput = assertOutput;
+exports.assertBlockerReportInvariants = assertBlockerReportInvariants;
+exports.assertContinueTokenPresence = assertContinueTokenPresence;
+function assertOutput(data, check) {
+    if (process.env['WORKRAIL_DEV'] === '1') {
+        check(data);
+    }
+    return data;
+}
+function assertBlockerReportInvariants(report) {
+    const keyFor = (b) => {
+        const p = b.pointer;
+        let ptrStable;
+        switch (p.kind) {
+            case 'context_key':
+                ptrStable = p.key;
+                break;
+            case 'output_contract':
+                ptrStable = p.contractRef;
+                break;
+            case 'capability':
+                ptrStable = p.capability;
+                break;
+            case 'assessment_dimension':
+                ptrStable = `${p.assessmentId}|${p.dimensionId}`;
+                break;
+            case 'workflow_step':
+                ptrStable = p.stepId;
+                break;
+            case 'context_budget':
+                ptrStable = '';
+                break;
+            default: {
+                const _exhaustive = p;
+                ptrStable = String(_exhaustive);
+            }
+        }
+        return `${b.code}|${p.kind}|${String(ptrStable)}`;
+    };
+    for (let i = 1; i < report.blockers.length; i++) {
+        if (keyFor(report.blockers[i - 1]) > keyFor(report.blockers[i])) {
+            throw new Error('assertOutput: blockers must be deterministically sorted by composite key');
+        }
+    }
+}
+function assertContinueTokenPresence(data) {
+    if (data.pending != null && data.continueToken == null) {
+        throw new Error('assertOutput: continueToken is required when a pending step exists');
+    }
+}

package/dist/mcp/boundary-coercion.d.ts

@@ -1,2 +1,3 @@
 import { z } from 'zod';
+export declare function buildCoercionFn(shapeSchema: z.ZodObject<z.ZodRawShape>, aliasMap?: Readonly<Record<string, string>>): (args: unknown) => unknown;
 export declare function coerceJsonStringObjectFields(args: unknown, shapeSchema: z.ZodObject<z.ZodRawShape>, aliasMap?: Readonly<Record<string, string>>): unknown;

package/dist/mcp/boundary-coercion.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCoercionFn = buildCoercionFn;
 exports.coerceJsonStringObjectFields = coerceJsonStringObjectFields;
 const zod_1 = require("zod");
+const schema_introspection_js_1 = require("./validation/schema-introspection.js");
 function unwrapToBaseType(schema) {
     let current = schema;
     for (;;) {
@@ -32,6 +34,48 @@ function tryParseJsonObject(value) {
         return null;
     }
 }
+function buildCoercionFn(shapeSchema, aliasMap) {
+    const shape = (0, schema_introspection_js_1.getCachedShape)(shapeSchema);
+    const objectFields = new Set();
+    for (const [key, fieldSchema] of Object.entries(shape)) {
+        if (expectsObjectValue(fieldSchema)) {
+            objectFields.add(key);
+        }
+    }
+    const aliasesToCoerce = new Set();
+    if (aliasMap) {
+        for (const [alias, canonical] of Object.entries(aliasMap)) {
+            if (objectFields.has(canonical)) {
+                aliasesToCoerce.add(alias);
+            }
+        }
+    }
+    const hasCoercibleFields = objectFields.size > 0 || aliasesToCoerce.size > 0;
+    return (args) => {
+        if (!hasCoercibleFields)
+            return args;
+        if (typeof args !== 'object' || args === null)
+            return args;
+        const input = args;
+        let result = null;
+        const coerceField = (key) => {
+            const value = input[key];
+            if (typeof value !== 'string')
+                return;
+            const parsed = tryParseJsonObject(value);
+            if (parsed === null)
+                return;
+            if (result === null)
+                result = { ...input };
+            result[key] = parsed;
+        };
+        for (const key of objectFields)
+            coerceField(key);
+        for (const alias of aliasesToCoerce)
+            coerceField(alias);
+        return result ?? args;
+    };
+}
 function coerceJsonStringObjectFields(args, shapeSchema, aliasMap) {
     if (typeof args !== 'object' || args === null)
         return args;

package/dist/mcp/dev-mode.d.ts

@@ -0,0 +1 @@
+export declare const DEV_MODE: boolean;

package/dist/mcp/dev-mode.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEV_MODE = void 0;
+exports.DEV_MODE = process.env['WORKRAIL_DEV'] === '1';

package/dist/mcp/handler-factory.js

@@ -36,7 +36,7 @@ function toMcpResult(result) {
             return {
                 content: [{
                         type: 'text',
-                        text: JSON.stringify(jsonPayload, null, 2),
+                        text: JSON.stringify(jsonPayload),
                     }],
             };
         }
@@ -49,17 +49,18 @@ function toMcpResult(result) {
                             message: result.message,
                             retry: result.retry,
                             ...(result.details !== undefined ? { details: result.details } : {}),
-                        }, null, 2),
+                        }),
                     }],
                 isError: true,
             };
     }
 }
 function createHandler(schema, handler, shapeSchema, aliasMap) {
+    const coerce = shapeSchema !== undefined
+        ? (0, boundary_coercion_js_1.buildCoercionFn)(shapeSchema, aliasMap)
+        : null;
     return async (args, ctx) => {
-        const normalizedArgs = shapeSchema !== undefined
-            ? (0, boundary_coercion_js_1.coerceJsonStringObjectFields)(args, shapeSchema, aliasMap)
-            : args;
+        const normalizedArgs = coerce !== null ? coerce(args) : args;
         const parseResult = schema.safeParse(normalizedArgs);
         if (!parseResult.success) {
             const introspectionSchema = shapeSchema ?? schema;
@@ -87,10 +88,12 @@ function createHandler(schema, handler, shapeSchema, aliasMap) {
     };
 }
 function createValidatingHandler(schema, preValidate, handler, shapeSchema, aliasMap) {
+    const coerce = shapeSchema !== undefined
+        ? (0, boundary_coercion_js_1.buildCoercionFn)(shapeSchema, aliasMap)
+        : null;
+    const innerHandler = createHandler(schema, handler, shapeSchema);
     return async (args, ctx) => {
-        const normalizedArgs = shapeSchema !== undefined
-            ? (0, boundary_coercion_js_1.coerceJsonStringObjectFields)(args, shapeSchema, aliasMap)
-            : args;
+        const normalizedArgs = coerce !== null ? coerce(args) : args;
         const pre = preValidate(normalizedArgs);
         if (!pre.ok) {
             const error = pre.error;
@@ -110,6 +113,6 @@ function createValidatingHandler(schema, preValidate, handler, shapeSchema, alia
             }
             return toMcpResult(error);
         }
-        return createHandler(schema, handler, shapeSchema, aliasMap)(normalizedArgs, ctx);
+        return innerHandler(normalizedArgs, ctx);
     };
 }

package/dist/mcp/handlers/session.js

@@ -5,7 +5,6 @@ exports.handleUpdateSession = handleUpdateSession;
 exports.handleReadSession = handleReadSession;
 exports.handleOpenDashboard = handleOpenDashboard;
 const types_js_1 = require("../types.js");
-const output_schemas_js_1 = require("../output-schemas.js");
 const SESSION_SCHEMA_OVERVIEW = {
     description: 'Bug Investigation Session Data Structure',
     mainSections: {
@@ -58,13 +57,13 @@ async function handleCreateSession(input, ctx) {
     const session = res.value;
     const baseUrl = httpServer.getBaseUrl();
     const dashboardUrl = baseUrl ? `${baseUrl}?session=${input.sessionId}` : null;
-    const payload = output_schemas_js_1.CreateSessionOutputSchema.parse({
+    const payload = {
         sessionId: session.id,
         workflowId: session.workflowId,
         path: sessionManager.getSessionPath(input.workflowId, input.sessionId),
         dashboardUrl,
         createdAt: session.createdAt,
-    });
+    };
     return (0, types_js_1.success)(payload);
 }
 async function handleUpdateSession(input, ctx) {
@@ -81,7 +80,7 @@ async function handleUpdateSession(input, ctx) {
         }
         return (0, types_js_1.errNotRetryable)('INTERNAL_ERROR', res.error.message);
     }
-    const payload = output_schemas_js_1.UpdateSessionOutputSchema.parse({ updatedAt: new Date().toISOString() });
+    const payload = { updatedAt: new Date().toISOString() };
     return (0, types_js_1.success)(payload);
 }
 async function handleReadSession(input, ctx) {
@@ -90,10 +89,10 @@ async function handleReadSession(input, ctx) {
         return guardError;
     const sessionManager = ctx.sessionManager;
     if (input.path === '$schema') {
-        const payload = output_schemas_js_1.ReadSessionSchemaOutputSchema.parse({
+        const payload = {
             query: '$schema',
             schema: SESSION_SCHEMA_OVERVIEW,
-        });
+        };
         return (0, types_js_1.success)(payload);
     }
     const res = await sessionManager.readSession(input.workflowId, input.sessionId, input.path);
@@ -105,10 +104,10 @@ async function handleReadSession(input, ctx) {
         }
         return (0, types_js_1.errNotRetryable)('INTERNAL_ERROR', res.error.message);
     }
-    const payload = output_schemas_js_1.ReadSessionOutputSchema.parse({
+    const payload = {
         query: input.path ?? '(full session)',
         data: res.value,
-    });
+    };
     return (0, types_js_1.success)(payload);
 }
 async function handleOpenDashboard(input, ctx) {
@@ -118,7 +117,7 @@ async function handleOpenDashboard(input, ctx) {
     const httpServer = ctx.httpServer;
     try {
         const url = await httpServer.openDashboard(input.sessionId);
-        const payload = output_schemas_js_1.OpenDashboardOutputSchema.parse({ url });
+        const payload = { url };
         return (0, types_js_1.success)(payload);
     }
     catch (err) {

package/dist/mcp/handlers/shared/request-workflow-reader.d.ts

@@ -1,12 +1,14 @@
 import type { IWorkflowReader } from '../../../types/storage.js';
 import type { IFeatureFlagProvider } from '../../../config/feature-flags.js';
 import type { RememberedRootsStorePortV2 } from '../../../v2/ports/remembered-roots-store.port.js';
+import type { ManagedSourceRecordV2, ManagedSourceStorePortV2 } from '../../../v2/ports/managed-source-store.port.js';
 export interface RequestWorkflowReaderOptions {
     readonly featureFlags: IFeatureFlagProvider;
     readonly workspacePath?: string;
     readonly resolvedRootUris?: readonly string[];
     readonly serverCwd?: string;
     readonly rememberedRootsStore?: RememberedRootsStorePortV2;
+    readonly managedSourceStore?: ManagedSourceStorePortV2;
 }
 export declare function hasRequestWorkspaceSignal(options: {
     readonly workspacePath?: string;
@@ -26,5 +28,8 @@ export declare function discoverRootedWorkflowDirectories(roots: readonly string
 export interface WorkflowReaderForRequestResult {
     readonly reader: IWorkflowReader;
     readonly stalePaths: readonly string[];
+    readonly managedSourceRecords: readonly ManagedSourceRecordV2[];
+    readonly staleManagedRecords: readonly ManagedSourceRecordV2[];
+    readonly managedStoreError?: string;
 }
 export declare function createWorkflowReaderForRequest(options: RequestWorkflowReaderOptions): Promise<WorkflowReaderForRequestResult>;

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

@@ -60,13 +60,58 @@ async function createWorkflowReaderForRequest(options) {
     const projectWorkflowDirectory = toProjectWorkflowDirectory(workspaceDirectory);
     const rememberedRoots = await listRememberedRoots(options.rememberedRootsStore);
     const { discovered: rootedWorkflowDirectories, stale: stalePaths } = await discoverRootedWorkflowDirectories(rememberedRoots);
-    const customPaths = rootedWorkflowDirectories.filter((directory) => directory !== projectWorkflowDirectory);
+    const rootedCustomPaths = rootedWorkflowDirectories.filter((directory) => directory !== projectWorkflowDirectory);
+    const { records: allManagedRecords, storeError: managedStoreError } = await listManagedSourceRecords(options.managedSourceStore);
+    const envCustomPaths = parseWorkflowStoragePathEnv();
+    const normalizedCustom = new Set([
+        ...rootedCustomPaths.map((p) => path_1.default.resolve(p)),
+        ...envCustomPaths.map((p) => path_1.default.resolve(p)),
+    ]);
+    const additionalManagedPaths = [];
+    const activeManagedRecords = [];
+    const staleManagedRecords = [];
+    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);
+        }
+        else {
+            staleManagedRecords.push(record);
+        }
+    }
+    const customPaths = [...rootedCustomPaths, ...additionalManagedPaths];
+    const allStalePaths = [...stalePaths, ...staleManagedRecords.map((r) => r.path)];
     const storage = (0, enhanced_multi_source_workflow_storage_js_1.createEnhancedMultiSourceWorkflowStorage)({
         customPaths,
         projectPath: projectWorkflowDirectory,
     }, options.featureFlags ?? undefined);
     const reader = new schema_validating_workflow_storage_js_1.SchemaValidatingCompositeWorkflowStorage(storage);
-    return { reader, stalePaths };
+    return {
+        reader,
+        stalePaths: allStalePaths,
+        managedSourceRecords: activeManagedRecords,
+        staleManagedRecords,
+        ...(managedStoreError !== undefined ? { managedStoreError } : {}),
+    };
+}
+function parseWorkflowStoragePathEnv() {
+    const raw = process.env['WORKFLOW_STORAGE_PATH'];
+    if (!raw)
+        return [];
+    return raw.split(path_1.default.delimiter).map((p) => p.trim()).filter((p) => p.length > 0);
+}
+async function listManagedSourceRecords(managedSourceStore) {
+    if (!managedSourceStore)
+        return { records: [] };
+    const result = await managedSourceStore.list();
+    if (result.isErr()) {
+        return { records: [], storeError: `${result.error.code}: ${result.error.message}` };
+    }
+    return { records: result.value };
 }
 async function listRememberedRoots(rememberedRootsStore) {
     if (!rememberedRootsStore)

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

@@ -3,7 +3,7 @@ import type { RecordedAssessmentV1 } from '../../../v2/durable-core/domain/asses
 export interface TriggeredAssessmentConsequenceV1 {
     readonly kind: 'require_followup';
     readonly assessmentId: string;
-    readonly triggerDimensionId: string;
+    readonly firstMatchedDimensionId: string;
     readonly triggerLevel: string;
     readonly guidance: string;
 }

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

@@ -10,15 +10,14 @@ function evaluateAssessmentConsequences(args) {
     const consequence = args.step.assessmentConsequences[0];
     if (!consequence)
         return undefined;
-    const matchedDimension = args.recordedAssessment.dimensions.find(dimension => dimension.dimensionId === consequence.when.dimensionId &&
-        dimension.level === consequence.when.equalsLevel);
-    if (!matchedDimension)
+    const matched = args.recordedAssessment.dimensions.find(d => d.level === consequence.when.anyEqualsLevel);
+    if (!matched)
         return undefined;
     return {
         kind: 'require_followup',
         assessmentId: args.recordedAssessment.assessmentId,
-        triggerDimensionId: consequence.when.dimensionId,
-        triggerLevel: consequence.when.equalsLevel,
+        firstMatchedDimensionId: matched.dimensionId,
+        triggerLevel: consequence.when.anyEqualsLevel,
         guidance: consequence.effect.guidance,
     };
 }

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

@@ -10,8 +10,10 @@ import type { V2ContinueWorkflowInput } from '../../v2/tools.js';
 import { type OutputToAppend } from '../../../v2/durable-core/domain/outputs.js';
 import type { InternalError } from '../v2-error-mapping.js';
 import type { AdvanceCorePorts } from './index.js';
+import type { SessionIndex } from '../../../v2/durable-core/session-index.js';
 type BuildAppendPlanArgs = {
     readonly truth: LoadedSessionTruthV2;
+    readonly lockedIndex: SessionIndex;
     readonly sessionId: SessionId;
     readonly runId: RunId;
     readonly currentNodeId: NodeId;

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

@@ -11,15 +11,15 @@ const outputs_js_1 = require("../../../v2/durable-core/domain/outputs.js");
 const ack_advance_append_plan_js_1 = require("../../../v2/durable-core/domain/ack-advance-append-plan.js");
 const constants_js_1 = require("../../../v2/durable-core/constants.js");
 function buildAndAppendPlan(args) {
-    const { truth, sessionId, runId, currentNodeId, attemptId, workflowHash, extraEventsToAppend, sessionStore, idFactory, lock } = args;
-    const nextEventIndex = truth.events.length === 0 ? 0 : truth.events[truth.events.length - 1].eventIndex + 1;
+    const { truth, lockedIndex, sessionId, runId, currentNodeId, attemptId, workflowHash, extraEventsToAppend, sessionStore, idFactory, lock } = args;
+    const nextEventIndex = lockedIndex.nextEventIndex;
     const evtAdvanceRecorded = idFactory.mintEventId();
     if (args.kind === 'blocked') {
         const toNodeId = String(idFactory.mintNodeId());
         const evtNodeCreated = idFactory.mintEventId();
         const evtEdgeCreated = idFactory.mintEventId();
         const outputEventIds = (args.outputsToAppend ?? []).map(() => idFactory.mintEventId());
-        const hasChildren = truth.events.some((e) => e.kind === constants_js_1.EVENT_KIND.EDGE_CREATED && e.data.fromNodeId === String(currentNodeId));
+        const hasChildren = lockedIndex.hasChildEdgeByFromNodeId.has(String(currentNodeId));
         const causeKind = hasChildren ? constants_js_1.EDGE_CAUSE.NON_TIP_ADVANCE : constants_js_1.EDGE_CAUSE.INTENTIONAL_FORK;
         const planRes = (0, ack_advance_append_plan_js_1.buildAckAdvanceAppendPlanV1)({
             sessionId: String(sessionId),
@@ -44,12 +44,12 @@ function buildAndAppendPlan(args) {
         });
         if (planRes.isErr())
             return (0, neverthrow_1.errAsync)({ kind: 'invariant_violation', message: planRes.error.message });
-        return sessionStore.append(lock, planRes.value);
+        return sessionStore.append(lock, planRes.value, truth);
     }
     const toNodeId = String(idFactory.mintNodeId());
     const evtNodeCreated = idFactory.mintEventId();
     const evtEdgeCreated = idFactory.mintEventId();
-    const hasChildren = truth.events.some((e) => e.kind === constants_js_1.EVENT_KIND.EDGE_CREATED && e.data.fromNodeId === String(currentNodeId));
+    const hasChildren = lockedIndex.hasChildEdgeByFromNodeId.has(String(currentNodeId));
     const causeKind = hasChildren ? constants_js_1.EDGE_CAUSE.NON_TIP_ADVANCE : constants_js_1.EDGE_CAUSE.INTENTIONAL_FORK;
     const normalizedOutputs = (0, outputs_js_1.normalizeOutputsForAppend)(args.outputsToAppend);
     const outputEventIds = normalizedOutputs.map(() => idFactory.mintEventId());
@@ -76,7 +76,7 @@ function buildAndAppendPlan(args) {
     });
     if (planRes.isErr())
         return (0, neverthrow_1.errAsync)({ kind: 'invariant_violation', message: planRes.error.message });
-    return sessionStore.append(lock, planRes.value);
+    return sessionStore.append(lock, planRes.value, truth);
 }
 function buildNotesOutputs(allowNotesAppend, attemptId, inputOutput) {
     if (!allowNotesAppend || !inputOutput?.notesMarkdown)

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

@@ -1,4 +1,5 @@
 import { ResultAsync as RA } from 'neverthrow';
+import type { SessionIndex } from '../../../v2/durable-core/session-index.js';
 import type { ExecutionSnapshotFileV1, EngineStateV1 } from '../../../v2/durable-core/schemas/execution-snapshot/index.js';
 import type { SessionId, RunId, NodeId, WorkflowHash } from '../../../v2/durable-core/ids/index.js';
 import type { AttemptId } from '../../../v2/durable-core/tokens/index.js';
@@ -63,4 +64,5 @@ export declare function executeAdvanceCore(args: {
     readonly lock: WithHealthySessionLock;
     readonly pinnedWorkflow: ReturnType<typeof createWorkflow>;
     readonly ports: AdvanceCorePorts;
+    readonly lockedIndex: SessionIndex;
 }): RA<void, InternalError | SessionEventLogStoreError | SnapshotStoreError>;

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

@@ -39,6 +39,7 @@ function executeAdvanceCore(args) {
     }
     const validatedRes = (0, input_validation_js_1.validateAdvanceInputs)({
         truth, runId, currentNodeId, inputContext, inputOutput, pinnedWorkflow, pendingStep,
+        precomputedIndex: args.lockedIndex,
     });
     if (validatedRes.isErr())
         return errAsync(validatedRes.error);
@@ -71,7 +72,7 @@ function executeAdvanceCore(args) {
             const ctx = { truth, sessionId, runId, currentNodeId, attemptId, workflowHash, inputOutput, pinnedWorkflow, engineState, pendingStep };
             const computed = { reasons: effectiveReasons, outputRequirement, validation: evalValidation };
             const portsLocal = { snapshotStore, sessionStore, sha256, idFactory };
-            return (0, outcome_blocked_js_1.buildBlockedOutcome)({ mode, snap, ctx, computed, v, lock, ports: portsLocal });
+            return (0, outcome_blocked_js_1.buildBlockedOutcome)({ mode, snap, ctx, computed, v, lock, ports: portsLocal, lockedIndex: args.lockedIndex });
         }
         const validation = phase.validation;
         const effectiveValidation = v.assessmentValidation && !v.assessmentValidation.validation.valid
@@ -94,7 +95,7 @@ function executeAdvanceCore(args) {
             assessmentFollowupRequired: v.triggeredAssessmentConsequence
                 ? {
                     assessmentId: v.triggeredAssessmentConsequence.assessmentId,
-                    dimensionId: v.triggeredAssessmentConsequence.triggerDimensionId,
+                    dimensionId: v.triggeredAssessmentConsequence.firstMatchedDimensionId,
                     level: v.triggeredAssessmentConsequence.triggerLevel,
                     guidance: v.triggeredAssessmentConsequence.guidance,
                 }
@@ -110,9 +111,9 @@ function executeAdvanceCore(args) {
         const computed = { reasons, outputRequirement, validation: effectiveValidation };
         const ports = { snapshotStore, sessionStore, sha256, idFactory };
         if (shouldBlockNow) {
-            return (0, outcome_blocked_js_1.buildBlockedOutcome)({ mode, snap, ctx, computed, v, lock, ports });
+            return (0, outcome_blocked_js_1.buildBlockedOutcome)({ mode, snap, ctx, computed, v, lock, ports, lockedIndex: args.lockedIndex });
         }
-        return (0, outcome_success_js_1.buildSuccessOutcome)({ mode, ctx, computed, v, lock, ports });
+        return (0, outcome_success_js_1.buildSuccessOutcome)({ mode, ctx, computed, v, lock, ports, lockedIndex: args.lockedIndex });
     });
 }
 function derivePendingStepForMode(mode, engineState) {

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

@@ -9,6 +9,7 @@ import type { AssessmentArtifactV1 } from '../../../v2/durable-core/schemas/arti
 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';
 export interface ValidatedAdvanceInputs {
     readonly pendingStep: {
         readonly stepId: string;
@@ -50,4 +51,5 @@ export declare function validateAdvanceInputs(args: {
             readonly iteration: number;
         }[];
     };
+    readonly precomputedIndex?: SessionIndex;
 }): Result<ValidatedAdvanceInputs, InternalError>;

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

@@ -5,14 +5,28 @@ const neverthrow_1 = require("neverthrow");
 const workflow_js_1 = require("../../../types/workflow.js");
 const run_context_js_1 = require("../../../v2/projections/run-context.js");
 const preferences_js_1 = require("../../../v2/projections/preferences.js");
+const sorted_event_log_js_1 = require("../../../v2/durable-core/sorted-event-log.js");
 const context_merge_js_1 = require("../../../v2/durable-core/domain/context-merge.js");
 const constants_js_1 = require("../../../v2/durable-core/constants.js");
 const assessment_validation_js_1 = require("./assessment-validation.js");
 const assessment_consequences_js_1 = require("./assessment-consequences.js");
 function validateAdvanceInputs(args) {
     const { truth, runId, currentNodeId, inputContext, inputOutput, pinnedWorkflow, pendingStep } = args;
-    const storedContextRes = (0, run_context_js_1.projectRunContextV2)(truth.events);
-    const storedContext = storedContextRes.isOk() ? storedContextRes.value.byRunId[String(runId)]?.context : undefined;
+    let sortedEvents;
+    let storedContext;
+    if (args.precomputedIndex) {
+        sortedEvents = args.precomputedIndex.sortedEvents;
+        storedContext = args.precomputedIndex.runContextByRunId.get(String(runId));
+    }
+    else {
+        const sortedEventsRes = (0, sorted_event_log_js_1.asSortedEventLog)(truth.events);
+        if (sortedEventsRes.isErr()) {
+            return (0, neverthrow_1.err)({ kind: 'invariant_violation', message: sortedEventsRes.error.message });
+        }
+        sortedEvents = sortedEventsRes.value;
+        const storedContextRes = (0, run_context_js_1.projectRunContextV2)(sortedEvents);
+        storedContext = storedContextRes.isOk() ? storedContextRes.value.byRunId[String(runId)]?.context : undefined;
+    }
     const inputContextObj = inputContext && typeof inputContext === 'object' && inputContext !== null && !Array.isArray(inputContext)
         ? inputContext
         : undefined;
@@ -39,14 +53,23 @@ function validateAdvanceInputs(args) {
     const notesOptional = outputContract !== undefined ||
         (step !== null && step !== undefined && 'notesOptional' in step && step.notesOptional === true);
     const parentByNodeId = {};
-    for (const e of truth.events) {
-        if (e.kind !== constants_js_1.EVENT_KIND.NODE_CREATED)
-            continue;
-        if (e.scope?.runId !== String(runId))
-            continue;
-        parentByNodeId[String(e.scope.nodeId)] = e.data.parentNodeId;
+    if (args.precomputedIndex) {
+        for (const [nodeId, evt] of args.precomputedIndex.nodeCreatedByNodeId) {
+            if (evt.scope.runId === String(runId)) {
+                parentByNodeId[nodeId] = evt.data.parentNodeId ?? null;
+            }
+        }
+    }
+    else {
+        for (const e of truth.events) {
+            if (e.kind !== constants_js_1.EVENT_KIND.NODE_CREATED)
+                continue;
+            if (e.scope?.runId !== String(runId))
+                continue;
+            parentByNodeId[String(e.scope.nodeId)] = e.data.parentNodeId;
+        }
     }
-    const prefs = (0, preferences_js_1.projectPreferencesV2)(truth.events, parentByNodeId);
+    const prefs = (0, preferences_js_1.projectPreferencesV2)(sortedEvents, parentByNodeId);
     const effectivePrefs = prefs.isOk() ? prefs.value.byNodeId[String(currentNodeId)]?.effective : undefined;
     const rawAutonomy = effectivePrefs?.autonomy ?? 'guided';
     const rawRiskPolicy = effectivePrefs?.riskPolicy ?? 'conservative';

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

@@ -1,4 +1,5 @@
 import { ResultAsync as RA } from 'neverthrow';
+import type { SessionIndex } from '../../../v2/durable-core/session-index.js';
 import type { ExecutionSnapshotFileV1 } from '../../../v2/durable-core/schemas/execution-snapshot/index.js';
 import type { SessionEventLogStoreError } from '../../../v2/ports/session-event-log-store.port.js';
 import type { SnapshotStoreError } from '../../../v2/ports/snapshot-store.port.js';
@@ -15,4 +16,5 @@ export declare function buildBlockedOutcome(args: {
     readonly v: ValidatedAdvanceInputs;
     readonly lock: WithHealthySessionLock;
     readonly ports: AdvanceCorePorts;
+    readonly lockedIndex: SessionIndex;
 }): RA<void, InternalError | SessionEventLogStoreError | SnapshotStoreError>;

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

@@ -89,7 +89,7 @@ function buildBlockedOutcome(args) {
             attemptId: String(attemptId),
             scope: { runId: String(runId), nodeId: String(currentNodeId) },
             assessmentId: validated.triggeredAssessmentConsequence.assessmentId,
-            dimensionId: validated.triggeredAssessmentConsequence.triggerDimensionId,
+            dimensionId: validated.triggeredAssessmentConsequence.firstMatchedDimensionId,
             level: validated.triggeredAssessmentConsequence.triggerLevel,
             guidance: validated.triggeredAssessmentConsequence.guidance,
             minted: { eventId: idFactory.mintEventId() },
@@ -102,7 +102,7 @@ function buildBlockedOutcome(args) {
     return snapshotStore.putExecutionSnapshotV1(blockedSnapshotRes.value).andThen((blockedSnapshotRef) => {
         return (0, event_builders_js_1.buildAndAppendPlan)({
             kind: 'blocked',
-            truth, sessionId, runId, currentNodeId, attemptId, workflowHash,
+            truth, lockedIndex: args.lockedIndex, sessionId, runId, currentNodeId, attemptId, workflowHash,
             extraEventsToAppend, blockers: blockersRes.value, snapshotRef: blockedSnapshotRef,
             outputsToAppend,
             sessionStore, idFactory, lock,

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

@@ -1,4 +1,5 @@
 import { ResultAsync as RA } from 'neverthrow';
+import type { SessionIndex } from '../../../v2/durable-core/session-index.js';
 import type { SessionEventLogStoreError } from '../../../v2/ports/session-event-log-store.port.js';
 import type { SnapshotStoreError } from '../../../v2/ports/snapshot-store.port.js';
 import type { WithHealthySessionLock } from '../../../v2/durable-core/ids/with-healthy-session-lock.js';
@@ -12,4 +13,5 @@ export declare function buildSuccessOutcome(args: {
     readonly v: ValidatedAdvanceInputs;
     readonly lock: WithHealthySessionLock;
     readonly ports: AdvanceCorePorts;
+    readonly lockedIndex: SessionIndex;
 }): RA<void, InternalError | SessionEventLogStoreError | SnapshotStoreError>;

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

@@ -149,7 +149,7 @@ function buildSuccessOutcome(args) {
         const outputsToAppend = [...notesOutputs, ...artifactOutputsRes.value];
         return (0, event_builders_js_1.buildAndAppendPlan)({
             kind: 'advanced',
-            truth, sessionId, runId, currentNodeId, attemptId, workflowHash,
+            truth, lockedIndex: args.lockedIndex, sessionId, runId, currentNodeId, attemptId, workflowHash,
             extraEventsToAppend, toNodeKind: successNodeKind(mode),
             snapshotRef: newSnapshotRef, outputsToAppend,
             sessionStore, idFactory, lock,