@exaudeus/workrail 0.12.0 → 0.14.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,16 +59,21 @@ 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 this.validationEngine.validate(output, criteria);
+            return { valid: true, issues: [], suggestions: [], warnings: undefined };
+        const result = await this.validationEngine.validate(output, criteria);
+        const contextualizedWarnings = result.warnings?.map(w => `Step '${workflowId}/${stepId}': ${w}`);
+        return {
+            ...result,
+            warnings: contextualizedWarnings,
+        };
     }
     getOrCompile(workflowId, workflow) {
         const cached = this.compiledCache.get(workflowId);

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/di/container.js

@@ -178,6 +178,9 @@ async function registerV2Services() {
     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)),
     });
@@ -193,6 +196,15 @@ async function registerV2Services() {
     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')));
@@ -202,7 +214,9 @@ async function registerV2Services() {
         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 LocalKeyringV2(dataDir, fs);
+            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, {
@@ -224,14 +238,16 @@ async function registerV2Services() {
     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);
-            return new LocalPinnedWorkflowStoreV2(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);
-            return new LocalSessionLockV2(dataDir, fs);
+            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')));

package/dist/di/tokens.d.ts

@@ -27,6 +27,9 @@ export declare const DI: {
         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;

package/dist/di/tokens.js

@@ -30,6 +30,9 @@ exports.DI = {
         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'),

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;
+}

package/dist/infrastructure/storage/enhanced-multi-source-workflow-storage.js

@@ -133,15 +133,21 @@ class EnhancedMultiSourceWorkflowStorage {
             try {
                 const workflows = await storage.loadAllWorkflows();
                 for (const workflow of workflows) {
-                    if (seenIds.has(workflow.definition.id)) {
-                        const existingIndex = allWorkflows.findIndex(wf => wf.definition.id === workflow.definition.id);
+                    const id = workflow.definition.id;
+                    if (seenIds.has(id)) {
+                        const existingIndex = allWorkflows.findIndex((wf) => wf.definition.id === id);
                         if (existingIndex >= 0) {
+                            const existing = allWorkflows[existingIndex];
+                            const isWr = id.startsWith('wr.');
+                            if (isWr && existing.source.kind === 'bundled') {
+                                continue;
+                            }
                             allWorkflows[existingIndex] = workflow;
                         }
                     }
                     else {
                         allWorkflows.push(workflow);
-                        seenIds.add(workflow.definition.id);
+                        seenIds.add(id);
                     }
                 }
             }
@@ -152,6 +158,21 @@ class EnhancedMultiSourceWorkflowStorage {
         return allWorkflows;
     }
     async getWorkflowById(id) {
+        if (id.startsWith('wr.')) {
+            for (let i = 0; i < this.storageInstances.length; i++) {
+                const storage = this.storageInstances[i];
+                if (storage.source.kind !== 'bundled')
+                    continue;
+                try {
+                    const workflow = await storage.getWorkflowById(id);
+                    if (workflow)
+                        return workflow;
+                }
+                catch (error) {
+                    this.handleSourceError(`source-${i}`, error);
+                }
+            }
+        }
         for (let i = this.storageInstances.length - 1; i >= 0; i--) {
             const storage = this.storageInstances[i];
             try {
@@ -174,15 +195,21 @@ class EnhancedMultiSourceWorkflowStorage {
             try {
                 const summaries = await storage.listWorkflowSummaries();
                 for (const summary of summaries) {
-                    if (seenIds.has(summary.id)) {
-                        const existingIndex = allSummaries.findIndex(s => s.id === summary.id);
+                    const id = summary.id;
+                    if (seenIds.has(id)) {
+                        const existingIndex = allSummaries.findIndex((s) => s.id === id);
                         if (existingIndex >= 0) {
+                            const existing = allSummaries[existingIndex];
+                            const isWr = id.startsWith('wr.');
+                            if (isWr && existing.source.kind === 'bundled') {
+                                continue;
+                            }
                             allSummaries[existingIndex] = summary;
                         }
                     }
                     else {
                         allSummaries.push(summary);
-                        seenIds.add(summary.id);
+                        seenIds.add(id);
                     }
                 }
             }

package/dist/infrastructure/storage/file-workflow-storage.js

@@ -10,12 +10,13 @@ const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
 const workflow_1 = require("../../types/workflow");
 const error_handler_1 = require("../../core/error-handler");
+const workflow_id_policy_1 = require("../../domain/workflow-id-policy");
 function sanitizeId(id) {
     if (id.includes('\u0000')) {
         throw new error_handler_1.SecurityError('Null byte detected in identifier', 'sanitizeId');
     }
     const normalised = id.normalize('NFC');
-    const valid = /^[a-zA-Z0-9_-]+$/.test(normalised);
+    const valid = /^[a-zA-Z0-9_.-]+$/.test(normalised);
     if (!valid) {
         throw new error_handler_1.InvalidWorkflowError(id, 'Invalid characters in workflow id');
     }
@@ -182,6 +183,7 @@ class FileWorkflowStorage {
         if (!definition.id || !definition.name || !definition.steps) {
             throw new error_handler_1.InvalidWorkflowError(definition.id || 'unknown', 'Definition must have id, name, and steps');
         }
+        (0, workflow_id_policy_1.validateWorkflowIdForSave)(definition.id, this.source.kind);
         const safeId = sanitizeId(definition.id);
         const filename = `${safeId}.json`;
         const filePath = path_1.default.resolve(this.baseDirReal, filename);