@exaudeus/workrail 0.8.5 → 0.9.0

package/dist/di/container.js

@@ -0,0 +1,244 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.container = void 0;
+exports.initializeContainer = initializeContainer;
+exports.startAsyncServices = startAsyncServices;
+exports.bootstrap = bootstrap;
+exports.resetContainer = resetContainer;
+exports.isInitialized = isInitialized;
+require("reflect-metadata");
+const tsyringe_1 = require("tsyringe");
+Object.defineProperty(exports, "container", { enumerable: true, get: function () { return tsyringe_1.container; } });
+const tokens_js_1 = require("./tokens.js");
+const assert_never_js_1 = require("../runtime/assert-never.js");
+const node_process_signals_js_1 = require("../runtime/adapters/node-process-signals.js");
+const noop_process_signals_js_1 = require("../runtime/adapters/noop-process-signals.js");
+const in_memory_shutdown_events_js_1 = require("../runtime/adapters/in-memory-shutdown-events.js");
+const node_process_terminator_js_1 = require("../runtime/adapters/node-process-terminator.js");
+const throwing_process_terminator_js_1 = require("../runtime/adapters/throwing-process-terminator.js");
+const app_config_js_1 = require("../config/app-config.js");
+const formatter_js_1 = require("../errors/formatter.js");
+let initialized = false;
+let asyncInitialized = false;
+let initializationPromise = null;
+let isInitializing = false;
+async function registerConfig() {
+    if (!tsyringe_1.container.isRegistered(tokens_js_1.DI.Config.App)) {
+        const configResult = (0, app_config_js_1.loadConfig)({ env: process.env, projectPath: process.cwd() });
+        if (configResult.kind === 'err') {
+            console.error((0, formatter_js_1.formatAppError)(configResult.error));
+            process.exit(1);
+        }
+        const config = configResult.value;
+        tsyringe_1.container.register(tokens_js_1.DI.Config.App, { useValue: config });
+        tsyringe_1.container.register(tokens_js_1.DI.Config.CacheTTL, { useValue: config.cache.ttlMs });
+        tsyringe_1.container.register(tokens_js_1.DI.Config.WorkflowDir, { useValue: config.paths.workflowDir });
+        tsyringe_1.container.register(tokens_js_1.DI.Config.ProjectPath, { useValue: config.paths.projectPath });
+        tsyringe_1.container.register(tokens_js_1.DI.Config.DashboardMode, { useValue: config.dashboard.mode });
+        tsyringe_1.container.register(tokens_js_1.DI.Config.BrowserBehavior, { useValue: config.dashboard.browserBehavior });
+    }
+    if (!tsyringe_1.container.isRegistered(tokens_js_1.DI.Infra.FeatureFlags)) {
+        const { EnvironmentFeatureFlagProvider } = await Promise.resolve().then(() => __importStar(require('../config/feature-flags.js')));
+        tsyringe_1.container.register(tokens_js_1.DI.Infra.FeatureFlags, {
+            useFactory: (0, tsyringe_1.instanceCachingFactory)((c) => c.resolve(EnvironmentFeatureFlagProvider))
+        });
+    }
+}
+function detectRuntimeMode() {
+    if (process.env.VITEST || process.env.NODE_ENV === 'test') {
+        return { kind: 'test' };
+    }
+    return { kind: 'production' };
+}
+function toProcessLifecyclePolicy(mode) {
+    switch (mode.kind) {
+        case 'test':
+            return { kind: 'no_signal_handlers' };
+        case 'cli':
+        case 'rpc':
+        case 'production':
+            return { kind: 'install_signal_handlers' };
+        default:
+            return (0, assert_never_js_1.assertNever)(mode);
+    }
+}
+function registerRuntime(options = {}) {
+    const mode = options.runtimeMode ?? detectRuntimeMode();
+    const policy = toProcessLifecyclePolicy(mode);
+    tsyringe_1.container.register(tokens_js_1.DI.Runtime.Mode, { useValue: mode });
+    tsyringe_1.container.register(tokens_js_1.DI.Runtime.ProcessLifecyclePolicy, { useValue: policy });
+    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();
+    tsyringe_1.container.register(tokens_js_1.DI.Runtime.ProcessTerminator, { useValue: terminator });
+}
+async function registerStorageChain() {
+    const { EnhancedMultiSourceWorkflowStorage } = await Promise.resolve().then(() => __importStar(require('../infrastructure/storage/enhanced-multi-source-workflow-storage.js')));
+    const { SchemaValidatingWorkflowStorage } = await Promise.resolve().then(() => __importStar(require('../infrastructure/storage/schema-validating-workflow-storage.js')));
+    const { CachingWorkflowStorage } = await Promise.resolve().then(() => __importStar(require('../infrastructure/storage/caching-workflow-storage.js')));
+    tsyringe_1.container.register(tokens_js_1.DI.Storage.Base, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)((c) => {
+            const featureFlags = c.resolve(tokens_js_1.DI.Infra.FeatureFlags);
+            return new EnhancedMultiSourceWorkflowStorage({}, featureFlags);
+        }),
+    });
+    tsyringe_1.container.register(tokens_js_1.DI.Storage.Validated, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)((c) => {
+            const base = c.resolve(tokens_js_1.DI.Storage.Base);
+            return new SchemaValidatingWorkflowStorage(base);
+        }),
+    });
+    tsyringe_1.container.register(tokens_js_1.DI.Storage.Primary, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)((c) => {
+            const validated = c.resolve(tokens_js_1.DI.Storage.Validated);
+            const ttl = c.resolve(tokens_js_1.DI.Config.CacheTTL);
+            return new CachingWorkflowStorage(validated, ttl);
+        }),
+    });
+}
+async function registerServices() {
+    const { EnhancedLoopValidator } = await Promise.resolve().then(() => __importStar(require('../application/services/enhanced-loop-validator.js')));
+    const { SessionDataNormalizer } = await Promise.resolve().then(() => __importStar(require('../infrastructure/session/SessionDataNormalizer.js')));
+    const { SessionDataValidator } = await Promise.resolve().then(() => __importStar(require('../infrastructure/session/SessionDataValidator.js')));
+    const { ValidationEngine } = await Promise.resolve().then(() => __importStar(require('../application/services/validation-engine.js')));
+    const { WorkflowCompiler } = await Promise.resolve().then(() => __importStar(require('../application/services/workflow-compiler.js')));
+    const { WorkflowInterpreter } = await Promise.resolve().then(() => __importStar(require('../application/services/workflow-interpreter.js')));
+    const { ToolDescriptionProvider } = await Promise.resolve().then(() => __importStar(require('../mcp/tool-description-provider.js')));
+    const { DefaultWorkflowService } = await Promise.resolve().then(() => __importStar(require('../application/services/workflow-service.js')));
+    const { SessionManager } = await Promise.resolve().then(() => __importStar(require('../infrastructure/session/SessionManager.js')));
+    const { HttpServer } = await Promise.resolve().then(() => __importStar(require('../infrastructure/session/HttpServer.js')));
+    tsyringe_1.container.register(tokens_js_1.DI.Infra.EnhancedLoopValidator, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)((c) => c.resolve(EnhancedLoopValidator))
+    });
+    tsyringe_1.container.register(tokens_js_1.DI.Infra.SessionDataNormalizer, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)((c) => c.resolve(SessionDataNormalizer))
+    });
+    tsyringe_1.container.register(tokens_js_1.DI.Infra.SessionDataValidator, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)((c) => c.resolve(SessionDataValidator))
+    });
+    tsyringe_1.container.register(tokens_js_1.DI.Infra.ValidationEngine, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)((c) => c.resolve(ValidationEngine))
+    });
+    tsyringe_1.container.register(tokens_js_1.DI.Services.WorkflowCompiler, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)((c) => c.resolve(WorkflowCompiler)),
+    });
+    tsyringe_1.container.register(tokens_js_1.DI.Services.WorkflowInterpreter, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)((c) => c.resolve(WorkflowInterpreter)),
+    });
+    tsyringe_1.container.register(tokens_js_1.DI.Services.Workflow, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)((c) => c.resolve(DefaultWorkflowService))
+    });
+    tsyringe_1.container.register(tokens_js_1.DI.Infra.SessionManager, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)((c) => c.resolve(SessionManager))
+    });
+    tsyringe_1.container.register(tokens_js_1.DI.Infra.HttpServer, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)((c) => c.resolve(HttpServer))
+    });
+    if (!tsyringe_1.container.isRegistered(tokens_js_1.DI.Mcp.DescriptionProvider)) {
+        tsyringe_1.container.registerSingleton(tokens_js_1.DI.Mcp.DescriptionProvider, ToolDescriptionProvider);
+    }
+}
+async function initializeContainer(options = {}) {
+    if (initialized)
+        return;
+    if (isInitializing) {
+        const INIT_TIMEOUT_MS = 5000;
+        const POLL_INTERVAL_MS = 10;
+        let waited = 0;
+        while (isInitializing && !initialized && waited < INIT_TIMEOUT_MS) {
+            await new Promise(resolve => setTimeout(resolve, POLL_INTERVAL_MS));
+            waited += POLL_INTERVAL_MS;
+        }
+        if (initialized)
+            return;
+        if (waited >= INIT_TIMEOUT_MS) {
+            throw new Error('[DI] Container initialization timeout after 5 seconds');
+        }
+    }
+    if (initialized)
+        return;
+    isInitializing = true;
+    try {
+        registerRuntime(options);
+        await registerConfig();
+        await registerStorageChain();
+        await registerServices();
+        initialized = true;
+        console.error('[DI] Container initialized');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`[DI] Container initialization failed: ${message}`);
+    }
+    finally {
+        isInitializing = false;
+    }
+}
+async function startAsyncServices() {
+    if (!initialized) {
+        await initializeContainer();
+    }
+    if (asyncInitialized)
+        return;
+    try {
+        const flags = tsyringe_1.container.resolve(tokens_js_1.DI.Infra.FeatureFlags);
+        if (flags.isEnabled('sessionTools')) {
+            const server = tsyringe_1.container.resolve(tokens_js_1.DI.Infra.HttpServer);
+            await server.start();
+            console.error('[DI] HTTP server started');
+        }
+        asyncInitialized = true;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`[DI] Async services initialization failed: ${message}`);
+    }
+}
+async function bootstrap(options = {}) {
+    await initializeContainer(options);
+    await startAsyncServices();
+}
+function resetContainer() {
+    tsyringe_1.container.reset();
+    initialized = false;
+    asyncInitialized = false;
+    initializationPromise = null;
+    isInitializing = false;
+}
+function isInitialized() {
+    return initialized;
+}

