@exaudeus/workrail 3.2.1 → 3.4.0

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

@@ -0,0 +1,3 @@
+export type ProjectBindings = ReadonlyMap<string, string>;
+export declare function getProjectBindings(workflowId: string, baseDir?: string): ProjectBindings;
+export declare function loadProjectBindings(workflowId: string, baseDir?: string): ProjectBindings;

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectBindings = getProjectBindings;
+exports.loadProjectBindings = loadProjectBindings;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const _projectBindingsCache = new Map();
+function getProjectBindings(workflowId, baseDir = process.cwd()) {
+    const key = `${workflowId}:${baseDir}`;
+    const cached = _projectBindingsCache.get(key);
+    if (cached !== undefined)
+        return cached;
+    const bindings = loadProjectBindings(workflowId, baseDir);
+    _projectBindingsCache.set(key, bindings);
+    return bindings;
+}
+function loadProjectBindings(workflowId, baseDir = process.cwd()) {
+    const filePath = (0, path_1.join)(baseDir, '.workrail', 'bindings.json');
+    let raw;
+    try {
+        raw = (0, fs_1.readFileSync)(filePath, 'utf-8');
+    }
+    catch (e) {
+        if (isNodeError(e) && e.code === 'ENOENT') {
+            return new Map();
+        }
+        console.warn(`[WorkflowCompiler] Failed to read .workrail/bindings.json: ${String(e)}`);
+        return new Map();
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        console.warn(`[WorkflowCompiler] .workrail/bindings.json is not valid JSON — ignoring`);
+        return new Map();
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        console.warn(`[WorkflowCompiler] .workrail/bindings.json must be a JSON object — ignoring`);
+        return new Map();
+    }
+    const obj = parsed;
+    const perWorkflow = obj[workflowId];
+    if (perWorkflow !== undefined) {
+        if (typeof perWorkflow === 'object' && !Array.isArray(perWorkflow) && perWorkflow !== null) {
+            return extractStringMap(perWorkflow, `[${workflowId}]`);
+        }
+        console.warn(`[WorkflowCompiler] .workrail/bindings.json[${workflowId}] is not an object — ignoring`);
+        return new Map();
+    }
+    const values = Object.values(obj);
+    const allStrings = values.every(v => typeof v === 'string');
+    if (allStrings && values.length > 0) {
+        return extractStringMap(obj, 'root');
+    }
+    return new Map();
+}
+function extractStringMap(obj, context) {
+    const result = new Map();
+    for (const [key, value] of Object.entries(obj)) {
+        if (typeof value !== 'string') {
+            console.warn(`[WorkflowCompiler] .workrail/bindings.json ${context}.${key} is not a string — skipping`);
+            continue;
+        }
+        result.set(key, value);
+    }
+    return result;
+}
+function isNodeError(e) {
+    return e instanceof Error && 'code' in e;
+}

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

