@smithers-orchestrator/engine 0.16.0

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

@@ -0,0 +1,308 @@
+import { Effect, Metric } from "effect";
+import { z } from "zod";
+import { buildOutputRow, stripAutoColumns, validateOutput } from "@smithers-orchestrator/db/output";
+import { EventBus } from "../events.js";
+import { makeAbortError, wireAbortSignal } from "./bridge-utils.js";
+import { logDebug, logError, logInfo } from "@smithers-orchestrator/observability/logging";
+import { attemptDuration, nodeDuration } from "@smithers-orchestrator/observability/metrics";
+import { errorToJson } from "@smithers-orchestrator/errors/errorToJson";
+import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
+import { nowMs } from "@smithers-orchestrator/scheduler/nowMs";
+import { getJjPointer } from "@smithers-orchestrator/vcs/jj";
+import * as BunContext from "@effect/platform-bun/BunContext";
+/** @typedef {import("@smithers-orchestrator/db/adapter").SmithersDb} _SmithersDb */
+/**
+ * @typedef {{ rootDir: string; }} StaticTaskBridgeToolConfig
+ */
+/** @typedef {import("@smithers-orchestrator/graph/TaskDescriptor").TaskDescriptor} _TaskDescriptor */
+
+/**
+ * @param {unknown} err
+ * @returns {boolean}
+ */
+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 instanceof Error) {
+        return /aborted|abort/i.test(err.message);
+    }
+    return false;
+}
+/**
+ * @param {_TaskDescriptor} desc
+ * @param {boolean} cacheEnabled
+ * @returns {boolean}
+ */
+export const canExecuteBridgeManagedStaticTask = (desc, cacheEnabled) => {
+    if (cacheEnabled || desc.cachePolicy) {
+        return false;
+    }
+    if (desc.agent || desc.computeFn || desc.staticPayload === undefined) {
+        return false;
+    }
+    if (desc.worktreePath) {
+        return false;
+    }
+    return !desc.scorers || Object.keys(desc.scorers).length === 0;
+};
+/**
+ * @param {_SmithersDb} adapter
+ * @param {string} runId
+ * @param {_TaskDescriptor} desc
+ * @param {EventBus} eventBus
+ * @param {StaticTaskBridgeToolConfig} toolConfig
+ * @param {string} workflowName
+ * @param {AbortSignal} [signal]
+ * @returns {Promise<void>}
+ */
+export const executeStaticTaskBridge = async (adapter, runId, desc, eventBus, toolConfig, workflowName, signal) => {
+    const taskStartMs = performance.now();
+    const attempts = await Effect.runPromise(adapter.listAttempts(runId, desc.nodeId, desc.iteration));
+    const attemptNo = (attempts[0]?.attempt ?? 0) + 1;
+    const taskAbortController = new AbortController();
+    const removeAbortForwarder = wireAbortSignal(taskAbortController, signal);
+    const taskSignal = taskAbortController.signal;
+    const startedAtMs = nowMs();
+    const attemptMeta = {
+        kind: "static",
+        prompt: desc.prompt ?? null,
+        staticPayload: desc.staticPayload ?? null,
+        label: desc.label ?? null,
+        outputTable: desc.outputTableName,
+        needsApproval: desc.needsApproval,
+        retries: desc.retries,
+        timeoutMs: desc.timeoutMs,
+        heartbeatTimeoutMs: desc.heartbeatTimeoutMs,
+        lastHeartbeat: null,
+        agentId: null,
+        agentModel: null,
+        agentEngine: null,
+        agentResume: null,
+        agentConversation: null,
+        resumedFromSession: null,
+        resumedFromConversation: false,
+        hijackHandoff: null,
+    };
+    await adapter.withTransaction("task-start", Effect.gen(function* () {
+        yield* adapter.insertAttempt({
+            runId,
+            nodeId: desc.nodeId,
+            iteration: desc.iteration,
+            attempt: attemptNo,
+            state: "in-progress",
+            startedAtMs,
+            finishedAtMs: null,
+            heartbeatAtMs: null,
+            heartbeatDataJson: null,
+            errorJson: null,
+            jjPointer: null,
+            jjCwd: toolConfig.rootDir,
+            cached: false,
+            metaJson: JSON.stringify(attemptMeta),
+        });
+        yield* adapter.insertNode({
+            runId,
+            nodeId: desc.nodeId,
+            iteration: desc.iteration,
+            state: "in-progress",
+            lastAttempt: attemptNo,
+            updatedAtMs: nowMs(),
+            outputTable: desc.outputTableName,
+            label: desc.label ?? null,
+        });
+    }));
+    await Effect.runPromise(eventBus.emitEventWithPersist({
+        type: "NodeStarted",
+        runId,
+        nodeId: desc.nodeId,
+        iteration: desc.iteration,
+        attempt: attemptNo,
+        timestampMs: nowMs(),
+    }));
+    try {
+        if (taskSignal.aborted) {
+            throw taskSignal.reason ?? makeAbortError();
+        }
+        logDebug("bridge-managed static task execution starting", {
+            runId,
+            nodeId: desc.nodeId,
+            iteration: desc.iteration,
+            attempt: attemptNo,
+            workflowName,
+        }, "engine:task");
+        let payload = stripAutoColumns(desc.staticPayload);
+        const payloadWithKeys = buildOutputRow(desc.outputTable, runId, desc.nodeId, desc.iteration, payload);
+        let validation = validateOutput(desc.outputTable, payloadWithKeys);
+        if (validation.ok && desc.outputSchema) {
+            const zodResult = desc.outputSchema.safeParse(payload);
+            if (!zodResult.success) {
+                validation = { ok: false, error: zodResult.error };
+            }
+        }
+        if (!validation.ok) {
+            attemptMeta.failureRetryable = false;
+            throw new SmithersError("INVALID_OUTPUT", `Task output failed validation for ${desc.outputTableName}`, {
+                attempt: attemptNo,
+                nodeId: desc.nodeId,
+                iteration: desc.iteration,
+                outputTable: desc.outputTableName,
+                issues: validation.error?.issues,
+            }, { cause: validation.error });
+        }
+        payload = validation.data;
+        const completedAtMs = nowMs();
+        const jjPointer = await Effect.runPromise(getJjPointer(toolConfig.rootDir).pipe(Effect.provide(BunContext.layer)));
+        await adapter.withTransaction("task-completion", Effect.gen(function* () {
+            yield* adapter.upsertOutputRow(desc.outputTable, { runId, nodeId: desc.nodeId, iteration: desc.iteration }, payload);
+            yield* adapter.updateAttempt(runId, desc.nodeId, desc.iteration, attemptNo, {
+                state: "finished",
+                finishedAtMs: completedAtMs,
+                jjPointer,
+                cached: false,
+                metaJson: JSON.stringify(attemptMeta),
+                responseText: null,
+            });
+            yield* adapter.insertNode({
+                runId,
+                nodeId: desc.nodeId,
+                iteration: desc.iteration,
+                state: "finished",
+                lastAttempt: attemptNo,
+                updatedAtMs: completedAtMs,
+                outputTable: desc.outputTableName,
+                label: desc.label ?? null,
+            });
+        }));
+        await Effect.runPromise(eventBus.emitEventWithPersist({
+            type: "NodeFinished",
+            runId,
+            nodeId: desc.nodeId,
+            iteration: desc.iteration,
+            attempt: attemptNo,
+            timestampMs: nowMs(),
+        }));
+        const taskElapsedMs = performance.now() - taskStartMs;
+        void Effect.runPromise(Effect.all([
+            Metric.update(nodeDuration, taskElapsedMs),
+            Metric.update(attemptDuration, taskElapsedMs),
+        ], { discard: true }));
+        logInfo("bridge-managed static task execution finished", {
+            runId,
+            nodeId: desc.nodeId,
+            iteration: desc.iteration,
+            attempt: attemptNo,
+            durationMs: Math.round(taskElapsedMs),
+            jjPointer,
+        }, "engine:task");
+    }
+    catch (err) {
+        const aborted = taskSignal.aborted || isAbortError(err);
+        const effectiveError = aborted && taskSignal.reason !== undefined
+            ? taskSignal.reason
+            : aborted
+                ? makeAbortError()
+                : err;
+        if (aborted) {
+            const cancelledAtMs = nowMs();
+            await adapter.withTransaction("task-cancel", Effect.gen(function* () {
+                yield* adapter.updateAttempt(runId, desc.nodeId, desc.iteration, attemptNo, {
+                    state: "cancelled",
+                    finishedAtMs: cancelledAtMs,
+                    errorJson: JSON.stringify(errorToJson(effectiveError)),
+                    metaJson: JSON.stringify(attemptMeta),
+                    responseText: null,
+                });
+                yield* adapter.insertNode({
+                    runId,
+                    nodeId: desc.nodeId,
+                    iteration: desc.iteration,
+                    state: "cancelled",
+                    lastAttempt: attemptNo,
+                    updatedAtMs: cancelledAtMs,
+                    outputTable: desc.outputTableName,
+                    label: desc.label ?? null,
+                });
+            }));
+            await Effect.runPromise(eventBus.emitEventWithPersist({
+                type: "NodeCancelled",
+                runId,
+                nodeId: desc.nodeId,
+                iteration: desc.iteration,
+                attempt: attemptNo,
+                reason: "aborted",
+                timestampMs: nowMs(),
+            }));
+            logInfo("bridge-managed static task execution cancelled", {
+                runId,
+                nodeId: desc.nodeId,
+                iteration: desc.iteration,
+                attempt: attemptNo,
+                error: effectiveError instanceof Error
+                    ? effectiveError.message
+                    : String(effectiveError),
+            }, "engine:task");
+            return;
+        }
+        logError("bridge-managed static task execution failed", {
+            runId,
+            nodeId: desc.nodeId,
+            iteration: desc.iteration,
+            attempt: attemptNo,
+            maxAttempts: Number.isFinite(desc.retries) ? desc.retries + 1 : "infinite",
+            error: effectiveError instanceof Error
+                ? effectiveError.message
+                : String(effectiveError),
+        }, "engine:task");
+        const failedAtMs = nowMs();
+        await adapter.withTransaction("task-fail", Effect.gen(function* () {
+            yield* adapter.updateAttempt(runId, desc.nodeId, desc.iteration, attemptNo, {
+                state: "failed",
+                finishedAtMs: failedAtMs,
+                errorJson: JSON.stringify(errorToJson(effectiveError)),
+                metaJson: JSON.stringify(attemptMeta),
+                responseText: null,
+            });
+            yield* adapter.insertNode({
+                runId,
+                nodeId: desc.nodeId,
+                iteration: desc.iteration,
+                state: "failed",
+                lastAttempt: attemptNo,
+                updatedAtMs: failedAtMs,
+                outputTable: desc.outputTableName,
+                label: desc.label ?? null,
+            });
+        }));
+        await Effect.runPromise(eventBus.emitEventWithPersist({
+            type: "NodeFailed",
+            runId,
+            nodeId: desc.nodeId,
+            iteration: desc.iteration,
+            attempt: attemptNo,
+            error: errorToJson(effectiveError),
+            timestampMs: nowMs(),
+        }));
+        const updatedAttempts = await Effect.runPromise(adapter.listAttempts(runId, desc.nodeId, desc.iteration));
+        const failedAttempts = updatedAttempts.filter((attempt) => attempt.state === "failed");
+        if (attemptMeta.failureRetryable !== false && failedAttempts.length <= desc.retries) {
+            await Effect.runPromise(eventBus.emitEventWithPersist({
+                type: "NodeRetrying",
+                runId,
+                nodeId: desc.nodeId,
+                iteration: desc.iteration,
+                attempt: attemptNo + 1,
+                timestampMs: nowMs(),
+            }));
+        }
+    }
+    finally {
+        removeAbortForwarder();
+    }
+};

