@exaudeus/workrail 3.0.0 → 3.2.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.2.0",
   "description": "Step-by-step workflow enforcement for AI agents via MCP",
   "license": "MIT",
   "repository": {

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

@@ -1,7 +1,7 @@
 {
   "id": "coding-task-workflow-agentic",
   "name": "Agentic Task Dev Workflow (Lean • Notes-First • WorkRail Executor)",
-  "version": "2.1.0",
+  "version": "1.0.0",
   "description": "Lean variant of the agentic coding workflow. Merges triage, inputs gate, context gathering, and re-triage into a single Understand & Classify phase. Reduces context variable count and removes top-level clarificationPrompts. Same quality guarantees with fewer tokens.",
   "recommendedPreferences": {
     "recommendedAutonomy": "guided",
@@ -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- Which tensions it resolves and which it accepts\n- How it relates to existing repo patterns (follows / adapts / departs)\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` with this structure:\n- Problem Understanding (core tensions, what makes it hard)\n- Philosophy Constraints (which principles matter for this problem)\n- Candidates (each with: summary, tensions resolved/accepted, failure mode, philosophy fit)\n- Comparison and Recommendation\n- Open Questions (if any remain)",
+      "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" },
@@ -74,13 +112,30 @@
       },
       "body": [
         {
-          "id": "phase-2a-review-design",
-          "title": "Review Design for Gaps, Issues, and Improvements",
-          "prompt": "Review the selected architecture using the explicit tradeoffs and failure modes from Phase 1 as your review criteria — not a generic gaps checklist.\n\nTargeted review (derived from Phase 1 outputs):\n1. Are the `acceptedTradeoffs` actually acceptable? For each accepted tradeoff, verify it won't violate acceptance criteria or invariants under realistic conditions.\n2. Are the `identifiedFailureModes` actually handled? For each failure mode, trace through the design and confirm there's a mitigation path. If not, flag it.\n3. Does the selected approach's relationship to existing repo patterns hold up? If it 'adapts' an existing pattern, verify the adaptation doesn't break the invariants the original pattern protects.\n4. Is there a simpler version of the selected approach that still satisfies acceptance criteria? (Complexity must continue to justify itself.)\n\nCompare against the runner-up:\n- Are there elements from the runner-up that would strengthen the selected approach without adding complexity?\n- Would a hybrid resolve an accepted tradeoff that's bothering you?\n\nPhilosophy alignment: does the architecture respect the user's active coding rules?\n\nBefore delegating, state your current assessment: what do you think the strongest and weakest parts of the design are right now?\n\nMode-adaptive delegation:\n- QUICK: self-review only\n- STANDARD: optionally spawn ONE WorkRail Executor running `routine-hypothesis-challenge` focused specifically on the accepted tradeoffs and failure modes\n- THOROUGH: spawn TWO WorkRail Executors — `routine-hypothesis-challenge` on tradeoffs + `routine-execution-simulation` on failure modes\n\nAfter receiving subagent output (if used), interrogate it against your pre-assessment. Do not adopt their framing wholesale. State what changed your thinking and what didn't.\n\nIf issues are found, fix the design (update `selectedApproach`, `architectureRationale`, `pivotTriggers`, `acceptedTradeoffs`, `identifiedFailureModes`) before continuing.\n\nSet context variables:\n- `designFindings`\n- `designRevised`",
+          "id": "phase-2a-pre-assess-design-review",
+          "title": "Pre-Assess Design Review",
+          "prompt": "Before the detailed design review, state your current assessment in 2-4 sentences.\n\nSay:\n- what you think the strongest part of the selected design is right now\n- what you think the weakest part is right now\n- which tradeoff or failure mode worries you most\n\nThis is your reference point for interpreting the review findings.\n\nSet context variable:\n- `designReviewAssessment`",
+          "requireConfirmation": false
+        },
+        {
+          "id": "phase-2b-design-review-core",
+          "title": "Design Review Core",
+          "templateCall": {
+            "templateId": "wr.templates.routine.design-review",
+            "args": {
+              "deliverableName": "design-review-findings.md"
+            }
+          },
           "requireConfirmation": false
         },
         {
-          "id": "phase-2b-loop-decision",
+          "id": "phase-2c-synthesize-design-review",
+          "title": "Synthesize Design Review Findings",
+          "prompt": "Read `design-review-findings.md` and synthesize the review into workflow-owned decisions.\n\nPart A — Compare against your pre-assessment:\nRevisit `designReviewAssessment`.\n- What did the review confirm?\n- What did it surface that you missed?\n- What changed your mind and what held firm?\n\nPart B — Optional mode-adaptive challenge around the review findings:\n- QUICK: self-synthesize only\n- STANDARD: optionally spawn ONE WorkRail Executor running `routine-hypothesis-challenge` focused on the most serious review finding\n- THOROUGH: optionally spawn TWO WorkRail Executors — `routine-hypothesis-challenge` on the most serious finding + `routine-execution-simulation` on the most dangerous failure mode\n\nPart C — Decide:\nInterpret the findings yourself. Do not adopt the review artifact or any subagent framing wholesale.\n\nIf issues are found, fix the design (update `selectedApproach`, `architectureRationale`, `pivotTriggers`, `acceptedTradeoffs`, `identifiedFailureModes`) before continuing.\n\nSet context variables:\n- `designFindings`\n- `designRevised`",
+          "requireConfirmation": false
+        },
+        {
+          "id": "phase-2d-loop-decision",
           "title": "Design Review Loop Decision",
           "prompt": "Provide a loop control artifact.\n\nDecision rules:\n- if `designFindings` is non-empty and design was revised -> continue (verify the revision)\n- if `designFindings` is empty -> stop\n- if max iterations reached -> stop and document remaining concerns\n\nOutput exactly:\n```json\n{\n  \"artifacts\": [{\n    \"kind\": \"wr.loop_control\",\n    \"decision\": \"continue\"\n  }]\n}\n```",
           "requireConfirmation": false,
@@ -204,13 +259,24 @@
       },
       "body": [
         {
-          "id": "phase-7a-verify-and-fix",
-          "title": "Verify Integration and Fix Issues",
-          "prompt": "Perform integration verification across all implemented slices.\n\nRequired:\n- verify acceptance criteria\n- map invariants to concrete proof (tests, build results, explicit reasoning)\n- run whole-task validation commands\n- identify any invariant violations or regressions\n- confirm the implemented result aligns with the user's coding philosophy, naming any tensions explicitly\n- review cumulative drift across all slices\n- check whether repeated small compromises added up to a larger pattern problem\n\nIf issues are found, fix them immediately:\n- apply code fixes\n- re-run affected tests\n- update `implementation_plan.md` if the fix changed boundaries or approach\n\nSet context variables:\n- `integrationFindings`\n- `integrationPassed`\n- `regressionDetected`",
+          "id": "phase-7a-final-verification-core",
+          "title": "Final Verification Core",
+          "templateCall": {
+            "templateId": "wr.templates.routine.final-verification",
+            "args": {
+              "deliverableName": "final-verification-findings.md"
+            }
+          },
+          "requireConfirmation": false
+        },
+        {
+          "id": "phase-7b-fix-and-summarize",
+          "title": "Fix Issues and Summarize Verification",
+          "prompt": "Read `final-verification-findings.md` and turn it into workflow-owned decisions and fixes.\n\nRequired:\n- interpret the findings yourself rather than rubber-stamping them\n- identify any invariant violations or regressions that must be fixed now\n- if issues are found, fix them immediately\n- re-run affected tests\n- update `implementation_plan.md` if the fix changed boundaries or approach\n\nSet context variables:\n- `integrationFindings`\n- `integrationPassed`\n- `regressionDetected`",
           "requireConfirmation": false
         },
         {
-          "id": "phase-7b-loop-decision",
+          "id": "phase-7c-loop-decision",
           "title": "Final Verification Loop Decision",
           "prompt": "Provide a loop control artifact.\n\nDecision rules:\n- if `integrationFindings` is non-empty and fixes were applied -> continue (re-verify the fixes)\n- if `integrationFindings` is empty or all issues resolved -> stop and produce handoff\n- if max iterations reached -> stop and document remaining concerns\n\nWhen stopping, include the handoff summary:\n- acceptance criteria status\n- invariant status\n- test/build summary\n- concise PR/MR description draft (why, test plan, rollout notes)\n- follow-up tickets\n- any philosophy tensions accepted intentionally and why\n\nKeep the handoff concise and executive-level. Do not auto-merge or push unless the user explicitly asks.\n\nOutput exactly:\n```json\n{\n  \"artifacts\": [{\n    \"kind\": \"wr.loop_control\",\n    \"decision\": \"continue\"\n  }]\n}\n```",
           "requireConfirmation": true,

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."
+    }
+  ]
+}

package/workflows/routines/design-review.json

@@ -0,0 +1,60 @@
+{
+  "id": "routine-design-review",
+  "name": "Design Review Routine",
+  "version": "1.0.0",
+  "description": "Reviews a selected design using explicit tradeoffs, failure modes, simpler-alternative checks, runner-up comparison, and philosophy alignment. Produces a reusable design-review findings artifact.",
+  "clarificationPrompts": [
+    "What design artifact or summary should I review?",
+    "What tradeoffs, failure modes, and runner-up option are available?",
+    "What artifact name should I produce?"
+  ],
+  "preconditions": [
+    "A selected design or design summary is available",
+    "Accepted tradeoffs and failure modes are available",
+    "A runner-up or alternative approach is available",
+    "The dev's philosophy or rules are available"
+  ],
+  "metaGuidance": [
+    "PURPOSE: review the quality of a selected design, not generate a fresh design from scratch.",
+    "ROLE: you are a reviewer looking for real gaps, not generic criticism.",
+    "PHILOSOPHY: name tensions by principle when they matter.",
+    "SIMPLICITY: always ask whether a simpler version would still satisfy acceptance criteria."
+  ],
+  "steps": [
+    {
+      "id": "step-review-tradeoffs",
+      "title": "Step 1: Review Accepted Tradeoffs",
+      "prompt": "Review the selected design by walking through the accepted tradeoffs explicitly.\n\nFor each accepted tradeoff:\n- Verify it will not violate acceptance criteria or invariants under realistic conditions\n- Identify what would make the tradeoff no longer acceptable\n- Note any hidden assumptions\n\nWorking notes:\n- Tradeoff review\n- Hidden assumptions\n- Conditions under which the tradeoff fails",
+      "agentRole": "You are a reviewer validating whether accepted tradeoffs are actually acceptable.",
+      "requireConfirmation": false
+    },
+    {
+      "id": "step-review-failure-modes",
+      "title": "Step 2: Review Failure Modes",
+      "prompt": "Review the identified failure modes for the selected design.\n\nFor each failure mode:\n- Trace whether the design handles it adequately\n- Identify missing mitigations\n- Note which failure mode is most dangerous if it occurs\n\nWorking notes:\n- Failure mode coverage\n- Missing mitigations\n- Highest-risk failure mode",
+      "agentRole": "You are a failure analyst checking whether the design can survive realistic problems.",
+      "requireConfirmation": false
+    },
+    {
+      "id": "step-compare-runner-up",
+      "title": "Step 3: Compare Against Runner-Up and Simpler Alternatives",
+      "prompt": "Compare the selected design against the runner-up and a simpler possible variant.\n\nReview:\n- Whether the runner-up has elements worth pulling into the selected design\n- Whether a hybrid would resolve an uncomfortable tradeoff without adding much complexity\n- Whether a simpler version of the selected design would still satisfy acceptance criteria\n\nWorking notes:\n- Runner-up strengths worth borrowing\n- Simpler alternative analysis\n- Hybrid opportunities",
+      "agentRole": "You are comparing options honestly rather than defending the current favorite.",
+      "requireConfirmation": false
+    },
+    {
+      "id": "step-review-philosophy",
+      "title": "Step 4: Review Philosophy Alignment",
+      "prompt": "Review the selected design against the dev's philosophy.\n\nName the principles that matter for this design and assess:\n- Which principles are satisfied clearly\n- Which principles are under tension\n- Which tensions are acceptable versus risky\n\nWorking notes:\n- Relevant principles\n- Satisfied principles\n- Tensions and why they matter",
+      "agentRole": "You are checking whether the design respects what the dev actually values.",
+      "requireConfirmation": false
+    },
+    {
+      "id": "step-deliver",
+      "title": "Step 5: Deliver Design Review Findings",
+      "prompt": "Create `{deliverableName}`.\n\nRequired structure:\n- Tradeoff Review\n- Failure Mode Review\n- Runner-Up / Simpler Alternative Review\n- Philosophy Alignment\n- Findings (Red / Orange / Yellow or equivalent severity)\n- Recommended Revisions\n- Residual Concerns\n\nOptimize for concise, actionable findings that the main workflow can interpret and decide on.",
+      "agentRole": "You are delivering a review artifact for the main workflow to synthesize and act on.",
+      "requireConfirmation": false
+    }
+  ]
+}

package/workflows/routines/final-verification.json

@@ -0,0 +1,62 @@
+{
+  "id": "routine-final-verification",
+  "name": "Final Verification Routine",
+  "version": "1.0.0",
+  "description": "Performs reusable final verification over acceptance criteria, invariants, validation evidence, regressions, cumulative drift, and philosophy alignment. Produces a proof-oriented verification artifact built around claim -> evidence -> gap -> severity -> readiness verdict.",
+  "clarificationPrompts": [
+    "What implementation or slices should I verify?",
+    "What acceptance criteria and invariants must hold?",
+    "What validation commands or evidence are available?",
+    "What artifact name should I produce?"
+  ],
+  "preconditions": [
+    "Implementation is available for review",
+    "Acceptance criteria are available",
+    "Invariants are available",
+    "A deterministic validation path exists"
+  ],
+  "metaGuidance": [
+    "PURPOSE: verify whether the whole task is truly done, not just locally green.",
+    "ROLE: you are a verifier proving or disproving readiness using evidence.",
+    "PROOF: map every readiness claim to tests, build output, artifacts, or explicit reasoning.",
+    "SEVERITY: every gap should be classified clearly so the caller knows what blocks shipping.",
+    "DRIFT: look for cumulative compromise, not just isolated defects."
+  ],
+  "steps": [
+    {
+      "id": "step-map-claims-to-proof",
+      "title": "Step 1: Map Acceptance Criteria and Invariants to Proof",
+      "prompt": "Map the implementation's readiness claims to concrete proof.\n\nFor each acceptance criterion and invariant:\n- state the claim clearly\n- identify the strongest supporting evidence (test, build output, artifact, code reasoning)\n- note whether the proof is strong, partial, or missing\n- record any gap that prevents the claim from being fully proven\n\nWorking notes:\n- Claim -> proof matrix\n- Strong / partial / missing proof\n- Gaps that weaken readiness",
+      "agentRole": "You are a verifier mapping claims to concrete proof.",
+      "requireConfirmation": false
+    },
+    {
+      "id": "step-review-validation-evidence",
+      "title": "Step 2: Review Validation Evidence Quality",
+      "prompt": "Review the overall validation evidence quality.\n\nCheck:\n- whether the right validation commands were run\n- whether the evidence is trustworthy and sufficient for readiness\n- whether any critical area has only weak or indirect proof\n- whether additional validation would materially change confidence\n\nWorking notes:\n- Validation commands reviewed\n- Evidence strength assessment\n- Missing or weak proof",
+      "agentRole": "You are checking whether the validation story is actually strong enough to trust.",
+      "requireConfirmation": false
+    },
+    {
+      "id": "step-classify-gaps-and-regressions",
+      "title": "Step 3: Classify Gaps, Regressions, and Drift by Severity",
+      "prompt": "Review the implementation for regressions, drift, and unresolved gaps.\n\nCheck:\n- invariant violations or regressions\n- whether repeated small compromises added up to a larger pattern problem\n- whether the implementation still matches intended plan boundaries\n- whether any proof gaps should block shipping versus merely lower confidence\n\nClassify each issue by severity:\n- Red: blocks readiness\n- Orange: should be fixed before shipping if possible\n- Yellow: acceptable tension or bounded follow-up\n\nWorking notes:\n- Regressions found\n- Drift assessment\n- Severity-classified gaps",
+      "agentRole": "You are looking for the subtle ways a task can go wrong even when individual slices seemed fine.",
+      "requireConfirmation": false
+    },
+    {
+      "id": "step-review-philosophy",
+      "title": "Step 4: Review Philosophy Alignment",
+      "prompt": "Review the final result against the dev's philosophy.\n\nAssess:\n- which principles are clearly satisfied\n- which tensions remain intentionally accepted\n- which philosophy violations should be severity Red, Orange, or Yellow\n- whether any philosophy concern changes the readiness verdict\n\nWorking notes:\n- Satisfied principles\n- Accepted tensions\n- Severity-classified philosophy concerns",
+      "agentRole": "You are checking whether the finished result still reflects the dev's standards.",
+      "requireConfirmation": false
+    },
+    {
+      "id": "step-deliver",
+      "title": "Step 5: Deliver Final Verification Findings",
+      "prompt": "Create `{deliverableName}`.\n\nRequired structure:\n- Readiness Claims and Proof Matrix\n  - claim\n  - supporting evidence\n  - proof strength (strong / partial / missing)\n  - proof gap\n- Validation Evidence Summary\n- Severity-Classified Gaps\n  - Red (blocking)\n  - Orange (should fix)\n  - Yellow (accepted tension / follow-up)\n- Regression / Drift Review\n- Philosophy Alignment\n- Recommended Fixes\n- Readiness Verdict\n  - Ready\n  - Ready with Accepted Tensions\n  - Not Ready\n\nOptimize for a compact artifact the main workflow can use to decide whether to fix, re-verify, or hand off.",
+      "agentRole": "You are delivering a verification artifact the main workflow can interpret and act on.",
+      "requireConfirmation": false
+    }
+  ]
+}

package/workflows/routines/hypothesis-challenge.json

@@ -1,113 +1,69 @@
 {
   "id": "routine-hypothesis-challenge",
   "name": "Hypothesis Challenge Routine",
-  "version": "1.1.0",
-  "description": "Adversarial testing of hypotheses using an Ideate -> Plan -> Execute strategy. Configurable rigor levels (1-5) allow for progressively deeper skepticism and stress testing.",
+  "version": "1.0.0",
+  "description": "Lean adversarial review of a hypothesis, recommendation, or diagnosis. Produces the strongest counter-argument, exposes weak assumptions and evidence gaps, identifies likely failure modes, and defines the critical tests needed to keep, revise, or reject the current claim.",
   "clarificationPrompts": [
-    "What hypotheses or assumptions should I challenge?",
-    "What rigor level do you need? (1=Surface, 3=Deep, 5=Maximum)",
-    "What evidence supports these hypotheses?",
-    "What context should I consider? (bug description, findings, constraints)"
+    "What hypothesis, recommendation, or diagnosis should I challenge?",
+    "What evidence currently supports it?",
+    "What depth do you need? (QUICK / STANDARD / THOROUGH; legacy rigor=1/3/5 is still accepted for compatibility)",
+    "What artifact name should I produce?"
   ],
   "preconditions": [
-    "Hypotheses or assumptions are clearly stated",
-    "Rigor level (1-5) is specified",
-    "Supporting evidence is available",
-    "Agent has read access to relevant context"
+    "A target hypothesis, recommendation, or diagnosis is available",
+    "Supporting evidence or reasoning is available",
+    "Relevant context is available for challenge"
   ],
   "metaGuidance": [
-    "**ROUTINE PURPOSE:**",
-    "This routine performs adversarial testing. It separates strategy (Ideating attack vectors) from execution (Challenging/Stress Testing).",
-    "**PHASES:**",
-    "1. IDEATE: Brainstorm attack vectors and common flaws",
-    "2. STRATEGIZE: Define the challenge plan for the requested rigor",
-    "3. EXECUTE: Run the challenge (Surface/Deep/Max)",
-    "4. SYNTHESIZE: Deliver verdicts and alternative explanations",
-    "**CORE PRINCIPLES:**",
-    "- ADVERSARIAL: Actively try to disprove, don't confirm",
-    "- SYSTEMATIC: Challenge assumptions, logic, and evidence",
-    "- CONSTRUCTIVE: Goal is to strengthen truth, not just destroy"
+    "PURPOSE: strengthen truth by trying to break the current story.",
+    "ROLE: you are an adversarial reviewer, not a neutral summarizer.",
+    "SCOPE: challenge assumptions, evidence quality, and likely failure modes.",
+    "DISCIPLINE: produce concrete counter-arguments and critical tests, not vague skepticism.",
+    "DEPTH: QUICK = strongest counter only; STANDARD = counter + failure-mode review; THOROUGH = add alternative explanations and sharper discrimination tests.",
+    "COMPATIBILITY: prefer depth language (QUICK / STANDARD / THOROUGH). Treat legacy rigor values as adapter input, not the primary model."
   ],
   "steps": [
     {
-      "id": "step-0-ideate-vectors",
-      "title": "Step 0: Ideate Challenge Strategy",
-      "prompt": "**IDEATE ATTACK VECTORS**\n\nBefore diving into specific hypotheses, step back and look at the whole picture.\n\n**YOUR MISSION:** Brainstorm ways to break these hypotheses.\n\n**EXECUTE:**\n1. Review all hypotheses together\n2. Identify shared assumptions (do they all assume X?)\n3. Brainstorm classes of failure (Concurrency? State? Logic?)\n4. Identify weak points in the evidence provided\n\n**REFLECT:**\n- Are these hypotheses too similar?\n- Are they missing a whole category of explanation?\n- What is the most likely \"unknown unknown\"?\n\n**WORKING NOTES:**\n- Common Assumptions\n- Potential Attack Vectors (e.g., Race Conditions, Edge Cases)\n- Evidence Weaknesses",
-      "agentRole": "You are a red-team strategist planning your attack.",
-      "requireConfirmation": false,
-      "guidance": [
-        "BRAINSTORM: Look for systemic issues first",
-        "CATEGORIES: Think in categories (Logic, Data, Timing, Environment)",
-        "SKEPTICISM: Assume the hypotheses are wrong. Why?"
-      ]
+      "id": "step-load-target",
+      "title": "Step 1: Load the Target Claim and Evidence",
+      "prompt": "Load the current claim you are challenging.\n\nCapture:\n- the target claim in one sentence\n- the main assumptions it depends on\n- the strongest supporting evidence currently available\n- what result would count as meaningful disproof\n\nKeep this step compact and precise. The goal is to define exactly what is under challenge and what would falsify it.",
+      "agentRole": "You are defining exactly what claim is on trial and what would falsify it.",
+      "requireConfirmation": false
     },
     {
-      "id": "step-1-plan-challenge",
-      "title": "Step 1: Plan Challenge Tactics",
-      "prompt": "**DEFINE CHALLENGE PLAN**\n\nNow define your specific tactics for the requested rigor level.\n\n**YOUR MISSION:** Create a concrete plan to test these hypotheses.\n\n**EXECUTE:**\n1. Map attack vectors to specific hypotheses\n2. Define **Key Questions** to answer\n3. Select **Stress Tests** or **Counter-Examples** to search for\n4. Define criteria for \"disproof\"\n\n**DELIVERABLE:**\nCreate `challenge-strategy.md`:\n- Attack Plan for each Hypothesis\n- Key Assumptions to Probe\n- Required Evidence check",
-      "agentRole": "You are a lead auditor defining the scope of the audit.",
-      "requireConfirmation": false,
-      "guidance": [
-        "TACTICS: Be specific (e.g., \"Check for null user in auth flow\")",
-        "CRITERIA: What would convince you the hypothesis is false?"
-      ]
+      "id": "step-break-claim",
+      "title": "Step 2: Find the Strongest Counter-Argument",
+      "prompt": "Find the strongest case against the current claim.\n\nChallenge it by asking:\n- What is the strongest counter-argument or competing explanation?\n- What evidence could be interpreted differently?\n- What hidden assumption is carrying too much weight?\n- What would a sharp skeptic say first?\n\nOptimize for the single strongest attack, not a long list of weak objections.",
+      "agentRole": "You are a sharp skeptic trying to overturn the current favorite with the strongest available attack.",
+      "requireConfirmation": false
     },
     {
-      "id": "step-execute-rigor-1",
-      "title": "Execution: Rigor 1 (Surface)",
-      "runCondition": {
-        "var": "rigor",
-        "gte": 1
-      },
-      "prompt": "**EXECUTE RIGOR 1: SURFACE CHALLENGE**\n\nExecute your challenge plan at Rigor 1 (Surface).\n\n**MISSION:** Identify obvious flaws and simple counter-examples.\n\n**EXECUTE:**\n1. Follow `challenge-strategy.md`\n2. Check for obvious logical gaps\n3. Identify simple counter-examples\n4. Check for Occam's Razor alternatives\n\n**WORKING NOTES:**\n- Obvious Flaws\n- Simple Counter-Examples\n- Better Alternatives",
-      "agentRole": "You are a skeptical reviewer looking for quick wins.",
-      "requireConfirmation": false,
-      "guidance": [
-        "FOCUS: Obvious errors, simple logic gaps",
-        "SPEED: Don't dig deep yet, look for low-hanging fruit"
-      ]
-    },
-    {
-      "id": "step-execute-rigor-3",
-      "title": "Execution: Rigor 3 (Deep)",
-      "runCondition": {
-        "var": "rigor",
-        "gte": 3
-      },
-      "prompt": "**EXECUTE RIGOR 3: DEEP CHALLENGE**\n\nExecute your challenge plan at Rigor 3 (Deep Analysis).\n\n**MISSION:** Deeply challenge with edge cases and hidden assumptions.\n\n**EXECUTE:**\n1. Follow `challenge-strategy.md`\n2. Expose hidden assumptions\n3. Generate systematic edge cases\n4. Analyze timing and environment factors\n\n**WORKING NOTES:**\n- Hidden Assumptions Exposed\n- Edge Case Analysis\n- Environmental Factors",
-      "agentRole": "You are a rigorous auditor digging for structural flaws.",
-      "requireConfirmation": false,
-      "guidance": [
-        "FOCUS: Unstated assumptions, boundary conditions",
-        "DEPTH: trace logic chains to find breaks"
-      ]
+      "id": "step-review-failure-modes",
+      "title": "Step 3: Review Weak Evidence and Likely Failure Modes",
+      "prompt": "Probe where the current claim could fail under realistic pressure.\n\nReview:\n- the weakest part of the evidence chain\n- the most likely failure modes if the claim is wrong\n- edge cases or environmental factors that could invalidate the conclusion\n- contradictions, unexplained facts, or missing proof\n\nFocus on the few things most likely to flip the conclusion rather than exhaustive enumeration.",
+      "agentRole": "You are testing whether the current story survives realistic pressure and real evidence quality.",
+      "requireConfirmation": false
     },
     {
-      "id": "step-execute-rigor-5",
-      "title": "Execution: Rigor 5 (Maximum)",
+      "id": "step-thorough-alternatives",
+      "title": "Step 4: Generate Alternative Explanations and Critical Tests",
       "runCondition": {
-        "var": "rigor",
-        "gte": 5
+        "or": [
+          { "var": "depth", "equals": "THOROUGH" },
+          { "var": "rigorMode", "equals": "THOROUGH" },
+          { "var": "rigor", "gte": 5 }
+        ]
       },
-      "prompt": "**EXECUTE RIGOR 5: MAX CHALLENGE**\n\nExecute your challenge plan at Rigor 5 (Maximum Skepticism).\n\n**MISSION:** Try to break it completely.\n\n**EXECUTE:**\n1. Follow `challenge-strategy.md`\n2. Exhaustive assumption enumeration\n3. Extreme edge cases and adversarial inputs\n4. Second-order effects and chaos scenarios\n\n**WORKING NOTES:**\n- Exhaustive Challenges\n- Extreme Scenarios\n- Disproof Attempts",
-      "agentRole": "You are a relentless adversary trying to prove it wrong.",
-      "requireConfirmation": false,
-      "guidance": [
-        "FOCUS: Breaking the system, extreme edge cases",
-        "MINDSET: Trust nothing, verify everything"
-      ]
+      "prompt": "For THOROUGH review, go beyond the primary counter-argument into alternatives and discrimination strategy.\n\nProduce:\n- the 1-2 strongest alternative explanations or competing hypotheses\n- why each might beat the current claim\n- the critical tests, observations, or traces that would discriminate between them\n- what result would cause you to keep, revise, or reject the current claim\n\nThis step exists to make THOROUGH meaningfully deeper than STANDARD, not just wordier.",
+      "agentRole": "You are building the shortest path to proving which explanation survives.",
+      "requireConfirmation": false
     },
     {
-      "id": "step-synthesize",
-      "title": "Step 5: Synthesize Verdicts",
-      "prompt": "**SYNTHESIZE VERDICTS**\n\nSynthesize all challenges into final verdicts.\n\n**MISSION:** Deliver clear judgments on each hypothesis.\n\n**EXECUTE:**\n1. Review all Working Notes\n2. Assign Verdicts (Keep/Revise/Reject)\n3. Prioritize Alternatives\n4. Define Critical Tests\n\n**DELIVERABLE:**\nCreate `{deliverableName}`:\n- Executive Summary\n- Hypothesis Analysis & Verdicts\n- Critical Tests Needed\n- Recommendations",
-      "agentRole": "You are a judge delivering the final verdict.",
-      "requireConfirmation": false,
-      "guidance": [
-        "VERDICTS: Be decisive based on evidence",
-        "ALTERNATIVES: Propose concrete, better explanations",
-        "ACTION: What specifically needs to be tested?"
-      ]
+      "id": "step-deliver",
+      "title": "Step 5: Deliver the Challenge Verdict",
+      "prompt": "Create `{deliverableName}`.\n\nRequired structure:\n- Target Claim\n- Strongest Counter-Argument\n- Weak Assumptions / Evidence Gaps\n- Likely Failure Modes\n- Alternative Explanations (if explored)\n- Critical Tests\n- Verdict: Keep / Revise / Reject\n- Next Action\n\nOptimize for a compact artifact that a main workflow can interrogate and act on immediately. Prefer decisive arguments over exhaustive ceremony.",
+      "agentRole": "You are delivering a decisive challenge artifact for the main workflow or caller to synthesize.",
+      "requireConfirmation": false
     }
   ]
-}
+}