@forestadmin/workflow-executor 1.0.0

package/dist/ports/logger-port.d.ts

@@ -0,0 +1,6 @@
+export interface Logger {
+    error(message: string, context: Record<string, unknown>): void;
+    warn(message: string, context: Record<string, unknown>): void;
+    info(message: string, context: Record<string, unknown>): void;
+}
+//# sourceMappingURL=logger-port.d.ts.map

package/dist/ports/logger-port.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2VyLXBvcnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcG9ydHMvbG9nZ2VyLXBvcnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/ports/run-store.d.ts

@@ -0,0 +1,9 @@
+import type { Logger } from './logger-port';
+import type { StepExecutionData } from '../types/step-execution-data';
+export interface RunStore {
+    init(logger?: Logger): Promise<void>;
+    close(logger?: Logger): Promise<void>;
+    getStepExecutions(runId: string): Promise<StepExecutionData[]>;
+    saveStepExecution(runId: string, stepExecution: StepExecutionData): Promise<void>;
+}
+//# sourceMappingURL=run-store.d.ts.map

package/dist/ports/run-store.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVuLXN0b3JlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3BvcnRzL3J1bi1zdG9yZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist/ports/workflow-port.d.ts

@@ -0,0 +1,30 @@
+import type { AvailableStepExecution, StepUser } from '../types/execution-context';
+import type { CollectionSchema } from '../types/validated/collection';
+import type { StepOutcome } from '../types/validated/step-outcome';
+import type { ToolConfig } from '@forestadmin/ai-proxy';
+export interface MalformedRunInfo {
+    runId: string;
+    stepId: string | null;
+    stepIndex: number | null;
+    userMessage: string;
+    technicalMessage: string;
+}
+export interface AvailableRunDispatch {
+    step: AvailableStepExecution;
+    auth: {
+        forestServerToken: string;
+    };
+}
+export interface AvailableRunsBatch {
+    pending: AvailableRunDispatch[];
+    malformed: MalformedRunInfo[];
+}
+export interface WorkflowPort {
+    getAvailableRuns(): Promise<AvailableRunsBatch>;
+    getAvailableRun(runId: string): Promise<AvailableRunDispatch | null>;
+    updateStepExecution(runId: string, stepOutcome: StepOutcome): Promise<AvailableRunDispatch | null>;
+    getCollectionSchema(collectionName: string, runId: string): Promise<CollectionSchema>;
+    getMcpServerConfigs(): Promise<Record<string, ToolConfig>>;
+    hasRunAccess(runId: string, user: StepUser): Promise<boolean>;
+}
+//# sourceMappingURL=workflow-port.d.ts.map

package/dist/ports/workflow-port.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ya2Zsb3ctcG9ydC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wb3J0cy93b3JrZmxvdy1wb3J0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist/remote-tool-fetcher.d.ts

@@ -0,0 +1,19 @@
+import type { AiModelPort } from './ports/ai-model-port';
+import type { Logger } from './ports/logger-port';
+import type { WorkflowPort } from './ports/workflow-port';
+import type { RemoteTool, ToolConfig } from '@forestadmin/ai-proxy';
+export declare function scopeConfigsToServer(configs: Record<string, ToolConfig>, mcpServerId: string): Record<string, ToolConfig>;
+export interface FetchRemoteToolsResult {
+    tools: RemoteTool[];
+    mcpServerName?: string;
+}
+export default class RemoteToolFetcher {
+    private readonly workflowPort;
+    private readonly aiModelPort;
+    private readonly logger;
+    constructor(workflowPort: WorkflowPort, aiModelPort: AiModelPort, logger: Logger);
+    fetch(mcpServerId: string): Promise<FetchRemoteToolsResult>;
+    private warnMissingTargetServer;
+    private errorOnPartialLoadFailure;
+}
+//# sourceMappingURL=remote-tool-fetcher.d.ts.map

