@inflexa-ai/harness 0.28.0 → 0.28.1

package/dist/execution/artifact-registration.js

@@ -49,6 +49,15 @@ logger = createNoopLogger()) {
     await upsertArtifacts(db, localEntries);
     const localPaths = new Set(localEntries.map((e) => e.path));
     const result = await registry.register(input, session);
+    // The registry excluded these from `failed` by its own severity judgement, so
+    // this is their only record. Logged here rather than left to the registry:
+    // the seam is implementable by an embedder, and a rejection does not get to
+    // go unrecorded because one implementation chose not to log it.
+    if (result.notCounted && result.notCounted.length > 0) {
+        log.warn("registry rejections excluded from the failure count", {
+            rejected: result.notCounted.map((f) => ({ path: f.path, error: f.error })),
+        });
+    }
     let externalRegistered = 0;
     for (const reg of result.registered) {
         // Skip files the registry also returned that we didn't upsert locally

package/dist/execution/artifact-registry.d.ts

@@ -64,6 +64,20 @@ export interface ExternalRegistrationResult {
      * back a whole batch (`failed` then carries one summary entry).
      */
     failedCount: number;
+    /**
+     * Rejections the registry judged non-terminal and deliberately kept out of
+     * `failed`/`failedCount`: rows it never attempted, so nothing registered and
+     * no bytes are at risk. Reported rather than dropped — excluding a rejection
+     * decides only that it is not worth failing a step over, never that it goes
+     * unrecorded. Keeping them out of `failed` is what lets the fail-fast message
+     * list only the paths that actually cost the step something; surfacing them
+     * here is what keeps the registry's verdict checkable against what the
+     * external system actually said.
+     */
+    notCounted?: ReadonlyArray<{
+        path: string;
+        error: string;
+    }>;
 }
 export interface ArtifactRegistry {
     /**

package/dist/execution/post-step-pipeline.d.ts

@@ -56,10 +56,12 @@ export declare function generateStepSummaryAndWrite(deps: PostStepPipelineDeps,
 /**
  * Reconcile the manifest against disk (drop phantoms, rehash) and register the
  * survivors with the local ledger + the injected `ArtifactRegistry`. Fail-fast
- * (see the artifact-manifest spec): a non-zero `externalFailed` is a persistent rejection that
- * orphans real outputs, so it throws with the per-file detail (the OSS
- * filesystem registry returns `externalFailed: 0`, so it never trips). Returns
- * the reconciled manifest.
+ * (see the artifact-manifest spec): `externalFailed` counts only the terminal
+ * rejections — a rejected output whose bytes exist nowhere but the step tree,
+ * plus anything rejected as a consequence of one — so a non-zero count means
+ * real outputs went unregistered, and it throws with the per-file detail (the
+ * OSS filesystem registry returns `externalFailed: 0`, so it never trips).
+ * Returns the reconciled manifest.
  */
 export declare function reconcileAndRegisterStepArtifacts(deps: PostStepPipelineDeps, postCtx: PostStepContext, manifest: readonly ArtifactManifestEntry[]): Promise<readonly ArtifactManifestEntry[]>;
 /**

package/dist/execution/post-step-pipeline.js

@@ -95,10 +95,12 @@ export async function generateStepSummaryAndWrite(deps, postCtx, manifest) {
 /**
  * Reconcile the manifest against disk (drop phantoms, rehash) and register the
  * survivors with the local ledger + the injected `ArtifactRegistry`. Fail-fast
- * (see the artifact-manifest spec): a non-zero `externalFailed` is a persistent rejection that
- * orphans real outputs, so it throws with the per-file detail (the OSS
- * filesystem registry returns `externalFailed: 0`, so it never trips). Returns
- * the reconciled manifest.
+ * (see the artifact-manifest spec): `externalFailed` counts only the terminal
+ * rejections — a rejected output whose bytes exist nowhere but the step tree,
+ * plus anything rejected as a consequence of one — so a non-zero count means
+ * real outputs went unregistered, and it throws with the per-file detail (the
+ * OSS filesystem registry returns `externalFailed: 0`, so it never trips).
+ * Returns the reconciled manifest.
  */
 export async function reconcileAndRegisterStepArtifacts(deps, postCtx, manifest) {
     const { input, session, lineageCollector } = postCtx;
@@ -122,11 +124,18 @@ export async function reconcileAndRegisterStepArtifacts(deps, postCtx, manifest)
         collector: lineageCollector,
     }, session, deps.logger);
     if (reg.externalFailed > 0) {
-        const wholeActivityFailed = reg.externalRegistered === 0;
+        // The registry commits per leaf and per activity, so accepted and rejected
+        // rows arriving together is ordinary and `externalRegistered` is what
+        // genuinely landed. Zero of it means this batch registered nothing at all:
+        // no row carries an `artifact_id`, so the byte-sync that follows selects
+        // none of them and every output stays local-only. That reads as a payload-
+        // or credential-shaped rejection rather than a per-file one, so it rides on
+        // the message and as its own field.
+        const noneRegistered = reg.externalRegistered === 0;
         const detail = reg.failureDetails.map((f) => `${f.path}: ${f.error}`).join("\n  ");
         const msg = `[post-step.reconcile] external registration failed for ${input.stepId}: ` +
-            `${reg.externalFailed} row(s) rejected, ${reg.externalRegistered}/${reg.localCount} local artifact(s) registered` +
-            (wholeActivityFailed ? " (WHOLE ACTIVITY ROLLED BACK — outputs orphaned)" : "") +
+            `${reg.externalFailed} terminal rejection(s), ${reg.externalRegistered}/${reg.localCount} local artifact(s) registered` +
+            (noneRegistered ? " (nothing in this batch registered)" : "") +
             (detail ? `\n  ${detail}` : "");
         // Logged as fields as well as thrown: the throw reaches `failStep` as one
         // opaque string, so the per-path rejections are only queryable from here.
@@ -138,7 +147,7 @@ export async function reconcileAndRegisterStepArtifacts(deps, postCtx, manifest)
             externalFailed: reg.externalFailed,
             externalRegistered: reg.externalRegistered,
             localCount: reg.localCount,
-            wholeActivityFailed,
+            noneRegistered,
             failures: reg.failureDetails,
         });
         throw new Error(msg);

package/dist/workflows/sandbox-step.js

@@ -500,16 +500,46 @@ export async function runSandboxStepBody(input, deps) {
     // outputs, so it fails the step loudly instead of finishing green. Transient
     // managed-root errors are already retried in the client, so anything thrown here is
     // persistent — tear down, mark failed, and re-raise so the parent's fail-fast
-    // cascade fires (mirrors the agent-loop failure path).
+    // cascade fires (mirrors the agent-loop failure path). The two operations are
+    // sequenced independently: byte-sync is attempted on both arms, so a rejected
+    // registration still uploads the bytes of whatever DID register.
     await emitActivity("persisting", "Registering artifacts");
+    // A bare call, deliberately not `DBOS.runStep`-wrapped: it is reachable from
+    // two arms below, and a checkpointed step reached from a conditional arm
+    // would shift the body's function-ID sequence between the two paths (see the
+    // harness-durable-runtime spec).
+    const syncStepArtifacts = () => deps.artifactRegistry.sync({
+        resourceId: input.analysisId,
+        runId: input.runId,
+        stepId: input.stepId,
+    }, session);
     let reconciledManifest;
     try {
         reconciledManifest = await reconcileAndRegisterStepArtifacts(deps, postCtx, manifest);
-        await deps.artifactRegistry.sync({
-            resourceId: input.analysisId,
-            runId: input.runId,
-            stepId: input.stepId,
-        }, session);
+    }
+    catch (registrationErr) {
+        // Registration and byte-sync are independent, and a registry rejection is
+        // partial: the rows that DID register carry `artifact_id` with `file_id`
+        // still NULL, which is exactly what `queryUnsyncedStepArtifacts` selects.
+        // Syncing anyway uploads their bytes (rows that never registered are not
+        // selected, so this stays idempotent under re-execution); skipping it is
+        // what strands them registered-but-byteless.
+        try {
+            await syncStepArtifacts();
+        }
+        catch (syncErr) {
+            // A cancellation is control-flow, not a sync failure — re-raise it
+            // verbatim, as every other stage in this body does. Any real failure
+            // is swallowed so it cannot displace the registration rejection as the
+            // step's cause; this record is the only account of it.
+            if (syncErr instanceof DBOSErrors.DBOSWorkflowCancelledError)
+                throw syncErr;
+            logger.named("post-step.sync").warn("failed after a registration rejection (non-fatal)", logger.errorFields(syncErr));
+        }
+        throw await failStep("lineage_attestation", registrationErr);
+    }
+    try {
+        await syncStepArtifacts();
     }
     catch (err) {
         throw await failStep("lineage_attestation", err);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@inflexa-ai/harness",
-    "version": "0.28.0",
+    "version": "0.28.1",
     "description": "Host-agnostic bioinformatics agent harness — hand-rolled agent loop, DBOS-durable workflows, sandboxed compute.",
     "license": "Apache-2.0",
     "type": "module",