@smithers-orchestrator/engine 0.20.3 → 0.21.0

package/src/effect/static-task-bridge.js

@@ -21,13 +21,13 @@ import * as BunContext from "@effect/platform-bun/BunContext";
 function isAbortError(err) {
     if (!err)
         return false;
-    if (err.name === "AbortError")
-        return true;
     if (typeof DOMException !== "undefined" &&
         err instanceof DOMException &&
         err.name === "AbortError") {
         return true;
     }
+    if (err.name === "AbortError")
+        return true;
     if (err instanceof Error) {
         return /aborted|abort/i.test(err.message);
     }
@@ -304,3 +304,7 @@ export const executeStaticTaskBridge = async (adapter, runId, desc, eventBus, to
         removeAbortForwarder();
     }
 };
+
+export const __staticTaskBridgeInternals = {
+    isAbortError,
+};

package/src/effect/workflow-bridge.js

@@ -113,6 +113,12 @@ const getNextTaskActivityAttempt = async (adapter, runId, desc) => {
     const latestAttempt = attempts[0]?.attempt ?? 0;
     return latestAttempt + 1;
 };
+function taskBridgeResultForError(error) {
+    if (error instanceof RetriableTaskFailure) {
+        return { terminal: false };
+    }
+    throw error;
+}
 /**
  * @param {SmithersDb} adapter
  * @param {_BunSQLiteDatabase} db
@@ -174,10 +180,7 @@ const runTaskBridgeExecution = async (adapter, db, runId, desc, descriptorMap, i
             return { terminal: true };
         }
         catch (error) {
-            if (error instanceof RetriableTaskFailure) {
-                return { terminal: false };
-            }
-            throw error;
+            return taskBridgeResultForError(error);
         }
     });
 };
@@ -260,3 +263,11 @@ export const executeTaskBridgeEffect = (adapter, db, runId, desc, descriptorMap,
     try: () => executeTaskBridge(adapter, db, runId, desc, descriptorMap, inputTable, eventBus, toolConfig, workflowName, cacheEnabled, signal, disabledAgents, runAbortController, hijackState, legacyExecuteTaskFn),
     catch: (cause) => toSmithersError(cause, "execute task bridge"),
 });
+export const __workflowBridgeInternals = {
+    classifyTaskAttempt,
+    getNextTaskActivityAttempt,
+    isRetryableBridgeTaskFailure,
+    parseAttemptErrorCode,
+    runEffectOrPromise,
+    taskBridgeResultForError,
+};

package/src/effect/workflow-make-bridge.js

@@ -175,9 +175,6 @@ export function createSchedulerWakeQueue() {
             }
             return new Promise((resolve) => {
                 resolver = () => {
-                    if (pending > 0) {
-                        pending -= 1;
-                    }
                     resolve();
                 };
             });
@@ -231,3 +228,13 @@ export async function runWorkflowWithMakeBridge(workflow, opts, executeBody) {
         }
     }
 }
+
+export const __workflowMakeBridgeInternals = {
+    createWorkflowExecutionEffect,
+    createWorkflowMakeBridgeRuntime,
+    executeRegisteredChildWorkflow,
+    getWorkflowNamespace,
+    isSuspendingStatus,
+    makeBridgeWorkflow,
+    registerBridgeWorkflow,
+};

package/src/engine.js

@@ -30,14 +30,13 @@ import { Cause, Chunk, Duration, Effect, Exit, Fiber, Metric, Queue, Schedule }
 import { attemptDuration, cacheHits, cacheMisses, nodeDuration, promptSizeBytes, responseSizeBytes, runDuration, runsResumedTotal, schedulerConcurrencyUtilization, schedulerQueueDepth, schedulerWaitDuration, trackEvent, } from "@smithers-orchestrator/observability/metrics";
 import { runScorersAsync } from "@smithers-orchestrator/scorers/run-scorers";
 import { dirname, resolve } from "node:path";
-import { existsSync, statSync } from "node:fs";
-import { readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
 import { toSmithersError } from "@smithers-orchestrator/errors/toSmithersError";
 import { logDebug, logError, logInfo, logWarning } from "@smithers-orchestrator/observability/logging";
 import { isPidAlive, parseRuntimeOwnerPid } from "./runtime-owner.js";
 import { HotWorkflowController } from "./hot/index.js";
 import { spawn as nodeSpawn } from "node:child_process";
-import { createHash, randomUUID } from "node:crypto";
+import { randomUUID } from "node:crypto";
 import { platform } from "node:os";
 import { annotateSmithersTrace, smithersSpanNames, withSmithersSpan, } from "@smithers-orchestrator/observability";
 import { withTaskRuntime } from "@smithers-orchestrator/driver/task-runtime";
@@ -45,9 +44,13 @@ import { hashCapabilityRegistry } from "@smithers-orchestrator/agents/capability
 import { cancelPendingTimersBridge, executeTaskBridgeEffect, isBridgeManagedTimerTask as isTimerTask, resolveDeferredTaskStateBridge, } from "./effect/workflow-bridge.js";
 import { AlertRuntime } from "./alert-runtime.js";
 import { executeChildWorkflow } from "./child-workflow.js";
+import { executeSandbox } from "@smithers-orchestrator/sandbox/execute";
+import { applyDiffBundle } from "./effect/diff-bundle.js";
+import { buildCacheScopeIdentity, isFreshCacheRow, normalizeCacheScope } from "./cache-policy.js";
 import { runWorkflowWithMakeBridge } from "./effect/workflow-make-bridge.js";
 import { createWorkflowVersioningRuntime, getWorkflowPatchDecisions, withWorkflowVersioningRuntime, } from "./effect/versioning.js";
 import { runWithCorrelationContext, updateCurrentCorrelationContext, withCorrelationContext, } from "@smithers-orchestrator/observability/correlation";
+import { extractWorkflowImportSpecifiers, getWorkflowImportScanLoader, readWorkflowEntryHash, readWorkflowGraphHash, resolveWorkflowImport, sha256Hex, } from "./workflow-hash.js";
 /** @typedef {import("@smithers-orchestrator/graph/GraphSnapshot").GraphSnapshot} GraphSnapshot */
 /** @typedef {import("./HijackState.ts").HijackState} HijackState */
 /** @typedef {import("@smithers-orchestrator/driver/RunOptions").RunOptions} RunOptions */
