@exaudeus/workrail 3.15.0 → 3.17.0

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

@@ -15,6 +15,8 @@ const v2_state_conversion_js_1 = require("../v2-state-conversion.js");
 const constants_js_1 = require("../../../v2/durable-core/constants.js");
 const index_js_2 = require("./index.js");
 const assessments_js_1 = require("../../../v2/projections/assessments.js");
+const assert_output_js_1 = require("../../assert-output.js");
+const sorted_event_log_js_1 = require("../../../v2/durable-core/sorted-event-log.js");
 function buildAdvancedReplayResponse(args) {
     const { sessionId, runId, fromNodeId, toNodeId, attemptId, toSnapshot, workflow, truth, workflowHash, ports, sha256, aliasStore, entropy } = args;
     const toNodeIdBranded = (0, index_js_1.asNodeId)(String(toNodeId));
@@ -75,29 +77,34 @@ function buildAdvancedReplayResponse(args) {
                 runId: (0, index_js_1.asRunId)(String(runId)),
                 nodeId: (0, index_js_1.asNodeId)(String(toNodeIdBranded)),
                 rehydrateOnly: false,
+                precomputedIndex: args.precomputedIndex,
+                cleanResponseFormat: args.cleanResponseFormat,
             });
             if (result.isErr()) {
                 return (0, neverthrow_1.errAsync)({ kind: 'prompt_render_failed', message: result.error.message });
             }
             blockedMeta = result.value;
         }
-        const preferences = (0, v2_execution_helpers_js_1.derivePreferencesOrDefault)({ truth, runId, nodeId: toNodeIdBranded });
+        const preferences = (0, v2_execution_helpers_js_1.derivePreferencesOrDefault)({ truth, runId, nodeId: toNodeIdBranded, precomputedIndex: args.precomputedIndex });
         const nextIntent = (0, v2_state_conversion_js_1.deriveNextIntent)({ rehydrateOnly: false, isComplete, pending: blockedMeta });
-        return nextTokensMint.andThen((nextTokens) => retryContinueMint.andThen((retryContinueToken) => (0, neverthrow_1.okAsync)(output_schemas_js_1.V2ContinueWorkflowOutputSchema.parse({
-            kind: 'blocked',
-            continueToken: pending ? nextTokens.continueToken : undefined,
-            checkpointToken: pending ? nextTokens.checkpointToken : undefined,
-            isComplete,
-            pending: (0, output_schemas_js_1.toPendingStep)(blockedMeta),
-            preferences,
-            nextIntent,
-            nextCall: (0, index_js_2.buildNextCall)({ continueToken: pending ? nextTokens.continueToken : undefined, isComplete, pending: blockedMeta, retryContinueToken }),
-            blockers,
-            retryable,
-            retryContinueToken,
-            validation,
-            assessmentFollowup,
-        }))));
+        return nextTokensMint.andThen((nextTokens) => retryContinueMint.andThen((retryContinueToken) => {
+            const out = (0, assert_output_js_1.assertOutput)({
+                kind: 'blocked',
+                continueToken: pending ? nextTokens.continueToken : undefined,
+                checkpointToken: pending ? nextTokens.checkpointToken : undefined,
+                isComplete,
+                pending: (0, output_schemas_js_1.toPendingStep)(blockedMeta),
+                preferences,
+                nextIntent,
+                nextCall: (0, index_js_2.buildNextCall)({ continueToken: pending ? nextTokens.continueToken : undefined, isComplete, pending: blockedMeta, retryContinueToken }),
+                blockers,
+                retryable,
+                retryContinueToken,
+                validation,
+                assessmentFollowup,
+            }, assert_output_js_1.assertContinueTokenPresence);
+            return (0, neverthrow_1.okAsync)(out);
+        }));
     }
     let okMeta = null;
     if (pending) {
@@ -109,29 +116,39 @@ function buildAdvancedReplayResponse(args) {
             runId: (0, index_js_1.asRunId)(String(runId)),
             nodeId: (0, index_js_1.asNodeId)(String(toNodeIdBranded)),
             rehydrateOnly: false,
+            precomputedIndex: args.precomputedIndex,
+            cleanResponseFormat: args.cleanResponseFormat,
         });
         if (result.isErr()) {
             return (0, neverthrow_1.errAsync)({ kind: 'prompt_render_failed', message: result.error.message });
         }
         okMeta = result.value;
     }
