@inflexa-ai/harness 0.42.2 → 0.43.0

package/dist/sandbox/types.js

@@ -1,45 +1,13 @@
 /**
  * Sandbox-client types — the wire/persistence shapes that cross the
- * submit/recv protocol (see the harness-sandbox-exec spec) and the active-sandbox registry.
+ * submit/poll protocol (see the harness-sandbox-exec spec) and the active-sandbox registry.
  *
- * `SandboxRef` is the in-memory handle the harness uses to talk to a live
- * sandbox; it carries the per-sandbox `callbackSecret` (see the harness-sandbox-exec spec). The
- * persistable subset is `PersistedSandboxRef` (from `harness/state/schema.ts`)
- * — that one OMITS the secret, which lives only in the cached
- * `createSandbox` DBOS step output.
+ * `SandboxRef` is the handle the harness uses to talk to a live sandbox. The
+ * active-sandbox registry persists the same shape (`PersistedSandboxRef`, from
+ * `harness/state/schema.ts`).
  */
 import { z } from "zod";
-import { PersistedSandboxRefSchema } from "../state/schema.js";
 export const SandboxBackend = z.enum(["docker", "k8s"]);
-/**
- * How a command's progress events and terminal result reach the host. Chosen by
- * the embedder at its composition root and carried into the container as
- * `SANDBOX_TRANSPORT`; backend-independent. The OSS default is `poll`.
- *
- * - `poll`: the host polls `GET /exec/{execId}?since={cursor}`; the sandbox
- *   never dials out and needs no egress.
- * - `callback`: the sandbox POSTs signed event/completion callbacks; the
- *   embedder runs an ingress. `GET /exec/{execId}` stays the recovery backstop.
- */
-export const SandboxTransportSchema = z.enum(["poll", "callback"]);
-export const SandboxRefSchema = PersistedSandboxRefSchema.extend({
-    /**
-     * 32-byte high-entropy bytes, base64-encoded. Minted once at
-     * `createSandbox` and handed to the sandbox container via
-     * `SANDBOX_CALLBACK_SECRET`. Never persisted outside the DBOS
-     * step-output cache.
-     */
-    callbackSecret: z.string(),
-});
-/** Strip the secret before persisting to the active-sandbox registry. */
-export function toPersistedRef(ref) {
-    return {
-        sandboxId: ref.sandboxId,
-        host: ref.host,
-        port: ref.port,
-        backend: ref.backend,
-    };
-}
 /**
  * One tracked file operation in the sandbox-server provenance frame.
  * Mirrors Go's `ProvenanceEntry` (`images/sandbox-base/server/provenance.go`):
@@ -50,8 +18,8 @@ export const ProvenanceFrameEntrySchema = z.object({
     layers: z.array(z.string()).default([]),
 });
 /**
- * Runtime file-I/O frame sandbox-server attaches to the `/complete`
- * callback. Mirrors Go's `provenancePayload` — every field is
+ * Runtime file-I/O frame sandbox-server attaches to the terminal result.
+ * Mirrors Go's `provenancePayload` — every field is
  * `omitempty` on the wire, so each arm defaults so a completion that
  * omits the frame (or any arm) still parses.
  */
