@inflexa-ai/harness 0.35.2 → 0.35.3

package/dist/lib/otel-spans.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Span policy of the harness TracerProvider: which DBOS traces are recorded,
+ * which spans reach the exporter, and the names the exported spans carry.
+ *
+ * DBOS names a workflow span after the registered workflow and a step span
+ * after the step function, and it runs each body under its span, so every
+ * child (a step, a patched fetch, a pg query) sits under the workflow span.
+ * Three shapes of that output are noise in a trace store, and each is stopped
+ * in the process, before export, rather than in a collector downstream. The
+ * decisions live where the workflows and steps are written; this module holds
+ * the mechanism only:
+ *
+ * - A module that registers a housekeeping workflow declares it untraced with
+ *   `untracedWorkflow(name)` next to its registration. The sampler drops a
+ *   root span that carries such a name at creation, and `ParentBased`
+ *   sampling carries the decision to every child.
+ * - A replayed step re-emits its span with `cached=true`, which DBOS sets
+ *   after the span has started. A sampler cannot see that, so
+ *   `DbosSpanProcessor` drops the span at `onEnd`.
+ * - A step whose DBOS name embeds an id calls `stableSpan` as the first
+ *   statement of its body. The helper renames the active DBOS span to the
+ *   stable prefix and puts the id in an `inflexa.*` attribute. The DBOS step
+ *   name itself is untouched: DBOS compares it against the recorded name on
+ *   replay and throws `DBOSUnexpectedStepError` on a mismatch, so a rename
+ *   would break every workflow in flight across a deploy.
+ */
+import { type Attributes, type Context } from "@opentelemetry/api";
+import { type ReadableSpan, type Sampler, type Span, type SpanProcessor } from "@opentelemetry/sdk-trace-base";
+/**
+ * Declare a registered DBOS workflow untraced: no root span for it is
+ * recorded, and no child span under it. Call it next to the
+ * `DBOS.registerWorkflow` that gives the workflow the same name.
+ */
+export declare function untracedWorkflow(name: string): void;
+/**
+ * The sampler of the harness TracerProvider. A root span named after an
+ * untraced workflow is not recorded; every other root is. A span with a parent
+ * takes the parent's decision (the standard `ParentBased` behaviour), so a DBOS
+ * step, a fetch, or a pg span under a dropped root is dropped with it, and a
+ * remote parent (an inbound `traceparent`) is honoured as usual.
+ */
+export declare function createHarnessSampler(): Sampler;
+/** The plan step id a `compose-step-seed` step carries. */
+export declare const ATTR_INFLEXA_STEP_ID = "inflexa.step_id";
+/** The provider tool-use id of a tool step. */
+export declare const ATTR_INFLEXA_TOOL_USE_ID = "inflexa.tool_use_id";
+/** The exec id (`${workflowId}:${stepId}:${fnId}`) of a sandbox exec step. */
+export declare const ATTR_INFLEXA_EXEC_ID = "inflexa.exec_id";
+/** The 1-based attempt counter of a sandbox poll, pull, or liveness-probe step. */
+export declare const ATTR_INFLEXA_ATTEMPT = "inflexa.attempt";
+/** The per-item key (a ChEMBL or NCT id) of a target-assessment fan-out step. */
+export declare const ATTR_INFLEXA_FANOUT_KEY = "inflexa.fanout_key";
+/**
+ * Rename the DBOS span of the step that is running to `name` and put its id
+ * in `attributes`. Call it as the first statement of a step body whose DBOS
+ * name embeds an id, with that DBOS name as `dbosName`.
+ *
+ * DBOS runs the body under its span, so with tracing on the active span is
+ * the step span. With tracing off DBOS opens no span, and the active span, if
+ * there is one, belongs to whoever started the workflow or the chat turn. The
+ * helper therefore renames a span only when its name is `dbosName`, and it
+ * leaves a missing or non-recording span alone.
+ */
+export declare function stableSpan(dbosName: string, name: string, attributes: Attributes): void;
+/**
+ * Sits in front of the exporting processor and forwards every span except a
+ * replayed one (`cached=true`), which it drops at `onEnd`.
+ */
+export declare class DbosSpanProcessor implements SpanProcessor {
+    private readonly next;
+    constructor(next: SpanProcessor);
+    onStart(span: Span, parentContext: Context): void;
+    onEnding(span: Span): void;
+    onEnd(span: ReadableSpan): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}