package/dist/di/tokens.d.ts

@@ -0,0 +1,40 @@
+export declare const DI: {
+    readonly Storage: {
+        readonly Primary: symbol;
+        readonly Base: symbol;
+        readonly Validated: symbol;
+    };
+    readonly Services: {
+        readonly Workflow: symbol;
+        readonly WorkflowCompiler: symbol;
+        readonly WorkflowInterpreter: symbol;
+    };
+    readonly Infra: {
+        readonly FeatureFlags: symbol;
+        readonly SessionManager: symbol;
+        readonly HttpServer: symbol;
+        readonly ValidationEngine: symbol;
+        readonly EnhancedLoopValidator: symbol;
+        readonly SessionDataNormalizer: symbol;
+        readonly SessionDataValidator: symbol;
+    };
+    readonly Mcp: {
+        readonly DescriptionProvider: symbol;
+    };
+    readonly Runtime: {
+        readonly Mode: symbol;
+        readonly ProcessLifecyclePolicy: symbol;
+        readonly ProcessSignals: symbol;
+        readonly ShutdownEvents: symbol;
+        readonly ProcessTerminator: symbol;
+    };
+    readonly Config: {
+        readonly App: symbol;
+        readonly CacheTTL: symbol;
+        readonly WorkflowDir: symbol;
+        readonly ProjectPath: symbol;
+        readonly DashboardMode: symbol;
+        readonly BrowserBehavior: symbol;
+    };
+};
+export type DIToken = typeof DI[keyof typeof DI][keyof typeof DI[keyof typeof DI]];

