@smithers-orchestrator/engine 0.16.8 → 0.17.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithers-orchestrator/engine",
-  "version": "0.16.8",
+  "version": "0.17.0",
   "description": "Concrete Smithers workflow execution engine",
   "type": "module",
   "sideEffects": false,
@@ -20,27 +20,36 @@
     "src/"
   ],
   "dependencies": {
+    "@effect/cluster": "^0.58.0",
+    "@effect/experimental": "^0.60.0",
     "@effect/platform-bun": "^0.89.0",
+    "@effect/rpc": "^0.75.0",
+    "@effect/sql": "^0.51.0",
     "@effect/sql-sqlite-bun": "^0.52.0",
+    "@effect/workflow": "^0.18.0",
+    "diff": "^9.0.0",
+    "drizzle-orm": "^0.45.2",
     "effect": "^3.21.1",
-    "@smithers-orchestrator/agents": "0.16.8",
-    "@smithers-orchestrator/db": "0.16.8",
-    "@smithers-orchestrator/components": "0.16.8",
-    "@smithers-orchestrator/driver": "0.16.8",
-    "@smithers-orchestrator/graph": "0.16.8",
-    "@smithers-orchestrator/errors": "0.16.8",
-    "@smithers-orchestrator/sandbox": "0.16.8",
-    "@smithers-orchestrator/memory": "0.16.8",
-    "@smithers-orchestrator/react-reconciler": "0.16.8",
-    "@smithers-orchestrator/observability": "0.16.8",
-    "@smithers-orchestrator/scheduler": "0.16.8",
-    "@smithers-orchestrator/scorers": "0.16.8",
-    "@smithers-orchestrator/time-travel": "0.16.8",
-    "@smithers-orchestrator/vcs": "0.16.8"
+    "react": "^19.2.5",
+    "react-dom": "^19.2.5",
+    "zod": "^4.3.6",
+    "@smithers-orchestrator/agents": "0.17.0",
+    "@smithers-orchestrator/components": "0.17.0",
+    "@smithers-orchestrator/driver": "0.17.0",
+    "@smithers-orchestrator/db": "0.17.0",
+    "@smithers-orchestrator/errors": "0.17.0",
+    "@smithers-orchestrator/graph": "0.17.0",
+    "@smithers-orchestrator/memory": "0.17.0",
+    "@smithers-orchestrator/react-reconciler": "0.17.0",
+    "@smithers-orchestrator/observability": "0.17.0",
+    "@smithers-orchestrator/sandbox": "0.17.0",
+    "@smithers-orchestrator/scheduler": "0.17.0",
+    "@smithers-orchestrator/scorers": "0.17.0",
+    "@smithers-orchestrator/time-travel": "0.17.0",
+    "@smithers-orchestrator/vcs": "0.17.0"
   },
   "devDependencies": {
     "@types/bun": "latest",
-    "react": "^19.2.5",
     "typescript": "~5.9.3"
   },
   "scripts": {

package/src/approvals.js

@@ -1,6 +1,5 @@
 import { Effect, Metric } from "effect";
 import { nowMs } from "@smithers-orchestrator/scheduler/nowMs";
-import { SmithersDb } from "@smithers-orchestrator/db/adapter";
 import { approvalWaitDuration, trackEvent, updateAsyncExternalWaitPending, } from "@smithers-orchestrator/observability/metrics";
 import { bridgeApprovalResolve } from "./effect/durable-deferred-bridge.js";
 import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";

package/src/effect/builder.js

@@ -298,7 +298,7 @@ function resolveHandleIteration(handle, ctx) {
  * @param {Record<string, unknown>} row
  */
 function stripPersistedKeys(row) {
-    const { runId, nodeId, iteration, payload, ...rest } = row;
+    const { runId: _runId, nodeId: _nodeId, iteration: _iteration, payload, ...rest } = row;
     if (payload !== undefined)
         return payload;
     return rest;
@@ -754,7 +754,7 @@ function normalizeExecutionError(result) {
 /**
  * @param {{ name: string; input: AnySchema }} options
  */
-function createWorkflow(options) {
+function _createWorkflow(options) {
     return {
         /**
      * @param {($: BuilderApi) => BuilderNode} buildGraph
@@ -804,7 +804,7 @@ function createWorkflow(options) {
 /**
  * @param {{ name: string; params?: Record<string, unknown> }} options
  */
-function createComponent(options) {
+function _createComponent(options) {
     return {
         /**
      * @param {($: BuilderApi, params: Record<string, unknown>) => BuilderNode} buildGraph

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

@@ -1,9 +1,7 @@
 import { Cause, Duration, Effect, Either, Exit, Metric, Schedule } from "effect";
-import { z } from "zod";
 import { buildOutputRow, stripAutoColumns, validateOutput } from "@smithers-orchestrator/db/output";
 import { TaskHeartbeatTimeout } from "@smithers-orchestrator/errors/TaskHeartbeatTimeout";
 import { TaskTimeout } from "@smithers-orchestrator/errors/TaskTimeout";
-import { EventBus } from "../events.js";
 import { makeAbortError, wireAbortSignal } from "./bridge-utils.js";
 import { withTaskRuntime } from "@smithers-orchestrator/driver/task-runtime";
 import { logDebug, logError, logInfo, logWarning } from "@smithers-orchestrator/observability/logging";
@@ -623,6 +621,14 @@ export const executeComputeTaskBridge = async (adapter, db, runId, desc, eventBu
         if (isHeartbeatPayloadValidationError(effectiveError)) {
             attemptMeta.failureRetryable = false;
         }
+        // Propagate non-retryable signal from any thrown SmithersError so the
+        // attempt is not retried (e.g. AGENT_CONFIG_INVALID from KimiAgent's
+        // expired-credentials check, or auth-failure patterns classified by
+        // BaseCliAgent.classifyNonRetryableAgentError).
+        if (effectiveError?.details?.failureRetryable === false ||
+            effectiveError?.code === "AGENT_CONFIG_INVALID") {
+            attemptMeta.failureRetryable = false;
+        }
         if (aborted) {
             await waitForHeartbeatWriteDrain();
             await flushHeartbeat(true);

package/src/effect/deferred-state-bridge.js

@@ -3,7 +3,6 @@ import { renderToStaticMarkup } from "react-dom/server";
 import { Effect, Exit } from "effect";
 import { buildOutputRow, describeSchemaShape, selectOutputRow, stripAutoColumns, validateExistingOutput, validateOutput, } from "@smithers-orchestrator/db/output";
 import { awaitApprovalDurableDeferred, awaitWaitForEventDurableDeferred, bridgeApprovalResolve, bridgeWaitForEventResolve, } from "./durable-deferred-bridge.js";
-import { EventBus } from "../events.js";
 import { buildHumanRequestId, getHumanTaskPrompt as getStoredHumanTaskPrompt, isHumanTaskMeta, } from "../human-requests.js";
 import { parseAttemptMetaJson } from "./bridge-utils.js";
 import { updateAsyncExternalWaitPending } from "@smithers-orchestrator/observability/metrics";

package/src/effect/diff-bundle.js

@@ -344,7 +344,7 @@ export async function applyDiffBundle(bundle, targetDir) {
         await runGit(targetDir, ["apply", "--binary", "--whitespace=nowarn", "--unsafe-paths", "-"], { input: fullPatch });
         return;
     }
-    catch (error) {
+    catch  {
         for (const patch of bundle.patches) {
             await applyPatchFallback(patch, targetDir);
         }

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

@@ -1,7 +1,5 @@
 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";

package/src/effect/workflow-bridge.js

@@ -1,6 +1,4 @@
 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";

package/src/engine.js

@@ -5,7 +5,7 @@ import { SmithersCtx } from "@smithers-orchestrator/driver/SmithersCtx";
 import { loadInput, loadOutputs } from "@smithers-orchestrator/db/snapshot";
 import { ensureSmithersTables } from "@smithers-orchestrator/db/ensure";
 import { SmithersDb } from "@smithers-orchestrator/db/adapter";
-import { selectOutputRow, validateOutput, validateExistingOutput, getAgentOutputSchema, describeSchemaShape, buildOutputRow, stripAutoColumns, } from "@smithers-orchestrator/db/output";
+import { selectOutputRow, validateOutput, validateExistingOutput, describeSchemaShape, buildOutputRow, stripAutoColumns, } from "@smithers-orchestrator/db/output";
 import { validateInput } from "@smithers-orchestrator/db/input";
 import { schemaSignature } from "@smithers-orchestrator/db/schema-signature";
 import { withSqliteWriteRetry } from "@smithers-orchestrator/db/write-retry";
@@ -23,7 +23,6 @@ import { EventBus } from "./events.js";
 import { getJjPointer, runJj, workspaceAdd } from "@smithers-orchestrator/vcs/jj";
 import { findVcsRoot } from "@smithers-orchestrator/vcs/find-root";
 import * as BunContext from "@effect/platform-bun/BunContext";
-import { z } from "zod";
 import { eq, getTableName } from "drizzle-orm";
 import { getTableColumns } from "drizzle-orm/utils";
 import { Chunk, Duration, Effect, Fiber, Metric, Queue, Schedule } from "effect";
@@ -448,16 +447,6 @@ function prependToolResumeWarningMessage(prompt, warningMessage) {
     }
     return `${warningMessage}\n\n${prompt}`;
 }
-/**
- * @param {HijackCompletion} completion
- * @returns {Error}
- */
-function buildHijackAbortError(completion) {
-    const err = makeAbortError(`Hijack requested for ${completion.engine}`);
-    err.code = "RUN_HIJACKED";
-    err.hijack = completion;
-    return err;
-}
 /**
  * @param {string} cwd
  * @param {string[]} args
@@ -1526,13 +1515,11 @@ function assertResumeDurabilityMetadata(existingRun, existingConfig, current, wo
     else if (shouldCheckWorkflowHashes) {
         compareNullableString(existingRun.workflowHash, current.entryWorkflowHash, "workflow entry file changed", mismatches);
     }
-    compareNullableString(existingRun.vcsType, current.vcsType, "VCS type changed", mismatches);
     if ((existingRun.vcsRoot && current.vcsRoot
         ? resolve(existingRun.vcsRoot) !== resolve(current.vcsRoot)
         : (existingRun.vcsRoot ?? null) !== (current.vcsRoot ?? null))) {
         mismatches.push("VCS root changed");
     }
-    compareNullableString(existingRun.vcsRevision, current.vcsRevision, "VCS revision changed", mismatches);
     if (mismatches.length > 0) {
         throw new SmithersError("RESUME_METADATA_MISMATCH", `Cannot resume run because durable metadata changed: ${mismatches.join(", ")}`, {
             existing: {
@@ -2031,8 +2018,15 @@ function isRetryableTaskFailure(attempt) {
     if (meta?.failureRetryable === false) {
         return false;
     }
+    const errorCode = parseAttemptErrorCode(attempt?.errorJson);
+    // AGENT_CONFIG_INVALID is a deterministic configuration failure (e.g.
+    // "LLM not set", unknown model). Retrying is guaranteed to fail again
+    // and just multiplies cost — short-circuit immediately.
+    if (errorCode === "AGENT_CONFIG_INVALID") {
+        return false;
+    }
     const kind = typeof meta?.kind === "string" ? meta.kind : null;
-    return !(kind !== "agent" && parseAttemptErrorCode(attempt?.errorJson) === "INVALID_OUTPUT");
+    return !(kind !== "agent" && errorCode === "INVALID_OUTPUT");
 }
 /**
  * @param {SmithersDb} adapter
@@ -2766,13 +2760,15 @@ async function legacyExecuteTask(adapter, db, runId, desc, descriptorMap, inputT
                     effectiveAgent.model ??
                         effectiveAgent.modelId ??
                         null;
-                const currentAgentEngine = typeof effectiveAgent.cliEngine === "string"
+                const hijackCapableEngine = typeof effectiveAgent.cliEngine === "string"
                     ? effectiveAgent.cliEngine
                     : typeof effectiveAgent.hijackEngine === "string"
                         ? effectiveAgent.hijackEngine
-                        : (typeof effectiveAgent.constructor?.name === "string"
-                            ? effectiveAgent.constructor.name
-                            : null);
+                        : null;
+                const currentAgentEngine = hijackCapableEngine ??
+                    (typeof effectiveAgent.constructor?.name === "string"
+                        ? effectiveAgent.constructor.name
+                        : null);
                 attemptMeta.agentEngine = currentAgentEngine;
                 const heartbeatCheckpoint = previousHeartbeat &&
                     typeof previousHeartbeat === "object" &&
@@ -2785,15 +2781,25 @@ async function legacyExecuteTask(adapter, db, runId, desc, descriptorMap, inputT
                 const heartbeatCheckpointUsable = !currentAgentEngine ||
                     !heartbeatCheckpointEngine ||
                     heartbeatCheckpointEngine === currentAgentEngine;
-                const checkpointResumeSession = heartbeatCheckpointUsable &&
-                    typeof heartbeatCheckpoint?.agentResume === "string"
+                // If the most recent failed attempt asked us to drop the resume
+                // session (e.g. kimi crashed mid-stream and reported `kimi -r
+                // <uuid>`; that session is now corrupt and re-resuming it just
+                // reproduces the crash), don't reuse the captured agentResume
+                // from the heartbeat. Forces the agent to start a fresh
+                // session on the next attempt.
+                const lastFailedAttempt = attempts.find((a) => a.state === "failed");
+                const lastFailedMeta = parseAttemptMetaJson(lastFailedAttempt?.metaJson);
+                const discardResumeSession = lastFailedMeta?.discardResumeSession === true;
+                const checkpointResumeSession = !discardResumeSession
+                    && heartbeatCheckpointUsable
+                    && typeof heartbeatCheckpoint?.agentResume === "string"
                     ? heartbeatCheckpoint.agentResume
                     : undefined;
                 const checkpointResumeMessages = heartbeatCheckpointUsable
                     ? asConversationMessages(heartbeatCheckpoint?.agentConversation)
                     : undefined;
-                const priorContinuation = currentAgentEngine
-                    ? findHijackContinuation(attempts, currentAgentEngine)
+                const priorContinuation = hijackCapableEngine
+                    ? findHijackContinuation(attempts, hijackCapableEngine)
                     : undefined;
                 const resumeSession = priorContinuation?.mode === "native-cli"
                     ? priorContinuation.resume
@@ -2803,6 +2809,37 @@ async function legacyExecuteTask(adapter, db, runId, desc, descriptorMap, inputT
                     : (cloneJsonValue(checkpointResumeMessages) ??
                         checkpointResumeMessages);
                 const guidedResumeMessages = appendToolResumeWarningMessage(resumeMessages, toolResumeWarningMessage);
+                if (desc.hijack) {
+                    if (!hijackCapableEngine) {
+                        attemptMeta.failureRetryable = false;
+                        throw new SmithersError("TASK_HIJACK_UNSUPPORTED", `Task ${desc.nodeId} sets hijack, but its agent is not hijack-capable. Hijack requires an agent with cliEngine or hijackEngine.`, {
+                            nodeId: desc.nodeId,
+                            agentId: attemptMeta.agentId ?? undefined,
+                        });
+                    }
+                    const shouldAutoHijack = desc.onHijackExit === "reopen" || !priorContinuation;
+                    if (shouldAutoHijack && !hijackState) {
+                        attemptMeta.failureRetryable = false;
+                        throw new SmithersError("TASK_HIJACK_UNSUPPORTED", `Task ${desc.nodeId} cannot auto-hijack in this execution mode.`, {
+                            nodeId: desc.nodeId,
+                            agentId: attemptMeta.agentId ?? undefined,
+                        });
+                    }
+                    if (shouldAutoHijack && !hijackState.request && !hijackState.completion) {
+                        const requestedAtMs = nowMs();
+                        hijackState.request = {
+                            requestedAtMs,
+                            target: hijackCapableEngine,
+                        };
+                        await Effect.runPromise(adapter.requestRunHijack(runId, requestedAtMs, hijackCapableEngine));
+                        await Effect.runPromise(eventBus.emitEventWithPersist({
+                            type: "RunHijackRequested",
+                            runId,
+                            target: hijackCapableEngine,
+                            timestampMs: requestedAtMs,
+                        }));
+                    }
+                }
                 if (resumeSession) {
                     attemptMeta.resumedFromSession = resumeSession;
                 }
@@ -2989,37 +3026,40 @@ async function legacyExecuteTask(adapter, db, runId, desc, descriptorMap, inputT
                 // Use fallback agent on retry attempts when available
                 let result;
                 try {
-                    result = await Effect.runPromise(withSmithersSpan(smithersSpanNames.agent, Effect.promise(() => {
-                        const agentCall = guidedResumeMessages?.length
-                            ? {
-                                messages: guidedResumeMessages,
-                            }
-                            : {
-                                prompt: effectivePrompt,
-                            };
-                        return effectiveAgent.generate({
-                            options: undefined,
-                            abortSignal: taskSignal,
-                            ...agentCall,
-                            resumeSession,
-                            lastHeartbeat: previousHeartbeat,
-                            rootDir: taskRoot,
-                            maxOutputBytes: toolConfig.maxOutputBytes,
-                            timeout: desc.timeoutMs
-                                ? { totalMs: desc.timeoutMs }
-                                : undefined,
-                            onStdout: (text) => {
-                                recordInternalHeartbeat();
-                                emitOutput(text, "stdout");
-                            },
-                            onStderr: (text) => {
-                                recordInternalHeartbeat();
-                                emitOutput(text, "stderr");
-                            },
-                            onEvent: handleAgentEvent,
-                            onStepFinish: handleSdkStepFinish,
-                            outputSchema: desc.outputSchema,
-                        });
+                    result = await Effect.runPromise(withSmithersSpan(smithersSpanNames.agent, Effect.tryPromise({
+                        try: () => {
+                            const agentCall = guidedResumeMessages?.length
+                                ? {
+                                    messages: guidedResumeMessages,
+                                }
+                                : {
+                                    prompt: effectivePrompt,
+                                };
+                            return effectiveAgent.generate({
+                                options: undefined,
+                                abortSignal: taskSignal,
+                                ...agentCall,
+                                resumeSession,
+                                lastHeartbeat: previousHeartbeat,
+                                rootDir: taskRoot,
+                                maxOutputBytes: toolConfig.maxOutputBytes,
+                                timeout: desc.timeoutMs
+                                    ? { totalMs: desc.timeoutMs }
+                                    : undefined,
+                                onStdout: (text) => {
+                                    recordInternalHeartbeat();
+                                    emitOutput(text, "stdout");
+                                },
+                                onStderr: (text) => {
+                                    recordInternalHeartbeat();
+                                    emitOutput(text, "stderr");
+                                },
+                                onEvent: handleAgentEvent,
+                                onStepFinish: handleSdkStepFinish,
+                                outputSchema: desc.outputSchema,
+                            });
+                        },
+                        catch: (error) => error,
                     }), {
                         ...taskSpanContext,
                         agent: attemptMeta.agentId ??
@@ -3100,10 +3140,12 @@ async function legacyExecuteTask(adapter, db, runId, desc, descriptorMap, inputT
                 // Fall back to parsing text/steps for JSON
                 if (output === undefined) {
                     const text = result.text ?? "";
-                    // Try to parse the whole text as JSON first
+                    // Try to parse the whole text as JSON first. Strip a leading
+                    // UTF-8 BOM and accept either object or array at the root,
+                    // since Zod schemas occasionally validate arrays.
                     try {
-                        const trimmed = text.trim();
-                        if (trimmed.startsWith("{")) {
+                        const trimmed = text.replace(/^\uFEFF/, "").trim();
+                        if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
                             output = JSON.parse(trimmed);
                         }
                     }
@@ -3280,14 +3322,28 @@ async function legacyExecuteTask(adapter, db, runId, desc, descriptorMap, inputT
                         const retryText = retryResult.text ?? "";
                         responseText = retryText || responseText;
                         try {
-                            const trimmed = retryText.trim();
-                            if (trimmed.startsWith("{")) {
+                            const trimmed = retryText.replace(/^\uFEFF/, "").trim();
+                            if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
                                 output = JSON.parse(trimmed);
                             }
                         }
                         catch {
                             // Still not valid JSON
                         }
+                        if (output === undefined) {
+                            // Try extracting JSON from a markdown code fence
+                            // (```json ... ``` or just ``` ... ```).
+                            const fenceMatch = retryText.match(/```(?:json)?\s*([\s\S]*?)```/i);
+                            if (fenceMatch) {
+                                const inner = fenceMatch[1].trim();
+                                try {
+                                    output = JSON.parse(inner);
+                                }
+                                catch {
+                                    // Fall through to balanced extraction
+                                }
+                            }
+                        }
                         if (output === undefined) {
                             // Try extracting balanced JSON from retry text
                             const jsonStr = extractBalancedJson(retryText);
@@ -3303,8 +3359,6 @@ async function legacyExecuteTask(adapter, db, runId, desc, descriptorMap, inputT
                     }
                     if (output === undefined) {
                         // Debug: log what we have
-                        const debugSteps = result.steps ?? [];
-                        const stepTexts = debugSteps.map((s, i) => `Step ${i}: ${(s?.text ?? "").slice(0, 200)}`);
                         const finishReason = result.finishReason ?? "unknown";
                         logDebug("agent response did not contain valid JSON output", {
                             runId,
@@ -3319,7 +3373,11 @@ async function legacyExecuteTask(adapter, db, runId, desc, descriptorMap, inputT
                             lastStepText: debugSteps[debugSteps.length - 1]?.text?.slice(0, 500) ??
                                 "none",
                         }, "engine:task-json");
-                        throw new SmithersError("INVALID_OUTPUT", "No valid JSON output found in agent response");
+                        const tail = (text ?? "").slice(-200).replace(/\s+/g, " ").trim();
+                        const tailHint = tail
+                            ? ` Last 200 chars of response: ${JSON.stringify(tail)}`
+                            : " Agent returned an empty response.";
+                        throw new SmithersError("INVALID_OUTPUT", `No valid JSON output found in agent response (finishReason=${finishReason}, textLength=${text.length}).${tailHint}`);
                     }
                 }
                 // Output should already be parsed, but handle string case
@@ -3327,7 +3385,7 @@ async function legacyExecuteTask(adapter, db, runId, desc, descriptorMap, inputT
                     try {
                         payload = JSON.parse(output);
                     }
-                    catch (e) {
+                    catch  {
                         throw new SmithersError("INVALID_OUTPUT", `Failed to parse agent output as JSON. Output starts with: "${output.slice(0, 100)}"`);
                     }
                 }
@@ -3679,6 +3737,30 @@ async function legacyExecuteTask(adapter, db, runId, desc, descriptorMap, inputT
         if (isHeartbeatPayloadValidationError(effectiveError)) {
             attemptMeta.failureRetryable = false;
         }
+        // Allow agents (e.g. BaseCliAgent on "LLM not set") to flag a failure as
+        // non-retryable via SmithersError details. Without this, the engine would
+        // retry deterministic configuration errors up to desc.retries times.
+        if (effectiveError &&
+            typeof effectiveError === "object" &&
+            // @ts-ignore — duck-type on SmithersError shape
+            effectiveError.details &&
+            // @ts-ignore
+            effectiveError.details.failureRetryable === false) {
+            attemptMeta.failureRetryable = false;
+        }
+        // Honour `discardResumeSession: true` from agent-side errors (e.g. kimi
+        // session-loss). The next attempt's resumeSession resolution checks
+        // attemptMeta.discardResumeSession on the most recent failed attempt
+        // and clears the captured agentResume so the agent starts fresh
+        // instead of redundantly trying to resume a corrupt session.
+        if (effectiveError &&
+            typeof effectiveError === "object" &&
+            // @ts-ignore — duck-type on SmithersError shape
+            effectiveError.details &&
+            // @ts-ignore
+            effectiveError.details.discardResumeSession === true) {
+            attemptMeta.discardResumeSession = true;
+        }
         if (!heartbeatTimeoutError && (taskSignal.aborted || isAbortError(err))) {
             await waitForHeartbeatWriteDrain();
             await flushHeartbeat(true);

package/src/hot/watch.js

@@ -1,6 +1,6 @@
 import { watch } from "node:fs";
-import { readdir, stat } from "node:fs/promises";
-import { resolve, relative } from "node:path";
+import { readdir } from "node:fs/promises";
+import { resolve } from "node:path";
 import { Effect } from "effect";
 import { toSmithersError } from "@smithers-orchestrator/errors/toSmithersError";
 import { logDebug, logInfo } from "@smithers-orchestrator/observability/logging";

package/src/signals.js

@@ -1,5 +1,4 @@
 import { Effect } from "effect";
-import { SmithersDb } from "@smithers-orchestrator/db/adapter";
 import { bridgeSignalResolve } from "./effect/durable-deferred-bridge.js";
 import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
 import { nowMs } from "@smithers-orchestrator/scheduler/nowMs";