package/dist/lib/otel-spans.js

@@ -0,0 +1,123 @@
+/**
+ * Span policy of the harness TracerProvider: which DBOS traces are recorded,
+ * which spans reach the exporter, and the names the exported spans carry.
+ *
+ * DBOS names a workflow span after the registered workflow and a step span
+ * after the step function, and it runs each body under its span, so every
+ * child (a step, a patched fetch, a pg query) sits under the workflow span.
+ * Three shapes of that output are noise in a trace store, and each is stopped
+ * in the process, before export, rather than in a collector downstream. The
+ * decisions live where the workflows and steps are written; this module holds
+ * the mechanism only:
+ *
+ * - A module that registers a housekeeping workflow declares it untraced with
+ *   `untracedWorkflow(name)` next to its registration. The sampler drops a
+ *   root span that carries such a name at creation, and `ParentBased`
+ *   sampling carries the decision to every child.
+ * - A replayed step re-emits its span with `cached=true`, which DBOS sets
+ *   after the span has started. A sampler cannot see that, so
+ *   `DbosSpanProcessor` drops the span at `onEnd`.
+ * - A step whose DBOS name embeds an id calls `stableSpan` as the first
+ *   statement of its body. The helper renames the active DBOS span to the
+ *   stable prefix and puts the id in an `inflexa.*` attribute. The DBOS step
+ *   name itself is untouched: DBOS compares it against the recorded name on
+ *   replay and throws `DBOSUnexpectedStepError` on a mismatch, so a rename
+ *   would break every workflow in flight across a deploy.
+ */
+import { trace } from "@opentelemetry/api";
+import { ParentBasedSampler, SamplingDecision, } from "@opentelemetry/sdk-trace-base";
+/**
+ * Names of the DBOS workflows whose traces are not recorded. A registering
+ * module adds its own name at registration, which runs at boot inside
+ * `assembleCoreRuntime`, before `DBOS.launch` starts the first workflow. The
+ * sampler reads the set on every root span, so the set is complete before it
+ * is consulted, and a name added later applies from the next root span on.
+ */
+const untracedWorkflowNames = new Set();
+/**
+ * Declare a registered DBOS workflow untraced: no root span for it is
+ * recorded, and no child span under it. Call it next to the
+ * `DBOS.registerWorkflow` that gives the workflow the same name.
+ */
+export function untracedWorkflow(name) {
+    untracedWorkflowNames.add(name);
+}
+/** Root decision only: `NOT_RECORD` for an untraced workflow, `RECORD_AND_SAMPLED` for every other root. */
+class UntracedWorkflowRootSampler {
+    shouldSample(_context, _traceId, spanName) {
+        return {
+            decision: untracedWorkflowNames.has(spanName) ? SamplingDecision.NOT_RECORD : SamplingDecision.RECORD_AND_SAMPLED,
+        };
+    }
+    toString() {
+        return "UntracedWorkflowRootSampler";
+    }
+}
+/**
+ * The sampler of the harness TracerProvider. A root span named after an
+ * untraced workflow is not recorded; every other root is. A span with a parent
+ * takes the parent's decision (the standard `ParentBased` behaviour), so a DBOS
+ * step, a fetch, or a pg span under a dropped root is dropped with it, and a
+ * remote parent (an inbound `traceparent`) is honoured as usual.
+ */
+export function createHarnessSampler() {
+    return new ParentBasedSampler({ root: new UntracedWorkflowRootSampler() });
+}
+/** The plan step id a `compose-step-seed` step carries. */
+export const ATTR_INFLEXA_STEP_ID = "inflexa.step_id";
+/** The provider tool-use id of a tool step. */
+export const ATTR_INFLEXA_TOOL_USE_ID = "inflexa.tool_use_id";
+/** The exec id (`${workflowId}:${stepId}:${fnId}`) of a sandbox exec step. */
+export const ATTR_INFLEXA_EXEC_ID = "inflexa.exec_id";
+/** The 1-based attempt counter of a sandbox poll, pull, or liveness-probe step. */
+export const ATTR_INFLEXA_ATTEMPT = "inflexa.attempt";
+/** The per-item key (a ChEMBL or NCT id) of a target-assessment fan-out step. */
+export const ATTR_INFLEXA_FANOUT_KEY = "inflexa.fanout_key";
+/**
+ * Rename the DBOS span of the step that is running to `name` and put its id
+ * in `attributes`. Call it as the first statement of a step body whose DBOS
+ * name embeds an id, with that DBOS name as `dbosName`.
+ *
+ * DBOS runs the body under its span, so with tracing on the active span is
+ * the step span. With tracing off DBOS opens no span, and the active span, if
+ * there is one, belongs to whoever started the workflow or the chat turn. The
+ * helper therefore renames a span only when its name is `dbosName`, and it
+ * leaves a missing or non-recording span alone.
+ */
+export function stableSpan(dbosName, name, attributes) {
+    const span = trace.getActiveSpan();
+    if (span === undefined || !span.isRecording())
+        return;
+    // The API `Span` has no name accessor; the SDK span the provider hands out does.
+    if (span.name !== dbosName)
+        return;
+    span.updateName(name);
+    span.setAttributes(attributes);
+}
+/**
+ * Sits in front of the exporting processor and forwards every span except a
+ * replayed one (`cached=true`), which it drops at `onEnd`.
+ */
+export class DbosSpanProcessor {
+    next;
+    constructor(next) {
+        this.next = next;
+    }
+    onStart(span, parentContext) {
+        this.next.onStart(span, parentContext);
+    }
+    onEnding(span) {
+        this.next.onEnding?.(span);
+    }
+    onEnd(span) {
+        if (span.attributes.cached === true)
+            return;
+        this.next.onEnd(span);
+    }
+    forceFlush() {
+        return this.next.forceFlush();
+    }
+    shutdown() {
+        return this.next.shutdown();
+    }
+}