-    const preferences = (0, v2_execution_helpers_js_1.derivePreferencesOrDefault)({ truth, runId, nodeId: toNodeIdBranded });
+    const preferences = (0, v2_execution_helpers_js_1.derivePreferencesOrDefault)({ truth, runId, nodeId: toNodeIdBranded, precomputedIndex: args.precomputedIndex });
     const nextIntent = (0, v2_state_conversion_js_1.deriveNextIntent)({ rehydrateOnly: false, isComplete, pending: okMeta });
     const stepContext = buildStepContext(truth.events, fromNodeId);
-    return nextTokensMint.andThen((nextTokens) => (0, neverthrow_1.okAsync)(output_schemas_js_1.V2ContinueWorkflowOutputSchema.parse({
-        kind: 'ok',
-        continueToken: pending ? nextTokens.continueToken : undefined,
-        checkpointToken: pending ? nextTokens.checkpointToken : undefined,
-        isComplete,
-        pending: (0, output_schemas_js_1.toPendingStep)(okMeta),
-        preferences,
-        nextIntent,
-        nextCall: (0, index_js_2.buildNextCall)({ continueToken: pending ? nextTokens.continueToken : undefined, isComplete, pending: okMeta }),
-        stepContext,
-    })));
+    return nextTokensMint.andThen((nextTokens) => {
+        const out = (0, assert_output_js_1.assertOutput)({
+            kind: 'ok',
+            continueToken: pending ? nextTokens.continueToken : undefined,
+            checkpointToken: pending ? nextTokens.checkpointToken : undefined,
+            isComplete,
+            pending: (0, output_schemas_js_1.toPendingStep)(okMeta),
+            preferences,
+            nextIntent,
+            nextCall: (0, index_js_2.buildNextCall)({ continueToken: pending ? nextTokens.continueToken : undefined, isComplete, pending: okMeta }),
+            stepContext,
+        }, assert_output_js_1.assertContinueTokenPresence);
+        return (0, neverthrow_1.okAsync)(out);
+    });
 }
 function buildStepContext(events, completedNodeId) {
-    const projection = (0, assessments_js_1.projectAssessmentsV2)(events);
+    const sortedEventsRes = (0, sorted_event_log_js_1.asSortedEventLog)(events);
+    if (sortedEventsRes.isErr()) {
+        console.warn(`[workrail:replay] stepContext events unsorted for node '${String(completedNodeId)}' — stepContext will be absent: ${sortedEventsRes.error.message}`);
+        return undefined;
+    }
+    const projection = (0, assessments_js_1.projectAssessmentsV2)(sortedEventsRes.value);
     if (projection.isErr()) {
         console.warn(`[workrail:replay] stepContext projection failed for node '${String(completedNodeId)}' — stepContext will be absent: ${projection.error.message}`);
         return undefined;
@@ -160,7 +177,8 @@ function replayFromRecordedAdvance(args) {
         });
     }
     const toNodeId = (0, index_js_1.asNodeId)(String(recordedEvent.data.outcome.toNodeId));
-    const toNode = truth.events.find((e) => e.kind === constants_js_1.EVENT_KIND.NODE_CREATED && e.scope?.nodeId === String(toNodeId));
+    const toNode = args.precomputedIndex?.nodeCreatedByNodeId.get(String(toNodeId))
+        ?? truth.events.find((e) => e.kind === constants_js_1.EVENT_KIND.NODE_CREATED && e.scope?.nodeId === String(toNodeId));
     if (!toNode) {
         return (0, neverthrow_1.errAsync)({
             kind: 'invariant_violation',
@@ -191,6 +209,8 @@ function replayFromRecordedAdvance(args) {
             sha256,
             aliasStore,
             entropy,
+            precomputedIndex: args.precomputedIndex,
+            cleanResponseFormat: args.cleanResponseFormat,
         });
     });
 }

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