package/dist/remote-tool-fetcher.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scopeConfigsToServer = scopeConfigsToServer;
+// Match by config.id, not by Record key: server names can collide across configs.
+function scopeConfigsToServer(configs, mcpServerId) {
+    return Object.fromEntries(Object.entries(configs).filter(([, cfg]) => cfg.id === mcpServerId));
+}
+class RemoteToolFetcher {
+    constructor(workflowPort, aiModelPort, logger) {
+        this.workflowPort = workflowPort;
+        this.aiModelPort = aiModelPort;
+        this.logger = logger;
+    }
+    async fetch(mcpServerId) {
+        const configs = await this.workflowPort.getMcpServerConfigs();
+        const scoped = scopeConfigsToServer(configs, mcpServerId);
+        const [mcpServerName] = Object.keys(scoped);
+        this.warnMissingTargetServer(configs, scoped, mcpServerId, mcpServerName);
+        if (Object.keys(scoped).length === 0)
+            return { tools: [], mcpServerName };
+        const tools = await this.aiModelPort.loadRemoteTools(scoped);
+        this.errorOnPartialLoadFailure(scoped, tools, mcpServerId, mcpServerName);
+        return { tools, mcpServerName };
+    }
+    // Distinguish "no configs at all" (deployment misconfig) from "configs exist but none match"
+    // (orchestrator/executor drift on server id) — both yield zero tools, but ops need to know
+    // which one to fix.
+    warnMissingTargetServer(configs, scoped, mcpServerId, mcpServerName) {
+        if (Object.keys(scoped).length > 0)
+            return;
+        const availableMcpServerIds = Object.values(configs)
+            .map(cfg => cfg.id)
+            .filter((id) => Boolean(id));
+        this.logger.warn(Object.keys(configs).length === 0
+            ? 'MCP step targets a server but orchestrator returned no MCP configs'
+            : 'MCP step targets a server not advertised by the orchestrator', { requestedMcpServerId: mcpServerId, mcpServerName, availableMcpServerIds });
+    }
+    // Partial-failure detection: McpClient swallows per-server load errors and returns whatever
+    // succeeded. Match config.id against tool.mcpServerId — both providers populate it from the
+    // orchestrator's persisted id, so the check is uniform across MCP and Forest connectors.
+    errorOnPartialLoadFailure(scoped, tools, mcpServerId, mcpServerName) {
+        const loadedMcpServerIds = new Set(tools.map(t => t.mcpServerId));
+        const failedConfigNames = Object.entries(scoped)
+            .filter(([, cfg]) => !loadedMcpServerIds.has(cfg.id))
+            .map(([name]) => name);
+        if (failedConfigNames.length === 0)
+            return;
+        this.logger.error('MCP servers failed to load tools', {
+            requestedMcpServerId: mcpServerId,
+            mcpServerName,
+            failedConfigNames,
+        });
+    }
+}
+exports.default = RemoteToolFetcher;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/runner.d.ts

@@ -0,0 +1,50 @@
+import type { ActivityLogPortFactory } from './ports/activity-log-port';
+import type { AgentPort } from './ports/agent-port';
+import type { AiModelPort } from './ports/ai-model-port';
+import type { Logger } from './ports/logger-port';
+import type { RunStore } from './ports/run-store';
+import type { WorkflowPort } from './ports/workflow-port';
+import type SchemaCache from './schema-cache';
+import type { StepExecutionData } from './types/step-execution-data';
+export type RunnerState = 'idle' | 'running' | 'draining' | 'stopped';
+export interface RunnerConfig {
+    agentPort: AgentPort;
+    workflowPort: WorkflowPort;
+    runStore: RunStore;
+    schemaCache: SchemaCache;
+    pollingIntervalMs: number;
+    aiModelPort: AiModelPort;
+    activityLogPortFactory: ActivityLogPortFactory;
+    envSecret: string;
+    authSecret: string;
+    logger?: Logger;
+    stopTimeoutMs?: number;
+    stepTimeoutMs?: number;
+    aiInvokeTimeoutMs?: number;
+    maxChainDepth?: number;
+}
+export default class Runner {
+    private readonly config;
+    private pollingTimer;
+    private readonly inFlightRuns;
+    private readonly logger;
+    private readonly remoteToolFetcher;
+    private _state;
+    constructor(config: RunnerConfig);
+    get state(): RunnerState;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getRunStepExecutions(runId: string): Promise<StepExecutionData[]>;
+    triggerPoll(runId: string, options?: {
+        pendingData?: unknown;
+        bearerUserId?: number;
+    }): Promise<void>;
+    private assertRunNotInFlight;
+    private schedulePoll;
+    private runPollCycle;
+    private reportMalformedRun;
+    private executeStep;
+    private doExecuteStep;
+    private get contextConfig();
+}
+//# sourceMappingURL=runner.d.ts.map

