@inflexa-ai/harness 0.39.0 → 0.39.2

package/dist/tasks/data-profile.js

@@ -19,7 +19,7 @@
  */
 import { DBOS, Error as DBOSErrors } from "@dbos-inc/dbos-sdk";
 import { randomUUID } from "node:crypto";
-import { err, ok } from "neverthrow";
+import { ResultAsync, err, ok } from "neverthrow";
 import { forStep, forSubAgent } from "../auth/types.js";
 import { createDataProfilerAgent } from "../agents/sandbox/data-profiler.js";
 import { runToTerminal } from "../loop/run-to-terminal.js";
@@ -345,14 +345,14 @@ export async function runDataProfileBody(input, deps) {
             return;
         }
         // 2. Register staged files in cortex_artifacts
-        await upsertArtifacts(deps.pool, stagedInputs.map((f) => ({
+        unwrapOrThrow(await upsertArtifacts(deps.pool, stagedInputs.map((f) => ({
             resourceId: analysisId,
             path: inputArtifactPath(f),
             hash: f.hash,
             size: f.size,
             role: "input",
             fileId: f.fileId,
-        })));
+        }))));
         const executionId = generateExecutionId(DATA_PROFILE_AGENT_ID);
         const workflowId = DBOS.workflowID ?? `${DATA_PROFILE_RUN_LITERAL}:${executionId}`;
         const childSession = forSubAgent(runSession, DATA_PROFILE_AGENT_ID);
@@ -636,6 +636,15 @@ function settleTerminalWrite(logger, analysisId, write, status) {
     }
     recordRunCompleted({ workflow: "data_profile", status, durationMs: elapsedSinceIso(write.startedAt) });
 }
+/** A one-line, user-facing description of a `DataProfileStartError`. */
+export function describeDataProfileStartError(e) {
+    switch (e.type) {
+        case "refused":
+            return `the profile run was not authorized: ${e.reason}`;
+        case "start_failed":
+            return `the profile workflow did not start: ${profileFailureReason(e.cause)}`;
+    }
+}
 /**
  * Resolve the `RunSession` the workflow runs under. Whether the authorization
  * is freshly minted (Cortex-owned) or reused (caller-owned) is decided by the
@@ -667,18 +676,14 @@ export function dataProfileWorkflowId(analysisId, nonce) {
     return `dataprofile:${analysisId}:${nonce}`;
 }
 /**
- * Authorize the run via the `RunAuthorizer` and start the data-profile workflow
- * under a per-attempt id `dataprofile:{analysisId}:{nonce}` — concurrent
- * triggers are already serialized by the ledger CAS. The caller has already
- * staged the inputs and supplied the manifest in `params.stagedInputs`; this
- * forwards it into the workflow input. Fire-and-forget: the handle result is
- * not awaited.
+ * Start the data-profile workflow under the authorization and a per-attempt id
+ * `dataprofile:{analysisId}:{nonce}` — concurrent triggers are already
+ * serialized by the ledger CAS. The caller has already staged the inputs and
+ * supplied the manifest in `params.stagedInputs`; this forwards it into the
+ * workflow input. The handle result is not awaited.
  */