package/dist/di/tokens.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DI = void 0;
+exports.DI = {
+    Storage: {
+        Primary: Symbol('Storage.Primary'),
+        Base: Symbol('Storage.Base'),
+        Validated: Symbol('Storage.Validated'),
+    },
+    Services: {
+        Workflow: Symbol('Services.Workflow'),
+        WorkflowCompiler: Symbol('Services.WorkflowCompiler'),
+        WorkflowInterpreter: Symbol('Services.WorkflowInterpreter'),
+    },
+    Infra: {
+        FeatureFlags: Symbol('Infra.FeatureFlags'),
+        SessionManager: Symbol('Infra.SessionManager'),
+        HttpServer: Symbol('Infra.HttpServer'),
+        ValidationEngine: Symbol('Infra.ValidationEngine'),
+        EnhancedLoopValidator: Symbol('Infra.EnhancedLoopValidator'),
+        SessionDataNormalizer: Symbol('Infra.SessionDataNormalizer'),
+        SessionDataValidator: Symbol('Infra.SessionDataValidator'),
+    },
+    Mcp: {
+        DescriptionProvider: Symbol('Mcp.DescriptionProvider'),
+    },
+    Runtime: {
+        Mode: Symbol('Runtime.Mode'),
+        ProcessLifecyclePolicy: Symbol('Runtime.ProcessLifecyclePolicy'),
+        ProcessSignals: Symbol('Runtime.ProcessSignals'),
+        ShutdownEvents: Symbol('Runtime.ShutdownEvents'),
+        ProcessTerminator: Symbol('Runtime.ProcessTerminator'),
+    },
+    Config: {
+        App: Symbol('Config.App'),
+        CacheTTL: Symbol('Config.CacheTTL'),
+        WorkflowDir: Symbol('Config.WorkflowDir'),
+        ProjectPath: Symbol('Config.ProjectPath'),
+        DashboardMode: Symbol('Config.DashboardMode'),
+        BrowserBehavior: Symbol('Config.BrowserBehavior'),
+    },
+};