@@ -0,0 +1,18 @@
+import type { Result } from 'neverthrow';
+import type { ExtensionPoint } from '../../../types/workflow-definition.js';
+import type { WorkflowStepDefinition, LoopStepDefinition } from '../../../types/workflow-definition.js';
+import type { ProjectBindings } from './binding-registry.js';
+export declare const BINDING_TOKEN_RE: RegExp;
+export type BindingPassError = {
+    readonly code: 'UNKNOWN_BINDING_SLOT';
+    readonly stepId: string;
+    readonly slotId: string;
+    readonly message: string;
+};
+export type BindingSource = 'project_override' | 'default';
+export interface BindingPassResult {
+    readonly steps: readonly (WorkflowStepDefinition | LoopStepDefinition)[];
+    readonly resolvedBindings: ReadonlyMap<string, string>;
+    readonly resolvedOverrides: ReadonlyMap<string, string>;
+}
+export declare function resolveBindingsPass(steps: readonly (WorkflowStepDefinition | LoopStepDefinition)[], extensionPoints: readonly ExtensionPoint[], projectBindings: ProjectBindings): Result<BindingPassResult, BindingPassError>;

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

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BINDING_TOKEN_RE = void 0;
+exports.resolveBindingsPass = resolveBindingsPass;
+const neverthrow_1 = require("neverthrow");
+const workflow_definition_js_1 = require("../../../types/workflow-definition.js");
+exports.BINDING_TOKEN_RE = /\{\{wr\.bindings\.([^\s{}]+)\}\}/g;
+function resolveSlot(slotId, stepId, extensionPoints, projectBindings) {
+    const override = projectBindings.get(slotId);
+    if (override !== undefined)
+        return (0, neverthrow_1.ok)({ value: override, source: 'project_override' });
+    const ep = extensionPoints.find(ep => ep.slotId === slotId);
+    if (ep !== undefined)
+        return (0, neverthrow_1.ok)({ value: ep.default, source: 'default' });
+    const knownSlots = extensionPoints.map(ep => ep.slotId);
+    const hint = knownSlots.length === 0
+        ? 'This workflow declares no extensionPoints. Add an extensionPoints entry with this slotId.'
+        : `Declared slots: [${knownSlots.join(', ')}]. Check for typos.`;
+    return (0, neverthrow_1.err)({
+        code: 'UNKNOWN_BINDING_SLOT',
+        stepId,
+        slotId,
+        message: `Step '${stepId}': unknown binding slot '${slotId}'. ${hint}`,
+    });
+}
+function resolveBindingTokensInString(text, stepId, extensionPoints, projectBindings) {
+    if (!text.includes('{{wr.bindings.'))
+        return (0, neverthrow_1.ok)({ text, resolved: new Map() });
+    let result = text;
+    const resolvedMap = new Map();
+    const matches = [];
+    const re = new RegExp(exports.BINDING_TOKEN_RE.source, 'g');
+    let match;
+    while ((match = re.exec(text)) !== null) {
+        matches.push({ full: match[0], slotId: match[1] });
+    }
+    for (const { full, slotId } of matches) {
+        const resolved = resolveSlot(slotId, stepId, extensionPoints, projectBindings);
+        if (resolved.isErr())
+            return (0, neverthrow_1.err)(resolved.error);
+        result = result.split(full).join(resolved.value.value);
+        resolvedMap.set(slotId, resolved.value);
+    }
+    return (0, neverthrow_1.ok)({ text: result, resolved: resolvedMap });
+}
+function accumulateSlotResolution(acc, slotId, resolution) {
+    acc.all.set(slotId, resolution.value);
+    if (resolution.source === 'project_override') {
+        acc.overrides.set(slotId, resolution.value);
+    }
+}
+function resolveBindingTokensInPromptValue(value, stepId, extensionPoints, projectBindings, acc) {
+    if (typeof value !== 'string')
+        return (0, neverthrow_1.ok)(value);
+    const res = resolveBindingTokensInString(value, stepId, extensionPoints, projectBindings);
+    if (res.isErr())
+        return (0, neverthrow_1.err)(res.error);
+    for (const [k, resolution] of res.value.resolved)
+        accumulateSlotResolution(acc, k, resolution);
+    return (0, neverthrow_1.ok)(res.value.text);
+}
+function resolveBindingTokensInPromptValues(values, stepId, extensionPoints, projectBindings, acc) {
+    const resolved = [];
+    for (const v of values) {
+        const res = resolveBindingTokensInPromptValue(v, stepId, extensionPoints, projectBindings, acc);
+        if (res.isErr())
+            return (0, neverthrow_1.err)(res.error);
+        resolved.push(res.value);
+    }
+    return (0, neverthrow_1.ok)(resolved);
+}
+function resolveBindingTokensInBlocks(blocks, stepId, extensionPoints, projectBindings, acc) {
+    let result = { ...blocks };
+    if (blocks.goal !== undefined) {
+        const res = resolveBindingTokensInPromptValue(blocks.goal, stepId, extensionPoints, projectBindings, acc);
+        if (res.isErr())
+            return (0, neverthrow_1.err)(res.error);
+        result = { ...result, goal: res.value };
+    }
+    if (blocks.constraints !== undefined) {
+        const res = resolveBindingTokensInPromptValues(blocks.constraints, stepId, extensionPoints, projectBindings, acc);
+        if (res.isErr())
+            return (0, neverthrow_1.err)(res.error);
+        result = { ...result, constraints: res.value };
+    }
+    if (blocks.procedure !== undefined) {
+        const res = resolveBindingTokensInPromptValues(blocks.procedure, stepId, extensionPoints, projectBindings, acc);
+        if (res.isErr())
+            return (0, neverthrow_1.err)(res.error);
+        result = { ...result, procedure: res.value };
+    }
+    if (blocks.verify !== undefined) {
+        const res = resolveBindingTokensInPromptValues(blocks.verify, stepId, extensionPoints, projectBindings, acc);
+        if (res.isErr())
+            return (0, neverthrow_1.err)(res.error);
+        result = { ...result, verify: res.value };
+    }
+    if (blocks.outputRequired !== undefined) {
+        const resolvedOutputRequired = {};
+        for (const [key, value] of Object.entries(blocks.outputRequired)) {
+            const res = resolveBindingTokensInString(value, stepId, extensionPoints, projectBindings);
+            if (res.isErr())
+                return (0, neverthrow_1.err)(res.error);
+            resolvedOutputRequired[key] = res.value.text;
+            for (const [k, resolution] of res.value.resolved)
+                accumulateSlotResolution(acc, k, resolution);
+        }
+        result = { ...result, outputRequired: resolvedOutputRequired };
+    }
+    return (0, neverthrow_1.ok)(result);
+}
+function resolveStepBindings(step, extensionPoints, projectBindings, acc) {
+    let updated = step;
+    if (step.prompt !== undefined) {
+        const res = resolveBindingTokensInString(step.prompt, step.id, extensionPoints, projectBindings);
+        if (res.isErr())
+            return (0, neverthrow_1.err)(res.error);
+        if (res.value.text !== step.prompt) {
+            updated = { ...updated, prompt: res.value.text };
+        }
+        for (const [k, resolution] of res.value.resolved)
+            accumulateSlotResolution(acc, k, resolution);
+    }
+    if (step.promptBlocks !== undefined) {
+        const res = resolveBindingTokensInBlocks(step.promptBlocks, step.id, extensionPoints, projectBindings, acc);
+        if (res.isErr())
+            return (0, neverthrow_1.err)(res.error);
+        updated = { ...updated, promptBlocks: res.value };
+    }
+    return (0, neverthrow_1.ok)(updated);
+}
+function resolveBindingsPass(steps, extensionPoints, projectBindings) {
+    const resolved = [];
+    const acc = { all: new Map(), overrides: new Map() };
+    for (const step of steps) {
+        if ((0, workflow_definition_js_1.isLoopStepDefinition)(step)) {
+            const loopRes = resolveStepBindings(step, extensionPoints, projectBindings, acc);
+            if (loopRes.isErr())
+                return (0, neverthrow_1.err)(loopRes.error);
+            if (Array.isArray(step.body)) {
+                const bodyResolved = [];
+                for (const bodyStep of step.body) {
+                    const bodyRes = resolveStepBindings(bodyStep, extensionPoints, projectBindings, acc);
+                    if (bodyRes.isErr())
+                        return (0, neverthrow_1.err)(bodyRes.error);
+                    bodyResolved.push(bodyRes.value);
+                }
+                resolved.push({ ...loopRes.value, body: bodyResolved });
+            }
+            else {
+                resolved.push(loopRes.value);
+            }
+        }
+        else {
+            const res = resolveStepBindings(step, extensionPoints, projectBindings, acc);
+            if (res.isErr())
+                return (0, neverthrow_1.err)(res.error);
+            resolved.push(res.value);
+        }
+    }
+    return (0, neverthrow_1.ok)({ steps: resolved, resolvedBindings: acc.all, resolvedOverrides: acc.overrides });
+}