package/dist/lib/otel.d.ts

@@ -5,7 +5,12 @@
  * so the bundler cannot tree-shake it (side-effect-only imports get dropped).
  *
  * Traces: NodeTracerProvider exports to OTLP when OTEL_EXPORTER_OTLP_ENDPOINT
- *         is set.
+ *         is set. The provider carries the span policy of otel-spans.ts: the
+ *         root span of a workflow declared with `untracedWorkflow` is not
+ *         recorded (and its children with it), a replayed `cached=true` span
+ *         is dropped before export, and a step body that calls `stableSpan`
+ *         is exported under a stable name with its id in an `inflexa.*`
+ *         attribute.
  *
  * Metrics: MeterProvider exports to OTLP when OTEL_EXPORTER_OTLP_ENDPOINT is
  *          set and OTEL_METRICS_EXPORTER is not `none`. The export interval is

package/dist/lib/otel.js

@@ -5,7 +5,12 @@
  * so the bundler cannot tree-shake it (side-effect-only imports get dropped).
  *
  * Traces: NodeTracerProvider exports to OTLP when OTEL_EXPORTER_OTLP_ENDPOINT
- *         is set.
+ *         is set. The provider carries the span policy of otel-spans.ts: the
+ *         root span of a workflow declared with `untracedWorkflow` is not
+ *         recorded (and its children with it), a replayed `cached=true` span
+ *         is dropped before export, and a step body that calls `stableSpan`
+ *         is exported under a stable name with its id in an `inflexa.*`
+ *         attribute.
  *
  * Metrics: MeterProvider exports to OTLP when OTEL_EXPORTER_OTLP_ENDPOINT is
  *          set and OTEL_METRICS_EXPORTER is not `none`. The export interval is
@@ -25,6 +30,7 @@
  */
 import { context, propagation, metrics, trace } from "@opentelemetry/api";
 import { createNoopLogger } from "./console-logger.js";