package/dist/domain/execution/error.d.ts

@@ -0,0 +1,32 @@
+export type DomainError = {
+    readonly _tag: 'WorkflowNotFound';
+    readonly workflowId: string;
+    readonly message: string;
+} | {
+    readonly _tag: 'InvalidState';
+    readonly message: string;
+} | {
+    readonly _tag: 'InvalidLoop';
+    readonly loopId: string;
+    readonly message: string;
+} | {
+    readonly _tag: 'ConditionEvalFailed';
+    readonly message: string;
+} | {
+    readonly _tag: 'MaxIterationsExceeded';
+    readonly loopId: string;
+    readonly maxIterations: number;
+    readonly message: string;
+} | {
+    readonly _tag: 'MissingContext';
+    readonly message: string;
+};
+export declare const Err: {
+    readonly workflowNotFound: (workflowId: string) => DomainError;
+    readonly invalidState: (message: string) => DomainError;
+    readonly invalidLoop: (loopId: string, message: string) => DomainError;
+    readonly conditionEvalFailed: (message: string) => DomainError;
+    readonly maxIterationsExceeded: (loopId: string, maxIterations: number) => DomainError;
+    readonly missingContext: (message: string) => DomainError;
+};
+export declare function isRetriable(_e: DomainError): boolean;

package/dist/domain/execution/error.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Err = void 0;
+exports.isRetriable = isRetriable;
+exports.Err = {
+    workflowNotFound: (workflowId) => ({
+        _tag: 'WorkflowNotFound',
+        workflowId,
+        message: `Workflow '${workflowId}' not found`,
+    }),
+    invalidState: (message) => ({ _tag: 'InvalidState', message }),
+    invalidLoop: (loopId, message) => ({ _tag: 'InvalidLoop', loopId, message }),
+    conditionEvalFailed: (message) => ({ _tag: 'ConditionEvalFailed', message }),
+    maxIterationsExceeded: (loopId, maxIterations) => ({
+        _tag: 'MaxIterationsExceeded',
+        loopId,
+        maxIterations,
+        message: `Loop '${loopId}' exceeded maxIterations (${maxIterations})`,
+    }),
+    missingContext: (message) => ({ _tag: 'MissingContext', message }),
+};
+function isRetriable(_e) {
+    return false;
+}

package/dist/domain/execution/event.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import type { StepInstanceId } from './ids';
+export type WorkflowEvent = {
+    readonly kind: 'step_completed';
+    readonly stepInstanceId: StepInstanceId;
+};
+export declare const WorkflowEventSchema: z.ZodType<WorkflowEvent>;

package/dist/domain/execution/event.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowEventSchema = void 0;
+const zod_1 = require("zod");
+const state_1 = require("./state");
+exports.WorkflowEventSchema = zod_1.z.discriminatedUnion('kind', [
+    zod_1.z.object({
+        kind: zod_1.z.literal('step_completed'),
+        stepInstanceId: state_1.StepInstanceIdSchema,
+    }),
+]);

package/dist/domain/execution/ids.d.ts

