@inflexa-ai/harness 0.7.1 → 0.8.0

package/dist/tools/workspace/execute-command.js

@@ -83,6 +83,7 @@ export function createExecuteCommandTool(deps) {
                         command,
                         exitCode: result.exitCode,
                         durationMs: result.durationMs,
+                        ...(deps.logger ? { logger: deps.logger } : {}),
                         ...(result.provenance ? { provenance: result.provenance } : {}),
                     });
                 }

package/dist/workflows/execute-analysis.d.ts

@@ -30,11 +30,16 @@
  *       completion
  *     - await child results via `getResult` (these are themselves cached
  *       in DBOS, so parent recovery does NOT re-run completed children)
- *  3. Fail-fast cascade
- *     - on the first non-resumable child failure (or on external parent
- *       cancel): stop scheduling, then
- *       `Promise.allSettled(handles.map(h => DBOS.cancelWorkflow(h.workflowID)))`
- *     - each cancelled child tears down its sandbox in its own terminal path
+ *  3. Failure isolation
+ *     - a child settling `failed`/`blocked` (or throwing for a non-budget
+ *       cause) dooms only its transitive dependents: they can never become
+ *       dependency-satisfied, are marked `skipped` on the dag-state part, and
+ *       are never dispatched. In-flight siblings and independent ready steps
+ *       continue; the loop drains and the run finalises (typically `partial`).
+ *     - the halt cascade (cancel in-flight via
+ *       `Promise.allSettled(handles.map(h => DBOS.cancelWorkflow(h.workflowID)))`,
+ *       stop scheduling) survives only for the budget paths: a
+ *       `budget_exceeded` settlement and the `neverFits` plan-validation guard.
  *  4. Pause cascade (402)
  *     - on a child cancelling itself with `budget_exceeded`: cancel siblings
  *       then self-cancel the parent to `CANCELLED` (NOT `ERROR` — ERROR

package/dist/workflows/execute-analysis.js

@@ -30,11 +30,16 @@
  *       completion
  *     - await child results via `getResult` (these are themselves cached
  *       in DBOS, so parent recovery does NOT re-run completed children)
- *  3. Fail-fast cascade
- *     - on the first non-resumable child failure (or on external parent
- *       cancel): stop scheduling, then
- *       `Promise.allSettled(handles.map(h => DBOS.cancelWorkflow(h.workflowID)))`
- *     - each cancelled child tears down its sandbox in its own terminal path
+ *  3. Failure isolation
+ *     - a child settling `failed`/`blocked` (or throwing for a non-budget
+ *       cause) dooms only its transitive dependents: they can never become
+ *       dependency-satisfied, are marked `skipped` on the dag-state part, and
+ *       are never dispatched. In-flight siblings and independent ready steps
+ *       continue; the loop drains and the run finalises (typically `partial`).
+ *     - the halt cascade (cancel in-flight via
+ *       `Promise.allSettled(handles.map(h => DBOS.cancelWorkflow(h.workflowID)))`,
+ *       stop scheduling) survives only for the budget paths: a
+ *       `budget_exceeded` settlement and the `neverFits` plan-validation guard.
  *  4. Pause cascade (402)
  *     - on a child cancelling itself with `budget_exceeded`: cancel siblings
  *       then self-cancel the parent to `CANCELLED` (NOT `ERROR` — ERROR
@@ -105,11 +110,23 @@ export function buildChildInput(args) {
     if (!resources) {
         throw new Error(`executeAnalysis: step "${stepId}" missing from resourcesByStepId — every step must declare resources`);
     }
+    const planStep = input.planStepById[stepId];
+    if (!planStep) {
+        throw new Error(`executeAnalysis: step "${stepId}" missing from planStepById — every step must carry its plan data`);
+    }
     return {
         analysisId: input.analysisId,
         runId,
         stepId,
         agentId: input.agentByStepId[stepId] ?? "scientific-executor",
+        // Carried into the child because lineage classification admits a same-run
+        // sibling edge only when the sibling was declared here — the scheduler's
+        // ordering guarantee attaches to this list and nothing else. Read from the
+        // keyed plan snapshot rather than scanning `steps`, and thrown for rather
+        // than defaulted: an empty list is indistinguishable from a step that
+        // genuinely declared nothing, and it silently deletes every same-run edge
+        // the step was entitled to.
+        dependsOn: planStep.depends_on,
         level,
         prompt,
         parentWorkflowId: workflowId,
@@ -319,7 +336,7 @@ export async function runExecuteAnalysisBody(input, deps) {
         stepCount: input.steps.length,
         atMs: startedAtMs,
     });
-    // (2-4) Scheduler loop + fail-fast + pause cascade.
+    // (2-4) Scheduler loop + failure isolation + pause cascade.
     const final = await runSchedulerLoop({
         input,
         runId,
@@ -434,7 +451,7 @@ async function runSchedulerLoop(args) {
     const canceled = new Set();
     const inFlight = new Map();
     const budgetExceededChildIds = new Set();
-    // Child workflow ids the parent itself cancelled (fail-fast / budget cascade). Their `getResult`
+    // Child workflow ids the parent itself cancelled (budget / neverFits halt cascade). Their `getResult`
     // rejects with a DBOS cancellation error and lands in the settlement error branch — but the step was
     // CANCELED by us, not failed on its own merits. Keyed here (deterministic: `cancelInFlight` runs the
     // same way on a replay) so that branch records it as canceled everywhere, matching how a child that
@@ -444,7 +461,40 @@ async function runSchedulerLoop(args) {
     for (const step of input.steps) {
         stepRuntime.set(step.id, { status: "pending" });
     }
-    let failFast = false;
+    // Reverse adjacency over the static plan — who depends on whom.
+    const dependentsByStepId = new Map();
+    for (const step of input.steps) {
+        for (const dep of step.depends_on) {
+            const list = dependentsByStepId.get(dep);
+            if (list)
+                list.push(step.id);
+            else
+                dependentsByStepId.set(dep, [step.id]);
+        }
+    }
+    /**
+     * Mark every transitive dependent of a failed/blocked step `skipped` in the
+     * dag snapshot: a failed step never enters `completed`, so its dependents
+     * can never become dependency-satisfied and will never be dispatched.
+     * Stream-only — ledger rows stay `pending` until the terminal sweep flips
+     * them to `skipped`. Dependents of an unfinished step are necessarily
+     * `pending` (never queued/running); an already-`skipped` one is not
+     * re-walked.
+     */
+    const markDependentsSkipped = (failedStepId) => {
+        const stack = [...(dependentsByStepId.get(failedStepId) ?? [])];
+        while (stack.length > 0) {
+            const id = stack.pop();
+            if (stepRuntime.get(id).status === "pending") {
+                stepRuntime.set(id, { status: "skipped" });
+                stack.push(...(dependentsByStepId.get(id) ?? []));
+            }
+        }
+    };
+    // Halts scheduling entirely — reserved for the budget paths (a
+    // `budget_exceeded` settlement, the `neverFits` guard). An ordinary step
+    // failure does NOT set it: it dooms only that step's transitive dependents.
+    let halted = false;
     let budgetExceeded = false;
     let failureReason = null;
     const stepIndexById = new Map(input.steps.map((s, i) => [s.id, i]));
@@ -473,20 +523,28 @@ async function runSchedulerLoop(args) {
     };
     const dbosParentId = DBOS.workflowID ?? workflowId;
     const dispatchReady = async () => {
-        if (failFast)
+        if (halted)
             return;
         const inFlightStepIds = new Set([...inFlight.values()].map((h) => h.stepId));
+        // A settled-but-not-completed step (failed / blocked / canceled) is not
+        // in `completed` and not in flight, so `scheduleReady` would offer it
+        // again — filter it out of the candidate list. This also stops its
+        // declared resources from weighing against the budget: settled steps
+        // hold no capacity.
+        const candidates = input.steps.filter((s) => !failed.has(s.id) && !canceled.has(s.id));
         let admit;
         let queuedChanged = false;
         if (input.budget) {
-            const scheduled = scheduleReady(input.steps, completed, inFlightStepIds, {
+            const scheduled = scheduleReady(candidates, completed, inFlightStepIds, {
                 budget: input.budget,
                 resourcesByStepId: input.resourcesByStepId,
             });
             if (scheduled.neverFits.length > 0) {
                 // An over-budget step can never be admitted — plan-time validation
                 // makes this unreachable for new plans; stored plans fail loudly
-                // instead of waiting forever. Standard fail-fast follows.
+                // instead of waiting forever. The stored plan is invalid against
+                // this machine, so the run halts outright — unlike an ordinary
+                // step failure, which dooms only its dependents.
                 for (const stepId of scheduled.neverFits) {
                     const r = input.resourcesByStepId[stepId];
                     const declared = r ? `${r.cpu} CPU / ${r.memoryGb} GB` : "undeclared";
@@ -496,7 +554,7 @@ async function runSchedulerLoop(args) {
                         error: `step resources (${declared}) exceed the machine budget (${input.budget.cpu} CPU / ${input.budget.memoryGb} GB)`,
                     });
                 }
-                failFast = true;
+                halted = true;
                 failureReason = `step "${scheduled.neverFits[0]}" exceeds the machine resource budget`;
                 await cancelInFlight(inFlight, "fail_fast", canceledByParent);
                 await emitDagSnapshot();
@@ -511,7 +569,7 @@ async function runSchedulerLoop(args) {
             admit = scheduled.admit;
         }
         else {
-            admit = scheduleReady(input.steps, completed, inFlightStepIds);
+            admit = scheduleReady(candidates, completed, inFlightStepIds);
         }
         if (admit.length === 0) {
             if (queuedChanged)
@@ -590,7 +648,7 @@ async function runSchedulerLoop(args) {
                 const isBudgetCancel = childWasBudgetExceeded || r.error === "budget_exceeded";
                 if (isBudgetCancel && !budgetExceeded) {
                     budgetExceeded = true;
-                    failFast = true;
+                    halted = true;
                     failureReason = "budget_exceeded";
                     await cancelInFlight(inFlight, "budget_exceeded", canceledByParent);
                 }
@@ -604,31 +662,31 @@ async function runSchedulerLoop(args) {
                 await emitDagSnapshot();
             }
             else {
-                // failed or blocked — a blocker (see the harness-sandbox-agents spec) fails fast exactly like a
-                // failure: the step declared it cannot deliver, so its dependents can
-                // never run. Same cancel-siblings + stop-scheduling path.
+                // failed or blocked — a blocker (see the harness-sandbox-agents spec)
+                // is treated exactly like a failure: the step declared it cannot
+                // deliver, so only its transitive dependents can never run. In-flight
+                // siblings and independent ready steps continue; the dispatch round
+                // below also lets a budget-held step claim the freed capacity.
                 failed.add(settled.stepId);
-                if (!failFast) {
-                    failFast = true;
-                    failureReason = r.error ?? (r.status === "blocked" ? "step_blocked" : "step_failed");
-                    await cancelInFlight(inFlight, "fail_fast", canceledByParent);
-                }
+                failureReason ??= r.error ?? (r.status === "blocked" ? "step_blocked" : "step_failed");
                 stepRuntime.set(settled.stepId, {
                     status: "failed",
                     durationMs: r.durationMs ?? undefined,
                     error: r.error ?? (r.status === "blocked" ? "step_blocked" : "step_failed"),
                 });
+                markDependentsSkipped(settled.stepId);
                 stepStatus = "failed";
                 stepDurationMs = r.durationMs ?? undefined;
                 await emitDagSnapshot();
+                await dispatchReady();
             }
         }
         else if (canceledByParent.has(settled.childId)) {
-            // The child threw because the PARENT cancelled it (fail-fast / budget cascade), not because
-            // it failed on its own — its `getResult` rejects with a DBOS cancellation error. Record it as
-            // canceled, mirroring the graceful `{status:"canceled"}` branch above so the `canceled` set,
-            // the terminal result, and the `step_completed` provenance all agree. No failFast / cancel
-            // cascade here: the run is already failing fast (that is why this child was cancelled).
+            // The child threw because the PARENT cancelled it (budget / neverFits halt cascade), not
+            // because it failed on its own — its `getResult` rejects with a DBOS cancellation error.
+            // Record it as canceled, mirroring the graceful `{status:"canceled"}` branch above so the
+            // `canceled` set, the terminal result, and the `step_completed` provenance all agree. No
+            // halt / cancel cascade here: the run is already halted (that is why this child was cancelled).
             canceled.add(settled.stepId);
             stepRuntime.set(settled.stepId, {
                 // `stepRuntime` (the DAG snapshot) has no canceled tier; the graceful-cancel branch above
@@ -641,18 +699,24 @@ async function runSchedulerLoop(args) {
             await emitDagSnapshot();
         }
         else {
+            // The child threw on its own (not a parent-driven cancel). A
+            // budget_exceeded throw still halts the run — the pause cascade is a
+            // money decision, not a DAG one. Any other throw is treated exactly
+            // like a step failure: dependents doomed, siblings continue.
             failed.add(settled.stepId);
-            const cause = childWasBudgetExceeded || isBudgetExceeded(settled.err) ? "budget_exceeded" : "fail_fast";
-            if (cause === "budget_exceeded" && !budgetExceeded) {
-                budgetExceeded = true;
-                failFast = true;
-                failureReason = "budget_exceeded";
+            const isBudgetThrow = childWasBudgetExceeded || isBudgetExceeded(settled.err);
+            if (isBudgetThrow) {
+                if (!budgetExceeded) {
+                    budgetExceeded = true;
+                    halted = true;
+                    failureReason = "budget_exceeded";
+                }
+                await cancelInFlight(inFlight, "budget_exceeded", canceledByParent);
             }
-            else if (!failFast) {
-                failFast = true;
-                failureReason = settled.err instanceof Error ? settled.err.message : String(settled.err);
+            else {
+                failureReason ??= settled.err instanceof Error ? settled.err.message : String(settled.err);
+                markDependentsSkipped(settled.stepId);
             }
-            await cancelInFlight(inFlight, cause, canceledByParent);
             stepRuntime.set(settled.stepId, {
                 status: "failed",
                 error: settled.err instanceof Error ? settled.err.message : String(settled.err),
@@ -661,6 +725,8 @@ async function runSchedulerLoop(args) {
             // A child that settled by throwing carries no durable duration.
             stepDurationMs = undefined;
             await emitDagSnapshot();
+            if (!isBudgetThrow)
+                await dispatchReady();
         }
         // One `step_completed` provenance emission per settled child — this
         // settlement loop is the only site that observes every executed step.

package/dist/workflows/sandbox-step.d.ts

@@ -51,6 +51,18 @@ export interface SandboxStepInput {
     readonly runId: string;
     readonly stepId: string;
     readonly agentId: string;
+    /**
+     * Step ids this step declared as dependencies. Load-bearing for lineage:
+     * classification admits a same-run sibling edge only on declaration, so a
+     * collector seeded without this refuses every same-run read — legitimate
+     * declared dependencies included.
+     *
+     * Optional because this is durable DBOS workflow input: a workflow started
+     * under an input shape predating the field recovers without it. Absence
+     * reads as an empty declaration list, which under-captures sibling edges
+     * rather than admitting unstable ones.
+     */
+    readonly dependsOn?: readonly string[];
     /** Topological level — persisted on `cortex_step_executions.wave`. */
     readonly level: number;
     /** User-content prompt the agent receives as its initial message. */
@@ -240,6 +252,19 @@ export interface PostStepContext {
     /** Same step-scoped collector the agent loop fed each exec frame into. */
     readonly lineageCollector: ProvenanceCollector;
 }
+/**
+ * Build the step's lineage collector from its durable input. The agent loop
+ * feeds each exec's provenance frame into it; post-step registration reads the
+ * resulting input/script edges. Reconstructed deterministically on replay — the
+ * frames it consumes are cached recv outputs and the command strings are cached
+ * LLM tool-use (see the harness-thread-store and harness-durable-runtime specs).
+ *
+ * Split out of the body, and taking only the fields it reads, so the seeding is
+ * exercisable without a live workflow: `dependsOn` is what makes a same-run edge
+ * admissible at all, so a collector built without it silently erases every
+ * legitimate declared-dependency edge while leaving each layer's own tests green.
+ */
+export declare function createLineageCollector(input: Pick<SandboxStepInput, "stepId" | "runId" | "dependsOn">): ProvenanceCollector;
 /**
  * Register the sandbox-step child workflow with DBOS. Returns the
  * registered callable so callers can dispatch via `DBOS.startWorkflow`.

package/dist/workflows/sandbox-step.js

@@ -82,6 +82,25 @@ function stepPartId(kind, runId, stepId) {
 function userFacingStepFailure(errorClass) {
     return errorClass === "lineage_attestation" ? "Step results could not be finalized." : "Step failed during execution.";
 }
+/**
+ * Build the step's lineage collector from its durable input. The agent loop
+ * feeds each exec's provenance frame into it; post-step registration reads the
+ * resulting input/script edges. Reconstructed deterministically on replay — the
+ * frames it consumes are cached recv outputs and the command strings are cached
+ * LLM tool-use (see the harness-thread-store and harness-durable-runtime specs).
+ *
+ * Split out of the body, and taking only the fields it reads, so the seeding is
+ * exercisable without a live workflow: `dependsOn` is what makes a same-run edge
+ * admissible at all, so a collector built without it silently erases every
+ * legitimate declared-dependency edge while leaving each layer's own tests green.
+ */
+export function createLineageCollector(input) {
+    return new ProvenanceCollector({
+        stepId: input.stepId,
+        runId: input.runId,
+        dependsOn: [...(input.dependsOn ?? [])],
+    });
+}
 // ── The child workflow body ───────────────────────────────────────────
 /**
  * Register the sandbox-step child workflow with DBOS. Returns the
@@ -132,15 +151,7 @@ async function runSandboxStepBody(input, deps) {
     // `session.provenance.agentId`, and billing tags ride the same provenance.
     const session = forSubAgent(input.runSession, input.agentId);
     const writePrefix = deps.resolveWritePrefix(input);
-    // One lineage collector per step. The agent loop feeds each exec's
-    // provenance frame into it; post-step registration reads the resulting
-    // input/script edges. Reconstructed deterministically on replay — the
-    // frames it consumes are cached recv outputs and the command strings are
-    // cached LLM tool-use (see the harness-thread-store and harness-durable-runtime specs).
-    const lineageCollector = new ProvenanceCollector({
-        stepId: input.stepId,
-        runId: input.runId,
-    });
+    const lineageCollector = createLineageCollector(input);
     // (2a) sandbox.mint — checkpoint the machine's identity (name + HMAC secret)
     // BEFORE it is spawned (see the harness-sandbox-exec spec). Durable-before-create is what makes (2b)
     // idempotent: a crash between spawn and the spawn checkpoint re-runs (2b)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@inflexa-ai/harness",
-    "version": "0.7.1",
+    "version": "0.8.0",
     "description": "Host-agnostic bioinformatics agent harness \u2014 hand-rolled agent loop, DBOS-durable workflows, sandboxed compute.",
     "license": "Apache-2.0",
     "type": "module",
@@ -40,12 +40,14 @@
         "prepare": "tsc -p tsconfig.json",
         "prepublishOnly": "bun run build && bun run smoke",
         "smoke": "node scripts/smoke.mjs",
+        "test:full": "bash scripts/test-full.sh",
         "typecheck": "tsc --noEmit"
     },
     "dependencies": {
         "@ai-sdk/anthropic": "^4.0.15",
         "@ai-sdk/openai-compatible": "^3.0.10",
         "@ai-sdk/provider": "^4.0.3",
+        "@ai-sdk/provider-utils": "5.0.10",
         "@anthropic-ai/sdk": "^0.107.0",
         "@dbos-inc/dbos-sdk": "^4.23.6",
         "@kubernetes/client-node": "^1.4.0",