+import { createHarnessSampler, DbosSpanProcessor } from "./otel-spans.js";
 import { W3CTraceContextPropagator } from "@opentelemetry/core";
 import { MeterProvider, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
 import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
@@ -92,10 +98,11 @@ export function initOtel(options = {}) {
         const spanProcessors = [];
         if (endpoint) {
             const base = endpoint.replace(/\/+$/, "");
-            spanProcessors.push(new BatchSpanProcessor(new OTLPTraceExporter({ url: `${base}/v1/traces` })));
+            spanProcessors.push(new DbosSpanProcessor(new BatchSpanProcessor(new OTLPTraceExporter({ url: `${base}/v1/traces` }))));
         }
         const tracerProvider = new NodeTracerProvider({
             resource,
+            sampler: createHarnessSampler(),
             spanProcessors,
         });
         tracerProvider.register();

package/dist/loop/run-agent.js

@@ -3,6 +3,7 @@ import { jsonSchema, tool as aiTool, } from "ai";
 import { createNoopUsageRecorder } from "../billing/noop-usage-recorder.js";
 import { stripNulCharacters } from "../input-sanitization.js";
 import { createNoopLogger } from "../lib/console-logger.js";
+import { ATTR_INFLEXA_TOOL_USE_ID, stableSpan } from "../lib/otel-spans.js";
 import { hintForZodIssue, repairToolInput } from "../lib/zod-issues.js";
 import { markInterruptedMessage, syntheticUserMessage } from "../memory/ai-sdk-message-storage.js";
 import { stripUnansweredToolCalls } from "../memory/tool-call-integrity.js";
@@ -70,7 +71,13 @@ export async function runAgent(agent, initial, session, opts) {
         session,
         signal,
         emit,
-        runStep: (name, fn) => runStep(`${formatStepName.tool(tu.toolName, tu.toolCallId)}:${name}`, fn),
+        runStep: (name, fn) => {
+            const stepName = `${formatStepName.tool(tu.toolName, tu.toolCallId)}:${name}`;
+            return runStep(stepName, () => {
+                stableSpan(stepName, `tool:${tu.toolName}:${name}`, { [ATTR_INFLEXA_TOOL_USE_ID]: tu.toolCallId });
+                return fn();
+            });
+        },
         ask,
         turnUsage,
     });
@@ -540,7 +547,11 @@ async function dispatchTools(toolUses, toolsById, toolCtx, isFatalLoopError, run
     }
     await Promise.all(stepTools.map(({ tu, idx }) => {
         const startedAt = performance.now();
-        return runStep(toolStepName(tu.toolName, tu.toolCallId), () => dispatchTool(tu, toolsById, toolCtx(tu), isFatalLoopError, encoding)).then((settled) => {
+        const stepName = toolStepName(tu.toolName, tu.toolCallId);
+        return runStep(stepName, () => {
+            stableSpan(stepName, `tool:${tu.toolName}`, { [ATTR_INFLEXA_TOOL_USE_ID]: tu.toolCallId });
+            return dispatchTool(tu, toolsById, toolCtx(tu), isFatalLoopError, encoding);
+        }).then((settled) => {
             durations[idx] = elapsedMs(startedAt);
             const dispatched = readDispatchedStep(settled);
             results[idx] = dispatched.result;

package/dist/runtime/dbos.d.ts

@@ -55,13 +55,14 @@ export interface DbosConfig {
      * Attribute names follow the `dbos.*` semantic-convention layout
      * (`otelAttributeFormat: "semconv"`).
      *
-     * Known SDK behavior a host must plan for:
-     * - a recovered workflow starts a new root trace, with no link to the trace
-     *   of the original execution
-     * - every already-completed step re-emits a `cached=true` span on replay,
-     *   so a restart with many in-flight steps bursts spans; size
-     *   `OTEL_BSP_MAX_QUEUE_SIZE` for it
-     * - step span names embed the step, tool-use, or exec id
+     * The harness TracerProvider shapes what the SDK emits (`lib/otel-spans.ts`):
+     * a workflow declared with `untracedWorkflow` is not recorded, a replayed
+     * `cached=true` span is dropped before export, and a step body that calls
+     * `stableSpan` is exported under a stable name with its id in an
+     * `inflexa.*` attribute. The step name DBOS records is unchanged.
+     *
+     * Known SDK behavior a host must plan for: a recovered workflow starts a
+     * new root trace, with no link to the trace of the original execution.
      */
     readonly tracingEnabled?: boolean;
 }

package/dist/sandbox/await-exec.js

@@ -55,6 +55,7 @@
  * varied between replays would desynchronise the recorded function-ID sequence.
  */
 import { DBOS } from "@dbos-inc/dbos-sdk";
+import { ATTR_INFLEXA_ATTEMPT, ATTR_INFLEXA_EXEC_ID, stableSpan } from "../lib/otel-spans.js";
 import { digestBody } from "./digest.js";
 import { signCallback, verifyCallback } from "./hmac.js";
 import { createEscalationPolicy, probeLiveness, syntheticFailureReason, syntheticFailureResult } from "./liveness.js";
@@ -182,9 +183,11 @@ export async function awaitExecCallback(ref, execId, emit, deadlineMs, options =
     /** Ask the sandbox directly. Returns null when the exec has not finished. */
     const pull = async () => {
         pullAttempt += 1;
-        const pulled = await runStep(() => pullExecResult(fetchImpl, ref, execId), {
-            name: `sandbox.pull-exec-result.${execId}.${pullAttempt}`,
-        });
+        const pullStepName = `sandbox.pull-exec-result.${execId}.${pullAttempt}`;
+        const pulled = await runStep(() => {
+            stableSpan(pullStepName, "sandbox.pull-exec-result", { [ATTR_INFLEXA_EXEC_ID]: execId, [ATTR_INFLEXA_ATTEMPT]: pullAttempt });
+            return pullExecResult(fetchImpl, ref, execId);
+        }, { name: pullStepName });
         if (pulled.kind !== "completed")
             return null;
         // Identical treatment to a pushed completion: the bytes were signed by
@@ -341,9 +344,11 @@ export async function awaitExecPoll(ref, execId, emit, deadlineMs, options = {})
     let probeAttempt = 0;
     while (true) {
         pollAttempt += 1;
-        const polled = await runStep(() => pollExecOnce(fetchImpl, ref, execId, cursor), {
-            name: `sandbox.poll-exec-result.${execId}.${pollAttempt}`,
-        });
+        const pollStepName = `sandbox.poll-exec-result.${execId}.${pollAttempt}`;
+        const polled = await runStep(() => {
+            stableSpan(pollStepName, "sandbox.poll-exec-result", { [ATTR_INFLEXA_EXEC_ID]: execId, [ATTR_INFLEXA_ATTEMPT]: pollAttempt });
+            return pollExecOnce(fetchImpl, ref, execId, cursor);
+        }, { name: pollStepName });
         if (polled.kind === "ok") {
             // Identical treatment to a pushed completion: the bytes were signed by
             // the same secret, so a forgery is as fatal here as it is there.
@@ -385,9 +390,11 @@ export async function awaitExecPoll(ref, execId, emit, deadlineMs, options = {})
         }
         if (isAlive && escalation.onPoll(polled.kind === "ok" ? "ok" : "unavailable")) {
             probeAttempt += 1;
-            const verdict = await runStep(() => probeLiveness(isAlive, ref), {
-                name: `sandbox.probe-liveness.${execId}.${probeAttempt}`,
-            });
+            const probeStepName = `sandbox.probe-liveness.${execId}.${probeAttempt}`;
+            const verdict = await runStep(() => {
+                stableSpan(probeStepName, "sandbox.probe-liveness", { [ATTR_INFLEXA_EXEC_ID]: execId, [ATTR_INFLEXA_ATTEMPT]: probeAttempt });
+                return probeLiveness(isAlive, ref);
+            }, { name: probeStepName });
             // Only an observably dead machine fails the exec — the result lives
             // in that machine and nowhere else, so it is unrecoverable and the
             // synthetic failure races nothing. `alive` (live-but-slow exec,

package/dist/sandbox/notification-sweep.js

@@ -18,7 +18,9 @@
  */
 import { DBOS } from "@dbos-inc/dbos-sdk";
 import { createNoopLogger } from "../lib/console-logger.js";
+import { untracedWorkflow } from "../lib/otel-spans.js";
 const SWEEP_CRON = "0 */5 * * * *";
+const SWEEP_WORKFLOW = "dbos-notifications-sweep";
 const DELETE_BATCH_LIMIT = 10_000;
 export async function sweepStaleNotifications(deps) {
     const logger = (deps.logger ?? createNoopLogger()).named("notification-sweep");
@@ -68,9 +70,10 @@ export function registerNotificationSweep(deps) {
     // a workflow registration. Register, then schedule the same callable.
     const sweep = DBOS.registerWorkflow(async () => {
         await sweepStaleNotifications({ deleteStale, logger: deps.logger });
-    }, { name: "dbos-notifications-sweep" });
+    }, { name: SWEEP_WORKFLOW });
+    untracedWorkflow(SWEEP_WORKFLOW);
     DBOS.registerScheduled(sweep, {
-        name: "dbos-notifications-sweep",
+        name: SWEEP_WORKFLOW,
         crontab: SWEEP_CRON,
     });
 }

package/dist/sandbox/reaper.js

@@ -21,9 +21,11 @@
  */
 import { DBOS } from "@dbos-inc/dbos-sdk";
 import { createNoopLogger } from "../lib/console-logger.js";
+import { untracedWorkflow } from "../lib/otel-spans.js";
 import { unwrapOrThrow } from "../lib/result.js";
 import { reconcileReapedSandbox } from "../state/active-sandboxes.js";
 const REAPER_CRON = "0 */5 * * * *";
+const REAPER_WORKFLOW = "sandbox-reaper";
 const DEFAULT_GRACE_MS = 10 * 60_000;
 /**
  * Workflow statuses that mean "still owns its sandbox — never reap". Must
@@ -152,9 +154,10 @@ export function registerSandboxReaper(deps) {
             graceMs: deps.graceMs,
             logger: deps.logger,
         }), { name: "sandbox-reaper-sweep" });
-    }, { name: "sandbox-reaper" });
+    }, { name: REAPER_WORKFLOW });
+    untracedWorkflow(REAPER_WORKFLOW);
     DBOS.registerScheduled(reaper, {
-        name: "sandbox-reaper",
+        name: REAPER_WORKFLOW,
         crontab: REAPER_CRON,
     });
 }

package/dist/sandbox/submit-exec.js

@@ -17,6 +17,7 @@
  * untouched.
  */
 import { DBOS } from "@dbos-inc/dbos-sdk";
+import { ATTR_INFLEXA_EXEC_ID, stableSpan } from "../lib/otel-spans.js";
 import { EXEC_STREAM_BYTE_CAP } from "../tools/workspace/result-bounds.js";
 import { signCallback } from "./hmac.js";
 const SUBMIT_HTTP_TIMEOUT_MS = 30_000;
@@ -71,7 +72,9 @@ export async function submitExec(ref, body, deps = {}) {
         stdoutByteCap: body.stdoutByteCap ?? deps.execStreamByteCap ?? EXEC_STREAM_BYTE_CAP,
         stderrByteCap: body.stderrByteCap ?? deps.execStreamByteCap ?? EXEC_STREAM_BYTE_CAP,
     };
-    await runStep(() => postExec(fetchImpl, ref, capped), {
-        name: `sandbox.submit-exec.${body.execId}`,
-    });
+    const stepName = `sandbox.submit-exec.${body.execId}`;
+    await runStep(() => {
+        stableSpan(stepName, "sandbox.submit-exec", { [ATTR_INFLEXA_EXEC_ID]: body.execId });
+        return postExec(fetchImpl, ref, capped);
+    }, { name: stepName });
 }

package/dist/sandbox/watchdog.js

@@ -21,11 +21,14 @@
 import { createHash } from "node:crypto";
 import { DBOS } from "@dbos-inc/dbos-sdk";
 import { createNoopLogger } from "../lib/console-logger.js";
+import { untracedWorkflow } from "../lib/otel-spans.js";
 import { unwrapOrThrow } from "../lib/result.js";
 import { workflowIdFromExec } from "./exec-id.js";
 import { syntheticFailureReason, syntheticFailureResult } from "./liveness.js";
 export const SHARD_COUNT = 8;
 const WATCHDOG_CRON = "*/60 * * * * *";
+const WATCHDOG_PARENT_WORKFLOW = "sandbox-watchdog-parent";
+const WATCHDOG_SHARD_WORKFLOW = "sandbox-watchdog-shard";
 /** Stable hash → shard mapping, exported for tests. */
 export function shardIndex(sandboxId, shardCount = SHARD_COUNT) {
     const digest = createHash("sha1").update(sandboxId).digest();
@@ -131,7 +134,8 @@ export function registerWatchdog(deps) {
             },
             logger: deps.logger,
         });
-    }, { name: "sandbox-watchdog-shard" });
+    }, { name: WATCHDOG_SHARD_WORKFLOW });
+    untracedWorkflow(WATCHDOG_SHARD_WORKFLOW);
     // The scheduled target must itself be a registered workflow — DBOS's
     // scheduler loop skips (and errors on) any `@scheduled` function that lacks
     // a workflow registration. Register, then schedule the same callable.
@@ -148,9 +152,10 @@ export function registerWatchdog(deps) {
                 continue;
             await DBOS.startWorkflow(childCheckShard)(shard);
         }
-    }, { name: "sandbox-watchdog-parent" });
+    }, { name: WATCHDOG_PARENT_WORKFLOW });
+    untracedWorkflow(WATCHDOG_PARENT_WORKFLOW);
     DBOS.registerScheduled(watchdogParent, {
-        name: "sandbox-watchdog-parent",
+        name: WATCHDOG_PARENT_WORKFLOW,
         crontab: WATCHDOG_CRON,
     });
 }

