@exaudeus/workrail 3.0.0 → 3.1.0

package/dist/application/services/compiler/resolve-templates.d.ts

@@ -9,5 +9,10 @@ export type ResolveTemplatesPassError = {
     readonly code: 'TEMPLATE_EXPAND_ERROR';
     readonly stepId: string;
     readonly cause: TemplateExpandError;
+} | {
+    readonly code: 'DUPLICATE_STEP_ID';
+    readonly stepId: string;
+    readonly templateId: string;
+    readonly message: string;
 };
 export declare function resolveTemplatesPass(steps: readonly (WorkflowStepDefinition | LoopStepDefinition)[], registry: TemplateRegistry): Result<readonly (WorkflowStepDefinition | LoopStepDefinition)[], ResolveTemplatesPassError>;

package/dist/application/services/compiler/resolve-templates.js

@@ -23,10 +23,17 @@ function resolveStepTemplate(step, registry) {
             cause: expandResult.error,
         });
     }
+    if (step.runCondition) {
+        return (0, neverthrow_1.ok)(expandResult.value.map(expanded => ({
+            ...expanded,
+            runCondition: expanded.runCondition ?? step.runCondition,
+        })));
+    }
     return (0, neverthrow_1.ok)(expandResult.value);
 }
 function resolveTemplatesPass(steps, registry) {
     const resolved = [];
+    const seenIds = new Set();
     for (const step of steps) {
         if ((0, workflow_definition_js_1.isLoopStepDefinition)(step)) {
             if (Array.isArray(step.body)) {
@@ -35,11 +42,22 @@ function resolveTemplatesPass(steps, registry) {
                     const res = resolveStepTemplate(bodyStep, registry);
                     if (res.isErr())
                         return (0, neverthrow_1.err)(res.error);
+                    for (const expanded of res.value) {
+                        const collision = checkIdCollision(expanded.id, bodyStep.templateCall?.templateId, seenIds);
+                        if (collision)
+                            return (0, neverthrow_1.err)(collision);
+                    }
                     bodyResolved.push(...res.value);
                 }
+                const loopCollision = checkIdCollision(step.id, undefined, seenIds);
+                if (loopCollision)
+                    return (0, neverthrow_1.err)(loopCollision);
                 resolved.push({ ...step, body: bodyResolved });
             }
             else {
+                const loopCollision = checkIdCollision(step.id, undefined, seenIds);
+                if (loopCollision)
+                    return (0, neverthrow_1.err)(loopCollision);
                 resolved.push(step);
             }
         }
@@ -47,8 +65,25 @@ function resolveTemplatesPass(steps, registry) {
             const res = resolveStepTemplate(step, registry);
             if (res.isErr())
                 return (0, neverthrow_1.err)(res.error);
+            for (const expanded of res.value) {
+                const collision = checkIdCollision(expanded.id, step.templateCall?.templateId, seenIds);
+                if (collision)
+                    return (0, neverthrow_1.err)(collision);
+            }
             resolved.push(...res.value);
         }
     }
     return (0, neverthrow_1.ok)(resolved);
 }
+function checkIdCollision(stepId, templateId, seenIds) {
+    if (seenIds.has(stepId)) {
+        return {
+            code: 'DUPLICATE_STEP_ID',
+            stepId,
+            templateId: templateId ?? '(none)',
+            message: `Duplicate step id '${stepId}' after template expansion${templateId ? ` (from template '${templateId}')` : ''}`,
+        };
+    }
+    seenIds.add(stepId);
+    return undefined;
+}

package/dist/application/services/compiler/routine-loader.d.ts

@@ -0,0 +1,11 @@
+import type { Result } from 'neverthrow';
+import type { WorkflowDefinition } from '../../../types/workflow-definition.js';
+export interface RoutineLoadWarning {
+    readonly file: string;
+    readonly reason: string;
+}
+export interface RoutineLoadResult {
+    readonly routines: ReadonlyMap<string, WorkflowDefinition>;
+    readonly warnings: readonly RoutineLoadWarning[];
+}
+export declare function loadRoutineDefinitions(routinesDir?: string): Result<RoutineLoadResult, string>;