package/src/effect/versioning.js

@@ -0,0 +1,123 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import React from "react";
+/** @typedef {import("./WorkflowPatchDecisionRecord.ts").WorkflowPatchDecisionRecord} WorkflowPatchDecisionRecord */
+/** @typedef {import("./WorkflowPatchDecisions.ts").WorkflowPatchDecisions} WorkflowPatchDecisions */
+/** @typedef {import("./WorkflowVersioningRuntime.ts").WorkflowVersioningRuntime} WorkflowVersioningRuntime */
+/**
+ * @typedef {{ baseConfig: Record<string, unknown>; initialDecisions?: WorkflowPatchDecisions; isNewRun: boolean; persist: (config: Record<string, unknown>) => Promise<void>; recordDecision?: (record: WorkflowPatchDecisionRecord) => Promise<void>; }} WorkflowVersioningRuntimeOptions
+ */
+
+const storage = new AsyncLocalStorage();
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+function normalizePatchId(value) {
+    return value.trim();
+}
+/**
+ * @param {unknown} value
+ * @returns {WorkflowPatchDecisions}
+ */
+function normalizePatchDecisions(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return {};
+    }
+    const decisions = {};
+    for (const [key, entry] of Object.entries(value)) {
+        const patchId = normalizePatchId(String(key));
+        if (!patchId)
+            continue;
+        if (typeof entry === "boolean") {
+            decisions[patchId] = entry;
+        }
+    }
+    return decisions;
+}
+/**
+ * @param {WorkflowVersioningRuntimeOptions} options
+ * @returns {WorkflowVersioningRuntime}
+ */
+export function createWorkflowVersioningRuntime(options) {
+    const decisions = new Map(Object.entries(normalizePatchDecisions(options.initialDecisions)));
+    let currentConfig = { ...options.baseConfig };
+    let dirty = false;
+    const pendingRecords = [];
+    return {
+        /**
+     * @param {string} patchId
+     * @returns {boolean}
+     */
+        resolve(patchId) {
+            const normalized = normalizePatchId(patchId);
+            if (!normalized) {
+                return false;
+            }
+            const existing = decisions.get(normalized);
+            if (typeof existing === "boolean") {
+                return existing;
+            }
+            const decision = options.isNewRun;
+            decisions.set(normalized, decision);
+            dirty = true;
+            pendingRecords.push({ patchId: normalized, decision });
+            return decision;
+        },
+        async flush() {
+            if (!dirty && pendingRecords.length === 0) {
+                return;
+            }
+            const nextConfig = dirty
+                ? {
+                    ...currentConfig,
+                    workflowPatches: Object.fromEntries(decisions.entries()),
+                }
+                : currentConfig;
+            if (dirty) {
+                await options.persist(nextConfig);
+                currentConfig = nextConfig;
+                dirty = false;
+            }
+            if (pendingRecords.length > 0 && options.recordDecision) {
+                const records = pendingRecords.slice();
+                for (const record of records) {
+                    await options.recordDecision(record);
+                }
+                pendingRecords.splice(0, records.length);
+            }
+        },
+        snapshot() {
+            return Object.fromEntries(decisions.entries());
+        },
+    };
+}
+/**
+ * @template T
+ * @param {WorkflowVersioningRuntime} runtime
+ * @param {() => T} execute
+ * @returns {T}
+ */
+export function withWorkflowVersioningRuntime(runtime, execute) {
+    return storage.run(runtime, execute);
+}
+/**
+ * @returns {| WorkflowVersioningRuntime | undefined}
+ */
+export function getWorkflowVersioningRuntime() {
+    return storage.getStore();
+}
+/**
+ * @param {Record<string, unknown> | null | undefined} config
+ * @returns {WorkflowPatchDecisions}
+ */
+export function getWorkflowPatchDecisions(config) {
+    return normalizePatchDecisions(config?.workflowPatches);
+}
+/**
+ * @param {string} patchId
+ * @returns {boolean}
+ */
+export function usePatched(patchId) {
+    const runtime = getWorkflowVersioningRuntime();
+    return React.useMemo(() => runtime?.resolve(patchId) ?? false, [runtime, patchId]);
+}