@@ -61,13 +64,6 @@ import { runWithCorrelationContext, updateCurrentCorrelationContext, withCorrela
 /** @typedef {import("drizzle-orm/bun-sqlite").BunSQLiteDatabase<Record<string, unknown>>} BunSQLiteDatabase */
 /** @typedef {import("drizzle-orm/sqlite-core").SQLiteTable} SQLiteTable */
 
-/**
- * @param {string} input
- * @returns {string}
- */
-function sha256Hex(input) {
-    return createHash("sha256").update(input).digest("hex");
-}
 /**
  * Track which worktree paths have already been created this run so we don't
  * re-create them for every task sharing the same worktree.
@@ -1345,143 +1341,6 @@ function resolveLogDir(rootDir, runId, logDir) {
     }
     return resolve(rootDir, ".smithers", "executions", runId, "logs");
 }
-const STATIC_IMPORT_RE = /\b(?:import|export)\s+(?:[^"'`]*?\s+from\s*)?["']([^"']+)["']/g;
-const DYNAMIC_IMPORT_RE = /\bimport\s*\(\s*["']([^"']+)["']\s*\)/g;
-const WORKFLOW_IMPORT_EXTENSIONS = [
-    "",
-    ".ts",
-    ".tsx",
-    ".mts",
-    ".cts",
-    ".js",
-    ".jsx",
-    ".mjs",
-    ".cjs",
-];
-/**
- * @param {string | null | undefined} sourcePath
- */
-function getWorkflowImportScanLoader(sourcePath) {
-    const lower = sourcePath?.toLowerCase() ?? "";
-    if (lower.endsWith(".tsx"))
-        return "tsx";
-    if (lower.endsWith(".jsx"))
-        return "jsx";
-    if (lower.endsWith(".ts") ||
-        lower.endsWith(".mts") ||
-        lower.endsWith(".cts")) {
-        return "ts";
-    }
-    return "js";
-}
-/**
- * @param {string | null} workflowPath
- * @returns {Promise<string | null>}
- */
-async function readWorkflowEntryHash(workflowPath) {
-    if (!workflowPath)
-        return null;
-    try {
-        const raw = await readFile(workflowPath, "utf8");
-        return sha256Hex(raw);
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * @param {string} source
- * @param {string | null} [sourcePath]
- * @returns {string[]}
- */
-function extractWorkflowImportSpecifiers(source, sourcePath) {
-    if (typeof Bun !== "undefined" && typeof Bun.Transpiler === "function") {
-        try {
-            const scanned = new Bun.Transpiler({
-                loader: getWorkflowImportScanLoader(sourcePath),
-            }).scanImports(source);
-            const specifiers = new Set();
-            for (const entry of scanned) {
-                const specifier = entry?.path?.trim();
-                if (specifier?.startsWith(".")) {
-                    specifiers.add(specifier);
-                }
-            }
-            return [...specifiers];
-        }
-        catch {
-            // Fall back to regex scanning if Bun's parser cannot handle the source.
-        }
-    }
-    const specifiers = new Set();
-    for (const pattern of [STATIC_IMPORT_RE, DYNAMIC_IMPORT_RE]) {
-        pattern.lastIndex = 0;
-        let match;
-        while ((match = pattern.exec(source)) !== null) {
-            const specifier = match[1]?.trim();
-            if (!specifier?.startsWith("."))
-                continue;
-            specifiers.add(specifier);
-        }
-    }
-    return [...specifiers];
-}
-/**
- * @param {string} baseFile
- * @param {string} specifier
- * @returns {string | null}
- */
-function resolveWorkflowImport(baseFile, specifier) {
-    const basePath = resolve(dirname(baseFile), specifier);
-    const candidates = [
-        ...WORKFLOW_IMPORT_EXTENSIONS.map((ext) => `${basePath}${ext}`),
-        ...WORKFLOW_IMPORT_EXTENSIONS
-            .filter((ext) => ext.length > 0)
-            .map((ext) => resolve(basePath, `index${ext}`)),
-    ];
-    for (const candidate of candidates) {
-        if (existsSync(candidate) && statSync(candidate).isFile()) {
-            return resolve(candidate);
-        }
-    }
-    return null;
-}
-/**
- * @param {string} workflowPath
- * @returns {Promise<string[]>}
- */
-async function collectWorkflowModuleHashEntries(workflowPath, visited = new Set()) {
-    const resolvedPath = resolve(workflowPath);
-    if (visited.has(resolvedPath)) {
-        return [];
-    }
-    visited.add(resolvedPath);
-    const source = await readFile(resolvedPath, "utf8");
-    const entries = [`${resolvedPath}:${sha256Hex(source)}`];
-    for (const specifier of extractWorkflowImportSpecifiers(source, resolvedPath)) {
-        const importedPath = resolveWorkflowImport(resolvedPath, specifier);
-        if (!importedPath) {
-            throw new SmithersError("WORKFLOW_HASH_RESOLUTION_FAILED", `Unable to resolve workflow import "${specifier}" from ${resolvedPath}.`, { workflowPath: resolvedPath, specifier });
-        }
-        entries.push(...(await collectWorkflowModuleHashEntries(importedPath, visited)));
-    }
-    return entries;
-}
-/**
- * @param {string | null} workflowPath
- * @returns {Promise<string | null>}
- */
-async function readWorkflowGraphHash(workflowPath) {
-    if (!workflowPath)
-        return null;
-    try {
-        const entries = await collectWorkflowModuleHashEntries(workflowPath);
-        return sha256Hex(entries.sort().join("|"));
-    }
-    catch {
-        return null;
-    }
-}
 /**
  * @param {string} cwd
  * @returns {Promise<string | null>}
@@ -1980,6 +1839,54 @@ function attachSubflowComputeFns(tasks, workflow, opts = {}) {
         task.meta = persistableMeta;
     }
 }
+/**
+ * @param {TaskDescriptor[]} tasks
+ * @param {SmithersWorkflow<any>} workflow
+ * @param {{ rootDir?: string; workflowPath?: string | null }} [opts]
+ */
+function attachSandboxComputeFns(tasks, workflow, opts = {}) {
+    for (const task of tasks) {
+        if (!task.meta?.__sandbox || task.computeFn)
+            continue;
+        const sandboxWorkflow = task.meta.__sandboxWorkflow;
+        if (!sandboxWorkflow)
+            continue;
+        const sandboxInput = task.meta.__sandboxInput;
+        const sandboxProvider = task.meta.__sandboxProvider;
+        const sandboxRuntime = task.meta.__sandboxRuntime;
+        const sandboxAllowNetwork = Boolean(task.meta.__sandboxAllowNetwork);
+        const sandboxReviewDiffs = task.meta.__sandboxReviewDiffs;
+        const sandboxAutoAcceptDiffs = task.meta.__sandboxAutoAcceptDiffs;
+        const sandboxAllowNested = Boolean(task.meta.__sandboxAllowNested);
+        const sandboxConfig = task.meta.__sandboxConfig && typeof task.meta.__sandboxConfig === "object"
+            ? task.meta.__sandboxConfig
+            : {};
+        task.computeFn = async () => executeSandbox({
+            parentWorkflow: workflow,
+            sandboxId: task.nodeId,
+            provider: sandboxProvider,
+            runtime: sandboxRuntime,
+            workflow: sandboxWorkflow,
+            executeChildWorkflow,
+            applyDiffBundle,
+            input: sandboxInput,
+            rootDir: task.worktreePath ?? opts.rootDir ?? process.cwd(),
+            allowNetwork: sandboxAllowNetwork,
+            maxOutputBytes: 200_000,
+            toolTimeoutMs: 60_000,
+            reviewDiffs: sandboxReviewDiffs,
+            autoAcceptDiffs: sandboxAutoAcceptDiffs,
+            allowNested: sandboxAllowNested,
+            config: sandboxConfig,
+        });
+        const {
+            __sandboxWorkflow: _workflow,
+            __sandboxProvider: _provider,
+            ...persistableMeta
+        } = task.meta;
+        task.meta = persistableMeta;
+    }
+}
 /**
  * @param {XmlNode} xml
  * @returns {string}
@@ -2660,6 +2567,9 @@ async function legacyExecuteTask(adapter, db, runId, desc, descriptorMap, inputT
     const taskRoot = desc.worktreePath ?? toolConfig.rootDir;
     const stepCacheEnabled = cacheEnabled || Boolean(desc.cachePolicy);
     const cacheAgent = Array.isArray(desc.agent) ? desc.agent[0] : desc.agent;
+    const cachePolicyTtlMs = typeof desc.cachePolicy?.ttlMs === "number" && Number.isFinite(desc.cachePolicy.ttlMs)
+        ? Math.max(0, desc.cachePolicy.ttlMs)
+        : null;
     let heartbeatWatchdogFiber = null;
     try {
         if (taskSignal.aborted) {
@@ -2732,6 +2642,7 @@ async function legacyExecuteTask(adapter, db, runId, desc, descriptorMap, inputT
             if (desc.cachePolicy) {
                 let cachePayload = null;
                 let cacheByOk = true;
+                const cacheScope = normalizeCacheScope(desc.cachePolicy);
                 try {
                     const ctx = await buildCacheContext(db, inputTable, runId, desc, descriptorMap, attemptNo);
                     if (desc.cachePolicy.by) {
@@ -2752,16 +2663,15 @@ async function legacyExecuteTask(adapter, db, runId, desc, descriptorMap, inputT
                     cacheKeyDisabled = true;
                 }
                 cacheBase = {
-                    workflowName,
-                    nodeId: desc.nodeId,
-                    iteration: desc.iteration,
-                    outputTableName: desc.outputTableName,
+                    cacheScope,
+                    ...buildCacheScopeIdentity(cacheScope, runId, workflowName, desc),
                     schemaSig,
                     outputSchemaSig,
                     agentSig,
                     toolsSig,
                     jjPointer: cacheJjBase,
                     cacheVersion: desc.cachePolicy.version ?? null,
+                    cacheKey: desc.cachePolicy.key ?? null,
                     cacheBy: cachePayload ?? null,
                 };
             }
@@ -2797,26 +2707,53 @@ async function legacyExecuteTask(adapter, db, runId, desc, descriptorMap, inputT
             }
             if (cacheKey) {
                 const cachedRow = await Effect.runPromise(adapter.getCache(cacheKey));
-                if (cachedRow) {
-                    const parsed = JSON.parse(cachedRow.payloadJson);
-                    const valid = validateOutput(desc.outputTable, parsed);
-                    if (valid.ok) {
-                        payload = valid.data;
-                        cached = true;
-                        void Effect.runPromise(Metric.increment(cacheHits));
-                        logInfo("cache hit for task output", {
+                if (cachedRow && isFreshCacheRow(cachedRow, desc.cachePolicy)) {
+                    const createdAtMs = Number(cachedRow.createdAtMs);
+                    const expired = cachePolicyTtlMs !== null &&
+                        Number.isFinite(createdAtMs) &&
+                        nowMs() - createdAtMs >= cachePolicyTtlMs;
+                    if (expired) {
+                        void Effect.runPromise(Metric.increment(cacheMisses));
+                        logInfo("cache entry expired for task output", {
                             runId,
                             nodeId: desc.nodeId,
                             iteration: desc.iteration,
                             attempt: attemptNo,
                             cacheKey,
+                            ttlMs: cachePolicyTtlMs,
                         }, "engine:task-cache");
                     }
                     else {
-                        void Effect.runPromise(Metric.increment(cacheMisses));
+                        const parsed = JSON.parse(cachedRow.payloadJson);
+                        const valid = validateOutput(desc.outputTable, parsed);
+                        if (valid.ok) {
+                            payload = valid.data;
+                            cached = true;
+                            void Effect.runPromise(Metric.increment(cacheHits));
+                            logInfo("cache hit for task output", {
+                                runId,
+                                nodeId: desc.nodeId,
+                                iteration: desc.iteration,
+                                attempt: attemptNo,
+                                cacheKey,
+                            }, "engine:task-cache");
+                        }
+                        else {
+                            void Effect.runPromise(Metric.increment(cacheMisses));
+                        }
                     }
                 }
                 else {
+                    if (cachedRow) {
+                        logInfo("cache entry expired for task output", {
+                            runId,
+                            nodeId: desc.nodeId,
+                            iteration: desc.iteration,
+                            attempt: attemptNo,
+                            cacheKey,
+                            ttlMs: desc.cachePolicy?.ttlMs,
+                        }, "engine:task-cache");
+                    }
                     void Effect.runPromise(Metric.increment(cacheMisses));
                 }
             }
@@ -2980,14 +2917,14 @@ async function legacyExecuteTask(adapter, db, runId, desc, descriptorMap, inputT
                 if (desc.outputTable && !supportsNativeStructuredOutput) {
                     const schemaDesc = describeSchemaShape(desc.outputTable, desc.outputSchema);
                     const jsonInstructions = [
-                        "**REQUIRED OUTPUT** — You MUST end your response with a JSON object in a code fence matching this schema:",
-                        "```json",
+                        "**REQUIRED OUTPUT** — You MUST return ONLY a raw JSON object matching this schema:",
                         schemaDesc,
-                        "```",
-                        "Output the JSON at the END of your response. The workflow will fail without it.",
+                        "Do not include prose, markdown, headings, commentary, or code fences.",
+                        "The first character of your response must be `{` and the last character must be `}`.",
+                        "The workflow will fail unless the entire response is the JSON object.",
                     ].join("\n");
                     effectivePrompt = [
-                        "IMPORTANT: After completing the task below, you MUST output a JSON object in a ```json code fence at the very end of your response. Do NOT forget this — the workflow fails without it.",
+                        "IMPORTANT: After completing the task below, you MUST output ONLY a raw JSON object. Do NOT wrap it in markdown or add any prose — the workflow fails without it.",
                         "",
                         effectivePrompt,
                         "",
@@ -3448,7 +3385,7 @@ async function legacyExecuteTask(adapter, db, runId, desc, descriptorMap, inputT
                             `Now you MUST output ONLY a valid JSON object (no other text) summarizing your work above, with exactly these fields and types:`,
                             schemaDesc,
                             ``,
-                            `Output ONLY the JSON object, nothing else.`,
+                            `Output ONLY the raw JSON object, with no markdown fences or prose.`,
                         ].join("\n");
                         const retryResult = await effectiveAgent.generate({
                             options: undefined,
@@ -3679,7 +3616,7 @@ async function legacyExecuteTask(adapter, db, runId, desc, descriptorMap, inputT
                     `You MUST output ONLY a valid JSON object with exactly these fields and types:`,
                     schemaDesc,
                     ``,
-                    `Output ONLY the JSON object, no other text.`,
+                    `Output ONLY the raw JSON object, with no markdown fences or other text.`,
                 ].join("\n");
             logInfo("schema validation retry", {
                 runId,
@@ -4132,6 +4069,10 @@ async function renderFrameAsync(workflow, ctx, opts) {
         rootDir: opts?.baseRootDir,
         workflowPath: opts?.workflowPath,
     });
+    attachSandboxComputeFns(tasks, workflow, {
+        rootDir: opts?.baseRootDir,
+        workflowPath: opts?.workflowPath,
+    });
     return { runId: ctx.runId, frameNo: 0, xml: result.xml, tasks };
 }
 /**
@@ -4318,7 +4259,8 @@ async function runWorkflowAsync(workflow, opts) {
  * @returns {Promise<RunBodyResult>}
  */
 async function runWorkflowBody(workflow, opts) {
-    if (process.env.SMITHERS_LEGACY_ENGINE === "1") {
+    if (opts.__smithersEngineMode === "legacy" ||
+        process.env.SMITHERS_LEGACY_ENGINE === "1") {
         return runWorkflowBodyLegacy(workflow, opts);
     }
     return runWorkflowBodyDriver(workflow, opts);
@@ -5268,10 +5210,14 @@ async function runWorkflowBodyDriver(workflow, opts) {
                 const graph = await withWorkflowVersioningRuntime(workflowVersioning, () => renderer.render(element, renderOpts));
                 await workflowVersioning.flush();
                 resolveTaskOutputs(graph.tasks, workflowRef);
-                attachSubflowComputeFns(graph.tasks, workflowRef, {
-                    rootDir,
-                    workflowPath: resolvedWorkflowPath ?? opts.workflowPath,
-                });
+            attachSubflowComputeFns(graph.tasks, workflowRef, {
+                rootDir,
+                workflowPath: resolvedWorkflowPath ?? opts.workflowPath,
+            });
+            attachSandboxComputeFns(graph.tasks, workflowRef, {
+                rootDir,
+                workflowPath: resolvedWorkflowPath ?? opts.workflowPath,
+            });
                 lastGraph = graph;
                 descriptorMap = buildDescriptorMap(graph.tasks);
                 workflowName = getWorkflowNameFromXml(graph.xml);
@@ -6347,6 +6293,10 @@ async function runWorkflowBodyLegacy(workflow, opts) {
                 rootDir,
                 workflowPath: resolvedWorkflowPath ?? opts.workflowPath,
             });
+            attachSandboxComputeFns(tasks, workflow, {
+                rootDir,
+                workflowPath: resolvedWorkflowPath ?? opts.workflowPath,
+            });
             const workflowName = getWorkflowNameFromXml(xml);
             updateCurrentCorrelationContext({ workflowName });
             const cacheEnabled = workflow.opts.cache ??
@@ -7229,3 +7179,79 @@ export function runWorkflow(workflow, opts) {
         root: true,
     });
 }
+
+export const __engineInternals = {
+    sha256Hex,
+    isBlockingAgentActionKind,
+    makeAbortError,
+    isAbortError,
+    collectErrorMessages,
+    isStructuredOutputParseFailure,
+    depsTextAccessHint,
+    makeStructuredOutputCompatibilityError,
+    makePlainTextOutputError,
+    abortPromise,
+    parseAttemptMetaJson,
+    asConversationMessages,
+    cloneJsonValue,
+    parseAttemptHeartbeatData,
+    validateHeartbeatValue,
+    serializeHeartbeatPayload,
+    heartbeatTimeoutReasonFromAbort,
+    isHeartbeatPayloadValidationError,
+    runPromisePreservingFailure,
+    extractHijackContinuation,
+    findHijackContinuation,
+    collectDefinedToolMetadata,
+    collectToolResumeWarnings,
+    buildToolResumeWarningMessage,
+    hasToolResumeWarningMessage,
+    appendToolResumeWarningMessage,
+    prependToolResumeWarningMessage,
+    workflowSessionTaskId,
+    workflowSessionTaskIds,
+    summarizeWorkflowSessionDecision,
+    summarizeLegacySchedulerDecision,
+    workflowSessionSummaryKey,
+    coercePositiveInt,
+    buildInputRow,
+    normalizeInputRow,
+    normalizeOutputRow,
+    quoteSqlIdent,
+    toSqlValue,
+    getTableColumnEntries,
+    insertRowWithClient,
+    copyRunScopedRowsWithClient,
+    ralphStateToObject,
+    cloneRalphStateMap,
+    buildCarriedInputRow,
+    continueRunAsNew,
+    resolveRootDir,
+    resolveLogDir,
+    getWorkflowImportScanLoader,
+    extractWorkflowImportSpecifiers,
+    resolveWorkflowImport,
+    buildDurabilityConfig,
+    getStoredDurabilityConfig,
+    compareNullableString,
+    assertResumeDurabilityMetadata,
+    wireAbortSignal,
+    parseRunConfigJson,
+    parseRunAuthContext,
+    isResumableRunStatus,
+    normalizeHotOptions,
+    assertInputObject,
+    validateRunOptions,
+    iterationsToMap,
+    ralphStateFromDriverTransition,
+    resolveTaskOutputs,
+    buildDescriptorMap,
+    buildRalphStateMap,
+    ralphIterationsFromState,
+    ralphIterationsObject,
+    buildRalphDoneMap,
+    parseAttemptErrorCode,
+    isRetryableTaskFailure,
+    cancelInProgress,
+    cancelStaleAttempts,
+};

package/src/hot/HotWorkflowController.js

@@ -17,6 +17,37 @@ import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
 
 const DEFAULT_MAX_GENERATIONS = 3;
 const DEFAULT_DEBOUNCE_MS = 100;
+
+function makeHotReloadFailureEvent(err, ctx) {
+    const { entryPath, generation, changedFiles } = ctx;
+    if (err instanceof Error && err.message?.includes("Schema change detected")) {
+        logWarning("hot workflow reload marked unsafe", {
+            entryPath,
+            generation,
+            changedFileCount: changedFiles.length,
+            reason: err.message,
+        }, "hot:reload");
+        return {
+            type: "unsafe",
+            generation,
+            changedFiles,
+            reason: err.message,
+        };
+    }
+    logWarning("hot workflow reload failed", {
+        entryPath,
+        generation,
+        changedFileCount: changedFiles.length,
+        error: err instanceof Error ? err.message : String(err),
+    }, "hot:reload");
+    return {
+        type: "failed",
+        generation,
+        changedFiles,
+        error: err,
+    };
+}
+
 export class HotWorkflowController {
     entryPath;
     hotRoot;
@@ -160,32 +191,11 @@ export class HotWorkflowController {
             };
         }).pipe(Effect.catchAll((err) => Effect.gen(function* () {
             yield* Metric.increment(hotReloadFailures);
-            if (err instanceof Error && err.message?.includes("Schema change detected")) {
-                logWarning("hot workflow reload marked unsafe", {
-                    entryPath,
-                    generation: gen,
-                    changedFileCount: changedFiles.length,
-                    reason: err.message,
-                }, "hot:reload");
-                return {
-                    type: "unsafe",
-                    generation: gen,
-                    changedFiles,
-                    reason: err.message,
-                };
-            }
-            logWarning("hot workflow reload failed", {
+            return makeHotReloadFailureEvent(err, {
                 entryPath,
                 generation: gen,
-                changedFileCount: changedFiles.length,
-                error: err instanceof Error ? err.message : String(err),
-            }, "hot:reload");
-            return {
-                type: "failed",
-                generation: gen,
                 changedFiles,
-                error: err,
-            };
+            });
         })), Effect.annotateLogs({
             entryPath,
             hotRoot,
@@ -218,3 +228,7 @@ export class HotWorkflowController {
         }), Effect.withLogSpan("hot:close"));
     }
 }
+
+export const __hotWorkflowControllerInternals = {
+    makeHotReloadFailureEvent,
+};