@exaudeus/workrail 3.15.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/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
@@ -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

@@ -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,

package/dist/mcp/handlers/v2-checkpoint.d.ts

@@ -2,7 +2,7 @@ import type { z } from 'zod';
 import type { ResultAsync as RA } from 'neverthrow';
 import type { ToolContext, ToolResult, V2ToolContext } from '../types.js';
 import type { V2CheckpointWorkflowInput } from '../v2/tools.js';
-import { V2CheckpointWorkflowOutputSchema } from '../output-schemas.js';
+import type { V2CheckpointWorkflowOutputSchema } from '../output-schemas.js';
 import { type ToolFailure } from './v2-execution-helpers.js';
 import type { ExecutionSessionGateErrorV2 } from '../../v2/usecases/execution-session-gate.js';
 import type { SessionEventLogStoreError } from '../../v2/ports/session-event-log-store.port.js';

package/dist/mcp/handlers/v2-checkpoint.js

@@ -4,7 +4,6 @@ exports.handleV2CheckpointWorkflow = handleV2CheckpointWorkflow;
 exports.executeCheckpoint = executeCheckpoint;
 const neverthrow_1 = require("neverthrow");
 const types_js_1 = require("../types.js");
-const output_schemas_js_1 = require("../output-schemas.js");
 const v2_token_ops_js_1 = require("./v2-token-ops.js");
 const v2_execution_helpers_js_1 = require("./v2-execution-helpers.js");
 const index_js_1 = require("../../v2/durable-core/ids/index.js");
@@ -107,11 +106,11 @@ function replayCheckpoint(events, dedupeKey, originalNode, sessionId, runId, nod
         .andThen((resumeTokenValue) => (0, v2_token_ops_js_1.mintContinueAndCheckpointTokens)({
         entry: { sessionId: String(sessionId), runId: String(runId), nodeId: String(nodeId), attemptId: String(attemptId), workflowHashRef },
         ports: tokenCodecPorts, aliasStore, entropy,
-    }).andThen(({ continueToken }) => (0, neverthrow_1.okAsync)(output_schemas_js_1.V2CheckpointWorkflowOutputSchema.parse({
+    }).andThen(({ continueToken }) => (0, neverthrow_1.okAsync)({
         checkpointNodeId,
         resumeToken: resumeTokenValue,
         nextCall: { tool: 'continue_workflow', params: { continueToken } },
-    }))))
+    })))
         .mapErr((e) => ({ kind: 'store_failed', cause: e }));
 }
 function writeCheckpoint(truth, dedupeKey, originalNode, sessionId, runId, nodeId, attemptId, checkpointNodeId, mintEventId, lock, sessionStore, tokenCodecPorts, aliasStore, entropy) {
@@ -161,7 +160,7 @@ function writeCheckpoint(truth, dedupeKey, originalNode, sessionId, runId, nodeI
             eventIndex: truth.events.length,
             createdByEventId: nodeCreatedEventId,
         }];
-    return sessionStore.append(lock, { events: validated, snapshotPins })
+    return sessionStore.append(lock, { events: validated, snapshotPins }, truth)
         .mapErr((cause) => ({ kind: 'store_failed', cause }))
         .andThen(() => {
         const workflowHashRefRes = (0, workflow_hash_ref_js_1.deriveWorkflowHashRef)(originalNode.data.workflowHash);
@@ -170,11 +169,11 @@ function writeCheckpoint(truth, dedupeKey, originalNode, sessionId, runId, nodeI
             .andThen((resumeTokenValue) => (0, v2_token_ops_js_1.mintContinueAndCheckpointTokens)({
             entry: { sessionId: String(sessionId), runId: String(runId), nodeId: String(nodeId), attemptId: String(attemptId), workflowHashRef },
             ports: tokenCodecPorts, aliasStore, entropy,
-        }).andThen(({ continueToken }) => (0, neverthrow_1.okAsync)(output_schemas_js_1.V2CheckpointWorkflowOutputSchema.parse({
+        }).andThen(({ continueToken }) => (0, neverthrow_1.okAsync)({
             checkpointNodeId: String(checkpointNodeId),
             resumeToken: resumeTokenValue,
             nextCall: { tool: 'continue_workflow', params: { continueToken } },
-        }))))
+        })))
             .mapErr((e) => ({ kind: 'store_failed', cause: e }));
     });
 }

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

