@exaudeus/workrail 2.0.0 → 3.0.0

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

@@ -1,5 +1,5 @@
 import type { Result } from 'neverthrow';
-import type { WorkflowStepDefinition } from '../../../types/workflow-definition.js';
+import type { WorkflowStepDefinition, WorkflowDefinition } from '../../../types/workflow-definition.js';
 export type TemplateExpander = (callerId: string, args: Readonly<Record<string, unknown>>) => Result<readonly WorkflowStepDefinition[], TemplateExpandError>;
 export type TemplateExpandError = {
     readonly code: 'TEMPLATE_EXPAND_FAILED';
@@ -16,4 +16,6 @@ export interface TemplateRegistry {
     readonly has: (templateId: string) => boolean;
     readonly knownIds: () => readonly string[];
 }
-export declare function createTemplateRegistry(): TemplateRegistry;
+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;

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

@@ -1,13 +1,105 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRoutineExpander = createRoutineExpander;
+exports.routineIdToTemplateId = routineIdToTemplateId;
 exports.createTemplateRegistry = createTemplateRegistry;
 const neverthrow_1 = require("neverthrow");
-const TEMPLATE_DEFINITIONS = new Map();
-function createTemplateRegistry() {
-    const knownIds = [...TEMPLATE_DEFINITIONS.keys()];
+const SINGLE_BRACE_ARG = /(?<!\{)\{([^{}]+)\}(?!\})/g;
+function substituteArgs(text, args, routineId, stepId) {
+    const missing = [];
+    const substituted = text.replace(SINGLE_BRACE_ARG, (match, argName) => {
+        if (argName in args) {
+            return String(args[argName]);
+        }
+        missing.push(argName);
+        return match;
+    });
+    if (missing.length > 0) {
+        return (0, neverthrow_1.err)({
+            code: 'TEMPLATE_EXPAND_FAILED',
+            templateId: `wr.templates.routine.${routineId}`,
+            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.`,
+            });
+        }
+    }
+    return (0, neverthrow_1.ok)(undefined);
+}
+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) {
+            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'.`,
+            });
+        }
+    }
+    const routineGuidance = definition.metaGuidance ?? [];
+    const expander = (callerId, args) => {
+        const expandedSteps = [];
+        for (const step of routineSteps) {
+            const promptResult = substituteArgs(step.prompt, args, routineId, step.id);
+            if (promptResult.isErr())
+                return (0, neverthrow_1.err)(promptResult.error);
+            const mergedGuidance = routineGuidance.length > 0
+                ? [...(step.guidance ?? []), ...routineGuidance]
+                : (step.guidance ?? []);
+            const expandedStep = {
+                id: `${callerId}.${step.id}`,
+                title: step.title,
+                prompt: promptResult.value,
+                ...(step.agentRole !== undefined && { agentRole: step.agentRole }),
+                ...(mergedGuidance.length > 0 && { guidance: mergedGuidance }),
+                ...(step.requireConfirmation !== undefined && { requireConfirmation: step.requireConfirmation }),
+            };
+            expandedSteps.push(expandedStep);
+        }
+        return (0, neverthrow_1.ok)(expandedSteps);
+    };
+    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 knownIds = [...allTemplates.keys()];
     return {
         resolve(templateId) {
-            const expander = TEMPLATE_DEFINITIONS.get(templateId);
+            const expander = allTemplates.get(templateId);
             if (!expander) {
                 return (0, neverthrow_1.err)({
                     code: 'UNKNOWN_TEMPLATE',
@@ -18,7 +110,7 @@ function createTemplateRegistry() {
             return (0, neverthrow_1.ok)(expander);
         },
         has(templateId) {
-            return TEMPLATE_DEFINITIONS.has(templateId);
+            return allTemplates.has(templateId);
         },
         knownIds() {
             return knownIds;

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 TemplateRegistry } from './compiler/template-registry';
 export interface CompiledLoop {
     readonly loop: LoopStepDefinition;
     readonly bodySteps: readonly WorkflowStepDefinition[];
@@ -14,8 +15,11 @@ export interface CompiledWorkflow {
     readonly compiledLoops: ReadonlyMap<string, CompiledLoop>;
     readonly loopBodyStepIds: ReadonlySet<string>;
 }
-export declare function resolveDefinitionSteps(steps: readonly (WorkflowStepDefinition | LoopStepDefinition)[], features: readonly string[]): Result<readonly (WorkflowStepDefinition | LoopStepDefinition)[], DomainError>;
+export declare function resolveDefinitionSteps(steps: readonly (WorkflowStepDefinition | LoopStepDefinition)[], features: readonly string[], templateRegistry?: TemplateRegistry): 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,6 +5,10 @@ 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;
@@ -22,9 +26,9 @@ const resolve_templates_1 = require("./compiler/resolve-templates");
 const template_registry_1 = require("./compiler/template-registry");
 const _refRegistry = (0, ref_registry_1.createRefRegistry)();
 const _featureRegistry = (0, feature_registry_1.createFeatureRegistry)();
-const _templateRegistry = (0, template_registry_1.createTemplateRegistry)();
-function resolveDefinitionSteps(steps, features) {
-    const templatesResult = (0, resolve_templates_1.resolveTemplatesPass)(steps, _templateRegistry);
+const _defaultTemplateRegistry = (0, template_registry_1.createTemplateRegistry)();
+function resolveDefinitionSteps(steps, features, templateRegistry = _defaultTemplateRegistry) {
+    const templatesResult = (0, resolve_templates_1.resolveTemplatesPass)(steps, templateRegistry);
     if (templatesResult.isErr()) {
         const e = templatesResult.error;
         const message = e.code === 'TEMPLATE_RESOLVE_ERROR'
@@ -55,9 +59,17 @@ function resolveDefinitionSteps(steps, features) {
     }
     return (0, neverthrow_1.ok)(blocksResult.value);
 }
-let WorkflowCompiler = class WorkflowCompiler {
+let WorkflowCompiler = WorkflowCompiler_1 = class WorkflowCompiler {
+    constructor() {
+        this.templateRegistry = _defaultTemplateRegistry;
+    }
+    static withTemplateRegistry(registry) {
+        const compiler = new WorkflowCompiler_1();
+        compiler.templateRegistry = registry;
+        return compiler;
+    }
     compile(workflow) {
-        const resolvedResult = resolveDefinitionSteps(workflow.definition.steps, workflow.definition.features ?? []);
+        const resolvedResult = resolveDefinitionSteps(workflow.definition.steps, workflow.definition.features ?? [], this.templateRegistry);
         if (resolvedResult.isErr())
             return (0, neverthrow_1.err)(resolvedResult.error);
         const steps = resolvedResult.value;
@@ -158,6 +170,7 @@ let WorkflowCompiler = class WorkflowCompiler {
     }
 };
 exports.WorkflowCompiler = WorkflowCompiler;
-exports.WorkflowCompiler = WorkflowCompiler = __decorate([
-    (0, tsyringe_1.singleton)()
+exports.WorkflowCompiler = WorkflowCompiler = WorkflowCompiler_1 = __decorate([
+    (0, tsyringe_1.singleton)(),
+    __metadata("design:paramtypes", [])
 ], WorkflowCompiler);

package/dist/application/use-cases/raw-workflow-file-scanner.d.ts

@@ -1,6 +1,6 @@
 import type { WorkflowDefinition } from '../../types/workflow-definition.js';
 export declare function findWorkflowJsonFiles(baseDirReal: string): Promise<string[]>;
-export type VariantKind = 'v2' | 'agentic' | 'standard';
+export type VariantKind = 'lean' | 'v2' | 'agentic' | 'standard';
 export interface ParsedRawWorkflowFile {
     readonly kind: 'parsed';
     readonly filePath: string;

package/dist/application/use-cases/raw-workflow-file-scanner.js

@@ -77,6 +77,8 @@ async function scanRawWorkflowFiles(baseDirReal) {
 }
 function detectVariantKind(relativeFilePath) {
     const normalized = relativeFilePath.replace(/\\/g, '/');
+    if (normalized.includes('.lean.'))
+        return 'lean';
     if (normalized.includes('.v2.'))
         return 'v2';
     if (normalized.includes('.agentic.'))

package/dist/application/use-cases/validate-workflow-registry.js

@@ -191,7 +191,7 @@ function deriveVariantResolutions(loadedWorkflows, allRawFiles, source) {
             const availableVariants = rawFilesForId.map(f => f.variantKind);
             const selectedRaw = rawFilesForId.find(f => f.definition.id === id);
             const selectedVariant = selectedRaw?.variantKind ?? 'standard';
-            if (selectedVariant === 'v2' || selectedVariant === 'agentic') {
+            if (selectedVariant === 'lean' || selectedVariant === 'v2' || selectedVariant === 'agentic') {
                 result.set(id, {
                     kind: 'feature_flag_selected',
                     selectedVariant,
@@ -199,6 +199,7 @@ function deriveVariantResolutions(loadedWorkflows, allRawFiles, source) {
                     enabledFlags: {
                         v2Tools: selectedVariant === 'v2',
                         agenticRoutines: selectedVariant === 'agentic',
+                        leanWorkflows: selectedVariant === 'lean',
                     },
                 });
             }

package/dist/config/feature-flags.js

@@ -45,6 +45,14 @@ exports.FEATURE_FLAG_DEFINITIONS = [
         since: '0.8.3',
         stable: false,
     },
+    {
+        key: 'leanWorkflows',
+        envVar: 'WORKRAIL_ENABLE_LEAN_WORKFLOWS',
+        defaultValue: false,
+        description: 'Enable lean workflow variants (.lean.) that merge phases and reduce token usage while preserving quality',
+        since: '0.10.0',
+        stable: false,
+    },
     {
         key: 'authoritativeDescriptions',
         envVar: 'WORKRAIL_AUTHORITATIVE_DESCRIPTIONS',

package/dist/di/container.js

@@ -86,6 +86,7 @@ function detectRuntimeMode() {
 function toProcessLifecyclePolicy(mode) {
     switch (mode.kind) {
         case 'test':
+        case 'library':
             return { kind: 'no_signal_handlers' };
         case 'cli':
         case 'rpc':
@@ -103,7 +104,7 @@ function registerRuntime(options = {}) {
     const signals = policy.kind === 'no_signal_handlers' ? new noop_process_signals_js_1.NoopProcessSignals() : new node_process_signals_js_1.NodeProcessSignals();
     tsyringe_1.container.register(tokens_js_1.DI.Runtime.ProcessSignals, { useValue: signals });
     tsyringe_1.container.register(tokens_js_1.DI.Runtime.ShutdownEvents, { useValue: new in_memory_shutdown_events_js_1.InMemoryShutdownEvents() });
-    const terminator = mode.kind === 'test' ? new throwing_process_terminator_js_1.ThrowingProcessTerminator() : new node_process_terminator_js_1.NodeProcessTerminator();
+    const terminator = (mode.kind === 'test' || mode.kind === 'library') ? new throwing_process_terminator_js_1.ThrowingProcessTerminator() : new node_process_terminator_js_1.NodeProcessTerminator();
     tsyringe_1.container.register(tokens_js_1.DI.Runtime.ProcessTerminator, { useValue: terminator });
 }
 async function registerStorageChain() {
@@ -221,6 +222,7 @@ async function registerV2Services() {
         }),
     });
     const { LocalKeyringV2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/keyring/index.js')));
+    const { LocalTokenAliasStoreV2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/token-alias-store/index.js')));
     const { LocalSessionEventLogStoreV2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/session-store/index.js')));
     const { LocalSnapshotStoreV2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/snapshot-store/index.js')));
     const { LocalPinnedWorkflowStoreV2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/pinned-workflow-store/index.js')));
@@ -234,6 +236,13 @@ async function registerV2Services() {
             return new LocalKeyringV2(dataDir, fs, base64url, entropy);
         }),
     });
+    tsyringe_1.container.register(tokens_js_1.DI.V2.TokenAliasStore, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)((c) => {
+            const dataDir = c.resolve(tokens_js_1.DI.V2.DataDir);
+            const fs = c.resolve(tokens_js_1.DI.V2.FileSystem);
+            return new LocalTokenAliasStoreV2(dataDir, fs);
+        }),
+    });
     tsyringe_1.container.register(tokens_js_1.DI.V2.SessionStore, {
         useFactory: (0, tsyringe_1.instanceCachingFactory)((c) => {
             const dataDir = c.resolve(tokens_js_1.DI.V2.DataDir);

package/dist/di/tokens.d.ts

@@ -38,6 +38,7 @@ export declare const DI: {
         readonly SnapshotStore: symbol;
         readonly PinnedWorkflowStore: symbol;
         readonly SessionLock: symbol;
+        readonly TokenAliasStore: symbol;
         readonly ExecutionGate: symbol;
     };
     readonly Runtime: {

package/dist/di/tokens.js

@@ -41,6 +41,7 @@ exports.DI = {
         SnapshotStore: Symbol('V2.SnapshotStore'),
         PinnedWorkflowStore: Symbol('V2.PinnedWorkflowStore'),
         SessionLock: Symbol('V2.SessionLock'),
+        TokenAliasStore: Symbol('V2.TokenAliasStore'),
         ExecutionGate: Symbol('V2.ExecutionGate'),
     },
     Runtime: {

package/dist/engine/engine-factory.d.ts

@@ -0,0 +1,3 @@
+import 'reflect-metadata';
+import type { EngineConfig, EngineResult, WorkRailEngine } from './types.js';
+export declare function createWorkRailEngine(config?: EngineConfig): Promise<EngineResult<WorkRailEngine>>;

package/dist/engine/engine-factory.js

@@ -0,0 +1,295 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorkRailEngine = createWorkRailEngine;
+require("reflect-metadata");
+const container_js_1 = require("../di/container.js");
+const tokens_js_1 = require("../di/tokens.js");
+const token_codec_ports_js_1 = require("../v2/durable-core/tokens/token-codec-ports.js");
+const validation_js_1 = require("../application/validation.js");
+const v1_to_v2_shim_js_1 = require("../v2/read-only/v1-to-v2-shim.js");
+const feature_flags_js_1 = require("../config/feature-flags.js");
+const index_js_1 = require("../v2/infra/local/data-dir/index.js");
+const start_js_1 = require("../mcp/handlers/v2-execution/start.js");
+const index_js_2 = require("../mcp/handlers/v2-execution/index.js");
+const v2_checkpoint_js_1 = require("../mcp/handlers/v2-checkpoint.js");
+const types_js_1 = require("./types.js");
+async function safeAsync(fn) {
+    try {
+        return (0, types_js_1.engineOk)(await fn());
+    }
+    catch (e) {
+        return (0, types_js_1.engineErr)({
+            kind: 'storage_error',
+            message: e instanceof Error ? e.message : String(e),
+        });
+    }
+}
+function mapStartError(e) {
+    switch (e.kind) {
+        case 'workflow_not_found':
+            return { kind: 'workflow_not_found', workflowId: e.workflowId };
+        case 'workflow_has_no_steps':
+            return { kind: 'workflow_has_no_steps', workflowId: e.workflowId };
+        case 'workflow_compile_failed':
+            return { kind: 'workflow_compile_failed', message: e.message };
+        case 'token_signing_failed':
+            return { kind: 'token_signing_failed', message: String(e.cause) };
+        case 'prompt_render_failed':
+            return { kind: 'prompt_render_failed', message: e.message };
+        case 'precondition_failed':
+            return { kind: 'precondition_failed', message: e.message };
+        case 'invariant_violation':
+            return { kind: 'internal_error', message: e.message };
+        case 'validation_failed':
+            return { kind: 'validation_failed', message: e.failure.message };
+        case 'keyring_load_failed':
+            return { kind: 'internal_error', message: e.cause.message, code: e.cause.code };
+        case 'hash_computation_failed':
+            return { kind: 'internal_error', message: e.message };
+        case 'pinned_workflow_store_failed':
+            return { kind: 'storage_error', message: e.cause.message, code: e.cause.code };
+        case 'snapshot_creation_failed':
+            return { kind: 'storage_error', message: e.cause.message, code: e.cause.code };
+        case 'session_append_failed':
+            return { kind: 'session_error', message: e.cause.message, code: e.cause.code };
+    }
+}
+function mapContinueError(e) {
+    switch (e.kind) {
+        case 'precondition_failed':
+            return { kind: 'precondition_failed', message: e.message };
+        case 'token_unknown_node':
+            return { kind: 'token_invalid', message: e.message };
+        case 'invariant_violation':
+            return { kind: 'internal_error', message: e.message };
+        case 'validation_failed':
+            return { kind: 'validation_failed', message: e.failure.message };
+        case 'token_decode_failed':
+            return { kind: 'token_invalid', message: e.cause.message, code: e.cause.code };
+        case 'token_verify_failed':
+            return { kind: 'token_invalid', message: e.cause.message, code: e.cause.code };
+        case 'keyring_load_failed':
+            return { kind: 'internal_error', message: e.cause.message, code: e.cause.code };
+        case 'session_load_failed':
+            return { kind: 'session_error', message: e.cause.message, code: e.cause.code };
+        case 'snapshot_load_failed':
+            return { kind: 'storage_error', message: e.cause.message, code: e.cause.code };
+        case 'pinned_workflow_store_failed':
+            return { kind: 'storage_error', message: e.cause.message, code: e.cause.code };
+        case 'pinned_workflow_missing':
+            return { kind: 'storage_error', message: `Pinned workflow missing: ${e.workflowHash}` };
+        case 'token_signing_failed':
+            return { kind: 'token_signing_failed', message: String(e.cause) };
+        case 'advance_execution_failed':
+            return { kind: 'session_error', message: e.cause.message, code: e.cause.code };
+        case 'prompt_render_failed':
+            return { kind: 'prompt_render_failed', message: e.message };
+    }
+}
+function mapCheckpointError(e) {
+    switch (e.kind) {
+        case 'precondition_failed':
+            return { kind: 'precondition_failed', message: e.message };
+        case 'token_signing_failed':
+            return { kind: 'token_signing_failed', message: String(e.cause) };
+        case 'validation_failed':
+            return { kind: 'validation_failed', message: e.failure.message };
+        case 'missing_node_or_run':
+            return { kind: 'session_error', message: 'Node or run not found in session events' };
+        case 'event_schema_invalid':
+            return { kind: 'internal_error', message: `Event schema invalid: ${e.issues}` };
+        case 'gate_failed':
+            return { kind: 'session_error', message: e.cause.message, code: e.cause.code };
+        case 'store_failed':
+            return { kind: 'storage_error', message: e.cause.message, code: e.cause.code };
+    }
+}
+function mapPending(raw) {
+    if (!raw)
+        return null;
+    return {
+        stepId: raw.stepId,
+        title: raw.title,
+        prompt: raw.prompt,
+        ...(raw.agentRole ? { agentRole: raw.agentRole } : {}),
+    };
+}
+function mapStartOutput(out) {
+    const ct = out.continueToken ?? '';
+    return {
+        kind: 'ok',
+        stateToken: (0, types_js_1.asStateToken)(ct),
+        ackToken: (0, types_js_1.asAckToken)(ct),
+        checkpointToken: out.checkpointToken ? (0, types_js_1.asCheckpointToken)(out.checkpointToken) : null,
+        isComplete: out.isComplete,
+        pending: mapPending(out.pending),
+        preferences: out.preferences,
+        nextIntent: out.nextIntent,
+    };
+}
+function mapContinueOutput(out) {
+    const ct = out.continueToken ?? '';
+    const base = {
+        stateToken: (0, types_js_1.asStateToken)(ct),
+        ackToken: (0, types_js_1.asAckToken)(ct),
+        checkpointToken: out.checkpointToken ? (0, types_js_1.asCheckpointToken)(out.checkpointToken) : null,
+        isComplete: out.isComplete,
+        pending: mapPending(out.pending),
+        preferences: out.preferences,
+        nextIntent: out.nextIntent,
+    };
+    if (out.kind === 'blocked') {
+        const blocked = {
+            kind: 'blocked',
+            ...base,
+            blockers: out.blockers.blockers.map(b => ({
+                code: b.code,
+                message: b.message,
+                ...(b.suggestedFix ? { suggestedFix: b.suggestedFix } : {}),
+            })),
+            retryable: out.retryable ?? false,
+            retryAckToken: out.retryContinueToken ? (0, types_js_1.asAckToken)(out.retryContinueToken) : null,
+        };
+        return blocked;
+    }
+    return { kind: 'ok', ...base };
+}
+let engineActive = false;
+async function createWorkRailEngine(config = {}) {
+    if (engineActive) {
+        return (0, types_js_1.engineErr)({
+            kind: 'precondition_failed',
+            message: 'An engine is already active. Call engine.close() before creating another instance.',
+        });
+    }
+    await (0, container_js_1.initializeContainer)({ runtimeMode: { kind: 'library' } });
+    if (config.dataDir) {
+        const customEnv = { ...process.env, WORKRAIL_DATA_DIR: config.dataDir };
+        container_js_1.container.register(tokens_js_1.DI.V2.DataDir, { useValue: new index_js_1.LocalDataDirV2(customEnv) });
+    }
+    const workflowService = container_js_1.container.resolve(tokens_js_1.DI.Services.Workflow);
+    const gate = container_js_1.container.resolve(tokens_js_1.DI.V2.ExecutionGate);
+    const sessionStore = container_js_1.container.resolve(tokens_js_1.DI.V2.SessionStore);
+    const snapshotStore = container_js_1.container.resolve(tokens_js_1.DI.V2.SnapshotStore);
+    const pinnedStore = container_js_1.container.resolve(tokens_js_1.DI.V2.PinnedWorkflowStore);
+    const keyringPort = container_js_1.container.resolve(tokens_js_1.DI.V2.Keyring);
+    const keyringResult = await keyringPort.loadOrCreate();
+    if (keyringResult.isErr()) {
+        (0, container_js_1.resetContainer)();
+        return (0, types_js_1.engineErr)({
+            kind: 'internal_error',
+            message: keyringResult.error.message,
+            code: keyringResult.error.code,
+        });
+    }
+    const sha256 = container_js_1.container.resolve(tokens_js_1.DI.V2.Sha256);
+    const crypto = container_js_1.container.resolve(tokens_js_1.DI.V2.Crypto);
+    const entropy = container_js_1.container.resolve(tokens_js_1.DI.V2.RandomEntropy);
+    const hmac = container_js_1.container.resolve(tokens_js_1.DI.V2.HmacSha256);
+    const base64url = container_js_1.container.resolve(tokens_js_1.DI.V2.Base64Url);
+    const base32 = container_js_1.container.resolve(tokens_js_1.DI.V2.Base32);
+    const bech32m = container_js_1.container.resolve(tokens_js_1.DI.V2.Bech32m);
+    const idFactory = container_js_1.container.resolve(tokens_js_1.DI.V2.IdFactory);
+    const tokenCodecPorts = (0, token_codec_ports_js_1.unsafeTokenCodecPorts)({
+        keyring: keyringResult.value,
+        hmac,
+        base64url,
+        base32,
+        bech32m,
+    });
+    const validationEngine = container_js_1.container.resolve(tokens_js_1.DI.Infra.ValidationEngine);
+    const compiler = container_js_1.container.resolve(tokens_js_1.DI.Services.WorkflowCompiler);
+    const validationPipelineDeps = {
+        schemaValidate: validation_js_1.validateWorkflowSchema,
+        structuralValidate: validationEngine.validateWorkflowStructureOnly.bind(validationEngine),
+        compiler,
+        normalizeToExecutable: v1_to_v2_shim_js_1.normalizeV1WorkflowToPinnedSnapshot,
+    };
+    const dataDir = container_js_1.container.resolve(tokens_js_1.DI.V2.DataDir);
+    const tokenAliasStore = container_js_1.container.resolve(tokens_js_1.DI.V2.TokenAliasStore);
+    const aliasLoadResult = await tokenAliasStore.loadIndex();
+    if (aliasLoadResult.isErr()) {
+        console.error(`[engine-factory] Token alias index load warning: ${aliasLoadResult.error.message}`);
+    }
+    const v2 = {
+        gate,
+        sessionStore,
+        snapshotStore,
+        pinnedStore,
+        sha256,
+        crypto,
+        entropy,
+        idFactory,
+        tokenCodecPorts,
+        tokenAliasStore,
+        validationPipelineDeps,
+        resolvedRootUris: [],
+        dataDir,
+    };
+    const featureFlags = new feature_flags_js_1.StaticFeatureFlagProvider({ v2Tools: true });
+    const ctx = {
+        workflowService,
+        featureFlags,
+        sessionManager: null,
+        httpServer: null,
+        v2,
+    };
+    const v2Ctx = ctx;
+    engineActive = true;
+    const engine = {
+        async startWorkflow(workflowId) {
+            const result = await (0, start_js_1.executeStartWorkflow)({ workflowId }, v2Ctx);
+            if (result.isErr()) {
+                return (0, types_js_1.engineErr)(mapStartError(result.error));
+            }
+            return (0, types_js_1.engineOk)(mapStartOutput(result.value));
+        },
+        async continueWorkflow(stateToken, ackToken, output, context) {
+            const intent = ackToken ? 'advance' : 'rehydrate';
+            const input = {
+                continueToken: (0, types_js_1.unwrapToken)(stateToken),
+                intent: intent,
+                ...(output ? {
+                    output: {
+                        notesMarkdown: output.notesMarkdown,
+                        ...(output.artifacts?.length ? { artifacts: [...output.artifacts] } : {}),
+                    },
+                } : {}),
+                ...(context ? { context } : {}),
+            };
+            const result = await (0, index_js_2.executeContinueWorkflow)(input, v2Ctx);
+            if (result.isErr()) {
+                return (0, types_js_1.engineErr)(mapContinueError(result.error));
+            }
+            return (0, types_js_1.engineOk)(mapContinueOutput(result.value));
+        },
+        async checkpointWorkflow(checkpointToken) {
+            const result = await (0, v2_checkpoint_js_1.executeCheckpoint)({ checkpointToken: (0, types_js_1.unwrapToken)(checkpointToken) }, v2Ctx);
+            if (result.isErr()) {
+                return (0, types_js_1.engineErr)(mapCheckpointError(result.error));
+            }
+            return (0, types_js_1.engineOk)({
+                checkpointNodeId: result.value.checkpointNodeId,
+                stateToken: (0, types_js_1.asStateToken)(result.value.stateToken),
+            });
+        },
+        async listWorkflows() {
+            const result = await safeAsync(() => workflowService.listWorkflowSummaries());
+            if (!result.ok)
+                return result;
+            return (0, types_js_1.engineOk)({
+                workflows: result.value.map((s) => ({
+                    workflowId: s.id,
+                    name: s.name,
+                    description: s.description,
+                    version: s.version,
+                })),
+            });
+        },
+        async close() {
+            (0, container_js_1.resetContainer)();
+            engineActive = false;
+        },
+    };
+    return (0, types_js_1.engineOk)(engine);
+}

package/dist/engine/index.d.ts

@@ -0,0 +1,3 @@
+export { createWorkRailEngine } from './engine-factory.js';
+export type { WorkRailEngine, EngineConfig, EngineResult, EngineError, InfraErrorCode, StepResponse, StepResponseOk, StepResponseBlocked, CheckpointResponse, WorkflowListResponse, WorkflowListItem, PendingStep, StepPreferences, Autonomy, RiskPolicy, NextIntent, Blocker, BlockerCode, StateToken, AckToken, CheckpointToken, } from './types.js';
+export { engineOk, engineErr, asStateToken, asAckToken, asCheckpointToken, unwrapToken } from './types.js';

package/dist/engine/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unwrapToken = exports.asCheckpointToken = exports.asAckToken = exports.asStateToken = exports.engineErr = exports.engineOk = exports.createWorkRailEngine = void 0;
+var engine_factory_js_1 = require("./engine-factory.js");
+Object.defineProperty(exports, "createWorkRailEngine", { enumerable: true, get: function () { return engine_factory_js_1.createWorkRailEngine; } });
+var types_js_1 = require("./types.js");
+Object.defineProperty(exports, "engineOk", { enumerable: true, get: function () { return types_js_1.engineOk; } });
+Object.defineProperty(exports, "engineErr", { enumerable: true, get: function () { return types_js_1.engineErr; } });
+Object.defineProperty(exports, "asStateToken", { enumerable: true, get: function () { return types_js_1.asStateToken; } });
+Object.defineProperty(exports, "asAckToken", { enumerable: true, get: function () { return types_js_1.asAckToken; } });
+Object.defineProperty(exports, "asCheckpointToken", { enumerable: true, get: function () { return types_js_1.asCheckpointToken; } });
+Object.defineProperty(exports, "unwrapToken", { enumerable: true, get: function () { return types_js_1.unwrapToken; } });