package/dist/workflows/execute-analysis.js

@@ -63,6 +63,7 @@ import { mkdir } from "node:fs/promises";
 import { join } from "node:path";
 import { forStep } from "../auth/types.js";
 import { createNoopLogger } from "../lib/console-logger.js";
+import { ATTR_INFLEXA_STEP_ID, stableSpan } from "../lib/otel-spans.js";
 import { unwrapOrThrow } from "../lib/result.js";
 import { RunDedupCollisionError, countArtifactsForRun, insertStepExecution, loadDataProfileStatus, queryActiveRun, queryStepArtifactPaths, seedStepExecutions, setRunSynthesisOutcome, suspendAnalysis as suspendAnalysisQuery, sweepPendingStepExecutions, updateRunStatus, updateStepExecution, } from "../state/index.js";
 import { isBudgetExceeded } from "../loop/budget-exceeded.js";
@@ -770,7 +771,11 @@ async function runSchedulerLoop(args) {
             // `completed`, so this is the first (and only) moment their results
             // can be named. Checkpointed so a replay re-dispatches the child
             // with a byte-identical prompt instead of re-reading the DB/disk.
-            const prompt = await DBOS.runStep(() => composeStepSeed({ input, stepId, runId, deps }), { name: `compose-step-seed:${stepId}` });
+            const seedStepName = `compose-step-seed:${stepId}`;
+            const prompt = await DBOS.runStep(() => {
+                stableSpan(seedStepName, "compose-step-seed", { [ATTR_INFLEXA_STEP_ID]: stepId });
+                return composeStepSeed({ input, stepId, runId, deps });
+            }, { name: seedStepName });
             const baseChildInput = buildChildInput({
                 input,
                 stepId,

package/dist/workflows/execute-target-assessment.js

@@ -37,6 +37,7 @@ import { DBOS } from "@dbos-inc/dbos-sdk";
 import { z } from "zod";
 import { forSubAgent } from "../auth/types.js";
 import { createNoopLogger } from "../lib/console-logger.js";
+import { ATTR_INFLEXA_FANOUT_KEY, stableSpan } from "../lib/otel-spans.js";
 import { unwrapOrThrow } from "../lib/result.js";
 import { durableStep } from "../loop/run-step.js";
 import { createPubMedTool } from "../tools/bio/pubmed.js";
@@ -278,9 +279,14 @@ export async function runExecuteTargetAssessmentBody(input, deps) {
             }))
             : [];
         async function runFanoutBlock(items, stepKindForName, keyOf, fn) {
-            return Promise.all(items.map((item) => DBOS.runStep(() => fn(item), {
-                name: `ta-fanout:${stepKindForName}:${keyOf(item)}`,
-            }).catch((err) => wrapCollectorThrow(err))));
+            return Promise.all(items.map((item) => {
+                const key = keyOf(item);
+                const stepName = `ta-fanout:${stepKindForName}:${key}`;
+                return DBOS.runStep(() => {
+                    stableSpan(stepName, `ta-fanout:${stepKindForName}`, { [ATTR_INFLEXA_FANOUT_KEY]: key });
+                    return fn(item);
+                }, { name: stepName }).catch((err) => wrapCollectorThrow(err));
+            }));
         }
         const [perModulatorFaersResults, perTrialAesResults, perModulatorPolypharmResults, perClassDrugAesResults] = await Promise.all([
             runFanoutBlock(triageShortlist, "modulator-faers", (item) => item.moleculeChemblId, faersForOneModulator),

package/package.json

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