@@ -0,0 +1,9 @@
+export interface LoopPathFrame {
+    readonly loopId: string;
+    readonly iteration: number;
+}
+export interface StepInstanceId {
+    readonly stepId: string;
+    readonly loopPath: readonly LoopPathFrame[];
+}
+export declare function toStepInstanceKey(id: StepInstanceId): string;

package/dist/domain/execution/ids.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toStepInstanceKey = toStepInstanceKey;
+function toStepInstanceKey(id) {
+    const path = id.loopPath
+        .map((f) => `${f.loopId}@${f.iteration}`)
+        .join('/');
+    return path.length === 0 ? id.stepId : `${path}::${id.stepId}`;
+}

package/dist/domain/execution/result.d.ts

@@ -0,0 +1,3 @@
+export { ok, err, type Result } from 'neverthrow';
+export declare const isOk: <T, E>(r: import("neverthrow").Result<T, E>) => boolean;
+export declare const isErr: <T, E>(r: import("neverthrow").Result<T, E>) => boolean;

package/dist/domain/execution/result.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isErr = exports.isOk = exports.err = exports.ok = void 0;
+var neverthrow_1 = require("neverthrow");
+Object.defineProperty(exports, "ok", { enumerable: true, get: function () { return neverthrow_1.ok; } });
+Object.defineProperty(exports, "err", { enumerable: true, get: function () { return neverthrow_1.err; } });
+const isOk = (r) => r.isOk();
+exports.isOk = isOk;
+const isErr = (r) => r.isErr();
+exports.isErr = isErr;