@@ -1,5 +1,6 @@
 import type { V2ContinueWorkflowInput } from '../../v2/tools.js';
-import { createWorkflow } from '../../../types/workflow.js';
+import type { SessionIndex } from '../../../v2/durable-core/session-index.js';
+import type { Workflow } from '../../../types/workflow.js';
 import { type AttemptId } from '../../../v2/durable-core/tokens/index.js';
 import { type SessionId, type RunId, type NodeId, type WorkflowHash } from '../../../v2/durable-core/ids/index.js';
 import type { LoadedSessionTruthV2 } from '../../../v2/ports/session-event-log-store.port.js';
@@ -21,7 +22,7 @@ export declare function advanceAndRecord(args: {
     readonly inputContext: JsonValue | undefined;
     readonly inputOutput: V2ContinueWorkflowInput['output'];
     readonly lock: WithHealthySessionLock;
-    readonly pinnedWorkflow: ReturnType<typeof createWorkflow>;
+    readonly pinnedWorkflow: Workflow;
     readonly snapshotStore: import('../../../v2/ports/snapshot-store.port.js').SnapshotStorePortV2;
     readonly sessionStore: import('../../../v2/ports/session-event-log-store.port.js').SessionEventLogAppendStorePortV2 & import('../../../v2/ports/session-event-log-store.port.js').SessionEventLogReadonlyStorePortV2;
     readonly sha256: Sha256PortV2;
@@ -29,4 +30,5 @@ export declare function advanceAndRecord(args: {
         readonly mintNodeId: () => NodeId;
         readonly mintEventId: () => string;
     };
+    readonly lockedIndex: SessionIndex;
 }): RA<void, InternalError | SessionEventLogStoreError | SnapshotStoreError>;

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

@@ -3,18 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.advanceAndRecord = advanceAndRecord;
 const neverthrow_1 = require("neverthrow");
 const v2_advance_core_js_1 = require("../v2-advance-core.js");
-const constants_js_1 = require("../../../v2/durable-core/constants.js");
 function advanceAndRecord(args) {
     const { truth, sessionId, runId, nodeId, attemptId, workflowHash, dedupeKey, inputContext, inputOutput, lock, pinnedWorkflow, snapshotStore, sessionStore, sha256, idFactory } = args;
-    const hasRun = truth.events.some((e) => e.kind === constants_js_1.EVENT_KIND.RUN_STARTED && e.scope?.runId === String(runId));
-    const hasNode = truth.events.some((e) => e.kind === constants_js_1.EVENT_KIND.NODE_CREATED && e.scope?.runId === String(runId) && e.scope?.nodeId === String(nodeId));
+    const hasRun = args.lockedIndex.runStartedByRunId.has(String(runId));
+    const nodeCreated = args.lockedIndex.nodeCreatedByNodeId.get(String(nodeId));
+    const hasNode = nodeCreated !== undefined;
     if (!hasRun || !hasNode) {
         return (0, neverthrow_1.errAsync)({ kind: 'missing_node_or_run' });
     }
-    const nodeCreated = truth.events.find((e) => e.kind === constants_js_1.EVENT_KIND.NODE_CREATED && e.scope?.nodeId === String(nodeId));
-    if (!nodeCreated) {
-        return (0, neverthrow_1.errAsync)({ kind: 'missing_node_or_run' });
-    }
     if (String(nodeCreated.data.workflowHash) !== String(workflowHash)) {
         return (0, neverthrow_1.errAsync)({ kind: 'workflow_hash_mismatch' });
     }
@@ -38,6 +34,7 @@ function advanceAndRecord(args) {
                 truth, sessionId, runId, attemptId, workflowHash, dedupeKey,
                 inputContext, inputOutput, lock, pinnedWorkflow,
                 ports: { snapshotStore, sessionStore, sha256, idFactory },
+                lockedIndex: args.lockedIndex,
             });
         }
         return (0, v2_advance_core_js_1.executeAdvanceCore)({
@@ -45,6 +42,7 @@ function advanceAndRecord(args) {
             truth, sessionId, runId, attemptId, workflowHash, dedupeKey,
             inputContext, inputOutput, lock, pinnedWorkflow,
             ports: { snapshotStore, sessionStore, sha256, idFactory },
+            lockedIndex: args.lockedIndex,
         });
     });
 }