package/dist/application/services/compiler/routine-loader.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRoutineDefinitions = loadRoutineDefinitions;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const neverthrow_1 = require("neverthrow");
+const workflow_definition_js_1 = require("../../../types/workflow-definition.js");
+function resolveRoutinesDir() {
+    const projectRoot = path_1.default.resolve(__dirname, '..', '..', '..', '..');
+    return path_1.default.join(projectRoot, 'workflows', 'routines');
+}
+function loadRoutineDefinitions(routinesDir) {
+    const dir = routinesDir ?? resolveRoutinesDir();
+    if (!(0, fs_1.existsSync)(dir)) {
+        return (0, neverthrow_1.ok)({ routines: new Map(), warnings: [] });
+    }
+    let files;
+    try {
+        files = (0, fs_1.readdirSync)(dir).filter(f => f.endsWith('.json'));
+    }
+    catch (e) {
+        return (0, neverthrow_1.err)(`Failed to read routines directory '${dir}': ${e}`);
+    }
+    const routines = new Map();
+    const warnings = [];
+    for (const file of files) {
+        const filePath = path_1.default.join(dir, file);
+        try {
+            const raw = (0, fs_1.readFileSync)(filePath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            if (!(0, workflow_definition_js_1.hasWorkflowDefinitionShape)(parsed)) {
+                warnings.push({ file, reason: 'does not match WorkflowDefinition shape (missing id, name, description, version, or steps)' });
+                continue;
+            }
+            routines.set(parsed.id, parsed);
+        }
+        catch (e) {
+            warnings.push({ file, reason: String(e) });
+        }
+    }
+    return (0, neverthrow_1.ok)({ routines, warnings });
+}

package/dist/application/services/compiler/template-registry.d.ts

@@ -16,6 +16,6 @@ export interface TemplateRegistry {
     readonly has: (templateId: string) => boolean;
     readonly knownIds: () => readonly string[];
 }
-export declare function createRoutineExpander(routineId: string, definition: WorkflowDefinition): Result<TemplateExpander, TemplateExpandError>;
 export declare function routineIdToTemplateId(routineId: string): string;
-export declare function createTemplateRegistry(routineDefinitions?: ReadonlyMap<string, WorkflowDefinition>): TemplateRegistry;
+export declare function createRoutineExpander(routineId: string, definition: WorkflowDefinition): Result<TemplateExpander, TemplateExpandError>;
+export declare function createTemplateRegistry(routineExpanders?: ReadonlyMap<string, TemplateExpander>): TemplateRegistry;

package/dist/application/services/compiler/template-registry.js

@@ -1,78 +1,95 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRoutineExpander = createRoutineExpander;
 exports.routineIdToTemplateId = routineIdToTemplateId;
+exports.createRoutineExpander = createRoutineExpander;
 exports.createTemplateRegistry = createTemplateRegistry;
 const neverthrow_1 = require("neverthrow");
 const SINGLE_BRACE_ARG = /(?<!\{)\{([^{}]+)\}(?!\})/g;
-function substituteArgs(text, args, routineId, stepId) {
+function isSubstitutableValue(value) {
+    return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
+}
+function substituteArgs(template, args, templateId, routineId, stepId) {
     const missing = [];
-    const substituted = text.replace(SINGLE_BRACE_ARG, (match, argName) => {
-        if (argName in args) {
-            return String(args[argName]);
+    const badType = [];
+    const result = template.replace(SINGLE_BRACE_ARG, (match, argName) => {
+        if (!(argName in args)) {
+            missing.push(argName);
+            return match;
         }
-        missing.push(argName);
-        return match;
+        const value = args[argName];
+        if (!isSubstitutableValue(value)) {
+            badType.push(argName);
+            return match;
+        }
+        return String(value);
     });
     if (missing.length > 0) {
         return (0, neverthrow_1.err)({
             code: 'TEMPLATE_EXPAND_FAILED',
-            templateId: `wr.templates.routine.${routineId}`,
+            templateId,
             message: `MISSING_TEMPLATE_ARG: routine '${routineId}' step '${stepId}' references arg(s) '${missing.join("', '")}' but they were not provided in templateCall.args`,
         });
     }
-    return (0, neverthrow_1.ok)(substituted);
-}
-function validateNoRecursiveTemplateCall(routineId, steps) {
-    for (const step of steps) {
-        if (step.templateCall) {
-            return (0, neverthrow_1.err)({
-                code: 'TEMPLATE_EXPAND_FAILED',
-                templateId: `wr.templates.routine.${routineId}`,
-                message: `Routine '${routineId}' step '${step.id}' contains a templateCall. Recursive routine injection is not supported.`,
-            });
-        }
+    if (badType.length > 0) {
+        return (0, neverthrow_1.err)({
+            code: 'TEMPLATE_EXPAND_FAILED',
+            templateId,
+            message: `INVALID_TEMPLATE_ARG_TYPE: routine '${routineId}' step '${stepId}' arg(s) '${badType.join("', '")}' must be string, number, or boolean (got non-primitive)`,
+        });
     }
-    return (0, neverthrow_1.ok)(undefined);
+    return (0, neverthrow_1.ok)(result);
+}
+function routineIdToTemplateId(routineId) {
+    const name = routineId.startsWith('routine-') ? routineId.slice('routine-'.length) : routineId;
+    return `wr.templates.routine.${name}`;
 }
 function createRoutineExpander(routineId, definition) {
-    const routineSteps = definition.steps;
-    const recursiveCheck = validateNoRecursiveTemplateCall(routineId, routineSteps);
-    if (recursiveCheck.isErr())
-        return (0, neverthrow_1.err)(recursiveCheck.error);
-    for (const step of routineSteps) {
-        if (!step.id || !step.title) {
+    for (const step of definition.steps) {
+        if ('templateCall' in step && step.templateCall) {
             return (0, neverthrow_1.err)({
                 code: 'TEMPLATE_EXPAND_FAILED',
-                templateId: `wr.templates.routine.${routineId}`,
-                message: `Routine '${routineId}' step '${step.id ?? '(missing id)'}' is missing required field '${!step.id ? 'id' : 'title'}'.`,
-            });
-        }
-        if (!step.prompt) {
-            return (0, neverthrow_1.err)({
-                code: 'TEMPLATE_EXPAND_FAILED',
-                templateId: `wr.templates.routine.${routineId}`,
-                message: `Routine '${routineId}' step '${step.id}' is missing required field 'prompt'.`,
+                templateId: routineIdToTemplateId(routineId),
+                message: `Routine '${routineId}' step '${step.id}' contains a templateCall. Recursive routine injection is not allowed.`,
             });
         }
     }
-    const routineGuidance = definition.metaGuidance ?? [];
+    const templateId = routineIdToTemplateId(routineId);
     const expander = (callerId, args) => {
         const expandedSteps = [];
-        for (const step of routineSteps) {
-            const promptResult = substituteArgs(step.prompt, args, routineId, step.id);
+        for (const step of definition.steps) {
+            if (!step.id || !step.title) {
+                return (0, neverthrow_1.err)({
+                    code: 'TEMPLATE_EXPAND_FAILED',
+                    templateId,
+                    message: `Routine '${routineId}' step '${step.id ?? '(missing id)'}' is missing required field '${!step.id ? 'id' : 'title'}'.`,
+                });
+            }
+            if (!step.prompt) {
+                return (0, neverthrow_1.err)({
+                    code: 'TEMPLATE_EXPAND_FAILED',
+                    templateId,
+                    message: `Routine '${routineId}' step '${step.id}' is missing required field 'prompt'.`,
+                });
+            }
+            const promptResult = substituteArgs(step.prompt, args, templateId, routineId, step.id);
             if (promptResult.isErr())
                 return (0, neverthrow_1.err)(promptResult.error);
-            const mergedGuidance = routineGuidance.length > 0
-                ? [...(step.guidance ?? []), ...routineGuidance]
-                : (step.guidance ?? []);
+            const titleResult = substituteArgs(step.title, args, templateId, routineId, step.id);
+            if (titleResult.isErr())
+                return (0, neverthrow_1.err)(titleResult.error);
             const expandedStep = {
+                ...step,
                 id: `${callerId}.${step.id}`,
-                title: step.title,
+                title: titleResult.value,
                 prompt: promptResult.value,
-                ...(step.agentRole !== undefined && { agentRole: step.agentRole }),
-                ...(mergedGuidance.length > 0 && { guidance: mergedGuidance }),
-                ...(step.requireConfirmation !== undefined && { requireConfirmation: step.requireConfirmation }),
+                ...(definition.metaGuidance && definition.metaGuidance.length > 0
+                    ? {
+                        guidance: [
+                            ...(step.guidance ?? []),
+                            ...definition.metaGuidance,
+                        ],
+                    }
+                    : {}),
             };
             expandedSteps.push(expandedStep);
         }
@@ -80,26 +97,18 @@ function createRoutineExpander(routineId, definition) {
     };
     return (0, neverthrow_1.ok)(expander);
 }
-function routineIdToTemplateId(routineId) {
-    const name = routineId.startsWith('routine-') ? routineId.slice('routine-'.length) : routineId;
-    return `wr.templates.routine.${name}`;
-}
-const STATIC_TEMPLATE_DEFINITIONS = new Map();
-function createTemplateRegistry(routineDefinitions) {
-    const allTemplates = new Map(STATIC_TEMPLATE_DEFINITIONS);
-    if (routineDefinitions) {
-        for (const [routineId, definition] of routineDefinitions) {
-            const templateId = routineIdToTemplateId(routineId);
-            const expanderResult = createRoutineExpander(routineId, definition);
-            if (expanderResult.isOk()) {
-                allTemplates.set(templateId, expanderResult.value);
-            }
+const TEMPLATE_DEFINITIONS = new Map();
+function createTemplateRegistry(routineExpanders) {
+    const allExpanders = new Map(TEMPLATE_DEFINITIONS);
+    if (routineExpanders) {
+        for (const [id, expander] of routineExpanders) {
+            allExpanders.set(id, expander);
         }
     }
-    const knownIds = [...allTemplates.keys()];
+    const knownIds = [...allExpanders.keys()];
     return {
         resolve(templateId) {
-            const expander = allTemplates.get(templateId);
+            const expander = allExpanders.get(templateId);
             if (!expander) {
                 return (0, neverthrow_1.err)({
                     code: 'UNKNOWN_TEMPLATE',
@@ -110,7 +119,7 @@ function createTemplateRegistry(routineDefinitions) {
             return (0, neverthrow_1.ok)(expander);
         },
         has(templateId) {
-            return allTemplates.has(templateId);
+            return allExpanders.has(templateId);
         },
         knownIds() {
             return knownIds;

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

@@ -2,7 +2,6 @@ import { Workflow, WorkflowStepDefinition, LoopStepDefinition } from '../../type
 import type { LoopConditionSource } from '../../types/workflow-definition';
 import type { Result } from 'neverthrow';
 import { type DomainError } from '../../domain/execution/error';
-import { type TemplateRegistry } from './compiler/template-registry';
 export interface CompiledLoop {
     readonly loop: LoopStepDefinition;
     readonly bodySteps: readonly WorkflowStepDefinition[];
@@ -15,11 +14,8 @@ export interface CompiledWorkflow {
     readonly compiledLoops: ReadonlyMap<string, CompiledLoop>;
     readonly loopBodyStepIds: ReadonlySet<string>;
 }
-export declare function resolveDefinitionSteps(steps: readonly (WorkflowStepDefinition | LoopStepDefinition)[], features: readonly string[], templateRegistry?: TemplateRegistry): Result<readonly (WorkflowStepDefinition | LoopStepDefinition)[], DomainError>;
+export declare function resolveDefinitionSteps(steps: readonly (WorkflowStepDefinition | LoopStepDefinition)[], features: readonly string[]): Result<readonly (WorkflowStepDefinition | LoopStepDefinition)[], DomainError>;
 export declare class WorkflowCompiler {
-    private readonly templateRegistry;
-    constructor();
-    static withTemplateRegistry(registry: TemplateRegistry): WorkflowCompiler;
     compile(workflow: Workflow): Result<CompiledWorkflow, DomainError>;
     private deriveConditionSource;
     private resolveLoopBody;

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

@@ -5,10 +5,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var WorkflowCompiler_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkflowCompiler = void 0;
 exports.resolveDefinitionSteps = resolveDefinitionSteps;
@@ -24,16 +20,47 @@ const resolve_features_1 = require("./compiler/resolve-features");
 const feature_registry_1 = require("./compiler/feature-registry");
 const resolve_templates_1 = require("./compiler/resolve-templates");
 const template_registry_1 = require("./compiler/template-registry");
+const routine_loader_1 = require("./compiler/routine-loader");
 const _refRegistry = (0, ref_registry_1.createRefRegistry)();
 const _featureRegistry = (0, feature_registry_1.createFeatureRegistry)();
-const _defaultTemplateRegistry = (0, template_registry_1.createTemplateRegistry)();
-function resolveDefinitionSteps(steps, features, templateRegistry = _defaultTemplateRegistry) {
-    const templatesResult = (0, resolve_templates_1.resolveTemplatesPass)(steps, templateRegistry);
+function buildTemplateRegistry() {
+    const routineExpanders = new Map();
+    const loadResult = (0, routine_loader_1.loadRoutineDefinitions)();
+    if (loadResult.isErr()) {
+        console.warn(`[WorkflowCompiler] Failed to load routine definitions: ${loadResult.error}`);
+        return (0, template_registry_1.createTemplateRegistry)();
+    }
+    const { routines, warnings } = loadResult.value;
+    for (const w of warnings) {
+        console.warn(`[WorkflowCompiler] Skipped routine file '${w.file}': ${w.reason}`);
+    }
+    for (const [routineId, definition] of routines) {
+        const expanderResult = (0, template_registry_1.createRoutineExpander)(routineId, definition);
+        if (expanderResult.isOk()) {
+            routineExpanders.set((0, template_registry_1.routineIdToTemplateId)(routineId), expanderResult.value);
+        }
+        else {
+            console.warn(`[WorkflowCompiler] Failed to create expander for routine '${routineId}': ${expanderResult.error.message}`);
+        }
+    }
+    return (0, template_registry_1.createTemplateRegistry)(routineExpanders.size > 0 ? routineExpanders : undefined);
+}
+let _templateRegistryCache;
+function getTemplateRegistry() {
+    if (!_templateRegistryCache) {
+        _templateRegistryCache = buildTemplateRegistry();
+    }
+    return _templateRegistryCache;
+}
+function resolveDefinitionSteps(steps, features) {
+    const templatesResult = (0, resolve_templates_1.resolveTemplatesPass)(steps, getTemplateRegistry());
     if (templatesResult.isErr()) {
         const e = templatesResult.error;
         const message = e.code === 'TEMPLATE_RESOLVE_ERROR'
             ? `Step '${e.stepId}': template error — ${e.cause.message}`
-            : `Step '${e.stepId}': template expansion error — ${e.cause.message}`;
+            : e.code === 'DUPLICATE_STEP_ID'
+                ? e.message
+                : `Step '${e.stepId}': template expansion error — ${e.cause.message}`;
         return (0, neverthrow_1.err)(error_1.Err.invalidState(message));
     }
     const featuresResult = (0, resolve_features_1.resolveFeaturesPass)(templatesResult.value, features, _featureRegistry);
@@ -59,17 +86,9 @@ function resolveDefinitionSteps(steps, features, templateRegistry = _defaultTemp
     }
     return (0, neverthrow_1.ok)(blocksResult.value);
 }
-let WorkflowCompiler = WorkflowCompiler_1 = class WorkflowCompiler {
-    constructor() {
-        this.templateRegistry = _defaultTemplateRegistry;
-    }
-    static withTemplateRegistry(registry) {
-        const compiler = new WorkflowCompiler_1();
-        compiler.templateRegistry = registry;
-        return compiler;
-    }
+let WorkflowCompiler = class WorkflowCompiler {
     compile(workflow) {
-        const resolvedResult = resolveDefinitionSteps(workflow.definition.steps, workflow.definition.features ?? [], this.templateRegistry);
+        const resolvedResult = resolveDefinitionSteps(workflow.definition.steps, workflow.definition.features ?? []);
         if (resolvedResult.isErr())
             return (0, neverthrow_1.err)(resolvedResult.error);
         const steps = resolvedResult.value;
@@ -170,7 +189,6 @@ let WorkflowCompiler = WorkflowCompiler_1 = class WorkflowCompiler {
     }
 };
 exports.WorkflowCompiler = WorkflowCompiler;
-exports.WorkflowCompiler = WorkflowCompiler = WorkflowCompiler_1 = __decorate([
-    (0, tsyringe_1.singleton)(),
-    __metadata("design:paramtypes", [])
+exports.WorkflowCompiler = WorkflowCompiler = __decorate([
+    (0, tsyringe_1.singleton)()
 ], WorkflowCompiler);

package/dist/infrastructure/storage/file-workflow-storage.d.ts

@@ -26,7 +26,6 @@ export declare class FileWorkflowStorage implements IWorkflowStorage {
     private loadDefinitionFromFile;
     loadAllWorkflows(): Promise<readonly Workflow[]>;
     getWorkflowById(id: string): Promise<Workflow | null>;
-    getRoutineDefinitions(): Promise<ReadonlyMap<string, WorkflowDefinition>>;
     listWorkflowSummaries(): Promise<readonly WorkflowSummary[]>;
     save(definition: WorkflowDefinition): Promise<void>;
 }

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

@@ -164,16 +164,6 @@ class FileWorkflowStorage {
         }
         return workflow;
     }
-    async getRoutineDefinitions() {
-        const index = await this.getWorkflowIndex();
-        const routines = new Map();
-        for (const entry of index.values()) {
-            if (entry.id.startsWith('routine-')) {
-                routines.set(entry.id, entry.definition);
-            }
-        }
-        return routines;
-    }
     async listWorkflowSummaries() {
         const workflows = await this.loadAllWorkflows();
         return workflows.map(workflow_1.toWorkflowSummary);

package/dist/manifest.json

@@ -42,20 +42,28 @@
       "bytes": 4214
     },
     "application/services/compiler/resolve-templates.d.ts": {
-      "sha256": "623e4b9e7b65c1cbe8a6acee232ba3fa7b11c9394f22a77c7443a02681b0a0a8",
-      "bytes": 767
+      "sha256": "ccb4fbbf00f3ccbfcb9225998bcb9bfbd30a7e64dcfc2b2bc0f06701ee9a8e33",
+      "bytes": 905
     },
     "application/services/compiler/resolve-templates.js": {
-      "sha256": "2d7bef8627cd933fa265d9faf9b0d6ced860bd66b39793af7ffa97956ba38a09",
-      "bytes": 1997
+      "sha256": "96f152a9f8b16aa7779b17ac56b555e45ad1213b32607961f060a080c6610a1a",
+      "bytes": 3590
+    },
+    "application/services/compiler/routine-loader.d.ts": {
+      "sha256": "831ed318f498c20ef9d547f38aea22a3fa2c677cd923634129545e7bf69ad241",
+      "bytes": 481
+    },
+    "application/services/compiler/routine-loader.js": {
+      "sha256": "fa5db5a759d88e63ef65bc877311d41003813d742fbdda7d06bc8abf56007988",
+      "bytes": 1849
     },
     "application/services/compiler/template-registry.d.ts": {
-      "sha256": "0945a6c997eccd03f96e1893e513519a78bfb923a832f3d66a2a31c8fdb2a945",
-      "bytes": 1172
+      "sha256": "5c8aef7bd75fce04d56985932eb2ad37e23c8bc87a77c75ee2addf018d3e619d",
+      "bytes": 1168
     },
     "application/services/compiler/template-registry.js": {
-      "sha256": "79dab84c14a2adb99b7b1ab2e02986e6fd7b8bed501dfa781e418164763ce0fb",
-      "bytes": 5147
+      "sha256": "92f824723e8d137533f8c752f2f753bb2a88e5812631de0a6428e3c6ff44543a",
+      "bytes": 5283
     },
     "application/services/enhanced-error-service.d.ts": {
       "sha256": "b6fe8fad92717f0962f87aa9c0f88277bf28fe2b5e3cfd7875612ee57eb8c684",
@@ -98,12 +106,12 @@
       "bytes": 32055
     },
     "application/services/workflow-compiler.d.ts": {
-      "sha256": "94ebc79efd351f6f1c29e98e57731c573c291632e148a78e04a13b3d1160dbc9",
-      "bytes": 1455
+      "sha256": "41d0643ae2f07e5ce77a6e02344b5ca5b3c26bde828fbb307528a2ae097ac9d5",
+      "bytes": 1211
     },
     "application/services/workflow-compiler.js": {
-      "sha256": "f0c185af822082f605e1d01612987ac9d75ade104a2606621e0fcd8faa899485",
-      "bytes": 8796
+      "sha256": "1adfbce7e79f827b1be530128dd9f4fc65bf427c851d7669fd11f20d4639631f",
+      "bytes": 9578
     },
     "application/services/workflow-interpreter.d.ts": {
       "sha256": "56b5b5ad06d42096deba9f0abe7642c18a355a1e598749aab1730df4e9847674",
@@ -546,12 +554,12 @@
       "bytes": 17854
     },
     "infrastructure/storage/file-workflow-storage.d.ts": {
-      "sha256": "6a10df10ab073c4d3611b42e69e1fe45bdb9d2e437af2c3b6ef90361698d2be5",
-      "bytes": 1507
+      "sha256": "3ddd5c692ebec52dc36cf96013db510a8b0eb77aaeeb7ba38b646a69083f002a",
+      "bytes": 1428
     },
     "infrastructure/storage/file-workflow-storage.js": {
-      "sha256": "1db12e1adcac4b119b44fcfbfb1b31e8c15c055fc040c1a82774238e8bfc6e41",
-      "bytes": 8897
+      "sha256": "e5cfd6f8a7fed72961e041aa9c92765c28f4b9872c16e7cbdbd533f0177ea0f0",
+      "bytes": 8562
     },
     "infrastructure/storage/git-workflow-storage.d.ts": {
       "sha256": "67d7f10e12c78c674ced83da378cd159465d4b09176d8dfca240864b0d6f38c2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exaudeus/workrail",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "Step-by-step workflow enforcement for AI agents via MCP",
   "license": "MIT",
   "repository": {

package/workflows/coding-task-workflow-agentic.lean.v2.json

@@ -40,13 +40,51 @@
       }
     },
     {
-      "id": "phase-1-architecture-decision",
-      "title": "Phase 1: Architecture Decision (Generate, Compare, Challenge, Select)",
+      "id": "phase-1a-hypothesis",
+      "title": "Phase 1a: State Hypothesis",
       "runCondition": {
         "var": "taskComplexity",
         "not_equals": "Small"
       },
-      "prompt": "Design the architecture through deep understanding, not surface-level generation.\n\nPart A — Understand the problem deeply:\n- What are the core tensions in this problem? (e.g., performance vs simplicity, flexibility vs type safety, backward compatibility vs clean design)\n- How does the codebase already solve similar problems? Study the most relevant existing patterns — don't just list files, analyze the architectural decisions and constraints they protect.\n- What's the simplest naive solution? Why is it insufficient? (If it IS sufficient, that's your leading candidate — the burden of proof is on complexity.)\n- What makes this problem hard? What would a junior developer miss?\n\nPart B — Identify tensions and constraints (including philosophy):\n- Extract 2-4 real tradeoffs from your understanding (not generic labels like 'simplicity' or 'maintainability')\n- These tensions drive candidate generation — each candidate resolves them differently\n- Filter `philosophySources` to the principles actually under pressure for THIS problem. Which of the dev's philosophy principles constrain the solution space? For example: does the simplest solution require mutable state when the dev prefers immutability? Does the existing pattern use exceptions when the dev prefers Result types? Would the cleanest approach violate their preference for small interfaces?\n- If `philosophyConflicts` exist for this area of the codebase, surface them as explicit tensions the design must resolve: follow the stated rule, follow the existing pattern, or reconcile them\n\nPart C — State your hypothesis before delegating:\nBefore spawning any subagents, write 2-3 sentences: what do you currently believe the best approach is, and what concerns you most about it? This is your reference point for interrogating subagent output later.\n\nPart D — Generate candidates from tensions:\n- QUICK: self-generate candidates from your tensions. Include mandatory candidates: (1) simplest possible change that satisfies acceptance criteria, (2) follow existing repo pattern.\n- STANDARD: spawn ONE WorkRail Executor running `routine-tension-driven-design` with your tensions, philosophy sources, and problem understanding as input. Simultaneously, spawn ONE WorkRail Executor running `routine-hypothesis-challenge`: 'What constraints or failure modes would make you choose a fundamentally different approach? Propose one, grounded in real reasons.'\n- THOROUGH: spawn ONE WorkRail Executor running `routine-tension-driven-design`, ONE running `routine-hypothesis-challenge` (adversarial divergence), and ONE running `routine-execution-simulation`: 'Trace through the leading approach's 3 most likely failure scenarios step by step.'\n- For STANDARD with riskLevel=High: also spawn the execution simulation subagent.\n\nThe main agent ALWAYS self-generates its own candidates too (at minimum the two mandatory ones: simplest change + existing pattern). Subagent candidates supplement, not replace, your own thinking.\n\nPart E — Interrogate subagent output (if subagents were used):\nDo NOT summarize subagent findings as your own. Instead, interrogate against your hypothesis:\n- Where do subagent findings challenge your hypothesis? Are they right or did they miss context?\n- What did they surface that you genuinely hadn't considered?\n- Where are they just restating the obvious or echoing each other?\n- What did they get wrong or overweight?\nState explicitly: what you changed your mind about and why, or what you held firm on despite their input and why.\n\nPart F — Compare via tradeoffs (not checklists):\nFor each surviving candidate, produce:\n- One-sentence summary of the approach\n- Which tensions it resolves and which it accepts\n- The specific failure mode you'd watch for\n- How it relates to existing repo patterns (follows / adapts / departs)\n- What you gain and what you give up\n- Which of the dev's philosophy principles it honors and which it conflicts with — be specific (principle name + how)\n\nPart G — Challenge the leading option:\n- STANDARD: optionally challenge with ONE WorkRail Executor running `routine-hypothesis-challenge`\n- THOROUGH: challenge top 1-2 candidates using ONE or TWO WorkRail Executors running `routine-hypothesis-challenge`\n\nPart H — Select:\nSet context variables:\n- `selectedApproach` — the chosen design with rationale tied back to tensions\n- `runnerUpApproach` — the next-best option and why it lost\n- `architectureRationale` — which tensions were resolved and which were accepted\n- `pivotTriggers` — specific conditions under which you'd switch to the runner-up\n- `keyRiskToMonitor` — the failure mode of the selected approach\n- `acceptedTradeoffs` — what the selected approach gives up (feeds directly into design review)\n- `identifiedFailureModes` — per-candidate failure modes (feeds directly into design review)\n\nRules:\n- the main agent owns the final decision; subagents contribute depth, not decisions\n- if the simplest solution satisfies acceptance criteria, prefer it — complexity must justify itself\n- if the challenged leading candidate no longer looks best, switch deliberately rather than defending sunk cost\n- subagents go deep on specific questions, not wide on generic plans",
+      "prompt": "Before any design work, state your current hypothesis in 3-5 sentences.\n\nBased on what you learned in Phase 0, write:\n1. Your current best guess for the approach\n2. Your main concern about that guess\n3. What would most likely make that guess wrong\n\nThis is your reference point. After design generation, you will compare the result against this hypothesis and say what changed your mind or what held firm.\n\nSet context variable:\n- `initialHypothesis`",
+      "requireConfirmation": false
+    },
+    {
+      "id": "phase-1b-design-quick",
+      "title": "Phase 1b: Lightweight Design (QUICK)",
+      "runCondition": {
+        "and": [
+          { "var": "taskComplexity", "not_equals": "Small" },
+          { "var": "rigorMode", "equals": "QUICK" }
+        ]
+      },
+      "prompt": "Generate a lightweight design inline. QUICK rigor means the path is clear and risk is low.\n\nProduce two mandatory candidates:\n1. The simplest possible change that satisfies acceptance criteria\n2. Follow the existing repo pattern for this kind of change\n\nFor each candidate:\n- One-sentence summary\n- Key tradeoff\n- Failure mode to watch\n- Philosophy fit (name specific principles)\n\nCompare and recommend. If both converge on the same approach, say so honestly.\n\nWrite the output to `design-candidates.md` using the same structure as the deep design path:\n- Problem Understanding\n- Candidates (each with: summary, tradeoff, failure mode, philosophy fit)\n- Comparison and Recommendation\n\nSet context variable:\n- `designSummary` — one-paragraph summary of the recommendation and why",
+      "requireConfirmation": false
+    },
+    {
+      "id": "phase-1b-design-deep",
+      "title": "Phase 1b: Design Generation (Injected Routine — Tension-Driven Design)",
+      "runCondition": {
+        "and": [
+          { "var": "taskComplexity", "not_equals": "Small" },
+          { "var": "rigorMode", "not_equals": "QUICK" }
+        ]
+      },
+      "templateCall": {
+        "templateId": "wr.templates.routine.tension-driven-design",
+        "args": {
+          "deliverableName": "design-candidates.md"
+        }
+      }
+    },
+    {
+      "id": "phase-1c-challenge-and-select",
+      "title": "Phase 1c: Challenge and Select",
+      "runCondition": {
+        "var": "taskComplexity",
+        "not_equals": "Small"
+      },
+      "prompt": "Read `design-candidates.md`, compare against your initial hypothesis, and make the final architecture decision.\n\nInput contract: both QUICK and deep design paths produce `design-candidates.md` with candidates, tradeoffs, and a recommendation. Use that artifact as your primary input.\n\nPart A — Compare to hypothesis:\nRevisit `initialHypothesis`. Now that you have design candidates:\n- Where did the design work confirm your hypothesis?\n- Where did it challenge or change your thinking?\n- What did you learn that you hadn't considered?\nState explicitly what changed your mind and what held firm.\n\nPart B — Challenge the leading option:\n- What's the strongest argument against the recommended approach?\n- What assumption, if wrong, would invalidate it?\n- STANDARD/THOROUGH: optionally spawn ONE WorkRail Executor running `routine-hypothesis-challenge` focused on the leading option's failure modes\n- THOROUGH: optionally also spawn ONE WorkRail Executor running `routine-execution-simulation` to trace the 3 most likely failure scenarios\n\nPart C — Select:\nMake the final architecture decision. The design output is evidence, not a decision — you own the choice.\n\nIf the simplest solution satisfies acceptance criteria, prefer it. Complexity must justify itself. If the challenged leading candidate no longer looks best, switch deliberately rather than defending sunk cost.\n\nSet context variables:\n- `selectedApproach` — the chosen design with rationale tied back to tensions\n- `runnerUpApproach` — the next-best option and why it lost\n- `architectureRationale` — which tensions were resolved and which were accepted\n- `pivotTriggers` — specific conditions under which you'd switch to the runner-up\n- `keyRiskToMonitor` — the failure mode of the selected approach\n- `acceptedTradeoffs` — what the selected approach gives up (feeds directly into design review)\n- `identifiedFailureModes` — per-candidate failure modes (feeds directly into design review)",
       "requireConfirmation": {
         "or": [
           { "var": "automationLevel", "equals": "Low" },

package/workflows/examples/routine-injection-example.json

@@ -0,0 +1,28 @@
+{
+  "id": "routine-injection-example",
+  "name": "Routine Injection Example — Design with Tension-Driven Design",
+  "version": "1.0.0",
+  "description": "Example workflow that uses templateCall to inject the tension-driven-design routine inline. Validates the end-to-end routine injection path.",
+  "steps": [
+    {
+      "id": "phase-0-gather",
+      "title": "Phase 0: Gather Context",
+      "prompt": "Gather context about the problem space."
+    },
+    {
+      "id": "phase-1-design",
+      "title": "Phase 1: Design (Injected Routine)",
+      "templateCall": {
+        "templateId": "wr.templates.routine.tension-driven-design",
+        "args": {
+          "deliverableName": "design-candidates.md"
+        }
+      }
+    },
+    {
+      "id": "phase-2-implement",
+      "title": "Phase 2: Implement",
+      "prompt": "Implement the selected design."
+    }
+  ]
+}