@exaudeus/workrail 0.11.0 → 0.13.0

package/dist/application/services/workflow-interpreter.js

@@ -13,6 +13,7 @@ const workflow_1 = require("../../types/workflow");
 const neverthrow_1 = require("neverthrow");
 const error_1 = require("../../domain/execution/error");
 const ids_1 = require("../../domain/execution/ids");
+const loop_runtime_1 = require("../../v2/durable-core/domain/loop-runtime");
 let WorkflowInterpreter = class WorkflowInterpreter {
     applyEvent(state, event) {
         if (state.kind === 'complete')
@@ -132,103 +133,165 @@ let WorkflowInterpreter = class WorkflowInterpreter {
         if (!loopCompiled) {
             return (0, neverthrow_1.err)(error_1.Err.invalidLoop(frame.loopId, 'Loop not found in compiled metadata'));
         }
-        const shouldContinue = this.shouldContinueLoop(loopCompiled.loop, frame, context);
-        if (shouldContinue.isErr())
-            return (0, neverthrow_1.err)(shouldContinue.error);
-        if (!shouldContinue.value) {
-            const popped = state.loopStack.slice(0, -1);
-            return (0, neverthrow_1.ok)({
-                state: {
-                    ...state,
-                    loopStack: popped,
-                    completed: [...state.completed, frame.loopId],
-                },
-                next: null,
-            });
-        }
         const body = loopCompiled.bodySteps;
-        for (let i = frame.bodyIndex; i < body.length; i++) {
-            const bodyStep = body[i];
-            const instance = {
-                stepId: bodyStep.id,
-                loopPath: [...state.loopStack.map((f) => ({ loopId: f.loopId, iteration: f.iteration }))],
-            };
-            const key = (0, ids_1.toStepInstanceKey)(instance);
-            if (state.completed.includes(key))
-                continue;
-            const projectedContext = this.projectLoopContext(loopCompiled.loop, frame, context);
-            if (bodyStep.runCondition && !(0, condition_evaluator_1.evaluateCondition)(bodyStep.runCondition, projectedContext)) {
-                continue;
-            }
-            const next = this.materializeStep(compiled, instance, projectedContext);
-            if (next.isErr())
-                return (0, neverthrow_1.err)(next.error);
-            const updatedTop = { ...frame, bodyIndex: i };
-            const updatedStack = [...state.loopStack.slice(0, -1), updatedTop];
-            return (0, neverthrow_1.ok)({
-                state: { ...state, loopStack: updatedStack, pendingStep: instance },
-                next: next.value,
-            });
-        }
-        if (frame.iteration + 1 > loopCompiled.loop.loop.maxIterations) {
-            return (0, neverthrow_1.err)(error_1.Err.maxIterationsExceeded(frame.loopId, loopCompiled.loop.loop.maxIterations));
-        }
-        const advanced = { ...frame, iteration: frame.iteration + 1, bodyIndex: 0 };
-        const updatedStack = [...state.loopStack.slice(0, -1), advanced];
-        return (0, neverthrow_1.ok)({ state: { ...state, loopStack: updatedStack }, next: null });
-    }
-    shouldContinueLoop(loop, frame, context) {
-        if (frame.iteration >= loop.loop.maxIterations) {
-            return (0, neverthrow_1.ok)(false);
-        }
-        switch (loop.loop.type) {
-            case 'for': {
-                const count = loop.loop.count;
-                if (typeof count === 'number') {
-                    return (0, neverthrow_1.ok)(frame.iteration < count);
-                }
-                if (typeof count === 'string') {
-                    const raw = context[count];
-                    if (typeof raw !== 'number') {
-                        return (0, neverthrow_1.err)(error_1.Err.missingContext(`for loop '${loop.id}' requires numeric context['${count}']`));
+        const loopPath = [...state.loopStack.map((f) => ({ loopId: f.loopId, iteration: f.iteration }))];
+        const completed = new Set(state.completed);
+        const ports = {
+            shouldEnterIteration: (iteration) => {
+                switch (loopCompiled.loop.loop.type) {
+                    case 'for': {
+                        const count = loopCompiled.loop.loop.count;
+                        if (typeof count === 'number') {
+                            return (0, neverthrow_1.ok)(iteration < count);
+                        }
+                        if (typeof count === 'string') {
+                            const raw = context[count];
+                            if (typeof raw !== 'number') {
+                                return (0, neverthrow_1.err)({
+                                    code: 'LOOP_MISSING_CONTEXT',
+                                    loopId: loopCompiled.loop.id,
+                                    message: `for loop '${loopCompiled.loop.id}' requires numeric context['${count}']`,
+                                });
+                            }
+                            return (0, neverthrow_1.ok)(iteration < raw);
+                        }
+                        return (0, neverthrow_1.err)({
+                            code: 'LOOP_INVALID_CONFIG',
+                            loopId: loopCompiled.loop.id,
+                            message: `for loop '${loopCompiled.loop.id}' missing count`,
+                        });
+                    }
+                    case 'forEach': {
+                        const itemsVar = loopCompiled.loop.loop.items;
+                        if (!itemsVar) {
+                            return (0, neverthrow_1.err)({
+                                code: 'LOOP_INVALID_CONFIG',
+                                loopId: loopCompiled.loop.id,
+                                message: `forEach loop '${loopCompiled.loop.id}' missing items`,
+                            });
+                        }
+                        const raw = context[itemsVar];
+                        if (!Array.isArray(raw)) {
+                            return (0, neverthrow_1.err)({
+                                code: 'LOOP_MISSING_CONTEXT',
+                                loopId: loopCompiled.loop.id,
+                                message: `forEach loop '${loopCompiled.loop.id}' requires array context['${itemsVar}']`,
+                            });
+                        }
+                        return (0, neverthrow_1.ok)(iteration < raw.length);
                     }
-                    return (0, neverthrow_1.ok)(frame.iteration < raw);
+                    case 'while': {
+                        if (!loopCompiled.loop.loop.condition) {
+                            return (0, neverthrow_1.err)({
+                                code: 'LOOP_INVALID_CONFIG',
+                                loopId: loopCompiled.loop.id,
+                                message: `while loop '${loopCompiled.loop.id}' missing condition`,
+                            });
+                        }
+                        return (0, neverthrow_1.ok)((0, condition_evaluator_1.evaluateCondition)(loopCompiled.loop.loop.condition, this.projectLoopContextAtIteration(loopCompiled.loop, iteration, context)));
+                    }
+                    case 'until': {
+                        if (!loopCompiled.loop.loop.condition) {
+                            return (0, neverthrow_1.err)({
+                                code: 'LOOP_INVALID_CONFIG',
+                                loopId: loopCompiled.loop.id,
+                                message: `until loop '${loopCompiled.loop.id}' missing condition`,
+                            });
+                        }
+                        return (0, neverthrow_1.ok)(!(0, condition_evaluator_1.evaluateCondition)(loopCompiled.loop.loop.condition, this.projectLoopContextAtIteration(loopCompiled.loop, iteration, context)));
+                    }
+                    default:
+                        return (0, neverthrow_1.err)({
+                            code: 'LOOP_INVALID_CONFIG',
+                            loopId: loopCompiled.loop.id,
+                            message: `Unknown loop type '${loopCompiled.loop.loop.type}'`,
+                        });
                 }
-                return (0, neverthrow_1.err)(error_1.Err.invalidLoop(loop.id, `for loop '${loop.id}' missing count`));
+            },
+            isBodyIndexEligible: (bodyIndex) => {
+                const bodyStep = body[bodyIndex];
+                if (!bodyStep)
+                    return false;
+                const instance = { stepId: bodyStep.id, loopPath };
+                const key = (0, ids_1.toStepInstanceKey)(instance);
+                if (completed.has(key))
+                    return false;
+                if (!bodyStep.runCondition)
+                    return true;
+                const projectedContext = this.projectLoopContext(loopCompiled.loop, frame, context);
+                return (0, condition_evaluator_1.evaluateCondition)(bodyStep.runCondition, projectedContext);
+            },
+        };
+        const decision = (0, loop_runtime_1.computeLoopDecision)({
+            loopId: frame.loopId,
+            iteration: frame.iteration,
+            bodyIndex: frame.bodyIndex,
+            bodyLength: body.length,
+            maxIterations: loopCompiled.loop.loop.maxIterations,
+            ports,
+        });
+        if (decision.isErr()) {
+            const e = decision.error;
+            switch (e.code) {
+                case 'LOOP_MAX_ITERATIONS_REACHED':
+                    return (0, neverthrow_1.err)(error_1.Err.maxIterationsExceeded(e.loopId, e.maxIterations));
+                case 'LOOP_MISSING_CONTEXT':
+                    return (0, neverthrow_1.err)(error_1.Err.missingContext(e.message));
+                case 'LOOP_INVALID_CONFIG':
+                    return (0, neverthrow_1.err)(error_1.Err.invalidLoop(e.loopId, e.message));
+                case 'LOOP_INVALID_STATE':
+                    return (0, neverthrow_1.err)(error_1.Err.invalidState(e.message));
+                default:
+                    return (0, neverthrow_1.err)(error_1.Err.invalidState('Unhandled loop kernel error'));
             }
-            case 'forEach': {
-                const itemsVar = loop.loop.items;
-                if (!itemsVar)
-                    return (0, neverthrow_1.err)(error_1.Err.invalidLoop(loop.id, `forEach loop '${loop.id}' missing items`));
-                const raw = context[itemsVar];
-                if (!Array.isArray(raw)) {
-                    return (0, neverthrow_1.err)(error_1.Err.missingContext(`forEach loop '${loop.id}' requires array context['${itemsVar}']`));
-                }
-                return (0, neverthrow_1.ok)(frame.iteration < raw.length);
+        }
+        switch (decision.value.kind) {
+            case 'exit_loop': {
+                const popped = state.loopStack.slice(0, -1);
+                return (0, neverthrow_1.ok)({
+                    state: {
+                        ...state,
+                        loopStack: popped,
+                        completed: [...state.completed, frame.loopId],
+                    },
+                    next: null,
+                });
             }
-            case 'while': {
-                if (!loop.loop.condition)
-                    return (0, neverthrow_1.err)(error_1.Err.invalidLoop(loop.id, `while loop '${loop.id}' missing condition`));
-                return (0, neverthrow_1.ok)((0, condition_evaluator_1.evaluateCondition)(loop.loop.condition, this.projectLoopContext(loop, frame, context)));
+            case 'advance_iteration': {
+                const advanced = { ...frame, iteration: decision.value.toIteration, bodyIndex: 0 };
+                const updatedStack = [...state.loopStack.slice(0, -1), advanced];
+                return (0, neverthrow_1.ok)({ state: { ...state, loopStack: updatedStack }, next: null });
             }
-            case 'until': {
-                if (!loop.loop.condition)
-                    return (0, neverthrow_1.err)(error_1.Err.invalidLoop(loop.id, `until loop '${loop.id}' missing condition`));
-                return (0, neverthrow_1.ok)(!(0, condition_evaluator_1.evaluateCondition)(loop.loop.condition, this.projectLoopContext(loop, frame, context)));
+            case 'execute_body_step': {
+                const bodyStep = body[decision.value.bodyIndex];
+                if (!bodyStep) {
+                    return (0, neverthrow_1.err)(error_1.Err.invalidState(`Loop '${frame.loopId}' selected missing bodyIndex ${decision.value.bodyIndex}`));
+                }
+                const instance = { stepId: bodyStep.id, loopPath };
+                const projectedContext = this.projectLoopContext(loopCompiled.loop, frame, context);
+                const next = this.materializeStep(compiled, instance, projectedContext);
+                if (next.isErr())
+                    return (0, neverthrow_1.err)(next.error);
+                const updatedTop = { ...frame, bodyIndex: decision.value.bodyIndex };
+                const updatedStack = [...state.loopStack.slice(0, -1), updatedTop];
+                return (0, neverthrow_1.ok)({
+                    state: { ...state, loopStack: updatedStack, pendingStep: instance },
+                    next: next.value,
+                });
             }
             default:
-                return (0, neverthrow_1.err)(error_1.Err.invalidLoop(loop.id, `Unknown loop type '${loop.loop.type}'`));
+                return (0, neverthrow_1.err)(error_1.Err.invalidState('Non-exhaustive loop decision'));
         }
     }
-    projectLoopContext(loop, frame, base) {
+    projectLoopContextAtIteration(loop, iteration, base) {
         const out = { ...base };
         const iterationVar = loop.loop.iterationVar || 'currentIteration';
-        out[iterationVar] = frame.iteration + 1;
+        out[iterationVar] = iteration + 1;
         if (loop.loop.type === 'forEach') {
             const itemsVar = loop.loop.items;
             const raw = base[itemsVar];
             if (Array.isArray(raw)) {
-                const index = frame.iteration;
+                const index = iteration;
                 const itemVar = loop.loop.itemVar || 'currentItem';
                 const indexVar = loop.loop.indexVar || 'currentIndex';
                 out[itemVar] = raw[index];
@@ -237,6 +300,9 @@ let WorkflowInterpreter = class WorkflowInterpreter {
         }
         return out;
     }
+    projectLoopContext(loop, frame, base) {
+        return this.projectLoopContextAtIteration(loop, frame.iteration, base);
+    }
     lookupStepInstance(compiled, id) {
         const step = compiled.stepById.get(id.stepId);
         if (!step)

package/dist/application/services/workflow-service.d.ts

@@ -19,6 +19,7 @@ export interface WorkflowService {
         valid: boolean;
         issues: readonly string[];
         suggestions: readonly string[];
+        warnings?: readonly string[];
     }>;
 }
 export declare class DefaultWorkflowService implements WorkflowService {
@@ -41,6 +42,7 @@ export declare class DefaultWorkflowService implements WorkflowService {
         valid: boolean;
         issues: readonly string[];
         suggestions: readonly string[];
+        warnings?: readonly string[];
     }>;
     private getOrCompile;
     __debugCompiledCacheSize(): number;

package/dist/application/services/workflow-service.js

@@ -59,15 +59,15 @@ let DefaultWorkflowService = class DefaultWorkflowService {
     async validateStepOutput(workflowId, stepId, output) {
         const workflow = await this.storage.getWorkflowById(workflowId);
         if (!workflow) {
-            return { valid: false, issues: [`Workflow '${workflowId}' not found`], suggestions: [] };
+            return { valid: false, issues: [`Workflow '${workflowId}' not found`], suggestions: [], warnings: undefined };
         }
         const step = workflow.definition.steps.find((s) => s.id === stepId);
         if (!step) {
-            return { valid: false, issues: [`Step '${stepId}' not found in workflow '${workflowId}'`], suggestions: [] };
+            return { valid: false, issues: [`Step '${stepId}' not found in workflow '${workflowId}'`], suggestions: [], warnings: undefined };
         }
         const criteria = step.validationCriteria;
         if (!criteria)
-            return { valid: true, issues: [], suggestions: [] };
+            return { valid: true, issues: [], suggestions: [], warnings: undefined };
         return this.validationEngine.validate(output, criteria);
     }
     getOrCompile(workflowId, workflow) {

package/dist/application/use-cases/validate-step-output.d.ts

@@ -3,9 +3,11 @@ export declare function createValidateStepOutput(service: WorkflowService): (wor
     valid: boolean;
     issues: readonly string[];
     suggestions: readonly string[];
+    warnings?: readonly string[];
 }>;
 export declare function validateStepOutput(service: WorkflowService, workflowId: string, stepId: string, output: string): Promise<{
     valid: boolean;
     issues: readonly string[];
     suggestions: readonly string[];
+    warnings?: readonly string[];
 }>;

package/dist/config/feature-flags.js

@@ -57,7 +57,7 @@ exports.FEATURE_FLAG_DEFINITIONS = [
         key: 'v2Tools',
         envVar: 'WORKRAIL_ENABLE_V2_TOOLS',
         defaultValue: false,
-        description: 'Enable WorkRail v2 MCP tools (Slice 1: list_workflows, inspect_workflow) behind an explicit opt-in flag',
+        description: 'Enable WorkRail v2 MCP tools (Slices 1–3: list/inspect/start/continue) behind an explicit opt-in flag',
         since: '0.9.0',
         stable: false,
     },

package/dist/di/container.js

@@ -172,6 +172,93 @@ async function registerServices() {
         tsyringe_1.container.registerSingleton(tokens_js_1.DI.Mcp.DescriptionProvider, ToolDescriptionProvider);
     }
 }
+async function registerV2Services() {
+    const { LocalDataDirV2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/data-dir/index.js')));
+    const { NodeFileSystemV2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/fs/index.js')));
+    const { NodeSha256V2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/sha256/index.js')));
+    const { NodeCryptoV2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/crypto/index.js')));
+    const { NodeHmacSha256V2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/hmac-sha256/index.js')));
+    const { NodeBase64UrlV2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/base64url/index.js')));
+    const { NodeRandomEntropyV2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/random-entropy/index.js')));
+    const { NodeTimeClockV2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/time-clock/index.js')));
+    tsyringe_1.container.register(tokens_js_1.DI.V2.DataDir, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)(() => new LocalDataDirV2(process.env)),
+    });
+    tsyringe_1.container.register(tokens_js_1.DI.V2.FileSystem, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)(() => new NodeFileSystemV2()),
+    });
+    tsyringe_1.container.register(tokens_js_1.DI.V2.Sha256, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)(() => new NodeSha256V2()),
+    });
+    tsyringe_1.container.register(tokens_js_1.DI.V2.Crypto, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)(() => new NodeCryptoV2()),
+    });
+    tsyringe_1.container.register(tokens_js_1.DI.V2.HmacSha256, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)(() => new NodeHmacSha256V2()),
+    });
+    tsyringe_1.container.register(tokens_js_1.DI.V2.Base64Url, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)(() => new NodeBase64UrlV2()),
+    });
+    tsyringe_1.container.register(tokens_js_1.DI.V2.RandomEntropy, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)(() => new NodeRandomEntropyV2()),
+    });
+    tsyringe_1.container.register(tokens_js_1.DI.V2.TimeClock, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)(() => new NodeTimeClockV2()),
+    });
+    const { LocalKeyringV2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/keyring/index.js')));
+    const { LocalSessionEventLogStoreV2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/session-store/index.js')));
+    const { LocalSnapshotStoreV2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/snapshot-store/index.js')));
+    const { LocalPinnedWorkflowStoreV2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/pinned-workflow-store/index.js')));
+    const { LocalSessionLockV2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/session-lock/index.js')));
+    tsyringe_1.container.register(tokens_js_1.DI.V2.Keyring, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)((c) => {
+            const dataDir = c.resolve(tokens_js_1.DI.V2.DataDir);
+            const fs = c.resolve(tokens_js_1.DI.V2.FileSystem);
+            const base64url = c.resolve(tokens_js_1.DI.V2.Base64Url);
+            const entropy = c.resolve(tokens_js_1.DI.V2.RandomEntropy);
+            return new LocalKeyringV2(dataDir, fs, base64url, entropy);
+        }),
+    });
+    tsyringe_1.container.register(tokens_js_1.DI.V2.SessionStore, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)((c) => {
+            const dataDir = c.resolve(tokens_js_1.DI.V2.DataDir);
+            const fs = c.resolve(tokens_js_1.DI.V2.FileSystem);
+            const sha256 = c.resolve(tokens_js_1.DI.V2.Sha256);
+            return new LocalSessionEventLogStoreV2(dataDir, fs, sha256);
+        }),
+    });
+    tsyringe_1.container.register(tokens_js_1.DI.V2.SnapshotStore, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)((c) => {
+            const dataDir = c.resolve(tokens_js_1.DI.V2.DataDir);
+            const fs = c.resolve(tokens_js_1.DI.V2.FileSystem);
+            const crypto = c.resolve(tokens_js_1.DI.V2.Crypto);
+            return new LocalSnapshotStoreV2(dataDir, fs, crypto);
+        }),
+    });
+    tsyringe_1.container.register(tokens_js_1.DI.V2.PinnedWorkflowStore, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)((c) => {
+            const dataDir = c.resolve(tokens_js_1.DI.V2.DataDir);
+            const fs = c.resolve(tokens_js_1.DI.V2.FileSystem);
+            return new LocalPinnedWorkflowStoreV2(dataDir, fs);
+        }),
+    });
+    tsyringe_1.container.register(tokens_js_1.DI.V2.SessionLock, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)((c) => {
+            const dataDir = c.resolve(tokens_js_1.DI.V2.DataDir);
+            const fs = c.resolve(tokens_js_1.DI.V2.FileSystem);
+            const clock = c.resolve(tokens_js_1.DI.V2.TimeClock);
+            return new LocalSessionLockV2(dataDir, fs, clock);
+        }),
+    });
+    const { ExecutionSessionGateV2 } = await Promise.resolve().then(() => __importStar(require('../v2/usecases/execution-session-gate.js')));
+    tsyringe_1.container.register(tokens_js_1.DI.V2.ExecutionGate, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)((c) => {
+            const lock = c.resolve(tokens_js_1.DI.V2.SessionLock);
+            const store = c.resolve(tokens_js_1.DI.V2.SessionStore);
+            return new ExecutionSessionGateV2(lock, store);
+        }),
+    });
+}
 async function initializeContainer(options = {}) {
     if (initialized)
         return;
@@ -196,6 +283,7 @@ async function initializeContainer(options = {}) {
         registerRuntime(options);
         await registerConfig();
         await registerStorageChain();
+        await registerV2Services();
         await registerServices();
         initialized = true;
         console.error('[DI] Container initialized');

package/dist/di/tokens.d.ts

@@ -21,6 +21,22 @@ export declare const DI: {
     readonly Mcp: {
         readonly DescriptionProvider: symbol;
     };
+    readonly V2: {
+        readonly DataDir: symbol;
+        readonly FileSystem: symbol;
+        readonly Sha256: symbol;
+        readonly Crypto: symbol;
+        readonly HmacSha256: symbol;
+        readonly Base64Url: symbol;
+        readonly RandomEntropy: symbol;
+        readonly TimeClock: symbol;
+        readonly Keyring: symbol;
+        readonly SessionStore: symbol;
+        readonly SnapshotStore: symbol;
+        readonly PinnedWorkflowStore: symbol;
+        readonly SessionLock: symbol;
+        readonly ExecutionGate: symbol;
+    };
     readonly Runtime: {
         readonly Mode: symbol;
         readonly ProcessLifecyclePolicy: symbol;

package/dist/di/tokens.js

@@ -24,6 +24,22 @@ exports.DI = {
     Mcp: {
         DescriptionProvider: Symbol('Mcp.DescriptionProvider'),
     },
+    V2: {
+        DataDir: Symbol('V2.DataDir'),
+        FileSystem: Symbol('V2.FileSystem'),
+        Sha256: Symbol('V2.Sha256'),
+        Crypto: Symbol('V2.Crypto'),
+        HmacSha256: Symbol('V2.HmacSha256'),
+        Base64Url: Symbol('V2.Base64Url'),
+        RandomEntropy: Symbol('V2.RandomEntropy'),
+        TimeClock: Symbol('V2.TimeClock'),
+        Keyring: Symbol('V2.Keyring'),
+        SessionStore: Symbol('V2.SessionStore'),
+        SnapshotStore: Symbol('V2.SnapshotStore'),
+        PinnedWorkflowStore: Symbol('V2.PinnedWorkflowStore'),
+        SessionLock: Symbol('V2.SessionLock'),
+        ExecutionGate: Symbol('V2.ExecutionGate'),
+    },
     Runtime: {
         Mode: Symbol('Runtime.Mode'),
         ProcessLifecyclePolicy: Symbol('Runtime.ProcessLifecyclePolicy'),

package/dist/domain/execution/state.d.ts

@@ -20,12 +20,12 @@ export declare const LoopFrameSchema: z.ZodObject<{
     iteration: z.ZodNumber;
     bodyIndex: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
-    iteration: number;
     loopId: string;
+    iteration: number;
     bodyIndex: number;
 }, {
-    iteration: number;
     loopId: string;
+    iteration: number;
     bodyIndex: number;
 }>;
 export declare const StepInstanceIdSchema: z.ZodObject<{
@@ -34,23 +34,23 @@ export declare const StepInstanceIdSchema: z.ZodObject<{
         loopId: z.ZodString;
         iteration: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
-        iteration: number;
         loopId: string;
-    }, {
         iteration: number;
+    }, {
         loopId: string;
+        iteration: number;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     stepId: string;
     loopPath: {
-        iteration: number;
         loopId: string;
+        iteration: number;
     }[];
 }, {
     stepId: string;
     loopPath: {
-        iteration: number;
         loopId: string;
+        iteration: number;
     }[];
 }>;
 export declare const ExecutionStateSchema: z.ZodType<ExecutionState>;

package/dist/domain/workflow-id-policy.d.ts

@@ -0,0 +1,17 @@
+import type { WorkflowSourceKind } from '../types/workflow-source';
+export type WorkflowIdParse = {
+    readonly kind: 'legacy';
+    readonly raw: string;
+} | {
+    readonly kind: 'namespaced';
+    readonly raw: string;
+    readonly namespace: string;
+    readonly name: string;
+};
+export interface WorkflowIdLoadValidation {
+    readonly parsed: WorkflowIdParse;
+    readonly warnings: readonly string[];
+}
+export declare function parseWorkflowId(raw: string): WorkflowIdParse | null;
+export declare function validateWorkflowIdForLoad(raw: string, sourceKind: WorkflowSourceKind): WorkflowIdLoadValidation;
+export declare function validateWorkflowIdForSave(raw: string, sourceKind: WorkflowSourceKind): WorkflowIdParse;

package/dist/domain/workflow-id-policy.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseWorkflowId = parseWorkflowId;
+exports.validateWorkflowIdForLoad = validateWorkflowIdForLoad;
+exports.validateWorkflowIdForSave = validateWorkflowIdForSave;
+const error_handler_1 = require("../core/error-handler");
+const NAMESPACED_SEGMENT_RE = /^[a-z][a-z0-9_-]*$/;
+const LEGACY_ID_RE = /^[a-z0-9_-]+$/;
+function parseWorkflowId(raw) {
+    if (typeof raw !== 'string' || raw.length === 0)
+        return null;
+    if (!raw.includes('.')) {
+        if (!LEGACY_ID_RE.test(raw))
+            return null;
+        return { kind: 'legacy', raw };
+    }
+    const parts = raw.split('.');
+    if (parts.length !== 2)
+        return null;
+    const [namespace, name] = parts;
+    if (!namespace || !name)
+        return null;
+    if (!NAMESPACED_SEGMENT_RE.test(namespace))
+        return null;
+    if (!NAMESPACED_SEGMENT_RE.test(name))
+        return null;
+    return { kind: 'namespaced', raw, namespace, name };
+}
+function validateWorkflowIdForLoad(raw, sourceKind) {
+    const parsed = parseWorkflowId(raw);
+    if (!parsed) {
+        throw new error_handler_1.InvalidWorkflowError(raw || 'unknown', 'Invalid workflow id format');
+    }
+    if (parsed.kind === 'legacy') {
+        return {
+            parsed,
+            warnings: ['legacy_workflow_id'],
+        };
+    }
+    if (parsed.namespace === 'wr' && sourceKind !== 'bundled') {
+        throw new error_handler_1.InvalidWorkflowError(parsed.raw, `Reserved workflow namespace 'wr.*' is only allowed for bundled workflows (sourceKind=${sourceKind})`);
+    }
+    return { parsed, warnings: [] };
+}
+function validateWorkflowIdForSave(raw, sourceKind) {
+    const parsed = parseWorkflowId(raw);
+    if (!parsed) {
+        throw new error_handler_1.InvalidWorkflowError(raw || 'unknown', 'Invalid workflow id format');
+    }
+    if (parsed.kind === 'legacy') {
+        throw new error_handler_1.InvalidWorkflowError(parsed.raw, "Legacy workflow ids (no dot) are no longer allowed for new workflows; use 'namespace.name'");
+    }
+    if (parsed.namespace === 'wr' && sourceKind !== 'bundled') {
+        throw new error_handler_1.InvalidWorkflowError(parsed.raw, `Reserved workflow namespace 'wr.*' is only allowed for bundled workflows (sourceKind=${sourceKind})`);
+    }
+    return parsed;
+}