package/dist/application/services/compiler/sentinel-scan.d.ts

@@ -0,0 +1,9 @@
+import type { Result } from 'neverthrow';
+import type { WorkflowStepDefinition, LoopStepDefinition } from '../../../types/workflow-definition.js';
+export type SentinelError = {
+    readonly code: 'UNRESOLVED_TOKEN';
+    readonly stepId: string;
+    readonly token: string;
+    readonly message: string;
+};
+export declare function sentinelScanPass(steps: readonly (WorkflowStepDefinition | LoopStepDefinition)[]): Result<void, SentinelError>;

package/dist/application/services/compiler/sentinel-scan.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sentinelScanPass = sentinelScanPass;
+const neverthrow_1 = require("neverthrow");
+const workflow_definition_js_1 = require("../../../types/workflow-definition.js");
+const UNRESOLVED_RE = /\{\{wr\./;
+function sentinelScanPass(steps) {
+    for (const step of steps) {
+        if (step.prompt && UNRESOLVED_RE.test(step.prompt)) {
+            const match = step.prompt.match(/\{\{wr\.[^}]*\}\}/);
+            const token = match ? match[0] : '{{wr.*}}';
+            return (0, neverthrow_1.err)({
+                code: 'UNRESOLVED_TOKEN',
+                stepId: step.id,
+                token,
+                message: `Step '${step.id}': compiled prompt contains unresolved token '${token}'. ` +
+                    `This indicates a bug in an upstream compiler pass.`,
+            });
+        }
+        if ((0, workflow_definition_js_1.isLoopStepDefinition)(step) && Array.isArray(step.body)) {
+            for (const bodyStep of step.body) {
+                if (bodyStep.prompt && UNRESOLVED_RE.test(bodyStep.prompt)) {
+                    const match = bodyStep.prompt.match(/\{\{wr\.[^}]*\}\}/);
+                    const token = match ? match[0] : '{{wr.*}}';
+                    return (0, neverthrow_1.err)({
+                        code: 'UNRESOLVED_TOKEN',
+                        stepId: bodyStep.id,
+                        token,
+                        message: `Loop body step '${bodyStep.id}': compiled prompt contains unresolved token '${token}'. ` +
+                            `This indicates a bug in an upstream compiler pass.`,
+                    });
+                }
+            }
+        }
+    }
+    return (0, neverthrow_1.ok)(undefined);
+}