@@ -1,6 +1,5 @@
 import type { V2ToolContext } from '../../types.js';
-import { V2StartWorkflowOutputSchema } from '../../output-schemas.js';
-import { createWorkflow } from '../../../types/workflow.js';
+import type { V2StartWorkflowOutputSchema } from '../../output-schemas.js';
 import type { DomainEventV1 } from '../../../v2/durable-core/schemas/session/index.js';
 import { type SessionId, type RunId, type NodeId, type WorkflowHash } from '../../../v2/durable-core/ids/index.js';
 import type { Sha256PortV2 } from '../../../v2/ports/sha256.port.js';
@@ -26,7 +25,7 @@ export declare function loadAndPinWorkflow(args: {
 }): RA<{
     readonly workflow: import('../../../types/workflow.js').Workflow;
     readonly workflowHash: WorkflowHash;
-    readonly pinnedWorkflow: ReturnType<typeof createWorkflow>;
+    readonly pinnedWorkflow: import('../../../types/workflow.js').Workflow;
     readonly firstStep: {
         readonly id: string;
     };

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

@@ -6,15 +6,14 @@ exports.mintStartTokens = mintStartTokens;
 exports.executeStartWorkflow = executeStartWorkflow;
 const output_schemas_js_1 = require("../../output-schemas.js");
 const step_instance_key_js_1 = require("../../../v2/durable-core/schemas/execution-snapshot/step-instance-key.js");
-const workflow_js_1 = require("../../../types/workflow.js");
 const index_js_1 = require("../../../v2/durable-core/ids/index.js");
 const workflow_hash_ref_js_1 = require("../../../v2/durable-core/ids/workflow-hash-ref.js");
 const neverthrow_1 = require("neverthrow");
 const workflow_validation_pipeline_js_1 = require("../../../application/services/workflow-validation-pipeline.js");
 const hashing_js_1 = require("../../../v2/durable-core/canonical/hashing.js");
 const observation_builder_js_1 = require("../../../v2/durable-core/domain/observation-builder.js");
-const workflow_source_js_1 = require("../../../types/workflow-source.js");
 const workflow_definition_js_1 = require("../../../types/workflow-definition.js");
+const workflow_object_cache_js_1 = require("./workflow-object-cache.js");
 const prompt_renderer_js_1 = require("../../../v2/durable-core/domain/prompt-renderer.js");
 const v2_workspace_resolution_js_1 = require("../v2-workspace-resolution.js");
 const v2_token_ops_js_1 = require("../v2-token-ops.js");
@@ -27,6 +26,8 @@ const request_workflow_reader_js_1 = require("../shared/request-workflow-reader.
 const step_content_envelope_js_1 = require("../../step-content-envelope.js");
 const v2_workspace_resolution_js_2 = require("../v2-workspace-resolution.js");
 const v2_reference_resolver_js_1 = require("../v2-reference-resolver.js");
+const with_timeout_js_1 = require("../shared/with-timeout.js");
+const REFERENCE_RESOLUTION_TIMEOUT_MS = 5000;
 function loadAndPinWorkflow(args) {
     const { workflowId, workflowReader, crypto, pinnedStore, validationPipelineDeps, workspacePath, resolvedRootUris } = args;
     return neverthrow_1.ResultAsync.fromPromise(workflowReader.getWorkflowById(workflowId), (e) => ({
@@ -73,13 +74,13 @@ function loadAndPinWorkflow(args) {
             return pinnedStore.get(workflowHash)
                 .mapErr((cause) => ({ kind: 'pinned_workflow_store_failed', cause }))
                 .andThen((existingPinned) => {
-                if (!existingPinned) {
-                    return pinnedStore.put(workflowHash, enrichedCompiled)
-                        .mapErr((cause) => ({ kind: 'pinned_workflow_store_failed', cause }));
+                if (existingPinned) {
+                    return (0, neverthrow_1.okAsync)(existingPinned);
                 }
-                return (0, neverthrow_1.okAsync)(undefined);
+                return pinnedStore.put(workflowHash, enrichedCompiled)
+                    .mapErr((cause) => ({ kind: 'pinned_workflow_store_failed', cause }))
+                    .map(() => enrichedCompiled);
             })
-                .andThen(() => pinnedStore.get(workflowHash).mapErr((cause) => ({ kind: 'pinned_workflow_store_failed', cause })))
                 .andThen((pinned) => {
                 if (!pinned || pinned.sourceKind !== 'v1_pinned' || !(0, workflow_definition_js_1.hasWorkflowDefinitionShape)(pinned.definition)) {
                     return (0, neverthrow_1.errAsync)({
@@ -87,7 +88,7 @@ function loadAndPinWorkflow(args) {
                         message: 'Failed to pin executable workflow snapshot (missing or invalid pinned workflow).',
                     });
                 }
-                const pinnedWorkflow = (0, workflow_js_1.createWorkflow)(pinned.definition, (0, workflow_source_js_1.createBundledSource)());
+                const pinnedWorkflow = (0, workflow_object_cache_js_1.getCachedWorkflow)(workflowHash, pinned.definition);
                 const resolution = (0, start_construction_js_1.resolveFirstStep)(workflow, pinned);
                 if (resolution.isErr()) {
                     const error = resolution.error.reason === 'no_steps'
@@ -240,10 +241,11 @@ function executeStartWorkflow(input, ctx) {
             workspacePath: input.workspacePath,
             resolvedRootUris: ctx.v2.resolvedRootUris,
             rememberedRootsStore: ctx.v2.rememberedRootsStore,
+            managedSourceStore: ctx.v2.managedSourceStore,
         }), (err) => ({
             kind: 'precondition_failed',
             message: `Failed to initialize workflow reader: ${String(err)}`,
-        })).map(({ reader, stalePaths }) => ({
+        })).map(({ reader, stalePaths, managedStoreError }) => ({
             workflowReader: {
                 getWorkflowById: async (workflowId) => {
                     const requestResult = await reader.getWorkflowById(workflowId);
@@ -253,21 +255,24 @@ function executeStartWorkflow(input, ctx) {
                 },
             },
             stalePaths,
+            managedStoreError,
         }))
-        : (0, neverthrow_1.okAsync)({ workflowReader: ctx.workflowService, stalePaths: [] });
-    return readerRA.andThen(({ workflowReader, stalePaths }) => loadAndPinWorkflow({
-        workflowId: input.workflowId,
-        workflowReader,
-        crypto,
-        pinnedStore,
-        validationPipelineDeps,
-        workspacePath: input.workspacePath,
-        resolvedRootUris: ctx.v2.resolvedRootUris,
-    })
-        .andThen(({ workflow, firstStep, workflowHash, pinnedWorkflow, resolvedReferences }) => {
-        const anchorsRA = (0, v2_workspace_resolution_js_1.resolveWorkspaceAnchors)(ctx.v2, input.workspacePath)
-            .map((anchors) => (0, observation_builder_js_1.anchorsToObservations)(anchors));
-        return anchorsRA.andThen((observations) => {
+        : (0, neverthrow_1.okAsync)({ workflowReader: ctx.workflowService, stalePaths: [], managedStoreError: undefined });
+    const anchorsRA = (0, v2_workspace_resolution_js_1.resolveWorkspaceAnchors)(ctx.v2, input.workspacePath)
+        .map((anchors) => (0, observation_builder_js_1.anchorsToObservations)(anchors))
+        .mapErr((x) => x);
+    return readerRA.andThen(({ workflowReader, stalePaths, managedStoreError }) => {
+        const pinnedRA = loadAndPinWorkflow({
+            workflowId: input.workflowId,
+            workflowReader,
+            crypto,
+            pinnedStore,
+            validationPipelineDeps,
+            workspacePath: input.workspacePath,
+            resolvedRootUris: ctx.v2.resolvedRootUris,
+        });
+        return neverthrow_1.ResultAsync.combine([pinnedRA, anchorsRA])
+            .andThen(([{ workflow, firstStep, workflowHash, pinnedWorkflow, resolvedReferences }, observations]) => {
             const sessionId = idFactory.mintSessionId();
             const runId = idFactory.mintRunId();
             const nodeId = idFactory.mintNodeId();
@@ -309,16 +314,17 @@ function executeStartWorkflow(input, ctx) {
                     idFactory,
                     goal: input.goal,
                 });
+                const emptyTruth = { manifest: [], events: [] };
                 return gate.withHealthySessionLock(sessionId, (lock) => sessionStore.append(lock, {
                     events,
                     snapshotPins: [{ snapshotRef, eventIndex: 2, createdByEventId: events[2].eventId }],
-                }))
+                }, emptyTruth))
                     .mapErr((cause) => ({ kind: 'session_append_failed', cause }))
-                    .map(() => ({ workflow, firstStep, workflowHash, pinnedWorkflow, resolvedReferences, sessionId, runId, nodeId }));
+                    .map(() => ({ workflow, firstStep, workflowHash, pinnedWorkflow, resolvedReferences, sessionId, runId, nodeId, stalePaths, managedStoreError }));
             });
         });
     })
-        .andThen(({ pinnedWorkflow, firstStep, workflowHash, sessionId, runId, nodeId, resolvedReferences }) => {
+        .andThen(({ pinnedWorkflow, firstStep, workflowHash, sessionId, runId, nodeId, resolvedReferences, stalePaths, managedStoreError }) => {
         const wfRefRes = (0, workflow_hash_ref_js_1.deriveWorkflowHashRef)(workflowHash);
         if (wfRefRes.isErr()) {
             return (0, neverthrow_1.errAsync)({
@@ -346,6 +352,7 @@ function executeStartWorkflow(input, ctx) {
                 runId: (0, index_js_1.asRunId)(String(runId)),
                 nodeId: (0, index_js_1.asNodeId)(String(nodeId)),
                 rehydrateOnly: false,
+                cleanResponseFormat: ctx.featureFlags?.isEnabled('cleanResponseFormat') ?? false,
             });
             if (metaResult.isErr()) {
                 return (0, neverthrow_1.errAsync)({
@@ -361,7 +368,10 @@ function executeStartWorkflow(input, ctx) {
                 meta,
                 references: resolvedReferences,
             });
-            const parsed = output_schemas_js_1.V2StartWorkflowOutputSchema.parse({
+            const startWarnings = managedStoreError !== undefined
+                ? [`Managed workflow source store was temporarily unavailable (${managedStoreError}). Managed sources were not loaded.`]
+                : undefined;
+            const parsed = {
                 continueToken: tokens.continueToken,
                 checkpointToken: tokens.checkpointToken,
                 isComplete: false,
@@ -370,16 +380,34 @@ function executeStartWorkflow(input, ctx) {
                 nextIntent,
                 nextCall: (0, index_js_2.buildNextCall)({ continueToken: tokens.continueToken, isComplete: false, pending }),
                 ...(stalePaths.length > 0 ? { staleRoots: [...stalePaths] } : {}),
-            });
+                ...(startWarnings !== undefined ? { warnings: startWarnings } : {}),
+            };
             return (0, neverthrow_1.okAsync)({ response: parsed, contentEnvelope });
         });
-    }));
+    });
 }
 function enrichPinnedSnapshotWithResolvedReferences(snapshot, references, workspacePath) {
     if (references.length === 0) {
         return (0, neverthrow_1.okAsync)({ snapshot, resolvedReferences: [] });
     }
-    return neverthrow_1.ResultAsync.fromPromise((0, v2_reference_resolver_js_1.resolveWorkflowReferences)(references, workspacePath), () => ({ kind: 'reference_resolution_failed' })).map((result) => {
+    const allUnresolved = references.map((ref) => ({
+        id: ref.id,
+        title: ref.title,
+        source: ref.source,
+        purpose: ref.purpose,
+        authoritative: ref.authoritative,
+        resolveFrom: (ref.resolveFrom ?? 'workspace'),
+        status: 'unresolved',
+    }));
+    const resolutionPromise = (0, with_timeout_js_1.withTimeout)((0, v2_reference_resolver_js_1.resolveWorkflowReferences)(references, workspacePath), REFERENCE_RESOLUTION_TIMEOUT_MS, 'reference_resolution').catch(() => null);
+    return neverthrow_1.ResultAsync.fromPromise(resolutionPromise, () => ({ kind: 'reference_resolution_failed' })).map((result) => {
+        if (result === null) {
+            console.warn('[workrail:reference-resolution] timed out; all references marked unresolved');
+            return {
+                snapshot: { ...snapshot, resolvedReferences: [...allUnresolved] },
+                resolvedReferences: allUnresolved,
+            };
+        }
         for (const warning of result.warnings) {
             console.warn(`[workrail:reference-resolution] ${warning.message}`);
         }

package/dist/mcp/handlers/v2-execution/workflow-object-cache.d.ts

@@ -0,0 +1,5 @@
+import type { WorkflowDefinition } from '../../../types/workflow-definition.js';
+import type { Workflow } from '../../../types/workflow.js';
+import type { WorkflowHash } from '../../../v2/durable-core/ids/index.js';
+export declare function getCachedWorkflow(workflowHash: WorkflowHash, definition: WorkflowDefinition): Workflow;
+export declare function clearWorkflowObjectCacheForTesting(): void;

package/dist/mcp/handlers/v2-execution/workflow-object-cache.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCachedWorkflow = getCachedWorkflow;
+exports.clearWorkflowObjectCacheForTesting = clearWorkflowObjectCacheForTesting;
+const workflow_js_1 = require("../../../types/workflow.js");
+const workflow_source_js_1 = require("../../../types/workflow-source.js");
+const _cache = new Map();
+function getCachedWorkflow(workflowHash, definition) {
+    const key = String(workflowHash);
+    const existing = _cache.get(key);
+    if (existing !== undefined)
+        return existing;
+    const wf = (0, workflow_js_1.createWorkflow)(definition, (0, workflow_source_js_1.createBundledSource)());
+    _cache.set(key, wf);
+    return wf;
+}
+function clearWorkflowObjectCacheForTesting() {
+    _cache.clear();
+}

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

@@ -120,4 +120,5 @@ export declare function derivePreferencesOrDefault(args: {
     readonly truth: LoadedSessionTruthV2;
     readonly runId: RunId;
     readonly nodeId: NodeId;
+    readonly precomputedIndex?: import('../../v2/durable-core/session-index.js').SessionIndex;
 }): PreferencesV2;

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

@@ -266,20 +266,36 @@ function mapSessionOrGateErrorToToolError(e) {
 }
 const constants_js_1 = require("../../v2/durable-core/constants.js");
 const preferences_js_1 = require("../../v2/projections/preferences.js");
+const sorted_event_log_js_1 = require("../../v2/durable-core/sorted-event-log.js");
 exports.defaultPreferences = {
     autonomy: 'guided',
     riskPolicy: 'conservative'
 };
 function derivePreferencesOrDefault(args) {
+    let sortedEventsForPrefs;
     const parentByNodeId = {};
-    for (const e of args.truth.events) {
-        if (e.kind !== constants_js_1.EVENT_KIND.NODE_CREATED)
-            continue;
-        if (e.scope?.runId !== String(args.runId))
-            continue;
-        parentByNodeId[String(e.scope.nodeId)] = e.data.parentNodeId;
+    if (args.precomputedIndex) {
+        sortedEventsForPrefs = args.precomputedIndex.sortedEvents;
+        for (const [nodeId, evt] of args.precomputedIndex.nodeCreatedByNodeId) {
+            if (evt.scope.runId === String(args.runId)) {
+                parentByNodeId[nodeId] = evt.data.parentNodeId ?? null;
+            }
+        }
+    }
+    else {
+        for (const e of args.truth.events) {
+            if (e.kind !== constants_js_1.EVENT_KIND.NODE_CREATED)
+                continue;
+            if (e.scope?.runId !== String(args.runId))
+                continue;
+            parentByNodeId[String(e.scope.nodeId)] = e.data.parentNodeId;
+        }
+        const sortedEventsRes = (0, sorted_event_log_js_1.asSortedEventLog)(args.truth.events);
+        if (sortedEventsRes.isErr())
+            return exports.defaultPreferences;
+        sortedEventsForPrefs = sortedEventsRes.value;
     }
-    const prefs = (0, preferences_js_1.projectPreferencesV2)(args.truth.events, parentByNodeId);
+    const prefs = (0, preferences_js_1.projectPreferencesV2)(sortedEventsForPrefs, parentByNodeId);
     if (prefs.isErr())
         return exports.defaultPreferences;
     const p = prefs.value.byNodeId[String(args.nodeId)]?.effective;

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

@@ -1,7 +1,7 @@
 import type { z } from 'zod';
 import type { V2ResumeSessionInput } from '../v2/tools.js';
 import type { ToolContext, ToolResult } from '../types.js';
-import { V2ResumeSessionOutputSchema } from '../output-schemas.js';
+import type { V2ResumeSessionOutputSchema } from '../output-schemas.js';
 type ResumeInput = z.infer<typeof V2ResumeSessionInput>;
 type ResumeOutput = z.infer<typeof V2ResumeSessionOutputSchema>;
 export declare function handleV2ResumeSession(input: ResumeInput, ctx: ToolContext): Promise<ToolResult<ResumeOutput>>;

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

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleV2ResumeSession = handleV2ResumeSession;
 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 index_js_1 = require("../../v2/durable-core/ids/index.js");
 const resume_session_js_1 = require("../../v2/usecases/resume-session.js");
@@ -43,10 +42,10 @@ async function handleV2ResumeSession(input, ctx) {
     if (skipped > 0) {
         console.error(`[workrail:resume] ${skipped}/${candidates.length} candidate(s) skipped: token minting failed (workflowHashRef derivation or signing error)`);
     }
-    const output = output_schemas_js_1.V2ResumeSessionOutputSchema.parse({
-        candidates: outputCandidates,
+    const output = {
+        candidates: [...outputCandidates],
         totalEligible: totalFound,
-    });
+    };
     return {
         type: 'success',
         data: output,

package/dist/mcp/handlers/v2-state-conversion.js

@@ -9,6 +9,7 @@ exports.derivePreferencesForNode = derivePreferencesForNode;
 exports.deriveNextIntent = deriveNextIntent;
 const step_instance_key_js_1 = require("../../v2/durable-core/schemas/execution-snapshot/step-instance-key.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 constants_js_1 = require("../../v2/durable-core/constants.js");
 function toV1ExecutionState(engineState) {
     if (engineState.kind === 'init')
@@ -94,7 +95,10 @@ function derivePreferencesForNode(args) {
             continue;
         parentByNodeId[String(e.scope.nodeId)] = e.data.parentNodeId;
     }
-    const prefs = (0, preferences_js_1.projectPreferencesV2)(args.truth.events, parentByNodeId);
+    const sortedEventsRes = (0, sorted_event_log_js_1.asSortedEventLog)(args.truth.events);
+    if (sortedEventsRes.isErr())
+        return exports.defaultPreferences;
+    const prefs = (0, preferences_js_1.projectPreferencesV2)(sortedEventsRes.value, parentByNodeId);
     if (prefs.isErr())
         return exports.defaultPreferences;
     const p = prefs.value.byNodeId[String(args.nodeId)]?.effective;

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

@@ -1,6 +1,10 @@
 import type { ToolContext, ToolResult } from '../types.js';
 import type { V2InspectWorkflowInput, V2ListWorkflowsInput } from '../v2/tools.js';
 import type { StalenessSummary } from '../output-schemas.js';
+import type { RememberedRootRecordV2 } from '../../v2/ports/remembered-roots-store.port.js';
+import type { CryptoPortV2 } from '../../v2/durable-core/canonical/hashing.js';
+import type { PinnedWorkflowStorePortV2 } from '../../v2/ports/pinned-workflow-store.port.js';
+import type { Workflow } from '../../types/workflow.js';
 export declare function shouldShowStaleness(category: string | undefined, devMode?: boolean): boolean;
 interface WorkflowTagsFile {
     readonly tags: ReadonlyArray<{
@@ -22,6 +26,82 @@ export declare function buildTagSummary(tagsFile: WorkflowTagsFile, compiledWork
     examples: string[];
 }>;
 export declare function computeWorkflowStaleness(stamp: number | undefined, currentVersion: number | null): StalenessSummary | undefined;
+interface WorkflowLookupReader {
+    readonly getWorkflowById: (id: string) => Promise<Workflow | null>;
+    readonly listWorkflowSummaries: () => Promise<readonly {
+        readonly id: string;
+        readonly name: string;
+        readonly description: string;
+        readonly version: string;
+    }[]>;
+    readonly loadAllWorkflows: () => Promise<readonly Workflow[]>;
+}
 export declare function handleV2ListWorkflows(input: V2ListWorkflowsInput, ctx: ToolContext): Promise<ToolResult<unknown>>;
 export declare function handleV2InspectWorkflow(input: V2InspectWorkflowInput, ctx: ToolContext): Promise<ToolResult<unknown>>;
+export declare function buildV2WorkflowListItem(options: {
+    readonly workflow: Workflow | null;
+    readonly summary: {
+        readonly id: string;
+        readonly name: string;
+        readonly description: string;
+        readonly version: string;
+    };
+    readonly workflowReader: WorkflowLookupReader;
+    readonly rememberedRootRecords: readonly RememberedRootRecordV2[];
+    readonly crypto: CryptoPortV2;
+    readonly pinnedStore: PinnedWorkflowStorePortV2;
+}): Promise<{
+    workflowId: string;
+    name: string;
+    description: string;
+    version: string;
+    workflowHash: null;
+    kind: "workflow";
+} | {
+    examples: string[];
+    workflowId: string;
+    name: string;
+    description: string;
+    version: string;
+    workflowHash: null;
+    kind: "workflow";
+    visibility: import("./shared/workflow-source-visibility.js").WorkflowVisibility;
+} | {
+    examples?: undefined;
+    workflowId: string;
+    name: string;
+    description: string;
+    version: string;
+    workflowHash: null;
+    kind: "workflow";
+    visibility: import("./shared/workflow-source-visibility.js").WorkflowVisibility;
+} | {
+    examples: string[];
+    staleness?: {
+        level: "none" | "possible" | "likely";
+        reason: string;
+        specVersionAtLastReview?: number | undefined;
+    } | undefined;
+    workflowId: string;
+    name: string;
+    description: string;
+    version: string;
+    workflowHash: never;
+    kind: "workflow";
+    visibility: import("./shared/workflow-source-visibility.js").WorkflowVisibility;
+} | {
+    examples?: undefined;
+    staleness?: {
+        level: "none" | "possible" | "likely";
+        reason: string;
+        specVersionAtLastReview?: number | undefined;
+    } | undefined;
+    workflowId: string;
+    name: string;
+    description: string;
+    version: string;
+    workflowHash: never;
+    kind: "workflow";
+    visibility: import("./shared/workflow-source-visibility.js").WorkflowVisibility;
+}>;
 export {};