package/dist/runner.js

@@ -0,0 +1,317 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const console_logger_1 = __importDefault(require("./adapters/console-logger"));
+const defaults_1 = require("./defaults");
+const errors_1 = require("./errors");
+const step_executor_factory_1 = __importDefault(require("./executors/step-executor-factory"));
+const in_flight_run_registry_1 = __importDefault(require("./in-flight-run-registry"));
+const remote_tool_fetcher_1 = __importDefault(require("./remote-tool-fetcher"));
+const step_outcome_1 = require("./types/validated/step-outcome");
+const validate_secrets_1 = __importDefault(require("./validate-secrets"));
+class Runner {
+    constructor(config) {
+        this.pollingTimer = null;
+        this.inFlightRuns = new in_flight_run_registry_1.default();
+        this._state = 'idle';
+        this.config = config;
+        this.logger = config.logger ?? new console_logger_1.default();
+        this.remoteToolFetcher = new remote_tool_fetcher_1.default(config.workflowPort, config.aiModelPort, this.logger);
+    }
+    get state() {
+        return this._state;
+    }
+    async start() {
+        if (this._state === 'stopped' || this._state === 'draining') {
+            throw new Error('Runner has been stopped and cannot be restarted');
+        }
+        if (this._state === 'running')
+            return;
+        (0, validate_secrets_1.default)({ envSecret: this.config.envSecret, authSecret: this.config.authSecret });
+        // Probe the agent first so we fail fast without opening DB connections when unreachable.
+        await this.config.agentPort.probe();
+        this.logger.info('Agent probe passed', {});
+        await this.config.runStore.init(this.logger);
+        this._state = 'running';
+        this.schedulePoll();
+    }
+    async stop() {
+        if (this._state === 'idle' || this._state === 'stopped' || this._state === 'draining')
+            return;
+        this._state = 'draining';
+        this.logger.info('Graceful shutdown initiated', { inFlightRuns: this.inFlightRuns.size });
+        if (this.pollingTimer !== null) {
+            clearTimeout(this.pollingTimer);
+            this.pollingTimer = null;
+        }
+        try {
+            // Drain in-flight runs (each entry may cover a whole auto-chain).
+            if (this.inFlightRuns.size > 0) {
+                this.logger.info('Draining in-flight runs', {
+                    count: this.inFlightRuns.size,
+                    runs: [...this.inFlightRuns.keys()],
+                });
+                const timeout = this.config.stopTimeoutMs ?? defaults_1.DEFAULT_STOP_TIMEOUT_MS;
+                let drainTimer;
+                const drainResult = await Promise.race([
+                    this.inFlightRuns.drain().then(() => {
+                        if (drainTimer)
+                            clearTimeout(drainTimer);
+                        return 'drained';
+                    }),
+                    new Promise(resolve => {
+                        drainTimer = setTimeout(() => resolve('timeout'), timeout);
+                    }),
+                ]);
+                if (drainResult === 'timeout') {
+                    this.logger.error('Drain timeout — runs still in flight', {
+                        remainingRuns: [...this.inFlightRuns.keys()],
+                        timeoutMs: timeout,
+                    });
+                }
+                else {
+                    this.logger.info('All in-flight runs drained', {});
+                }
+            }
+            // Wait for fire-and-forget activity-log transitions to settle before closing resources —
+            // otherwise audit-trail rows can be left stuck in Pending.
+            await this.config.activityLogPortFactory.drain();
+            const results = await Promise.allSettled([
+                this.config.aiModelPort.closeConnections(),
+                this.config.runStore.close(this.logger),
+            ]);
+            for (const result of results) {
+                if (result.status === 'rejected') {
+                    this.logger.error('Resource cleanup failed during shutdown', {
+                        error: result.reason instanceof Error ? result.reason.message : String(result.reason),
+                    });
+                }
+            }
+        }
+        finally {
+            this._state = 'stopped';
+            this.logger.info('Workflow executor stopped', {});
+        }
+    }
+    async getRunStepExecutions(runId) {
+        return this.config.runStore.getStepExecutions(runId);
+    }
+    async triggerPoll(runId, options) {
+        // Best-effort local short-circuit: skip the orchestrator round-trip when THIS instance is
+        // already running the run. It is NOT a concurrency guard — inFlightRuns is per-instance and a
+        // deployment can run several executors, so genuine duplicate-execution prevention is the
+        // orchestrator's job (it atomically claims a pending run; concurrent triggers get nothing).
+        this.assertRunNotInFlight(runId);
+        let dispatch;
+        try {
+            dispatch = await this.config.workflowPort.getAvailableRun(runId);
+        }
+        catch (err) {
+            if (err instanceof errors_1.MalformedRunError) {
+                await this.reportMalformedRun(err.info);
+            }
+            throw err;
+        }
+        if (!dispatch)
+            throw new errors_1.RunNotFoundError(runId);
+        const { step, auth } = dispatch;
+        if (options?.bearerUserId !== undefined && step.user.id !== options.bearerUserId) {
+            throw new errors_1.UserMismatchError(runId);
+        }
+        await this.executeStep(step, auth.forestServerToken, options?.pendingData);
+    }
+    assertRunNotInFlight(runId) {
+        if (this.inFlightRuns.has(runId)) {
+            this.logger.info('Trigger ignored — run already in flight', { runId });
+            throw new errors_1.RunAlreadyInFlightError(runId);
+        }
+    }
+    schedulePoll() {
+        if (this._state !== 'running')
+            return;
+        this.pollingTimer = setTimeout(() => this.runPollCycle(), this.config.pollingIntervalMs);
+    }
+    async runPollCycle() {
+        try {
+            const { pending, malformed } = await this.config.workflowPort.getAvailableRuns();
+            // Each reportMalformedRun has its own try/catch, no individual failure poisons the cycle.
+            await Promise.allSettled(malformed.map(info => this.reportMalformedRun(info)));
+            const dispatchable = pending.filter(d => !this.inFlightRuns.has(d.step.runId));
+            this.logger.info('Poll cycle completed', {
+                fetched: pending.length,
+                dispatching: dispatchable.length,
+                malformed: malformed.length,
+            });
+            await Promise.allSettled(dispatchable.map(d => this.executeStep(d.step, d.auth.forestServerToken)));
+        }
+        catch (error) {
+            this.logger.error('Poll cycle failed', {
+                error: (0, errors_1.extractErrorMessage)(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+        }
+        finally {
+            this.schedulePoll();
+        }
+    }
+    // Posts an error outcome so the orchestrator marks the run failed and stops re-dispatching it.
+    // Idempotent server-side. If stepIndex is null (empty/corrupt history), log loudly and skip —
+    // ops has to clean up manually.
+    async reportMalformedRun(info) {
+        if (info.stepId === null || info.stepIndex === null) {
+            this.logger.error('Malformed run cannot be reported — no available step identified', {
+                runId: info.runId,
+                error: info.technicalMessage,
+            });
+            return;
+        }
+        try {
+            await this.config.workflowPort.updateStepExecution(info.runId, {
+                type: 'record',
+                stepId: info.stepId,
+                stepIndex: info.stepIndex,
+                status: 'error',
+                error: info.userMessage,
+            });
+            this.logger.error('Malformed run reported as error', {
+                runId: info.runId,
+                stepIndex: info.stepIndex,
+                error: info.technicalMessage,
+            });
+        }
+        catch (reportErr) {
+            this.logger.error('Malformed run — also failed to report', {
+                runId: info.runId,
+                mappingError: info.technicalMessage,
+                reportError: (0, errors_1.extractErrorMessage)(reportErr),
+            });
+        }
+    }
+    executeStep(step, forestServerToken, incomingPendingData) {
+        // The tracked promise covers the entire auto-chain for this run plus the map cleanup —
+        // register it once, clean up once. Storing per-step entries (or Promise.resolve()) would
+        // break drain: Promise.allSettled would see already-resolved entries and stop waiting while
+        // the chain is still running.
+        return this.inFlightRuns.track(step.runId, this.doExecuteStep(step, forestServerToken, incomingPendingData));
+    }
+    async doExecuteStep(step, forestServerToken, incomingPendingData) {
+        let currentStep = step;
+        let currentToken = forestServerToken;
+        let currentIncomingData = incomingPendingData;
+        let chainedCount = 0; // additional steps chained after the initial one
+        const maxDepth = this.config.maxChainDepth ?? defaults_1.DEFAULT_MAX_CHAIN_DEPTH;
+        // Sequential by design: each step's outcome drives the next dispatch; steps within one run
+        // cannot overlap. The no-await-in-loop rule doesn't apply here.
+        /* eslint-disable no-await-in-loop, no-constant-condition */
+        while (true) {
+            let result;
+            try {
+                const executor = await step_executor_factory_1.default.create(currentStep, this.contextConfig, this.config.activityLogPortFactory.forRun(currentToken), mcpServerId => this.remoteToolFetcher.fetch(mcpServerId), currentIncomingData);
+                result = await executor.execute();
+            }
+            catch (error) {
+                this.logger.error('FATAL: executor contract violated — reporting synthetic error outcome', {
+                    runId: currentStep.runId,
+                    stepId: currentStep.stepId,
+                    stepIndex: currentStep.stepIndex,
+                    error: (0, errors_1.extractErrorMessage)(error),
+                });
+                // Report a synthetic error outcome so the orchestrator marks the run failed and stops
+                // re-dispatching — without this, the contract-violating step loops forever.
+                const syntheticOutcome = {
+                    type: (0, step_outcome_1.stepTypeToOutcomeType)(currentStep.stepDefinition.type),
+                    stepId: currentStep.stepId,
+                    stepIndex: currentStep.stepIndex,
+                    status: 'error',
+                    error: 'An unexpected error occurred.',
+                };
+                try {
+                    await this.config.workflowPort.updateStepExecution(currentStep.runId, syntheticOutcome);
+                }
+                catch (reportErr) {
+                    this.logger.error('FATAL: also failed to report synthetic error outcome', {
+                        runId: currentStep.runId,
+                        stepId: currentStep.stepId,
+                        reportError: (0, errors_1.extractErrorMessage)(reportErr),
+                    });
+                }
+                return;
+            }
+            let nextDispatch;
+            try {
+                nextDispatch = await this.config.workflowPort.updateStepExecution(currentStep.runId, result.stepOutcome);
+            }
+            catch (error) {
+                this.logger.error('Failed to report step outcome', {
+                    runId: currentStep.runId,
+                    stepId: currentStep.stepId,
+                    stepIndex: currentStep.stepIndex,
+                    error: (0, errors_1.extractErrorMessage)(error),
+                    cause: (0, errors_1.causeMessage)(error),
+                    stack: error instanceof Error ? error.stack : undefined,
+                });
+                return;
+            }
+            if (nextDispatch === null) {
+                this.logger.info('Chain completed — orchestrator returned no further step', {
+                    runId: currentStep.runId,
+                    stepIndex: currentStep.stepIndex,
+                });
+                return;
+            }
+            // Progression safety: the server must advance the workflow within the same run. A cross-run
+            // dispatch would execute under the initial run's inFlightRuns key (and leak the map entry
+            // on cleanup); a non-progressing stepIndex would loop forever. Both are server bugs —
+            // exit the chain and let the next poll re-fetch authoritative state.
+            if (nextDispatch.step.runId !== currentStep.runId ||
+                nextDispatch.step.stepIndex <= currentStep.stepIndex) {
+                this.logger.error('Server returned non-progressing next step — exiting chain', {
+                    runId: currentStep.runId,
+                    currentStepIndex: currentStep.stepIndex,
+                    returnedRunId: nextDispatch.step.runId,
+                    returnedStepIndex: nextDispatch.step.stepIndex,
+                });
+                return;
+            }
+            // Cap check BEFORE incrementing: chainedCount counts chained steps we've already executed.
+            // maxDepth=2 means "run up to 2 chained steps after the initial one" (3 total).
+            if (chainedCount >= maxDepth) {
+                this.logger.info('Chain depth cap reached — yielding to next poll', {
+                    runId: currentStep.runId,
+                    stepIndex: currentStep.stepIndex,
+                    maxDepth,
+                });
+                return;
+            }
+            // Graceful stop: finish the current step, then yield instead of chaining further.
+            if (this._state === 'draining') {
+                this.logger.info('Chain interrupted by stop() — yielding', {
+                    runId: currentStep.runId,
+                    stepIndex: currentStep.stepIndex,
+                });
+                return;
+            }
+            chainedCount += 1;
+            currentStep = nextDispatch.step;
+            currentToken = nextDispatch.auth.forestServerToken;
+            currentIncomingData = undefined; // chained steps never carry pending data
+        }
+        /* eslint-enable no-await-in-loop, no-constant-condition */
+    }
+    get contextConfig() {
+        return {
+            aiModelPort: this.config.aiModelPort,
+            agentPort: this.config.agentPort,
+            workflowPort: this.config.workflowPort,
+            runStore: this.config.runStore,
+            schemaCache: this.config.schemaCache,
+            logger: this.logger,
+            stepTimeoutMs: this.config.stepTimeoutMs,
+            aiInvokeTimeoutMs: this.config.aiInvokeTimeoutMs,
+        };
+    }
+}
+exports.default = Runner;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runner.js","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"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"}

package/dist/schema-cache.d.ts

@@ -0,0 +1,11 @@
+import type { CollectionSchema } from './types/validated/collection';
+export default class SchemaCache {
+    private readonly store;
+    private readonly ttlMs;
+    private readonly now;
+    constructor(ttlMs?: number, now?: () => number);
+    get(collectionName: string): CollectionSchema | undefined;
+    set(collectionName: string, schema: CollectionSchema): void;
+    [Symbol.iterator](): IterableIterator<[string, CollectionSchema]>;
+}
+//# sourceMappingURL=schema-cache.d.ts.map

package/dist/schema-cache.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const defaults_1 = require("./defaults");
+class SchemaCache {
+    constructor(ttlMs = defaults_1.DEFAULT_SCHEMA_CACHE_TTL_MS, now = Date.now) {
+        this.store = new Map();
+        this.ttlMs = ttlMs;
+        this.now = now;
+    }
+    get(collectionName) {
+        const entry = this.store.get(collectionName);
+        if (!entry)
+            return undefined;
+        if (this.now() - entry.fetchedAt > this.ttlMs) {
+            this.store.delete(collectionName);
+            return undefined;
+        }
+        return entry.schema;
+    }
+    set(collectionName, schema) {
+        this.store.set(collectionName, { schema, fetchedAt: this.now() });
+    }
+    // Yields non-expired entries; deletes stale ones along the way.
+    *[Symbol.iterator]() {
+        const now = this.now();
+        for (const [key, entry] of this.store) {
+            if (now - entry.fetchedAt <= this.ttlMs) {
+                yield [key, entry.schema];
+            }
+            else {
+                this.store.delete(key);
+            }
+        }
+    }
+}
+exports.default = SchemaCache;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hLWNhY2hlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3NjaGVtYS1jYWNoZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUVBLHlDQUF5RDtBQUV6RCxNQUFxQixXQUFXO0lBSzlCLFlBQVksUUFBZ0Isc0NBQTJCLEVBQUUsTUFBb0IsSUFBSSxDQUFDLEdBQUc7UUFKcEUsVUFBSyxHQUFHLElBQUksR0FBRyxFQUEyRCxDQUFDO1FBSzFGLElBQUksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDO1FBQ25CLElBQUksQ0FBQyxHQUFHLEdBQUcsR0FBRyxDQUFDO0lBQ2pCLENBQUM7SUFFRCxHQUFHLENBQUMsY0FBc0I7UUFDeEIsTUFBTSxLQUFLLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsY0FBYyxDQUFDLENBQUM7UUFFN0MsSUFBSSxDQUFDLEtBQUs7WUFBRSxPQUFPLFNBQVMsQ0FBQztRQUU3QixJQUFJLElBQUksQ0FBQyxHQUFHLEVBQUUsR0FBRyxLQUFLLENBQUMsU0FBUyxHQUFHLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztZQUM5QyxJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxjQUFjLENBQUMsQ0FBQztZQUVsQyxPQUFPLFNBQVMsQ0FBQztRQUNuQixDQUFDO1FBRUQsT0FBTyxLQUFLLENBQUMsTUFBTSxDQUFDO0lBQ3RCLENBQUM7SUFFRCxHQUFHLENBQUMsY0FBc0IsRUFBRSxNQUF3QjtRQUNsRCxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxjQUFjLEVBQUUsRUFBRSxNQUFNLEVBQUUsU0FBUyxFQUFFLElBQUksQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUFDLENBQUM7SUFDcEUsQ0FBQztJQUVELGdFQUFnRTtJQUNoRSxDQUFDLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQztRQUNoQixNQUFNLEdBQUcsR0FBRyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUM7UUFFdkIsS0FBSyxNQUFNLENBQUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxJQUFJLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztZQUN0QyxJQUFJLEdBQUcsR0FBRyxLQUFLLENBQUMsU0FBUyxJQUFJLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztnQkFDeEMsTUFBTSxDQUFDLEdBQUcsRUFBRSxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUM7WUFDNUIsQ0FBQztpQkFBTSxDQUFDO2dCQUNOLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDO1lBQ3pCLENBQUM7UUFDSCxDQUFDO0lBQ0gsQ0FBQztDQUNGO0FBeENELDhCQXdDQyJ9

package/dist/schema-resolver.d.ts

@@ -0,0 +1,11 @@
+import type { WorkflowPort } from './ports/workflow-port';
+import type SchemaCache from './schema-cache';
+import type { CollectionSchema } from './types/validated/collection';
+export default class SchemaResolver {
+    private readonly cache;
+    private readonly workflowPort;
+    private readonly runId;
+    constructor(cache: SchemaCache, workflowPort: WorkflowPort, runId: string);
+    resolve(collectionName: string): Promise<CollectionSchema>;
+}
+//# sourceMappingURL=schema-resolver.d.ts.map

package/dist/schema-resolver.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Per-run schema resolution: binds the shared SchemaCache, the orchestrator port and the
+// current runId once, so callers never thread a loader. Writes into the SAME SchemaCache
+// instance AgentClientAgentPort reads from (get/iterate): the resolver always populates an
+// entry before the agent-port reads it, so the agent-port's SchemaNotCachedError guard does
+// not fire under normal TTLs (a TTL shorter than a single step's round-trip could still evict).
+class SchemaResolver {
+    constructor(cache, workflowPort, runId) {
+        this.cache = cache;
+        this.workflowPort = workflowPort;
+        this.runId = runId;
+    }
+    async resolve(collectionName) {
+        const cached = this.cache.get(collectionName);
+        if (cached)
+            return cached;
+        const schema = await this.workflowPort.getCollectionSchema(collectionName, this.runId);
+        this.cache.set(collectionName, schema);
+        return schema;
+    }
+}
+exports.default = SchemaResolver;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hLXJlc29sdmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3NjaGVtYS1yZXNvbHZlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUlBLHlGQUF5RjtBQUN6Rix5RkFBeUY7QUFDekYsMkZBQTJGO0FBQzNGLDRGQUE0RjtBQUM1RixnR0FBZ0c7QUFDaEcsTUFBcUIsY0FBYztJQUtqQyxZQUFZLEtBQWtCLEVBQUUsWUFBMEIsRUFBRSxLQUFhO1FBQ3ZFLElBQUksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDO1FBQ25CLElBQUksQ0FBQyxZQUFZLEdBQUcsWUFBWSxDQUFDO1FBQ2pDLElBQUksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDO0lBQ3JCLENBQUM7SUFFRCxLQUFLLENBQUMsT0FBTyxDQUFDLGNBQXNCO1FBQ2xDLE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLGNBQWMsQ0FBQyxDQUFDO1FBQzlDLElBQUksTUFBTTtZQUFFLE9BQU8sTUFBTSxDQUFDO1FBRTFCLE1BQU0sTUFBTSxHQUFHLE1BQU0sSUFBSSxDQUFDLFlBQVksQ0FBQyxtQkFBbUIsQ0FBQyxjQUFjLEVBQUUsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQ3ZGLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLGNBQWMsRUFBRSxNQUFNLENBQUMsQ0FBQztRQUV2QyxPQUFPLE1BQU0sQ0FBQztJQUNoQixDQUFDO0NBQ0Y7QUFwQkQsaUNBb0JDIn0=

package/dist/stores/build-run-store.d.ts

@@ -0,0 +1,5 @@
+import type { RunStore } from '../ports/run-store';
+import type { Options } from 'sequelize';
+export declare function buildDatabaseRunStore(options: Options): Promise<RunStore>;
+export declare function buildInMemoryRunStore(): Promise<RunStore>;
+//# sourceMappingURL=build-run-store.d.ts.map