-async function startDataProfileWorkflow(deps, params) {
-    const authorized = await authorizeDataProfile(deps, params);
-    if (authorized.isErr())
-        return err(authorized.error);
-    const { runSession, ownsMandate } = authorized.value; // oss-core-managed-ok
+async function startDataProfileWorkflow(deps, params, authorization) {
+    const { runSession, ownsMandate } = authorization; // oss-core-managed-ok
     const attemptNonce = randomUUID();
     await DBOS.startWorkflow(deps.workflow, {
         workflowID: dataProfileWorkflowId(params.analysisId, attemptNonce),
@@ -688,20 +693,29 @@ async function startDataProfileWorkflow(deps, params) {
         ownsMandate, // oss-core-managed-ok
         stagedInputs: params.stagedInputs,
     });
-    return ok(undefined);
 }
 /**
- * Dispatch a claimed profile, fire-and-forget. The claim already flipped the
- * row to `running`, thus a refused authorization and a rejected start each
- * settle the row as `failed`, and it never wedges at `running`.
+ * Authorize and start a claimed profile. The claim already flipped the row to
+ * `running`, thus a refused authorization and a failed start each settle the
+ * row as `failed` before the `err`, and the row never wedges at `running`. A
+ * rejected `authorize` promise is a defect of the host: the row is settled the
+ * same way, and the rejection passes through.
  */
 async function dispatchClaimedProfile(deps, params, phase) {
-    const started = await startDataProfileWorkflow(deps, params).catch(async (cause) => {
-        await compensateStartFailure(deps, params.analysisId, phase, cause);
-        return undefined;
+    const authorized = await Promise.resolve(authorizeDataProfile(deps, params)).catch(async (defect) => {
+        await compensateStartFailure(deps, params.analysisId, phase, defect);
+        throw defect;
     });
-    if (started?.isErr())
-        await refuseClaimedProfile(deps, params.analysisId, phase, started.error);
+    if (authorized.isErr()) {
+        await refuseClaimedProfile(deps, params.analysisId, phase, authorized.error);
+        return err({ type: "refused", reason: authorized.error.reason, suspend: authorized.error.kind === "suspended" });
+    }
+    const started = await ResultAsync.fromPromise(startDataProfileWorkflow(deps, params, authorized.value), (cause) => cause);
+    if (started.isErr()) {
+        await compensateStartFailure(deps, params.analysisId, phase, started.error);
+        return err({ type: "start_failed", cause: started.error });
+    }
+    return ok(undefined);
 }
 /**
  * Attempt to claim and run data profiling for an analysis, then start the workflow
@@ -720,70 +734,85 @@ async function dispatchClaimedProfile(deps, params, phase) {
  * `"completed"`. An empty manifest against a seed that names files is a divergence
  * between the caller and the ledger, and the trigger refuses it.
  *
- * Returns what happened, so the caller can surface it (e.g. in the seed response).
+ * Returns what happened, so the caller can surface it (e.g. in the seed response). A
+ * failed ledger read or claim is the `err`. The dispatch settles its own row, thus a
+ * refusal or a failed start after a claim shows on the ledger only.
  */
-export async function triggerDataProfile(deps, params) {
+export function triggerDataProfile(deps, params) {
+    return new ResultAsync(claimAndDispatchProfile(deps, params));
+}
+async function claimAndDispatchProfile(deps, params) {
     const logger = (deps.logger ?? createNoopLogger()).named("data-profile").with({ analysisId: params.analysisId });
     const { analysisId } = params;
-    try {
-        // ADVISORY pre-check, not the enforcement — the claim CAS carries the same seed
-        // conjunct (see `SEEDED` in state/data-profile.ts) and is what actually makes a
-        // seedless `running` row impossible. This read exists only to name the cause: on
-        // the ordinary non-racing path it turns an opaque "no claim matched" into a
-        // precise reason. An empty array is not a seed — it names zero files. Reads via
-        // `loadSeedInputFileIds`, which returns null for BOTH a missing analysis row and
-        // a NULL-seed row (`loadDataProfileStatus` would hide the seed of a cleared row).
-        const seeded = unwrapOrThrow(await loadSeedInputFileIds(deps.pool, analysisId));
-        if (params.stagedInputs.length === 0) {
-            // The trigger validates the manifest it is about to dispatch against the ledger
-            // seed. A seeded row profiled against an EMPTY manifest would claim `running` and
-            // then hit the body's empty-manifest path, and complete with a NULL result while
-            // the seed still names files. Refuse the divergence before any claim.
-            if (seeded !== null && seeded.length > 0) {
-                logger.error("trigger rejected: empty manifest dispatched against a non-empty seed", { seededCount: seeded.length });
-                return "failed";
-            }
-            // The analysis has no input files, so there is nothing to profile. The row is
-            // `completed` at once, with no workflow. The CAS carries the same seed
-            // predicate as this pre-read, so a seed upsert that lands in between cannot be
-            // hidden behind a finished profile: the stamp refuses, and the status read
-            // below names the cause.
-            if (unwrapOrThrow(await completeEmptyDataProfile(deps.pool, analysisId)))
-                return "completed";
-            const current = unwrapOrThrow(await loadDataProfileStatus(deps.pool, analysisId));
-            if (current?.status === "running")
-                return "already_running";
-            logger.error("trigger rejected: empty-set completion refused (no analysis row, or the seed now names files)");
-            return "failed";
-        }
-        // A non-empty manifest against a seed that names no file: the caller skipped the
-        // seed, or the analysis row is missing. Name the cause before any claim.
-        if (seeded === null || seeded.length === 0) {
-            logger.error("trigger rejected: no seeded input set (missing analysis row or caller skipped seeding)");
-            return "failed";
-        }
-        const started = unwrapOrThrow(await tryStartDataProfile(deps.pool, analysisId));
-        if (started) {
-            void dispatchClaimedProfile(deps, params, "Run");
-            return "started";
+    // ADVISORY pre-check, not the enforcement — the claim CAS carries the same seed
+    // conjunct (see `SEEDED` in state/data-profile.ts) and is what actually makes a
+    // seedless `running` row impossible. This read exists only to name the cause: on
+    // the ordinary non-racing path it turns an opaque "no claim matched" into a
+    // precise reason. An empty array is not a seed — it names zero files. Reads via
+    // `loadSeedInputFileIds`, which returns null for BOTH a missing analysis row and
+    // a NULL-seed row (`loadDataProfileStatus` would hide the seed of a cleared row).
+    const seedRead = await loadSeedInputFileIds(deps.pool, analysisId);
+    if (seedRead.isErr())
+        return err(seedRead.error);
+    const seeded = seedRead.value;
+    if (params.stagedInputs.length === 0) {
+        // The trigger validates the manifest it is about to dispatch against the ledger
+        // seed. A seeded row profiled against an EMPTY manifest would claim `running` and
+        // then hit the body's empty-manifest path, and complete with a NULL result while
+        // the seed still names files. Refuse the divergence before any claim.
+        if (seeded !== null && seeded.length > 0) {
+            logger.error("trigger rejected: empty manifest dispatched against a non-empty seed", { seededCount: seeded.length });
+            return ok("failed");
         }
-        const restarted = unwrapOrThrow(await tryRerunDataProfile(deps.pool, analysisId));
-        if (restarted) {
-            void dispatchClaimedProfile(deps, params, "Re-run");
-            return "restarted";
-        }
-        const status = unwrapOrThrow(await loadDataProfileStatus(deps.pool, analysisId));
-        if (status?.status === "running")
-            return "already_running";
-        return "failed";
+        // The analysis has no input files, so there is nothing to profile. The row is
+        // `completed` at once, with no workflow. The CAS carries the same seed
+        // predicate as this pre-read, so a seed upsert that lands in between cannot be
+        // hidden behind a finished profile: the stamp refuses, and the status read
+        // below names the cause.
+        const completed = await completeEmptyDataProfile(deps.pool, analysisId);
+        if (completed.isErr())
+            return err(completed.error);
+        if (completed.value)
+            return ok("completed");
+        const current = await loadDataProfileStatus(deps.pool, analysisId);
+        if (current.isErr())
+            return err(current.error);
+        if (current.value?.status === "running")
+            return ok("already_running");
+        logger.error("trigger rejected: empty-set completion refused (no analysis row, or the seed now names files)");
+        return ok("failed");
     }
-    catch (err) {
-        logger.error("trigger error", logger.errorFields(err));
-        return "failed";
+    // A non-empty manifest against a seed that names no file: the caller skipped the
+    // seed, or the analysis row is missing. Name the cause before any claim.
+    if (seeded === null || seeded.length === 0) {
+        logger.error("trigger rejected: no seeded input set (missing analysis row or caller skipped seeding)");
+        return ok("failed");
+    }
+    const started = await tryStartDataProfile(deps.pool, analysisId);
+    if (started.isErr())
+        return err(started.error);
+    if (started.value) {
+        dispatchInBackground(deps, params, "Run");
+        return ok("started");
+    }
+    const restarted = await tryRerunDataProfile(deps.pool, analysisId);
+    if (restarted.isErr())
+        return err(restarted.error);
+    if (restarted.value) {
+        dispatchInBackground(deps, params, "Re-run");
+        return ok("restarted");
     }
+    const status = await loadDataProfileStatus(deps.pool, analysisId);
+    if (status.isErr())
+        return err(status.error);
+    return ok(status.value?.status === "running" ? "already_running" : "failed");
+}
+/** The dispatch settles the row on each arm and logs a defect, thus the trigger keeps no outcome of it. */
+function dispatchInBackground(deps, params, phase) {
+    void dispatchClaimedProfile(deps, params, phase).catch(() => undefined);
 }
 /**
- * Compensate a fire-and-forget start that rejected. The ledger CAS in
+ * Compensate a start that failed after the claim. The ledger CAS in
  * `tryStart`/`tryRerun`/`tryRetry` already flipped the row to `running`; if the
  * dispatch never landed a workflow, DBOS has nothing to recover, so without
  * this the row would sit at `running` forever and every later trigger would
@@ -827,23 +856,13 @@ async function failClaimedProfile(deps, analysisId, phase, reason) {
 /**
  * Start the data-profile workflow for an already-claimed analysis (the retry
  * route claims via `tryRetryDataProfile`, then calls this). The caller does not
- * await the workflow's completion, but a start that rejects compensates the
- * ledger (see {@link compensateStartFailure}) before re-throwing, so a caller's
- * own `.catch` still observes the error and the row never wedges at `running`.
- * A refused authorization fails the row with the reason of the host, and the
- * promise resolves: the row is where a caller reads the outcome.
+ * wait for the completion of the workflow. A refused authorization and a failed
+ * start each settle the row as `failed` before the `err` (see
+ * {@link dispatchClaimedProfile}), thus a caller that minted an authorization
+ * can revoke it.
  */
-export async function runDataProfile(deps, params) {
-    let started;
-    try {
-        started = await startDataProfileWorkflow(deps, params);
-    }
-    catch (cause) {
-        await compensateStartFailure(deps, params.analysisId, "Retry", cause);
-        throw cause;
-    }
-    if (started.isErr())
-        await refuseClaimedProfile(deps, params.analysisId, "Retry", started.error);
+export function runDataProfile(deps, params) {
+    return new ResultAsync(dispatchClaimedProfile(deps, params, "Retry"));
 }
 /**
  * Concise, UI-safe failure reason. `data_profile_error` is surfaced verbatim

package/dist/tools/ad-hoc-router.js

@@ -176,8 +176,9 @@ export async function routeAdHocRequest(deps, input) {
                     content: `Request:\n${input.request}\n\nPersisted data-profile orientation:\n${orientation}\n\nEligible specialists:\n${catalog}`,
                 },
             ],
+            // No forced tool choice: some Claude models reject it with a
+            // 400. A reply without the call falls back below as `malformed`.
             tools: routeTool(),
-            toolChoice: { type: "tool", toolName: "submit_route" },
         }, forSubAgent(input.session, AD_HOC_ROUTER_AGENT_ID), signal));
         const call = Array.isArray(response.message.content)
             ? response.message.content.find((part) => part.type === "tool-call" && part.toolName === "submit_route")

package/dist/tools/research/generate-analogy-report.js

@@ -228,10 +228,8 @@ export function createGenerateAnalogyReportTool(deps) {
             if (directParse.ok)
                 return ok(directParse.value);
             // Slow path: a single-shot conversion call (no tools) transforms the
-            // raw output into a valid envelope. The harness anthropic provider
-            // silently drops `temperature` on 4.7+ models, so an explicit
-            // Sonnet-vs-Opus split is unnecessary — the parse+validate+envelope
-            // cascade below is the real safety net.
+            // raw output into a valid envelope. The parse+validate+envelope
+            // cascade below is the safety net.
             try {
                 const reply = unwrapOrThrow(await deps.provider.chat({
                     tools: {},

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

@@ -65,9 +65,9 @@ const PLANNER_AGENT_ID = "planner";
  * path and submits the plan that it had, not the plan that it was building.
  * Thus the wall-clock guard, not this number, is what bounds the worst case.
  */
-const PLANNER_MAX_ITERATIONS = 200;
+const PLANNER_MAX_ITERATIONS = 300;
 /** Wall-clock guard for a single plan-generation invocation. */
-const PLAN_TIMEOUT_MS = 600_000;
+const PLAN_TIMEOUT_MS = 1_800_000;
 // ── Diagnostic bounds ───────────────────────────────────────────────
 //
 // This tool runs on `passthroughStep`: it writes no ledger row and owns no
@@ -674,8 +674,8 @@ function buildPlannerSearchTools(deps) {
         queryDocsTool,
         // The environment itself. The seed already carries a rendered census of
         // both stores. These two tools are for the narrow second look: one
-        // collection of the reference store, or one package name that a step is
-        // about to import.
+        // collection of the reference store, or one batch of the package names
+        // that the census leaves unclear.
         createListAvailableRefsTool(deps.refStorePath === undefined ? {} : { refStorePath: deps.refStorePath }),
         // The planner is a conversation surface, thus the pool-scope reader binds
         // when the embedder gives one, and the answer names what the store HOLDS.
@@ -894,10 +894,9 @@ export function createGeneratePlanTool(deps) {
                     emit: ctx.emit,
                     runStep: passthroughStep,
                     resolved: () => holder.outcome !== null,
-                    // Planner prose is unusable: every meaningful outcome is
-                    // a tool call, and the terminal predicate stops the loop
-                    // as soon as one is recorded.
-                    toolChoice: "required",
+                    // No forced tool choice: some Claude models reject it with a
+                    // 400. The prompt names the terminal tools, and the salvage
+                    // turn below recovers a run that ends on prose.
                     logger,
                     usageRecorder: deps.usageRecorder,
                     // Fold the planner's calls into the turn total the root loop reports.

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

@@ -515,8 +515,7 @@ export function createListAvailableRefsTool(deps) {
             '`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 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.",
+            "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.",
         inputSchema: ListAvailableRefsInputSchema,
         // `execute` resolves `path ?? category` for the subtree it inspects, and
         // it ignores `category` when `path` is present. `query` is an ADDITIVE

package/dist/workflows/execute-analysis.js

@@ -69,7 +69,7 @@
  *       via `inspectRun`)
  */
 import { DBOS, Error as DBOSErrors } from "@dbos-inc/dbos-sdk";
-import { ResultAsync, err, ok } from "neverthrow";
+import { err, ok } from "neverthrow";
 import { mkdir } from "node:fs/promises";
 import { join } from "node:path";
 import { forStep } from "../auth/types.js";
@@ -286,7 +286,7 @@ async function collectUpstreamHandoffs(args) {
     const handoffs = [];
     for (const summary of summaries) {
         const outputDir = stepSubdir(runStepDir(runId, summary.stepId), "output");
-        const artifacts = await queryStepArtifactPaths(pool, analysisId, runId, summary.stepId, MAX_UPSTREAM_ARTIFACTS);
+        const artifacts = unwrapOrThrow(await queryStepArtifactPaths(pool, analysisId, runId, summary.stepId, MAX_UPSTREAM_ARTIFACTS));
         handoffs.push({
             stepId: summary.stepId,
             agentId: summary.agentId,
@@ -1124,7 +1124,9 @@ async function collectAndComplete(args) {
     // beat the CLI's poll-and-shutdown). These branches only fan out the UI stream part, whose
     // completed/failed shapes genuinely differ — the provenance record does not.
     if (status === "completed" || status === "partial") {
-        const artifactCount = await DBOS.runStep(async () => await ResultAsync.fromPromise(countArtifactsForRun(deps.pool, input.analysisId, runId), () => "the artifact count failed").unwrapOr(0), { name: "count-run-artifacts" });
+        const artifactCount = await DBOS.runStep(async () => await countArtifactsForRun(deps.pool, input.analysisId, runId).unwrapOr(0), {
+            name: "count-run-artifacts",
+        });
         await emitStreamPart({
             type: "data-run-completed",
             runId,

package/package.json

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