package/dist/application/services/validation-engine.js

@@ -22,6 +22,7 @@ const condition_evaluator_1 = require("../../utils/condition-evaluator");
 const ajv_1 = __importDefault(require("ajv"));
 const neverthrow_1 = require("neverthrow");
 const workflow_definition_1 = require("../../types/workflow-definition");
+const resolve_bindings_1 = require("./compiler/resolve-bindings");
 const enhanced_loop_validator_1 = require("./enhanced-loop-validator");
 const step_output_decoder_1 = require("./step-output-decoder");
 let ValidationEngine = ValidationEngine_1 = class ValidationEngine {
@@ -458,6 +459,109 @@ let ValidationEngine = ValidationEngine_1 = class ValidationEngine {
         const suggestions = [];
         const warnings = [];
         const info = [];
+        const extensionPoints = workflow.definition.extensionPoints ?? [];
+        if (extensionPoints.length > 0) {
+            const seenSlotIds = new Set();
+            for (const ep of extensionPoints) {
+                if (!ep.slotId || typeof ep.slotId !== 'string') {
+                    issues.push(`extensionPoints entry has missing or empty slotId`);
+                    suggestions.push('Each extensionPoint must have a non-empty slotId string');
+                }
+                else if (!ep.purpose || typeof ep.purpose !== 'string') {
+                    issues.push(`extensionPoints[${ep.slotId}]: purpose must be a non-empty string`);
+                }
+                else if (!ep.default || typeof ep.default !== 'string') {
+                    issues.push(`extensionPoints[${ep.slotId}]: default must be a non-empty string`);
+                }
+                if (ep.slotId) {
+                    if (seenSlotIds.has(ep.slotId)) {
+                        issues.push(`extensionPoints has duplicate slotId '${ep.slotId}'`);
+                        suggestions.push('Each slotId must be unique within extensionPoints');
+                    }
+                    seenSlotIds.add(ep.slotId);
+                }
+            }
+            const declaredSlotIds = new Set(extensionPoints.map(ep => ep.slotId).filter(Boolean));
+            const checkStringForUnknownBindings = (text, stepId) => {
+                resolve_bindings_1.BINDING_TOKEN_RE.lastIndex = 0;
+                let match;
+                while ((match = resolve_bindings_1.BINDING_TOKEN_RE.exec(text)) !== null) {
+                    const slotId = match[1];
+                    if (!declaredSlotIds.has(slotId)) {
+                        issues.push(`Step '${stepId}': binding token '{{wr.bindings.${slotId}}}' references undeclared slot. Declared slots: [${[...declaredSlotIds].join(', ')}]`);
+                        suggestions.push(`Add an extensionPoint with slotId '${slotId}' to the workflow definition`);
+                    }
+                }
+            };
+            const checkStepForUnknownBindings = (step, stepId) => {
+                if (step.prompt !== undefined) {
+                    checkStringForUnknownBindings(step.prompt, stepId);
+                }
+                if (step.promptBlocks !== undefined) {
+                    const pb = step.promptBlocks;
+                    if (typeof pb.goal === 'string')
+                        checkStringForUnknownBindings(pb.goal, stepId);
+                    for (const v of pb.constraints ?? []) {
+                        if (typeof v === 'string')
+                            checkStringForUnknownBindings(v, stepId);
+                    }
+                    for (const v of pb.procedure ?? []) {
+                        if (typeof v === 'string')
+                            checkStringForUnknownBindings(v, stepId);
+                    }
+                    for (const v of pb.verify ?? []) {
+                        if (typeof v === 'string')
+                            checkStringForUnknownBindings(v, stepId);
+                    }
+                    for (const v of Object.values(pb.outputRequired ?? {})) {
+                        checkStringForUnknownBindings(v, stepId);
+                    }
+                }
+            };
+            for (const step of workflow.definition.steps) {
+                checkStepForUnknownBindings(step, step.id);
+                if ((0, workflow_definition_1.isLoopStepDefinition)(step) && Array.isArray(step.body)) {
+                    for (const inlineStep of step.body) {
+                        checkStepForUnknownBindings(inlineStep, inlineStep.id ?? 'unknown');
+                    }
+                }
+            }
+        }
+        else {
+            const BINDING_TOKEN_DETECT = /\{\{wr\.bindings\./;
+            const stepUsesBindingToken = (step) => {
+                if (typeof step.prompt === 'string' && BINDING_TOKEN_DETECT.test(step.prompt))
+                    return true;
+                if (step.promptBlocks !== undefined) {
+                    const pb = step.promptBlocks;
+                    if (typeof pb.goal === 'string' && BINDING_TOKEN_DETECT.test(pb.goal))
+                        return true;
+                    for (const v of [...(pb.constraints ?? []), ...(pb.procedure ?? []), ...(pb.verify ?? [])]) {
+                        if (typeof v === 'string' && BINDING_TOKEN_DETECT.test(v))
+                            return true;
+                    }
+                    for (const v of Object.values(pb.outputRequired ?? {})) {
+                        if (BINDING_TOKEN_DETECT.test(v))
+                            return true;
+                    }
+                }
+                return false;
+            };
+            for (const step of workflow.definition.steps) {
+                if (stepUsesBindingToken(step)) {
+                    issues.push(`Step '${step.id}': uses {{wr.bindings.*}} token but workflow declares no extensionPoints`);
+                    suggestions.push('Add an extensionPoints array to the workflow definition');
+                }
+                if ((0, workflow_definition_1.isLoopStepDefinition)(step) && Array.isArray(step.body)) {
+                    for (const inlineStep of step.body) {
+                        if (stepUsesBindingToken(inlineStep)) {
+                            issues.push(`Step '${inlineStep.id ?? 'unknown'}' (loop body): uses {{wr.bindings.*}} token but workflow declares no extensionPoints`);
+                            suggestions.push('Add an extensionPoints array to the workflow definition');
+                        }
+                    }
+                }
+            }
+        }
         const stepIds = new Set();
         for (const step of workflow.definition.steps) {
             if (stepIds.has(step.id)) {

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

@@ -2,6 +2,7 @@ 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 { ExtensionPoint } from '../../types/workflow-definition';
 export interface CompiledLoop {
     readonly loop: LoopStepDefinition;
     readonly bodySteps: readonly WorkflowStepDefinition[];
@@ -13,10 +14,17 @@ export interface CompiledWorkflow {
     readonly stepById: ReadonlyMap<string, WorkflowStepDefinition | LoopStepDefinition>;
     readonly compiledLoops: ReadonlyMap<string, CompiledLoop>;
     readonly loopBodyStepIds: ReadonlySet<string>;
+    readonly resolvedBindings: ReadonlyMap<string, string>;
+    readonly resolvedOverrides: ReadonlyMap<string, string>;
 }
-export declare function resolveDefinitionSteps(steps: readonly (WorkflowStepDefinition | LoopStepDefinition)[], features: readonly string[]): Result<readonly (WorkflowStepDefinition | LoopStepDefinition)[], DomainError>;
+export interface ResolvedDefinitionResult {
+    readonly steps: readonly (WorkflowStepDefinition | LoopStepDefinition)[];
+    readonly resolvedBindings: ReadonlyMap<string, string>;
+    readonly resolvedOverrides: ReadonlyMap<string, string>;
+}
+export declare function resolveDefinitionSteps(steps: readonly (WorkflowStepDefinition | LoopStepDefinition)[], features: readonly string[], extensionPoints?: readonly ExtensionPoint[], workflowId?: string, baseDir?: string): Result<ResolvedDefinitionResult, DomainError>;
 export declare class WorkflowCompiler {
-    compile(workflow: Workflow): Result<CompiledWorkflow, DomainError>;
+    compile(workflow: Workflow, baseDir?: string): Result<CompiledWorkflow, DomainError>;
     private deriveConditionSource;
     private resolveLoopBody;
 }

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

@@ -21,6 +21,9 @@ 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 resolve_bindings_1 = require("./compiler/resolve-bindings");
+const binding_registry_1 = require("./compiler/binding-registry");
+const sentinel_scan_1 = require("./compiler/sentinel-scan");
 const _refRegistry = (0, ref_registry_1.createRefRegistry)();
 const _featureRegistry = (0, feature_registry_1.createFeatureRegistry)();
 function buildTemplateRegistry() {
@@ -52,7 +55,7 @@ function getTemplateRegistry() {
     }
     return _templateRegistryCache;
 }
-function resolveDefinitionSteps(steps, features) {
+function resolveDefinitionSteps(steps, features, extensionPoints = [], workflowId = '', baseDir) {
     const templatesResult = (0, resolve_templates_1.resolveTemplatesPass)(steps, getTemplateRegistry());
     if (templatesResult.isErr()) {
         const e = templatesResult.error;
@@ -63,7 +66,12 @@ function resolveDefinitionSteps(steps, features) {
                 : `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);
+    const bindingsResult = (0, resolve_bindings_1.resolveBindingsPass)(templatesResult.value, extensionPoints, workflowId ? (0, binding_registry_1.getProjectBindings)(workflowId, baseDir) : new Map());
+    if (bindingsResult.isErr()) {
+        const e = bindingsResult.error;
+        return (0, neverthrow_1.err)(error_1.Err.invalidState(e.message));
+    }
+    const featuresResult = (0, resolve_features_1.resolveFeaturesPass)(bindingsResult.value.steps, features, _featureRegistry);
     if (featuresResult.isErr()) {
         const e = featuresResult.error;
         const message = e.code === 'FEATURE_RESOLVE_ERROR'
@@ -84,14 +92,23 @@ function resolveDefinitionSteps(steps, features) {
             : `Step '${e.stepId}': promptBlocks error — ${e.cause.message}`;
         return (0, neverthrow_1.err)(error_1.Err.invalidState(message));
     }
-    return (0, neverthrow_1.ok)(blocksResult.value);
+    const sentinelResult = (0, sentinel_scan_1.sentinelScanPass)(blocksResult.value);
+    if (sentinelResult.isErr()) {
+        const e = sentinelResult.error;
+        return (0, neverthrow_1.err)(error_1.Err.invalidState(e.message));
+    }
+    return (0, neverthrow_1.ok)({
+        steps: blocksResult.value,
+        resolvedBindings: bindingsResult.value.resolvedBindings,
+        resolvedOverrides: bindingsResult.value.resolvedOverrides,
+    });
 }
 let WorkflowCompiler = class WorkflowCompiler {
-    compile(workflow) {
-        const resolvedResult = resolveDefinitionSteps(workflow.definition.steps, workflow.definition.features ?? []);
+    compile(workflow, baseDir) {
+        const resolvedResult = resolveDefinitionSteps(workflow.definition.steps, workflow.definition.features ?? [], workflow.definition.extensionPoints ?? [], workflow.definition.id, baseDir);
         if (resolvedResult.isErr())
             return (0, neverthrow_1.err)(resolvedResult.error);
-        const steps = resolvedResult.value;
+        const { steps, resolvedBindings, resolvedOverrides } = resolvedResult.value;
         const stepById = new Map();
         for (const step of steps) {
             if (stepById.has(step.id)) {
@@ -136,6 +153,8 @@ let WorkflowCompiler = class WorkflowCompiler {
             stepById,
             compiledLoops,
             loopBodyStepIds,
+            resolvedBindings,
+            resolvedOverrides,
         });
     }
     deriveConditionSource(loop, bodySteps) {

package/dist/application/services/workflow-validation-pipeline.js

@@ -24,7 +24,14 @@ function validateWorkflowPhase1a(workflow, deps) {
     if (normalizationResult.isErr()) {
         return { kind: 'normalization_failed', workflowId, cause: normalizationResult.error };
     }
-    const snapshot = normalizationResult.value;
+    const { resolvedBindings, resolvedOverrides } = v1CompilationResult.value;
+    const snapshotBase = normalizationResult.value;
+    const snapshotWithBindings = resolvedBindings.size > 0
+        ? { ...snapshotBase, resolvedBindings: Object.fromEntries(resolvedBindings) }
+        : snapshotBase;
+    const snapshot = resolvedOverrides.size > 0
+        ? { ...snapshotWithBindings, pinnedOverrides: Object.fromEntries(resolvedOverrides) }
+        : snapshotWithBindings;
     if ((0, workflow_definition_js_1.hasWorkflowDefinitionShape)(snapshot.definition)) {
         const executableWorkflow = (0, workflow_js_1.createWorkflow)(snapshot.definition, (0, workflow_source_js_1.createBundledSource)());
         const execCompileResult = deps.compiler.compile(executableWorkflow);

package/dist/cli.js

@@ -10,7 +10,7 @@ const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const container_js_1 = require("./di/container.js");
 const tokens_js_1 = require("./di/tokens.js");
-const server_js_1 = require("./mcp/server.js");
+const stdio_entry_js_1 = require("./mcp/transports/stdio-entry.js");
 const workflow_js_1 = require("./types/workflow.js");
 const validation_js_1 = require("./application/validation.js");
 const validate_workflow_file_js_1 = require("./application/use-cases/validate-workflow-file.js");
@@ -116,7 +116,7 @@ program
     await (0, container_js_1.initializeContainer)({ runtimeMode: { kind: 'cli' } });
     const terminator = container_js_1.container.resolve(tokens_js_1.DI.Runtime.ProcessTerminator);
     const result = await (0, index_js_1.executeStartCommand)({
-        createServer: () => ({ start: () => (0, server_js_1.startServer)() }),
+        createServer: () => ({ start: () => (0, stdio_entry_js_1.startStdioServer)() }),
     });
     (0, interpret_result_js_1.interpretCliResult)(result, terminator);
 });

package/dist/config/feature-flags.js

@@ -40,10 +40,10 @@ exports.FEATURE_FLAG_DEFINITIONS = [
     {
         key: 'agenticRoutines',
         envVar: 'WORKRAIL_ENABLE_AGENTIC_ROUTINES',
-        defaultValue: false,
+        defaultValue: true,
         description: 'Enable Agentic Orchestration features (subagent delegation, .agentic.json overrides, routines)',
         since: '0.8.3',
-        stable: false,
+        stable: true,
     },
     {
         key: 'leanWorkflows',
@@ -162,7 +162,8 @@ class StaticFeatureFlagProvider {
         this.flags = flags;
     }
     isEnabled(key) {
-        return this.flags[key] ?? false;
+        const definition = exports.FEATURE_FLAG_DEFINITIONS.find(flag => flag.key === key);
+        return this.flags[key] ?? definition?.defaultValue ?? false;
     }
     getAll() {
         const allFlags = {};

package/dist/engine/engine-factory.js

@@ -270,7 +270,7 @@ async function createWorkRailEngine(config = {}) {
             }
             return (0, types_js_1.engineOk)({
                 checkpointNodeId: result.value.checkpointNodeId,
-                stateToken: (0, types_js_1.asStateToken)(result.value.stateToken),
+                stateToken: (0, types_js_1.asStateToken)(result.value.resumeToken),
             });
         },
         async listWorkflows() {

package/dist/index.d.ts

@@ -4,4 +4,5 @@ export { DI } from './di/tokens.js';
 export type { WorkflowService } from './application/services/workflow-service.js';
 export type { IWorkflowStorage } from './types/storage.js';
 export type { IFeatureFlagProvider } from './config/feature-flags.js';
-export { startServer } from './mcp/server.js';
+export { composeServer } from './mcp/server.js';
+export { startStdioServer } from './mcp/transports/stdio-entry.js';

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.startServer = exports.DI = exports.resetContainer = exports.container = exports.initializeContainer = exports.bootstrap = void 0;
+exports.startStdioServer = exports.composeServer = exports.DI = exports.resetContainer = exports.container = exports.initializeContainer = exports.bootstrap = void 0;
 var container_js_1 = require("./di/container.js");
 Object.defineProperty(exports, "bootstrap", { enumerable: true, get: function () { return container_js_1.bootstrap; } });
 Object.defineProperty(exports, "initializeContainer", { enumerable: true, get: function () { return container_js_1.initializeContainer; } });
@@ -10,4 +10,6 @@ Object.defineProperty(exports, "resetContainer", { enumerable: true, get: functi
 var tokens_js_1 = require("./di/tokens.js");
 Object.defineProperty(exports, "DI", { enumerable: true, get: function () { return tokens_js_1.DI; } });
 var server_js_1 = require("./mcp/server.js");
-Object.defineProperty(exports, "startServer", { enumerable: true, get: function () { return server_js_1.startServer; } });
+Object.defineProperty(exports, "composeServer", { enumerable: true, get: function () { return server_js_1.composeServer; } });
+var stdio_entry_js_1 = require("./mcp/transports/stdio-entry.js");
+Object.defineProperty(exports, "startStdioServer", { enumerable: true, get: function () { return stdio_entry_js_1.startStdioServer; } });