@@ -86,9 +54,9 @@ export const ExecUsageSchema = z
     .optional()
     .catch(undefined);
 /**
- * Final outcome of a single exec, returned by `awaitExec`. Mirrors the
- * sandbox-server completion payload plus a discriminant for synthetic
- * (watchdog-emitted) failures.
+ * Final outcome of a single exec, returned by `SandboxClient.exec`. Mirrors
+ * the sandbox-server completion payload plus a discriminant for a synthetic
+ * failure: the machine died under the exec.
  */
 export const ExecResultSchema = z.object({
     execId: z.string(),
@@ -104,74 +72,45 @@ export const ExecResultSchema = z.object({
      * a capped stream and an empty one are indistinguishable downstream.
      *
      * Optional because a sandbox image that pre-dates the cap omits both, and
-     * because the watchdog's synthetic failures carry neither.
+     * because a synthetic failure carries neither.
      */
     stdoutTruncated: z.boolean().optional(),
     stderrTruncated: z.boolean().optional(),
     stdoutTotalBytes: z.number().int().nonnegative().optional(),
     stderrTotalBytes: z.number().int().nonnegative().optional(),
-    /** Set when the watchdog synthesises a completion for a dead sandbox. */
+    /** Set when the liveness probe found the machine dead under the exec. */
     syntheticFailure: z
         .object({
         reason: z.string(),
     })
         .optional(),
-    /**
-     * Runtime file-I/O frame from sandbox-server. Optional so synthetic
-     * watchdog failures and pre-change cached recv messages parse; rides
-     * the recv payload into the durable DBOS step output.
-     */
+    /** Runtime file-I/O frame from sandbox-server. Absent from a synthetic failure. */
     provenance: ProvenanceFrameSchema.optional(),
     /**
      * Kernel accounting of the exec, for the sandbox-sizing histograms. Absent
-     * from a synthetic watchdog failure, from a sandbox image that predates the
+     * from a synthetic failure, from a sandbox image that predates the
      * frame, and from any exec whose command never spawned.
      */
     usage: ExecUsageSchema,
 });
-/**
- * Per-message envelope on the per-exec DBOS topic. Real callbacks carry
- * a non-null `signature` and `timestamp`; the in-process watchdog uses a
- * `null` signature + a `synthetic-failure` payload (see `await-exec.ts`).
- *
- * `payloadDigest` is the hex SHA-256 of the exact bytes sandbox-server POSTed.
- * The HMAC signs that digest rather than the body itself, so the digest is all
- * verification needs — and carrying it instead of the bytes keeps the message
- * from holding a second copy of a payload that can be arbitrarily large.
- * Re-serializing the parsed payload would not do: Go's `encoding/json`
- * HTML-escapes `<`, `>`, `&` by default, so a JS re-serialization diverges for
- * any output containing those characters (common in bioinformatics: FASTA
- * headers, shell stderr, command pipelines).
- *
- * `payloadRaw` is the superseded form, kept optional so messages already in
- * flight or persisted still verify.
- */
-export const ExecEventMessageSchema = z.object({
-    payload: z.unknown(),
-    payloadDigest: z.string().optional(),
-    payloadRaw: z.string().optional(),
-    signature: z.string().nullable(),
-    timestamp: z.number().int().nullable(),
-});
 /**
  * One buffered progress event in a poll response: the sandbox's monotonic
  * per-exec sequence number (the poll cursor) plus the event payload the host
- * forwards via `emit` — the same payload a callback-mode event POST carries.
+ * forwards via `emit`.
  */
 export const PollEventSchema = z.object({
     seq: z.number().int(),
     payload: z.unknown(),
 });
 /**
- * Body of `GET /exec/{execId}?since={cursor}` in poll mode. Mirrors Go's
+ * Body of `GET /exec/{execId}?since={cursor}`. Mirrors Go's
  * `pollResponseBody`: the events newer than the caller's cursor, the new
  * high-water `cursor`, a `truncated` marker set once the ring shed an event,
  * and — once the exec is terminal — the completion `result` (with its
- * provenance frame). The whole body is HMAC-signed, verified exactly as a
- * pushed completion is.
+ * provenance frame).
  */
 export const PollResponseSchema = z.object({
-    status: z.string(),
+    status: z.enum(["running", "completed", "failed"]),
     events: z.array(PollEventSchema).default([]),
     cursor: z.number().int(),
     /**
@@ -182,9 +121,3 @@ export const PollResponseSchema = z.object({
     truncated: z.boolean().default(false),
     result: ExecResultSchema.optional(),
 });
-export function isDoneMarker(value) {
-    return (typeof value === "object" && value !== null && value.done === true && typeof value.result === "object");
-}
-export function isSyntheticFailure(value) {
-    return isDoneMarker(value) && value.kind === "synthetic-failure";
-}

package/dist/state/active-sandboxes.d.ts

@@ -1,9 +1,9 @@
 /**
  * Active-sandbox registry (CONTEXT.md) — the projection over
  * `cortex_step_executions` rows with a non-null `sandbox_ref` and a running
- * status. Owns the `sandbox_ref` + `exec_id` columns: written by
- * `sandbox/create-sandbox.ts` on mint, cleared on teardown, enumerated by
- * `sandbox/watchdog.ts` for liveness sweeps.
+ * status. Owns the `sandbox_ref` column: written by
+ * `sandbox/create-sandbox.ts` on mint, cleared on teardown, reconciled by
+ * `sandbox/reaper.ts` after it deletes a machine.
  */
 import type { ResultAsync } from "neverthrow";
 import { type DbError } from "../lib/db-result.js";
@@ -12,47 +12,22 @@ import type { PersistedSandboxRef } from "./schema.js";
 /**
  * Record the live sandbox handle on a step row. Called inside the
  * `createSandbox` DBOS step after the backend has confirmed the sandbox
- * is up. The `callbackSecret` is deliberately not part of the persisted
- * shape (see the harness-sandbox-exec spec) — it lives only in the cached step output.
+ * is up.
  */
-export declare function setSandboxRef(pool: Querier, runId: string, stepId: string, sandboxRef: PersistedSandboxRef, execId: string | null): ResultAsync<void, DbError>;
-/**
- * Tag the active-sandbox row with the exec currently in flight. Called from
- * `run-exec.ts` right before `awaitExec` so the liveness watchdog can target
- * the hung exec when the sandbox dies mid-command. Targets the same
- * `(run_id, step_id)` row `setSandboxRef` writes and `queryActiveSandboxes`
- * enumerates. Overwritten by the next exec; cleared on teardown.
- */
-export declare function setActiveExecId(pool: Querier, runId: string, stepId: string, execId: string): ResultAsync<void, DbError>;
+export declare function setSandboxRef(pool: Querier, runId: string, stepId: string, sandboxRef: PersistedSandboxRef): ResultAsync<void, DbError>;
 /**
  * Clear the sandbox handle. Called inside the `teardown` DBOS step. Safe
  * to call when no sandbox was ever recorded — the UPDATE simply targets
  * zero rows.
  */
 export declare function clearSandboxRef(pool: Querier, runId: string, stepId: string): ResultAsync<void, DbError>;
-/**
- * Enumerate the active-sandbox registry — every running step with a live
- * sandbox attached. The liveness watchdog consumes this, shards the
- * result, and fans out per-shard check workflows.
- *
- * Returns the raw row tuple (no Zod parse) so the watchdog can shard
- * without paying for parse work it doesn't need.
- */
-export interface ActiveSandboxRow {
-    runId: string;
-    stepId: string;
-    analysisId: string;
-    sandboxRef: PersistedSandboxRef;
-    execId: string | null;
-}
 /**
  * Reconcile a step row after the reaper deletes its sandbox machine (ADR
- * 0016). Always clears `sandbox_ref`/`exec_id` (drops the row from the
- * active-sandbox registry, ending the watchdog churn); a row still stuck at
+ * 0016). Always clears `sandbox_ref` (drops the row from the
+ * active-sandbox registry); a row still stuck at
  * `status='running'` — a cancellation that never ran its `mark-*` step — is
  * also flipped to the owning workflow's terminal status so a terminal workflow
  * never leaves a perpetually-"running" step behind. Returns true if a row
  * matched. Safe when no row exists (Class A pure orphan): matches zero rows.
  */
 export declare function reconcileReapedSandbox(pool: Querier, sandboxId: string, terminalStatus: "canceled" | "failed" | "completed"): ResultAsync<boolean, DbError>;
-export declare function queryActiveSandboxes(pool: Querier): ResultAsync<ActiveSandboxRow[], DbError>;

package/dist/state/active-sandboxes.js

@@ -1,41 +1,23 @@
 /**
  * Active-sandbox registry (CONTEXT.md) — the projection over
  * `cortex_step_executions` rows with a non-null `sandbox_ref` and a running
- * status. Owns the `sandbox_ref` + `exec_id` columns: written by
- * `sandbox/create-sandbox.ts` on mint, cleared on teardown, enumerated by
- * `sandbox/watchdog.ts` for liveness sweeps.
+ * status. Owns the `sandbox_ref` column: written by
+ * `sandbox/create-sandbox.ts` on mint, cleared on teardown, reconciled by
+ * `sandbox/reaper.ts` after it deletes a machine.
  */
-import { tryMutation, tryQuery } from "../lib/db-result.js";
+import { tryMutation } from "../lib/db-result.js";
 /**
  * Record the live sandbox handle on a step row. Called inside the
  * `createSandbox` DBOS step after the backend has confirmed the sandbox
- * is up. The `callbackSecret` is deliberately not part of the persisted
- * shape (see the harness-sandbox-exec spec) — it lives only in the cached step output.
+ * is up.
  */
-export function setSandboxRef(pool, runId, stepId, sandboxRef, execId) {
+export function setSandboxRef(pool, runId, stepId, sandboxRef) {
     return tryMutation("activeSandboxes.setSandboxRef", async () => {
         await pool.query({
             text: `UPDATE cortex_step_executions
-          SET sandbox_ref = $1::jsonb, exec_id = $2
-          WHERE run_id = $3 AND step_id = $4`,
-            values: [JSON.stringify(sandboxRef), execId, runId, stepId],
-        });
-    });
-}
-/**
- * Tag the active-sandbox row with the exec currently in flight. Called from
- * `run-exec.ts` right before `awaitExec` so the liveness watchdog can target
- * the hung exec when the sandbox dies mid-command. Targets the same
- * `(run_id, step_id)` row `setSandboxRef` writes and `queryActiveSandboxes`
- * enumerates. Overwritten by the next exec; cleared on teardown.
- */
-export function setActiveExecId(pool, runId, stepId, execId) {
-    return tryMutation("activeSandboxes.setActiveExecId", async () => {
-        await pool.query({
-            text: `UPDATE cortex_step_executions
-          SET exec_id = $1
+          SET sandbox_ref = $1::jsonb
           WHERE run_id = $2 AND step_id = $3`,
-            values: [execId, runId, stepId],
+            values: [JSON.stringify(sandboxRef), runId, stepId],
         });
     });
 }
@@ -48,7 +30,7 @@ export function clearSandboxRef(pool, runId, stepId) {
     return tryMutation("activeSandboxes.clearSandboxRef", async () => {
         await pool.query({
             text: `UPDATE cortex_step_executions
-          SET sandbox_ref = NULL, exec_id = NULL
+          SET sandbox_ref = NULL
           WHERE run_id = $1 AND step_id = $2`,
             values: [runId, stepId],
         });
@@ -56,8 +38,8 @@ export function clearSandboxRef(pool, runId, stepId) {
 }
 /**
  * Reconcile a step row after the reaper deletes its sandbox machine (ADR
- * 0016). Always clears `sandbox_ref`/`exec_id` (drops the row from the
- * active-sandbox registry, ending the watchdog churn); a row still stuck at
+ * 0016). Always clears `sandbox_ref` (drops the row from the
+ * active-sandbox registry); a row still stuck at
  * `status='running'` — a cancellation that never ran its `mark-*` step — is
  * also flipped to the owning workflow's terminal status so a terminal workflow
  * never leaves a perpetually-"running" step behind. Returns true if a row
@@ -73,7 +55,6 @@ export function reconcileReapedSandbox(pool, sandboxId, terminalStatus) {
         const result = await pool.query({
             text: `UPDATE cortex_step_executions
           SET sandbox_ref = NULL,
-              exec_id = NULL,
               status = CASE WHEN status = 'running' THEN $2 ELSE status END,
               completed_at = CASE WHEN status = 'running' THEN $3 ELSE completed_at END
           WHERE sandbox_ref->>'sandboxId' = $1`,
@@ -82,19 +63,3 @@ export function reconcileReapedSandbox(pool, sandboxId, terminalStatus) {
         return (result.rowCount ?? 0) > 0;
     });
 }
-export function queryActiveSandboxes(pool) {
-    return tryQuery("activeSandboxes.queryActiveSandboxes", async () => {
-        const result = await pool.query({
-            text: `SELECT run_id, step_id, analysis_id, sandbox_ref, exec_id
-          FROM cortex_step_executions
-          WHERE status = 'running' AND sandbox_ref IS NOT NULL`,
-        });
-        return result.rows.map((r) => ({
-            runId: r.run_id,
-            stepId: r.step_id,
-            analysisId: r.analysis_id,
-            sandboxRef: r.sandbox_ref,
-            execId: r.exec_id ?? null,
-        }));
-    });
-}

package/dist/state/index.d.ts

@@ -16,8 +16,7 @@ setRunSynthesisOutcome, queryRun, queryActiveRun, queryNonTerminalRunsByAnalysis
 export type { InsertRunInput, RunPage, RunReservation } from "./runs.js";
 export { insertStepExecution, seedStepExecutions, sweepPendingStepExecutions, updateStepExecution, queryStepsByRun } from "./step-executions.js";
 export type { InsertStepExecutionInput, SeedStepExecutionRow, UpdateStepExecutionInput } from "./step-executions.js";
-export { setSandboxRef, setActiveExecId, clearSandboxRef, queryActiveSandboxes, reconcileReapedSandbox } from "./active-sandboxes.js";
-export type { ActiveSandboxRow } from "./active-sandboxes.js";
+export { setSandboxRef, clearSandboxRef, reconcileReapedSandbox } from "./active-sandboxes.js";
 export { insertPlan, upsertPlan, loadPlan } from "./plans.js";
 export type { InsertPlanInput, UpsertPlanInput } from "./plans.js";
 export { tryStartDataProfile, tryRetryDataProfile, tryRerunDataProfile, completeDataProfile, failDataProfile, expireStaleDataProfile, reconcileOrphanedDataProfile, clearDataProfile, completeEmptyDataProfile, loadDataProfileStatus, loadSeedInputFileIds, recordDataProfileWorkflowId, } from "./data-profile.js";

package/dist/state/index.js

@@ -12,7 +12,7 @@ export { upsertArtifact, upsertArtifacts, queryInputArtifacts, queryStepArtifact
 export { insertRun, reserveRunById, RunDedupCollisionError, RunIdentityCollisionError, updateRunStatus, markRunCanceledIfActive, promoteFailedToPartial, setRunMandate, // oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
 setRunSynthesisOutcome, queryRun, queryActiveRun, queryNonTerminalRunsByAnalysis, queryRunsForInspection, queryRunsByAnalysis, queryRunsByThread, } from "./runs.js";
 export { insertStepExecution, seedStepExecutions, sweepPendingStepExecutions, updateStepExecution, queryStepsByRun } from "./step-executions.js";
-export { setSandboxRef, setActiveExecId, clearSandboxRef, queryActiveSandboxes, reconcileReapedSandbox } from "./active-sandboxes.js";
+export { setSandboxRef, clearSandboxRef, reconcileReapedSandbox } from "./active-sandboxes.js";
 export { insertPlan, upsertPlan, loadPlan } from "./plans.js";
 export { tryStartDataProfile, tryRetryDataProfile, tryRerunDataProfile, completeDataProfile, failDataProfile, expireStaleDataProfile, reconcileOrphanedDataProfile, clearDataProfile, completeEmptyDataProfile, loadDataProfileStatus, loadSeedInputFileIds, recordDataProfileWorkflowId, } from "./data-profile.js";
 export { queryRunCountsByAnalyses, queryThreadCountsByAnalyses, queryDataProfileStatusByAnalyses } from "./analyses-metrics.js";

package/dist/state/migrations/20261005120000_drop_the_active_exec_tracking.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Drop the in-flight exec id of a step row, and the partial index of the rows
+ * that hold a sandbox. The exec id is the function id of its DBOS step, thus
+ * nothing outside the step reads it, and no query reads the rows by status.
+ */
+import type { Migration } from "kysely/migration";
+export declare const dropActiveExecTracking: Migration;

package/dist/state/migrations/20261005120000_drop_the_active_exec_tracking.js

@@ -0,0 +1,12 @@
+/**
+ * Drop the in-flight exec id of a step row, and the partial index of the rows
+ * that hold a sandbox. The exec id is the function id of its DBOS step, thus
+ * nothing outside the step reads it, and no query reads the rows by status.
+ */
+import { sql } from "kysely";
+export const dropActiveExecTracking = {
+    async up(db) {
+        await sql `ALTER TABLE cortex_step_executions DROP COLUMN IF EXISTS exec_id`.execute(db);
+        await sql `DROP INDEX IF EXISTS idx_cortex_step_exec_active_sandbox`.execute(db);
+    },
+};

package/dist/state/migrations/index.js

@@ -7,9 +7,11 @@
  */
 import { baseline } from "./20260927120000_baseline.js";
 import { threadTitleSetByUser } from "./20260927180000_thread_title_set_by_user.js";
+import { dropActiveExecTracking } from "./20261005120000_drop_the_active_exec_tracking.js";
 export function cortexMigrations(logger) {
     return {
         "20260927120000_baseline": baseline(logger),
         "20260927180000_thread_title_set_by_user": threadTitleSetByUser,
+        "20261005120000_drop_the_active_exec_tracking": dropActiveExecTracking,
     };
 }

package/dist/state/schema.d.ts

@@ -102,10 +102,7 @@ export declare const CortexRunRowSchema: z.ZodObject<{
 export type CortexRunRow = z.infer<typeof CortexRunRowSchema>;
 /**
  * Persistable sandbox handle — what the active-sandbox registry stores on
- * `cortex_step_executions.sandbox_ref`. Excludes the per-sandbox
- * `callbackSecret`, which lives only in the DBOS step-output cache (ADR
- * 0007). The harness reconstructs the full in-memory `SandboxRef` by
- * reading the secret from the cached `createSandbox` step output.
+ * `cortex_step_executions.sandbox_ref`.
  */
 export declare const PersistedSandboxRefSchema: z.ZodObject<{
     sandboxId: z.ZodString;
@@ -150,7 +147,6 @@ export declare const StepExecutionRowSchema: z.ZodObject<{
             k8s: "k8s";
         }>;
     }, z.core.$strip>>>;
-    execId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     childWorkflowId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
 }, z.core.$strip>;
 export type StepExecutionRow = z.infer<typeof StepExecutionRowSchema>;

package/dist/state/schema.js

@@ -60,10 +60,7 @@ export const CortexRunRowSchema = z.object({
 });
 /**
  * Persistable sandbox handle — what the active-sandbox registry stores on
- * `cortex_step_executions.sandbox_ref`. Excludes the per-sandbox
- * `callbackSecret`, which lives only in the DBOS step-output cache (ADR
- * 0007). The harness reconstructs the full in-memory `SandboxRef` by
- * reading the secret from the cached `createSandbox` step output.
+ * `cortex_step_executions.sandbox_ref`.
  */
 export const PersistedSandboxRefSchema = z.object({
     sandboxId: z.string(),
@@ -94,8 +91,6 @@ export const StepExecutionRowSchema = z.object({
     blockedReason: z.string().nullable().default(null),
     /** Active-sandbox registry handle; null when no sandbox is live for this step. */
     sandboxRef: PersistedSandboxRefSchema.nullable().default(null),
-    /** In-flight `${workflowId}:${stepId}:${functionId}`; null when no exec is in flight. */
-    execId: z.string().nullable().default(null),
     /** DBOS child workflow id (`"${parentWorkflowId}-${N}"`); null on pre-DBOS rows. */
     childWorkflowId: z.string().nullable().default(null),
 });

package/dist/state/step-executions.js

@@ -142,7 +142,7 @@ export function queryStepsByRun(pool, runId) {
             text: `SELECT run_id, step_id, analysis_id, wave, agent_id,
                  status, started_at, completed_at, duration_ms, error,
                  attempts, last_error_class, finish_reason, hit_max_steps,
-                 blocked_reason, sandbox_ref, exec_id, child_workflow_id
+                 blocked_reason, sandbox_ref, child_workflow_id
           FROM cortex_step_executions
           WHERE run_id = $1
           ORDER BY wave, started_at NULLS LAST, step_id`,
@@ -169,7 +169,6 @@ function mapStepExecutionRow(row) {
         hitMaxSteps: row.hit_max_steps === 1 || row.hit_max_steps === true,
         blockedReason: row.blocked_reason ?? null,
         sandboxRef: row.sandbox_ref ?? null,
-        execId: row.exec_id ?? null,
         childWorkflowId: row.child_workflow_id ?? null,
     };
 }

package/dist/tasks/data-profile.js

@@ -127,7 +127,7 @@ export function buildDataProfileResult(submission, resolution, stagedInputs, pro
  * rests on, so failing the profile over it would trade the whole capability for a nicety.
  */
 async function readSetHeaders(args) {
-    const { session, deps, analysisId, detected, sandbox, execId, deadlineMs, logger } = args;
+    const { session, deps, analysisId, detected, sandbox, deadlineMs, logger } = args;
     try {
         return await readHeaders({
             targets: readoutTargets(detected),
@@ -136,7 +136,6 @@ async function readSetHeaders(args) {
             sandboxClient: deps.sandboxClient,
             sandbox,
             mountRoot: `/${analysisId}`,
-            execId,
             deadlineMs,
             emit: async () => { },
         });
@@ -306,8 +305,8 @@ export async function runDataProfileBody(input, deps) {
         selfCancelled = true;
         await cancelSelf("self-cancel-suspended");
     };
-    // The profile's activity channel. `DBOS.writeStream` is body-only, so the write is bound here
-    // while every phase and phrase lives in the emitter — the phrases are the observable contract of
+    // The profile's activity channel. The write to the stream is bound here, while every phase and
+    // phrase lives in the emitter — the phrases are the observable contract of
     // this capability, and a body that composed its own strings is a body they can drift from.
     // The frame is the workflow's synthetic one: both values are constants shared by every analysis,
     // so they identify nothing and consumers are required not to key on them.
@@ -434,20 +433,16 @@ export async function runDataProfileBody(input, deps) {
             return await suspendProfile(suspensionOfSpawnRefusal(spawned.error));
         const sandbox = spawned.value;
         try {
-            // Checkpointed clock, not `Date.now()`: `awaitExec` gates on this absolute
-            // deadline and its recovery-pull is a durable step, so a wall-clock deadline
-            // that grew on replay would shift which loop iteration crosses the deadline
-            // and desynchronise the recorded function-ID sequence (see sandbox-step.ts,
-            // which captures its step deadline the same way).
+            // Checkpointed clock, not `Date.now()`: one deadline bounds every exec of the
+            // profile, and a wall-clock deadline would grow on each recovery (see
+            // sandbox-step.ts, which captures its step deadline the same way).
             const deadlineAbs = (await DBOS.now()) + DEFAULT_DEADLINE_MS;
-            const nextFunctionId = makeNextFunctionId();
             const headers = await readSetHeaders({
                 session: childSession,
                 deps,
                 analysisId,
                 detected,
                 sandbox,
-                execId: `${workflowId}:${DATA_PROFILE_STEP_LITERAL}:${nextFunctionId()}`,
                 deadlineMs: deadlineAbs,
                 logger,
             });
@@ -482,14 +477,10 @@ export async function runDataProfileBody(input, deps) {
                 sandbox,
                 workspaceRoot,
                 analysisId,
-                runId: DATA_PROFILE_RUN_LITERAL,
-                stepId: DATA_PROFILE_STEP_LITERAL,
-                workflowId,
                 // The profiler writes Python scripts and intermediate artifacts under
                 // the synthetic step path; the post-agent `rm -rf runs/data-profile/`
                 // cleanup wipes them.
                 allowedWritePrefix: profileWritePrefix,
-                nextFunctionId,
                 deadlineMs: () => deadlineAbs,
             });
             let accepted = null;
@@ -548,6 +539,7 @@ export async function runDataProfileBody(input, deps) {
                 },
                 runStep: durableStep,
                 resolved: () => accepted !== null,
+                invocationId: workflowId,
                 usageRecorder: deps.usageRecorder,
                 toolOutputStore: deps.toolOutputStore,
                 isFatalLoopError: (err) => err instanceof DBOSErrors.DBOSWorkflowCancelledError,
@@ -878,8 +870,3 @@ function profileFailureReason(err) {
     const firstLine = raw.split("\n", 1)[0].replace(/\s+/g, " ").trim();
     return firstLine.length > PROFILE_ERROR_MAX_LEN ? firstLine.slice(0, PROFILE_ERROR_MAX_LEN - 1) + "…" : firstLine || "Data profiling failed";
 }
-/** Per-call function-id minter — replay-deterministic. */
-function makeNextFunctionId() {
-    let n = 0;
-    return () => `fn-${(n++).toString(36)}`;
-}

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

@@ -1,22 +1,17 @@
 /**
  * The container of one report-session derivation, as a registered DBOS workflow.
  *
- * The `derive_table` tool runs inside one live chat turn, and a chat turn is not a workflow body. An await
- * of an exec under the callback transport calls `DBOS.recv`, which a workflow body alone can call. Thus the
+ * The `derive_table` tool runs inside one live chat turn, and a chat turn is not a workflow. An exec runs as
+ * a durable step of a workflow, and the reaper maps each container to the workflow that owns it. Thus the
  * container lives here, behind a registered workflow, and the tool starts it and awaits the handle.
  *
  * The shape is the shape of `tasks/extract-values.ts`: a body that a test drives directly, a registration
  * that closes over the construction-time deps, and a trigger that starts the workflow and gives the result
  * back. The tool holds the trigger as a plain function, thus no module under `tools/` imports DBOS.
  *
- * The body owns the whole machine lifetime. It creates the container, submits one exec, awaits the terminal
+ * The body owns the whole machine lifetime. It creates the container, runs one exec to its 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 Result } from "neverthrow";
 import type { Logger } from "../lib/logger.js";
@@ -48,12 +43,7 @@ export declare function runDeriveTableExecBody(input: DeriveTableExecInput, deps
  * dispatches with `DBOS.startWorkflow`.
  */
 export declare function registerDeriveTableExecWorkflow(deps: DeriveTableExecDeps): (input: DeriveTableExecInput) => Promise<Result<ExecResult, Suspension>>;
-/**
- * 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.
- */
+/** The workflow id of one derivation. 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.