package/dist/domain/execution/state.d.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import type { StepInstanceId } from './ids';
+export interface LoopFrame {
+    readonly loopId: string;
+    readonly iteration: number;
+    readonly bodyIndex: number;
+}
+export type ExecutionState = {
+    readonly kind: 'init';
+} | {
+    readonly kind: 'running';
+    readonly completed: readonly string[];
+    readonly loopStack: readonly LoopFrame[];
+    readonly pendingStep?: StepInstanceId;
+} | {
+    readonly kind: 'complete';
+};
+export declare const LoopFrameSchema: z.ZodObject<{
+    loopId: z.ZodString;
+    iteration: z.ZodNumber;
+    bodyIndex: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    iteration: number;
+    loopId: string;
+    bodyIndex: number;
+}, {
+    iteration: number;
+    loopId: string;
+    bodyIndex: number;
+}>;
+export declare const StepInstanceIdSchema: z.ZodObject<{
+    stepId: z.ZodString;
+    loopPath: z.ZodArray<z.ZodObject<{
+        loopId: z.ZodString;
+        iteration: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        iteration: number;
+        loopId: string;
+    }, {
+        iteration: number;
+        loopId: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    stepId: string;
+    loopPath: {
+        iteration: number;
+        loopId: string;
+    }[];
+}, {
+    stepId: string;
+    loopPath: {
+        iteration: number;
+        loopId: string;
+    }[];
+}>;
+export declare const ExecutionStateSchema: z.ZodType<ExecutionState>;
+export declare const initialExecutionState: () => ExecutionState;

package/dist/domain/execution/state.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initialExecutionState = exports.ExecutionStateSchema = exports.StepInstanceIdSchema = exports.LoopFrameSchema = void 0;
+const zod_1 = require("zod");
+exports.LoopFrameSchema = zod_1.z.object({
+    loopId: zod_1.z.string().min(1),
+    iteration: zod_1.z.number().int().min(0),
+    bodyIndex: zod_1.z.number().int().min(0),
+});
+exports.StepInstanceIdSchema = zod_1.z.object({
+    stepId: zod_1.z.string().min(1),
+    loopPath: zod_1.z.array(zod_1.z.object({
+        loopId: zod_1.z.string().min(1),
+        iteration: zod_1.z.number().int().min(0),
+    })),
+});
+exports.ExecutionStateSchema = zod_1.z.discriminatedUnion('kind', [
+    zod_1.z.object({ kind: zod_1.z.literal('init') }),
+    zod_1.z.object({
+        kind: zod_1.z.literal('running'),
+        completed: zod_1.z.array(zod_1.z.string()),
+        loopStack: zod_1.z.array(exports.LoopFrameSchema),
+        pendingStep: exports.StepInstanceIdSchema.optional(),
+    }),
+    zod_1.z.object({ kind: zod_1.z.literal('complete') }),
+]);
+const initialExecutionState = () => ({ kind: 'init' });
+exports.initialExecutionState = initialExecutionState;

package/dist/errors/app-error.d.ts

@@ -0,0 +1,23 @@
+import type { Brand } from '../runtime/brand.js';
+export type ConfigIssue = Readonly<{
+    readonly path: string;
+    readonly message: string;
+}>;
+export type ConfigInvalidError = Readonly<{
+    readonly _tag: 'ConfigInvalid';
+    readonly issues: readonly ConfigIssue[];
+    readonly message: string;
+}>;
+export type StartupFailedError = Readonly<{
+    readonly _tag: 'StartupFailed';
+    readonly phase: string;
+    readonly message: string;
+    readonly cause?: unknown;
+}>;
+export type UnexpectedError = Readonly<{
+    readonly _tag: 'Unexpected';
+    readonly message: string;
+    readonly cause: unknown;
+}>;
+export type AppError = ConfigInvalidError | StartupFailedError | UnexpectedError;
+export type ValidatedAppConfig<T> = Brand<T, 'ValidatedAppConfig'>;

package/dist/errors/factories.d.ts

@@ -0,0 +1,6 @@
+import type { ConfigIssue, ConfigInvalidError, StartupFailedError, UnexpectedError } from './app-error.js';
+export declare const Err: {
+    readonly configInvalid: (issues: readonly ConfigIssue[]) => ConfigInvalidError;
+    readonly startupFailed: (phase: string, message: string, cause?: unknown) => StartupFailedError;
+    readonly unexpected: (message: string, cause: unknown) => UnexpectedError;
+};

package/dist/errors/factories.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Err = void 0;
+exports.Err = {
+    configInvalid: (issues) => ({
+        _tag: 'ConfigInvalid',
+        issues,
+        message: 'Invalid configuration',
+    }),
+    startupFailed: (phase, message, cause) => ({
+        _tag: 'StartupFailed',
+        phase,
+        message,
+        cause,
+    }),
+    unexpected: (message, cause) => ({
+        _tag: 'Unexpected',
+        message,
+        cause,
+    }),
+};

package/dist/errors/formatter.d.ts

@@ -0,0 +1,2 @@
+import type { AppError } from './app-error.js';
+export declare function formatAppError(error: AppError): string;

package/dist/errors/formatter.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatAppError = formatAppError;
+const assert_never_js_1 = require("../runtime/assert-never.js");
+function formatAppError(error) {
+    switch (error._tag) {
+        case 'ConfigInvalid': {
+            const issues = error.issues.length
+                ? error.issues.map((i) => `  - ${i.path}: ${i.message}`).join('\n')
+                : '  - (no details)';
+            return `${error.message}\n\n${issues}`;
+        }
+        case 'StartupFailed': {
+            const base = `Startup failed during ${error.phase}: ${error.message}`;
+            return error.cause ? `${base}\nCause: ${safeToString(error.cause)}` : base;
+        }
+        case 'Unexpected':
+            return `${error.message}\nCause: ${safeToString(error.cause)}`;
+        default:
+            return (0, assert_never_js_1.assertNever)(error);
+    }
+}
+function safeToString(value) {
+    if (value instanceof Error)
+        return `${value.name}: ${value.message}`;
+    try {
+        return typeof value === 'string' ? value : JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}

package/dist/errors/index.d.ts

@@ -0,0 +1,3 @@
+export type { AppError, ConfigIssue, ConfigInvalidError, StartupFailedError, UnexpectedError, ValidatedAppConfig, } from './app-error.js';
+export { Err } from './factories.js';
+export { formatAppError } from './formatter.js';

package/dist/errors/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatAppError = exports.Err = void 0;
+var factories_js_1 = require("./factories.js");
+Object.defineProperty(exports, "Err", { enumerable: true, get: function () { return factories_js_1.Err; } });
+var formatter_js_1 = require("./formatter.js");
+Object.defineProperty(exports, "formatAppError", { enumerable: true, get: function () { return formatter_js_1.formatAppError; } });

package/dist/index.d.ts

@@ -1,2 +1,7 @@
 #!/usr/bin/env node
-export { createWorkflowLookupServer } from './infrastructure/rpc/server';
+export { bootstrap, initializeContainer, container, resetContainer } from './di/container.js';
+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';