@inflexa-ai/harness 0.7.0 → 0.7.2

package/dist/tasks/data-profile.d.ts

@@ -18,6 +18,7 @@
  */
 import type { Pool } from "pg";
 import { type AuthContext, type RunSession } from "../auth/types.js";
+import type { EnvironmentStorePaths } from "../config/environment-stores.js";
 import type { RunAuthorization, RunAuthorizer } from "../execution/run-authorizer.js";
 import type { StagedInput } from "../execution/staged-input.js";
 import type { BioToolKeys } from "../tools/bio/keys.js";
@@ -29,7 +30,7 @@ import { type ResolveWorkspaceRoot } from "../workspace/paths.js";
 import { type ProfilerOutput } from "../schemas/data-profile-schemas.js";
 import { type DataProfileInputFile, type DataProfileResult } from "../state/index.js";
 /** The body's construction-time deps — closed over at registration. */
-export interface DataProfileDeps {
+export interface DataProfileDeps extends EnvironmentStorePaths {
     /** Operational logging seam; omitted falls back to no-op. */
     readonly logger?: Logger;
     readonly provider: ChatProvider;
@@ -52,18 +53,6 @@ export interface DataProfileDeps {
     readonly embedding: EmbeddingProvider;
     /** Absolute path to the skills tree (one subdirectory per skill). */
     readonly skillsDir: string;
-    /**
-     * Host path of the library store's `packages.txt`. Omit when the host mounts the
-     * store at the sandbox's own path; a host whose store is baked into the image must
-     * inject its extracted copy, or the profiler reads the inventory as unknown.
-     */
-    readonly packagesFile?: string;
-    /**
-     * Host path of the reference store. Omit only when none is provisioned: the
-     * profiler carries reference discovery, and without this it reports an installed
-     * store as absent.
-     */
-    readonly refStorePath?: string;
 }
 /**
  * Workflow input. JSON-serialisable — DBOS persists it as the workflow's

package/dist/tools/research/generate-plan.d.ts

@@ -27,8 +27,9 @@
 import type { Pool } from "pg";
 import { type ChatProvider } from "../../providers/types.js";
 import { type Tool } from "../define-tool.js";
+import type { EnvironmentStorePaths } from "../../config/environment-stores.js";
 import { type ResourcePolicy } from "../../config/resource-limits.js";
-export interface GeneratePlanDeps {
+export interface GeneratePlanDeps extends EnvironmentStorePaths {
     /** The LLM seam the planner loop runs on. */
     readonly provider: ChatProvider;
     /** Database pool — plan persistence and prior-plan loading. */
@@ -41,13 +42,6 @@ export interface GeneratePlanDeps {
      * default guidance and validation skips the ceiling check.
      */
     readonly resourcePolicy?: ResourcePolicy;
-    /**
-     * Host path of the reference store, giving the planner reference discovery.
-     * Absent, the tool reports the store as unavailable and the planner keeps
-     * planning as though nothing is guaranteed present — which is what the prompt
-     * already tells it to do.
-     */
-    readonly refStorePath?: string;
 }
 /** Build the `generate_plan` tool bound to its provider and pool. */
 export declare function createGeneratePlanTool(deps: GeneratePlanDeps): Tool;

package/dist/tools/research/generate-plan.js

@@ -32,6 +32,7 @@ import { runToTerminal } from "../../loop/run-to-terminal.js";
 import { passthroughStep } from "../../loop/run-step.js";
 import { forSubAgent, scopeResource } from "../../auth/types.js";
 import { defineTool } from "../define-tool.js";
+import { createListAvailablePackagesTool } from "../sandbox/list-available-packages.js";
 import { createListAvailableRefsTool } from "../sandbox/list-available-refs.js";
 import { createReportBlockerToolFor } from "../sandbox/report-blocker.js";
 import { DATA_PROFILE_ORIENTATION_MAX_CHARS, buildDataProfileOrientation } from "../../app/data-profile-orientation.js";
@@ -250,7 +251,10 @@ function fullyValidate(candidate, resourcePolicy) {
  * shared `holder` so the outer `execute` reads the terminal outcome after the
  * loop finishes.
  */
-function buildInnerTools(holder, persistCtx, pool, resourcePolicy, refStorePath) {
+function buildInnerTools(holder, persistCtx, pool, resourcePolicy, 
+// The two environment stores travel together as one bag rather than as a pair
+// of adjacent optional strings, which would be silently swappable at the call site.
+stores) {
     const validatePlanTool = defineTool({
         id: "validate_plan",
         description: "Dry-run a candidate plan and get back everything that is wrong with it. " +
@@ -354,12 +358,15 @@ function buildInnerTools(holder, persistCtx, pool, resourcePolicy, refStorePath)
             "incompatible with every available agent, etc.) — not for a plan you " +
             "could fix and submit.",
     });
-    // Reference discovery is non-terminal and read-only: it lets the planner check what
-    // reference data this environment actually holds before committing a step to needing
-    // it. It reads the store host-side, so no sandbox exists or is needed at plan time.
-    const listAvailableRefs = createListAvailableRefsTool(refStorePath === undefined ? {} : { refStorePath });
+    // Environment discovery is non-terminal and read-only: it lets the planner check what
+    // reference data this environment holds, and what a step will actually be able to
+    // import, before committing a step to needing either. Both read host-side, so no
+    // sandbox exists or is needed at plan time — which is the whole point, since a plan
+    // that assumes an absent package fails only once the run reaches that step.
+    const listAvailableRefs = createListAvailableRefsTool(stores.refStorePath === undefined ? {} : { refStorePath: stores.refStorePath });
+    const listAvailablePackages = createListAvailablePackagesTool(stores.packagesFile === undefined ? {} : { packagesFile: stores.packagesFile });
     const terminal = [submitPlanTool, requestClarificationTool, reportBlockerTool];
-    return { all: [validatePlanTool, listAvailableRefs, ...terminal], terminal };
+    return { all: [validatePlanTool, listAvailableRefs, listAvailablePackages, ...terminal], terminal };
 }
 /**
  * Translate the captured `PlannerOutcome` (plus any loop error) into the
@@ -491,7 +498,7 @@ export function createGeneratePlanTool(deps) {
                 analysisId,
                 parentPlanId: input.parentPlanId ?? null,
             };
-            const innerTools = buildInnerTools(holder, persistCtx, deps.pool, deps.resourcePolicy, deps.refStorePath);
+            const innerTools = buildInnerTools(holder, persistCtx, deps.pool, deps.resourcePolicy, deps);
             const planner = {
                 id: PLANNER_AGENT_ID,
                 systemPrompt: composeSystemPrompt(plannerInstructions(deps.resourcePolicy)),

package/dist/tools/sandbox/list-available-packages.d.ts

@@ -22,6 +22,7 @@
  * The file carries **names only — there are no version strings in it**, so this
  * tool reports presence and language track and cannot report a version.
  */
+import type { EnvironmentStorePaths } from "../../config/environment-stores.js";
 /** One language track of the store, in `packages.txt` section order. */
 export interface Section {
     /** The section heading verbatim, e.g. `R (CRAN)`, `Python (pip)`. */
@@ -75,16 +76,7 @@ export interface PackagesQuery {
  * is only the file read plus this call.
  */
 export declare function queryPackages(sections: readonly Section[], { names, query, language, limit }: PackagesQuery): PackagesResult;
-export interface ListAvailablePackagesDeps {
-    /**
-     * Path to the store's `packages.txt` AS THE HOST SEES IT. Defaults to the
-     * container path, which is correct only when the host mounts the same store.
-     * A host that does not — one whose store is baked into the sandbox image and
-     * never bind-mounted — must inject the path to its own extracted copy, or the
-     * read fails and every caller is told the inventory is unknown.
-     */
-    readonly packagesFile?: string;
-}
+export type ListAvailablePackagesDeps = Pick<EnvironmentStorePaths, "packagesFile">;
 /** Create the package inventory over a host-readable `packages.txt`. */
 export declare function createListAvailablePackagesTool(deps?: ListAvailablePackagesDeps): import("../define-tool.js").Tool<{
     names?: string[] | undefined;

package/dist/tools/sandbox/list-available-refs.d.ts

@@ -4,7 +4,10 @@
  * installs and user-added files alike). Narrow with `path`/`category`, filter
  * with `query`, cap with `limit`; every response carries `returned`/`total`/
  * `hasMore` and the `categories` present, so a listing is never an unbounded
- * dump. Symlinks are never followed; nothing can be downloaded at runtime.
+ * dump. Symlinks are never followed. This tool only ever READS the store: the
+ * analysis environment cannot fetch reference data, and staging more is the
+ * host's job — so an absent dataset is a fact about this moment, not a verdict
+ * that it is unobtainable.
  *
  * The store is read from the host filesystem at the embedder-supplied
  * `refStorePath` and reported at `/mnt/refs`, the container path sandboxes mount
@@ -20,14 +23,8 @@
  * only ever ENRICHES an entry — a file with no receipt and no catalog match is
  * still returned, because a user-provided store is as valid as a managed one.
  */
-export interface ListAvailableRefsDeps {
-    /**
-     * Host path of the reference store — the same bytes sandboxes see at
-     * `/mnt/refs`. Omitted (or absent on disk) means no store is provisioned,
-     * which is a normal state reported as `unavailable`, not an error.
-     */
-    readonly refStorePath?: string;
-}
+import type { EnvironmentStorePaths } from "../../config/environment-stores.js";
+export type ListAvailableRefsDeps = Pick<EnvironmentStorePaths, "refStorePath">;
 export interface ReferenceInventoryMetadata {
     readonly datasetId?: string;
     readonly version?: string;

package/dist/tools/sandbox/list-available-refs.js

@@ -4,7 +4,10 @@
  * installs and user-added files alike). Narrow with `path`/`category`, filter
  * with `query`, cap with `limit`; every response carries `returned`/`total`/
  * `hasMore` and the `categories` present, so a listing is never an unbounded
- * dump. Symlinks are never followed; nothing can be downloaded at runtime.
+ * dump. Symlinks are never followed. This tool only ever READS the store: the
+ * analysis environment cannot fetch reference data, and staging more is the
+ * host's job — so an absent dataset is a fact about this moment, not a verdict
+ * that it is unobtainable.
  *
  * The store is read from the host filesystem at the embedder-supplied
  * `refStorePath` and reported at `/mnt/refs`, the container path sandboxes mount
@@ -456,7 +459,8 @@ function collectCategories(entries) {
 }
 function renderContent(path, scan, entries) {
     if (scan.state === "unavailable")
-        return "No reference store is provisioned. Reference data cannot be downloaded at runtime; provision it through the host setup flow.";
+        return ("No reference store is provisioned. Nothing in the analysis environment can fetch reference data — the host stages it, " +
+            "so a store provisioned through the host's own path will show up on a later call.");
     if (scan.state === "not_found")
         return `Reference path does not exist: ${path}`;
     if (scan.state === "not_a_directory")
@@ -492,7 +496,8 @@ function renderContent(path, scan, entries) {
 export function createListAvailableRefsTool(deps) {
     return defineTool({
         id: "list_available_refs",
-        description: "Resolve reference data you need into a real path. Reports the reference data actually provisioned for this environment — the ONLY reference data that exists here; nothing can be downloaded at runtime. " +
+        description: "Resolve reference data you need into a real path. Reports the reference data provisioned for this environment right now — the only reference data an analysis script can open. " +
+            "Nothing inside the analysis environment reaches the network, so never write a download into a script. " +
             "Search by what the data IS, not by where you expect it: the store's directory layout is an installer detail and is not a stable interface. " +
             "Catalogued files come back with the organism, the format, and the file's internal shape (key columns, identifier space), so you can pick the right reader and the right species without opening the file first. " +
             "User-added files are returned too, with whatever labels exist — often none. Symlinks are never followed. " +
@@ -502,7 +507,9 @@ export function createListAvailableRefsTool(deps) {
             "`path` inspects one directory beneath /mnt/refs (a returned path, or store-relative) — drill in with it when a listing is truncated; " +
             '`category` is shorthand for a top-level group (e.g. "pathways", "regulatory-networks"), and the groups present come back in `categories`; ' +
             "`limit` caps the entries returned. The response carries `returned`, `total`, and `hasMore`, so truncation is never silent. " +
-            "An empty result means the data is genuinely absent — say so and proceed with what you have; do not guess a path. Provision additional files through the host setup flow.",
+            "An empty result means the dataset is absent right now — not that it is unobtainable. Say so; never guess a path, and never silently substitute a different dataset. " +
+            "The store is provisioned by the host and is NOT frozen: datasets can be added through the host's own provisioning path, and whatever is added shows up on a later call. " +
+            "So before you report a gap as permanent, check whether any tool you hold reaches that provisioning path — offer that route if one exists, and call the gap permanent only when none does.",
         inputSchema: ListAvailableRefsInputSchema,
         execute: async ({ path, category, query, limit }) => {
             // `category` is shorthand for a top-level path; an explicit `path` wins.

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.0",
+    "version": "0.7.2",
     "description": "Host-agnostic bioinformatics agent harness \u2014 hand-rolled agent loop, DBOS-durable workflows, sandboxed compute.",
     "license": "Apache-2.0",
     "type": "module",
@@ -40,6 +40,7 @@
         "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": {