package/src/effect/workflow-bridge.js

@@ -0,0 +1,260 @@
+import { Effect } from "effect";
+import { SmithersDb } from "@smithers-orchestrator/db/adapter";
+import { EventBus } from "../events.js";
+import { toSmithersError } from "@smithers-orchestrator/errors/toSmithersError";
+import { makeWorkerTask, } from "./entity-worker.js";
+import { executeTaskActivity, makeTaskBridgeKey, RetriableTaskFailure, } from "./activity-bridge.js";
+import { parseAttemptMetaJson } from "./bridge-utils.js";
+import { canExecuteBridgeManagedComputeTask, executeComputeTaskBridge, } from "./compute-task-bridge.js";
+import { canExecuteBridgeManagedStaticTask, executeStaticTaskBridge, } from "./static-task-bridge.js";
+import { dispatchWorkerTask } from "./single-runner.js";
+/** @typedef {import("../HijackState.ts").HijackState} HijackState */
+/** @typedef {import("./LegacyExecuteTaskFn.ts").LegacyExecuteTaskFn} LegacyExecuteTaskFn */
+/** @typedef {import("./TaskBridgeToolConfig.ts").TaskBridgeToolConfig} TaskBridgeToolConfig */
+/** @typedef {import("@smithers-orchestrator/graph/TaskDescriptor").TaskDescriptor} _TaskDescriptor */
+/** @typedef {import("./TaskActivityContext.ts").TaskActivityContext} _TaskActivityContext */
+/** @typedef {import("drizzle-orm/bun-sqlite").BunSQLiteDatabase<Record<string, unknown>>} _BunSQLiteDatabase */
+/** @typedef {import("drizzle-orm/sqlite-core").SQLiteTable} SQLiteTable */
+/**
+ * @typedef {"compute" | "static" | "legacy"} BridgeManagedTaskKind
+ */
+
+export { bridgeApprovalResolve, bridgeSignalResolve, bridgeWaitForEventResolve, awaitApprovalDurableDeferred, awaitWaitForEventDurableDeferred, makeApprovalDurableDeferred, makeDurableDeferredBridgeExecutionId, makeWaitForEventDurableDeferred, } from "./durable-deferred-bridge.js";
+export { cancelPendingTimersBridge, isBridgeManagedTimerTask, isBridgeManagedWaitForEventTask, resolveDeferredTaskStateBridge, } from "./deferred-state-bridge.js";
+export { createSchedulerWakeQueue, getWorkflowMakeBridgeRuntime, runWorkflowWithMakeBridge, withWorkflowMakeBridgeRuntime, } from "./workflow-make-bridge.js";
+export { SqlMessageStorage, ensureSqlMessageStorage, ensureSqlMessageStorageEffect, getSqlMessageStorage, } from "./sql-message-storage.js";
+export { SandboxEntity, SandboxEntityExecutor, makeSandboxEntityId, makeSandboxTransportServiceEffect, } from "@smithers-orchestrator/sandbox/effect/sandbox-entity";
+export { CodeplaneSandboxExecutorLive, DockerSandboxExecutorLive, SandboxHttpRunner, } from "./http-runner.js";
+export { BubblewrapSandboxExecutorLive, SandboxSocketRunner, } from "@smithers-orchestrator/sandbox/effect/socket-runner";
+export { isTaskResultFailure, makeWorkerTask, TaskResult, WorkerDispatchKind, WorkerTask, WorkerTaskKind, TaskWorkerEntity, } from "./entity-worker.js";
+export { dispatchWorkerTask, subscribeTaskWorkerDispatches, } from "./single-runner.js";
+/**
+ * Phase 0 Seam Adapter
+ *
+ * This file establishes the interface boundaries for bridging the legacy Smithers engine
+ * with the Effect ecosystem.
+ *
+ * Currently, it delegates to the legacy implementations exactly as they are.
+ * In Phase 1, `executeTaskBridge` will be replaced by `Activity.make()`.
+ * In subsequent phases, other engine boundaries will be modeled as Workflows.
+ */
+const inflightTaskExecutions = new Map();
+const completedTaskExecutions = new Map();
+/**
+ * @template A
+ * @param {Effect.Effect<A, unknown, never> | PromiseLike<A> | A} value
+ * @returns {Promise<A>}
+ */
+const runEffectOrPromise = async (value) => {
+    if (Effect.isEffect?.(value)) {
+        return Effect.runPromise(value);
+    }
+    return await value;
+};
+/**
+ * @param {string | null} [errorJson]
+ * @returns {string | null}
+ */
+function parseAttemptErrorCode(errorJson) {
+    if (!errorJson)
+        return null;
+    try {
+        const parsed = JSON.parse(errorJson);
+        return typeof parsed?.code === "string" ? parsed.code : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * @param {{ errorJson?: string | null; metaJson?: string | null } | null} [attempt]
+ */
+function isRetryableBridgeTaskFailure(attempt) {
+    const meta = parseAttemptMetaJson(attempt?.metaJson);
+    if (meta?.failureRetryable === false) {
+        return false;
+    }
+    const kind = typeof meta?.kind === "string" ? meta.kind : null;
+    return !(kind !== "agent" && parseAttemptErrorCode(attempt?.errorJson) === "INVALID_OUTPUT");
+}
+/**
+ * @param {SmithersDb} adapter
+ * @param {string} runId
+ * @param {_TaskDescriptor} desc
+ * @param {_TaskActivityContext} context
+ */
+const classifyTaskAttempt = async (adapter, runId, desc, context) => {
+    const attempts = await runEffectOrPromise(adapter.listAttempts(runId, desc.nodeId, desc.iteration));
+    const latest = attempts[0];
+    const latestAttempt = latest?.attempt ?? context.attempt;
+    const latestState = latest?.state ?? null;
+    if (latestState === "failed") {
+        const failedAttempts = attempts.filter((attempt) => attempt.state === "failed");
+        const hasNonRetryableFailure = failedAttempts.some((attempt) => !isRetryableBridgeTaskFailure(attempt));
+        if (!hasNonRetryableFailure && failedAttempts.length <= desc.retries) {
+            throw new RetriableTaskFailure(desc.nodeId, latestAttempt);
+        }
+    }
+    return {
+        state: latestState,
+        attempt: latestAttempt,
+        idempotencyKey: context.idempotencyKey,
+    };
+};
+/**
+ * @param {SmithersDb} adapter
+ * @param {string} runId
+ * @param {_TaskDescriptor} desc
+ */
+const getNextTaskActivityAttempt = async (adapter, runId, desc) => {
+    const attempts = await runEffectOrPromise(adapter.listAttempts(runId, desc.nodeId, desc.iteration));
+    const latestAttempt = attempts[0]?.attempt ?? 0;
+    return latestAttempt + 1;
+};
+/**
+ * @param {SmithersDb} adapter
+ * @param {_BunSQLiteDatabase} db
+ * @param {string} runId
+ * @param {_TaskDescriptor} desc
+ * @param {Map<string, _TaskDescriptor>} descriptorMap
+ * @param {SQLiteTable} inputTable
+ * @param {EventBus} eventBus
+ * @param {TaskBridgeToolConfig} toolConfig
+ * @param {string} workflowName
+ * @param {boolean} cacheEnabled
+ * @param {BridgeManagedTaskKind} bridgeManagedExecution
+ * @param {_TaskActivityContext} context
+ * @param {AbortSignal} [signal]
+ * @param {Set<string>} [disabledAgents]
+ * @param {AbortController} [runAbortController]
+ * @param {HijackState} [hijackState]
+ * @param {LegacyExecuteTaskFn} [legacyExecuteTaskFn]
+ */
+const executeBridgeAttempt = async (adapter, db, runId, desc, descriptorMap, inputTable, eventBus, toolConfig, workflowName, cacheEnabled, bridgeManagedExecution, context, signal, disabledAgents, runAbortController, hijackState, legacyExecuteTaskFn) => {
+    if (bridgeManagedExecution === "static") {
+        await executeStaticTaskBridge(adapter, runId, desc, eventBus, toolConfig, workflowName, signal);
+    }
+    else if (bridgeManagedExecution === "compute") {
+        await executeComputeTaskBridge(adapter, db, runId, desc, eventBus, toolConfig, workflowName, signal);
+    }
+    else {
+        await legacyExecuteTaskFn(adapter, db, runId, desc, descriptorMap, inputTable, eventBus, toolConfig, workflowName, cacheEnabled, signal, disabledAgents, runAbortController, hijackState);
+    }
+    return classifyTaskAttempt(adapter, runId, desc, context);
+};
+/**
+ * @param {SmithersDb} adapter
+ * @param {_BunSQLiteDatabase} db
+ * @param {string} runId
+ * @param {_TaskDescriptor} desc
+ * @param {Map<string, _TaskDescriptor>} descriptorMap
+ * @param {SQLiteTable} inputTable
+ * @param {EventBus} eventBus
+ * @param {TaskBridgeToolConfig} toolConfig
+ * @param {string} workflowName
+ * @param {boolean} cacheEnabled
+ * @param {BridgeManagedTaskKind} bridgeManagedExecution
+ * @param {string} bridgeKey
+ * @param {AbortSignal} [signal]
+ * @param {Set<string>} [disabledAgents]
+ * @param {AbortController} [runAbortController]
+ * @param {HijackState} [hijackState]
+ * @param {LegacyExecuteTaskFn} [legacyExecuteTaskFn]
+ */
+const runTaskBridgeExecution = async (adapter, db, runId, desc, descriptorMap, inputTable, eventBus, toolConfig, workflowName, cacheEnabled, bridgeManagedExecution, bridgeKey, signal, disabledAgents, runAbortController, hijackState, legacyExecuteTaskFn) => {
+    const initialAttempt = await getNextTaskActivityAttempt(adapter, runId, desc);
+    return dispatchWorkerTask(makeWorkerTask(bridgeKey, workflowName, runId, desc, bridgeManagedExecution), async () => {
+        try {
+            await executeTaskActivity(adapter, workflowName, runId, desc, (context) => executeBridgeAttempt(adapter, db, runId, desc, descriptorMap, inputTable, eventBus, toolConfig, workflowName, cacheEnabled, bridgeManagedExecution, context, signal, disabledAgents, runAbortController, hijackState, legacyExecuteTaskFn), {
+                initialAttempt,
+                retry: false,
+            });
+            return { terminal: true };
+        }
+        catch (error) {
+            if (error instanceof RetriableTaskFailure) {
+                return { terminal: false };
+            }
+            throw error;
+        }
+    });
+};
+/**
+ * @param {SmithersDb} adapter
+ * @param {_BunSQLiteDatabase} db
+ * @param {string} runId
+ * @param {_TaskDescriptor} desc
+ * @param {Map<string, _TaskDescriptor>} descriptorMap
+ * @param {SQLiteTable} inputTable
+ * @param {EventBus} eventBus
+ * @param {TaskBridgeToolConfig} toolConfig
+ * @param {string} workflowName
+ * @param {boolean} cacheEnabled
+ * @param {AbortSignal} [signal]
+ * @param {Set<string>} [disabledAgents]
+ * @param {AbortController} [runAbortController]
+ * @param {HijackState} [hijackState]
+ * @param {LegacyExecuteTaskFn} [legacyExecuteTaskFn]
+ * @returns {Promise<void>}
+ */
+export const executeTaskBridge = (adapter, db, runId, desc, descriptorMap, inputTable, eventBus, toolConfig, workflowName, cacheEnabled, signal, disabledAgents, runAbortController, hijackState, legacyExecuteTaskFn) => {
+    const bridgeManagedExecution = canExecuteBridgeManagedComputeTask(desc, cacheEnabled)
+        ? "compute"
+        : canExecuteBridgeManagedStaticTask(desc, cacheEnabled)
+            ? "static"
+            : "legacy";
+    if (bridgeManagedExecution === "legacy" && typeof legacyExecuteTaskFn !== "function") {
+        return Promise.reject(new TypeError("legacyExecuteTaskFn must be provided"));
+    }
+    const bridgeKey = makeTaskBridgeKey(adapter, workflowName, runId, desc);
+    const completed = completedTaskExecutions.get(bridgeKey);
+    if (completed) {
+        return completed;
+    }
+    const existing = inflightTaskExecutions.get(bridgeKey);
+    if (existing) {
+        return existing;
+    }
+    const execution = runTaskBridgeExecution(adapter, db, runId, desc, descriptorMap, inputTable, eventBus, toolConfig, workflowName, cacheEnabled, bridgeManagedExecution, bridgeKey, signal, disabledAgents, runAbortController, hijackState, legacyExecuteTaskFn)
+        .then((result) => {
+        if (!result.terminal) {
+            return undefined;
+        }
+        completedTaskExecutions.set(bridgeKey, execution);
+        setTimeout(() => {
+            if (completedTaskExecutions.get(bridgeKey) === execution) {
+                completedTaskExecutions.delete(bridgeKey);
+            }
+        }, 0);
+        return undefined;
+    })
+        .finally(() => {
+        if (inflightTaskExecutions.get(bridgeKey) === execution) {
+            inflightTaskExecutions.delete(bridgeKey);
+        }
+    });
+    inflightTaskExecutions.set(bridgeKey, execution);
+    return execution;
+};
+/**
+ * @param {SmithersDb} adapter
+ * @param {_BunSQLiteDatabase} db
+ * @param {string} runId
+ * @param {_TaskDescriptor} desc
+ * @param {Map<string, _TaskDescriptor>} descriptorMap
+ * @param {SQLiteTable} inputTable
+ * @param {EventBus} eventBus
+ * @param {TaskBridgeToolConfig} toolConfig
+ * @param {string} workflowName
+ * @param {boolean} cacheEnabled
+ * @param {AbortSignal} [signal]
+ * @param {Set<string>} [disabledAgents]
+ * @param {AbortController} [runAbortController]
+ * @param {HijackState} [hijackState]
+ * @param {LegacyExecuteTaskFn} [legacyExecuteTaskFn]
+ * @returns {Effect.Effect<void, import("@smithers-orchestrator/errors/SmithersError").SmithersError, never>}
+ */
+export const executeTaskBridgeEffect = (adapter, db, runId, desc, descriptorMap, inputTable, eventBus, toolConfig, workflowName, cacheEnabled, signal, disabledAgents, runAbortController, hijackState, legacyExecuteTaskFn) => Effect.tryPromise({
+    try: () => executeTaskBridge(adapter, db, runId, desc, descriptorMap, inputTable, eventBus, toolConfig, workflowName, cacheEnabled, signal, disabledAgents, runAbortController, hijackState, legacyExecuteTaskFn),
+    catch: (cause) => toSmithersError(cause, "execute task bridge"),
+});