@inflexa-ai/harness 0.26.1 → 0.26.2

package/dist/tasks/derive-table-exec.d.ts

@@ -12,6 +12,11 @@
  * The body owns the whole machine lifetime. It creates the container, submits one exec, awaits the terminal
  * result, and tears the container down on both paths. A teardown fault reaches the log alone, because the
  * work is done by then.
+ *
+ * The exec id is `${workflowId}:${stepId}:${fnId}`, the one shape that `workflowIdFromExec` parses. A
+ * callback host reads the owner workflow out of the exec id alone, thus a flat id makes the completion
+ * callback unroutable and it lands as a `400`. The pull backstop still settles such an exec, but it pays
+ * the quiet interval first.
  */
 import type { Logger } from "../lib/logger.js";
 import type { SandboxClient } from "../sandbox/client.js";
@@ -39,8 +44,13 @@ export declare function runDeriveTableExecBody(input: DeriveTableExecInput, deps
  * dispatches with `DBOS.startWorkflow`.
  */
 export declare function registerDeriveTableExecWorkflow(deps: DeriveTableExecDeps): (input: DeriveTableExecInput) => Promise<ExecResult>;
-/** The per-attempt workflow id. The execution id is unique already, and the nonce keeps a retry distinct. */
-export declare function deriveTableExecWorkflowId(executionId: string, nonce: string): string;
+/**
+ * The workflow id of one derivation.
+ *
+ * It carries exactly one colon, because `workflowIdFromExec` recovers the id by a strip of the last two
+ * colon-delimited segments of the exec id. The execution id is unique already, thus no nonce joins it.
+ */
+export declare function deriveTableExecWorkflowId(executionId: string): string;
 /**
  * The async edge. It starts the registered workflow and it awaits the terminal result.
  *

package/dist/tasks/derive-table-exec.js

@@ -12,9 +12,13 @@
  * The body owns the whole machine lifetime. It creates the container, submits one exec, awaits the terminal
  * result, and tears the container down on both paths. A teardown fault reaches the log alone, because the
  * work is done by then.
+ *
+ * The exec id is `${workflowId}:${stepId}:${fnId}`, the one shape that `workflowIdFromExec` parses. A
+ * callback host reads the owner workflow out of the exec id alone, thus a flat id makes the completion
+ * callback unroutable and it lands as a `400`. The pull backstop still settles such an exec, but it pays
+ * the quiet interval first.
  */
 import { DBOS } from "@dbos-inc/dbos-sdk";
-import { randomUUID } from "node:crypto";
 import { createNoopLogger } from "../lib/console-logger.js";
 import { mintSandboxIdentity } from "../sandbox/identity.js";
 import { buildDerivationExec, DERIVATION_DEADLINE_MS, DERIVATION_RESOURCES, DERIVE_RUN_LITERAL, DERIVE_STEP_LITERAL, } from "../tools/report-session/derive-table.js";
@@ -28,7 +32,10 @@ const noopEmit = () => { };
  */
 export async function runDeriveTableExecBody(input, deps) {
     const logger = (deps.logger ?? createNoopLogger()).named("derive-table-exec").with({ analysisId: input.analysisId });
-    const workflowId = DBOS.workflowID ?? `${DERIVE_RUN_LITERAL}:${input.executionId}`;
+    const workflowId = DBOS.workflowID ?? deriveTableExecWorkflowId(input.executionId);
+    // One workflow submits one exec, thus the function id is a constant. The three segments are what a
+    // callback host parses to find the workflow that awaits this exec.
+    const execId = `${workflowId}:${DERIVE_STEP_LITERAL}:fn-0`;
     const sandbox = await deps.sandboxClient.createSandbox({
         runId: DERIVE_RUN_LITERAL,
         stepId: DERIVE_STEP_LITERAL,
@@ -43,12 +50,12 @@ export async function runDeriveTableExecBody(input, deps) {
         const deadline = (await (deps.now ?? (() => DBOS.now()))()) + DERIVATION_DEADLINE_MS;
         await deps.sandboxClient.submitExec(sandbox, buildDerivationExec({
             script: input.script,
-            execId: input.executionId,
+            execId,
             workingDir: input.workingDir,
             inputs: input.inputs,
             output: input.output,
         }));
-        return await deps.sandboxClient.awaitExec(sandbox, input.executionId, noopEmit, deadline);
+        return await deps.sandboxClient.awaitExec(sandbox, execId, noopEmit, deadline);
     }
     finally {
         try {
@@ -66,9 +73,14 @@ export async function runDeriveTableExecBody(input, deps) {
 export function registerDeriveTableExecWorkflow(deps) {
     return DBOS.registerWorkflow((input) => runDeriveTableExecBody(input, deps), { name: "derive-table-exec" });
 }
-/** The per-attempt workflow id. The execution id is unique already, and the nonce keeps a retry distinct. */
-export function deriveTableExecWorkflowId(executionId, nonce) {
-    return `${DERIVE_RUN_LITERAL}:${executionId}:${nonce}`;
+/**
+ * The workflow id of one derivation.
+ *
+ * It carries exactly one colon, because `workflowIdFromExec` recovers the id by a strip of the last two
+ * colon-delimited segments of the exec id. The execution id is unique already, thus no nonce joins it.
+ */
+export function deriveTableExecWorkflowId(executionId) {
+    return `${DERIVE_RUN_LITERAL}:${executionId}`;
 }
 /**
  * The async edge. It starts the registered workflow and it awaits the terminal result.
@@ -78,7 +90,7 @@ export function deriveTableExecWorkflowId(executionId, nonce) {
  */
 export async function triggerDeriveTableExec(workflow, input) {
     const handle = (await DBOS.startWorkflow(workflow, {
-        workflowID: deriveTableExecWorkflowId(input.executionId, randomUUID()),
+        workflowID: deriveTableExecWorkflowId(input.executionId),
     })(input));
     return handle.getResult();
 }

package/package.json

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