@intx/workflow-host 0.2.2 → 0.3.0

package/dist/child/run-child.js

@@ -25,7 +25,8 @@
 //      each one whose log lacks a terminal event.
 //   4. Emit `ready` on the control channel.
 //   5. Loop on control-channel frames:
-//        - `trigger.fired` -> open a new run via `runtimeRun`.
+//        - `trigger.fired` -> first-fire the deployment's top-level run via
+//          `runtimeRun` (the supervisor only sends this for an absent log).
 //        - `grants-updated` -> replace the credentialsSnapshot.
 //        - `drain` -> forward to the drain controller (no-op here).
 //        - `shutdown` -> stop accepting new triggers and exit the
@@ -47,24 +48,26 @@
 // classifies each in-flight step as cancel-mode or wait-mode. The
 // supervisor's recycle policy is OS-driven (drain, SIGTERM, SIGKILL,
 // respawn) and does not require a child-side control frame.
-import { type } from "arktype";
 import { getLogger } from "@intx/log";
 import { generateKeyPair } from "@intx/crypto";
 import { base64Decode, hexEncode } from "@intx/types";
-import { readProcessingEntry, workflowDefinitionEnvelopeSchema, } from "@intx/hub-sessions/substrate";
-import { extractPartByPath, parseHeaderSection, parseMimePart, } from "@intx/mime";
-import { createDefaultDirectorRegistry } from "@intx/agent";
-import { emptyState, runtimeRun } from "@intx/workflow";
+import { readProcessingEntry } from "@intx/hub-sessions/substrate";
+import { rewriteInlineOnTriggerBodies, rewriteInlineChildWorkflowBodies, } from "@intx/workflow";
+import { baseStepId, emptyState, runtimeRun } from "@intx/workflow";
 import { createWorkflowHostDrainController, } from "../drain-controller.js";
 import { createWorkflowRunRepoStore } from "../adapters/repo-store.js";
 import { createWorkflowRunBlobSubstrate } from "../adapters/blob-substrate.js";
+import { createInMemorySpawnSuspendableChild, createInMemorySpawnChild, } from "../adapters/spawn-child.js";
 import { createControlChannelSender, createEventChannelSender, receiveControlChannel, } from "../ipc/index.js";
 import { createWorkflowHostSignalChannel } from "../seams/signal-channel.js";
+import { extractConversationText } from "../conversation-text.js";
 import { hashGrants } from "../supervisor/credentials.js";
+import { loadVerifiedWorkflowDefinitionFromClosure } from "./verified-definition-loader.js";
+import { loadWorkflowDirectorRegistryFromClosure } from "../workflow-definition-loader.js";
 import { discoverInFlightRuns } from "./self-discovery.js";
+import { collectParkedApprovalCorrelations, } from "./parked-correlations.js";
 import { createWarmAgentCache } from "./warm-agent-cache.js";
 const logger = getLogger(["workflow-host", "child"]);
-const WORKFLOW_JSON_PATH = "workflow.json";
 export function createCredentialsBackedAuthorize(ref, evaluate) {
     return async (resource, action, ctx) => {
         const stepId = ctx?.stepId;
@@ -75,9 +78,17 @@ export function createCredentialsBackedAuthorize(ref, evaluate) {
         if (snapshot === null) {
             throw new Error("workflow-child authorize: no credentialsSnapshot active; the supervisor must push one before any step runs");
         }
-        const entry = snapshot.steps.find((s) => s.stepId === stepId);
+        // The credentials snapshot is keyed per base step; a map iteration's
+        // scoped id `<base>[<index>]` resolves to its base entry so every
+        // iteration shares the base step's grants. `baseStepId` is the identity
+        // on an unscoped id, so a plain step is unaffected.
+        const lookupStepId = baseStepId(stepId);
+        const entry = snapshot.steps.find((s) => s.stepId === lookupStepId);
         if (entry === undefined) {
-            throw new Error(`workflow-child authorize: credentialsSnapshot has no entry for stepId ${stepId}`);
+            const scopedNote = lookupStepId === stepId
+                ? ""
+                : ` (normalized from scoped invocation id ${stepId})`;
+            throw new Error(`workflow-child authorize: credentialsSnapshot has no entry for stepId ${lookupStepId}${scopedNote}`);
         }
         return evaluate({
             resource,
@@ -101,7 +112,28 @@ export async function runWorkflowChild(opts) {
     const sourcesRef = {
         current: opts.bindings.initialSources ?? {},
     };
-    const directors = opts.bindings.directors ?? createDefaultDirectorRegistry();
+    const credentialMaterialRef = {
+        current: opts.bindings.initialCredentialMaterial ?? null,
+    };
+    // The per-run credential wiring the top-level step invoker carries to the
+    // substrate: the live material cell and a resolver for a step's grants from
+    // the same credentials snapshot `authorize` reads. Built once over the two
+    // refs; every step build reads them live, so a rotation -- or a revoking
+    // re-push that swaps a ref -- is reflected without rebuilding the wiring.
+    const credentialWiring = {
+        materialRef: credentialMaterialRef,
+        resolveStepGrants: (stepId) => {
+            const snapshot = credentialsRef.current;
+            if (snapshot === null) {
+                throw new Error(`workflow-child credential wiring: no credentials snapshot for step ${stepId}; a tool-bearing step cannot resolve its grants before the run carries any`);
+            }
+            const entry = snapshot.steps.find((step) => step.stepId === baseStepId(stepId));
+            if (entry === undefined) {
+                throw new Error(`workflow-child credential wiring: credentials snapshot has no entry for step ${baseStepId(stepId)}`);
+            }
+            return entry.grants;
+        },
+    };
     const clock = opts.bindings.clock ?? defaultClock;
     const newId = opts.bindings.newId ?? defaultNewId;
     // Mint the child's own upstream-signing keypair. The private half
@@ -120,7 +152,103 @@ export async function runWorkflowChild(opts) {
         channelId: opts.env.channelId,
         writer: opts.eventWriter,
     });
-    const definition = await loadWorkflowDefinition(opts.bindings);
+    // Re-verify barrier at the load boundary. Source-ref is the only deploy
+    // lineage: the inert projection is a non-executable approval surface (agents
+    // carry `modelSources`/no `inference`, tool factories are plain data), so the
+    // child EVALUATES the pinned code closure to a live definition and re-verifies
+    // by projecting it back to inert and hashing (`computeLiveDefinitionHash`)
+    // against `opts.env.definitionHash`; a divergent closure fails closed. The
+    // load happens once before both the resume loop and the trigger loop, so the
+    // same verified definition serves every fresh trigger AND every resume.
+    //
+    // Post-verify structural rewrite: the re-verify above hashed the closure's
+    // INLINE onTrigger bodies (matching the frozen approval); now lift each to a
+    // `{ ref }` so the runtime dispatches to the body child, and keep the
+    // extracted body definitions in an in-memory map. The suspendable-child
+    // resolver runs each body from THIS map -- the parent's already-re-verified
+    // closure -- with no disk read and no separate per-body re-verify. The rewrite
+    // MUST follow the re-verify: rewriting first would diverge from the frozen
+    // inline-body hash.
+    const verifiedDefinition = await loadVerifiedWorkflowDefinitionFromClosure({
+        packageDir: opts.env.closurePackageDir,
+        approvedHash: opts.env.definitionHash,
+    });
+    const { workflow, bodies } = rewriteInlineOnTriggerBodies(verifiedDefinition);
+    let definition = workflow;
+    const bodiesMap = new Map(bodies.map((b) => [b.ref, b.definition]));
+    // An owned `childWorkflow` import embeds its child inline in the parent's
+    // definition (folded into the parent's hash and approval), so it is already
+    // covered by the re-verify above. Lift each inline child to an internal
+    // `{ ref }` -- the form the runtime dispatches -- and keep the lifted
+    // definitions in an in-memory map. The terminal childWorkflow resolver below
+    // runs each child from THIS map, with no on-disk asset read and no separate
+    // per-child re-verify.
+    const childRewrite = rewriteInlineChildWorkflowBodies(definition);
+    definition = childRewrite.workflow;
+    const childBodiesMap = new Map(childRewrite.bodies.map((b) => [b.ref, b.definition]));
+    // Directors resolve from the pinned closure so a custom director authored in
+    // the workflow's own package runs. Loading directors OUTSIDE the
+    // definition-hash re-verify is safe: the approved hash pins each director's
+    // id + config (which director runs cannot change post-approval) and the
+    // closure's SRI pins its module bytes. Folding directors into the hash would
+    // be redundant, so it is deliberately not done -- see
+    // `loadWorkflowDirectorRegistryFromClosure`.
+    const directors = await loadWorkflowDirectorRegistryFromClosure({
+        packageDir: opts.env.closurePackageDir,
+    });
+    // Suspendable-child (onTrigger body) resolver, selected ONCE per deployment:
+    // the bodies map is immutable and the per-run `onEvent` is injected later in
+    // `buildRuntimeEnv`. Resolve each body from the parent's in-memory closure
+    // (already re-verified above) via the raw executor binding. A deployment that
+    // carries bodies but whose host wired no executor is a misconfiguration --
+    // fail loud at startup rather than silently falling back to a disk read (the
+    // exact behaviour this arm exists to avoid). A deployment with no onTrigger
+    // body leaves the host undefined; its suspendable-child slot is never invoked.
+    let suspendableChildHost;
+    if (bodiesMap.size > 0) {
+        const executor = opts.bindings.runSuspendableChild;
+        if (executor === undefined) {
+            throw new Error("workflow-child: source-ref deployment carries onTrigger bodies but " +
+                "the host wired no runSuspendableChild executor; cannot resolve " +
+                "bodies in-memory");
+        }
+        suspendableChildHost = createInMemorySpawnSuspendableChild({
+            bodies: bodiesMap,
+            runSuspendableChild: executor,
+        });
+    }
+    // Terminal childWorkflow resolver, selected ONCE per deployment. When the
+    // definition embeds any inline child (the lifted map is non-empty), resolve
+    // each from that in-memory map via the raw terminal executor -- the parent's
+    // own re-verified closure -- so an owned child spawns with no disk read. A
+    // deployment that embeds a childWorkflow but whose host wired no executor is
+    // a misconfiguration and fails loud at startup rather than falling back to a
+    // disk read. A definition with no inline child keeps the injected binding (a
+    // test seam); its childWorkflow slot is never invoked.
+    let spawnChild;
+    if (childBodiesMap.size > 0) {
+        const executor = opts.bindings.runChild;
+        if (executor === undefined) {
+            throw new Error("workflow-child: deployment embeds childWorkflow imports but the " +
+                "host wired no runChild executor; cannot resolve children in-memory");
+        }
+        spawnChild = createInMemorySpawnChild({
+            bodies: childBodiesMap,
+            runChild: executor,
+        });
+    }
+    else if (opts.bindings.spawnChild !== undefined) {
+        spawnChild = opts.bindings.spawnChild;
+    }
+    else {
+        // No inline child and no injected binding: a workflow that nonetheless
+        // reaches a childWorkflow spawn fails loud here rather than silently
+        // completing against a child that never ran.
+        spawnChild = async ({ definitionRef }) => {
+            throw new Error(`workflow-child: childWorkflow ${definitionRef} reached the runtime ` +
+                `but no child executor is wired`);
+        };
+    }
     const authorize = createCredentialsBackedAuthorize(credentialsRef, opts.bindings.evaluateGrants);
     const drainController = createWorkflowHostDrainController({ definition });
     // Warm-agent cache (design §3b). Built only when the deployment is a
@@ -174,16 +302,20 @@ export async function runWorkflowChild(opts) {
             runtimeRepoStore,
             authorize,
             directors,
+            suspendableChildHost,
+            spawnChild,
             clock,
             newId,
             drainController,
             warmCache,
             sourcesRef,
+            credentialWiring,
             onEvent: (event) => {
                 void eventSender.send(event).catch((cause) => {
                     logger.error `event-channel send failed during resume run ${run.runId}: ${String(cause)}`;
                 });
             },
+            upstreamSender,
         });
         const handle = runtimeRun(definition, env, {
             runId: run.runId,
@@ -202,13 +334,12 @@ export async function runWorkflowChild(opts) {
                 cleanupRunStorage: opts.bindings.cleanupRunStorage,
                 runId: run.runId,
             });
+            runsInFlight.delete(run.runId);
             return emitTerminalEvent(upstreamSender, result);
         })
             .catch((cause) => {
-            logger.error `resumed run ${run.runId} failed: ${String(cause)}`;
-        })
-            .finally(() => {
             runsInFlight.delete(run.runId);
+            logger.error `resumed run ${run.runId} failed: ${String(cause)}`;
         });
         resumedRunIds.push(run.runId);
     }
@@ -231,6 +362,12 @@ export async function runWorkflowChild(opts) {
             childPublicKey: hexEncode(childKeyPair.publicKey),
         },
     });
+    // Report self-discovered runs so the supervisor seeds its cohort
+    // tracking before the dispatch loop starts.
+    await upstreamSender.send({
+        type: "resumed.runs",
+        data: { runIds: resumedRunIds },
+    });
     const triggeredRunIds = [];
     // Control-loop. The receiver iterator yields one verified payload
     // per call; any signature/channelId/seq violation crashes the
@@ -253,6 +390,8 @@ export async function runWorkflowChild(opts) {
                 definition,
                 authorize,
                 directors,
+                suspendableChildHost,
+                spawnChild,
                 clock,
                 newId,
                 eventSender,
@@ -262,6 +401,8 @@ export async function runWorkflowChild(opts) {
                 runsInFlight,
                 warmCache,
                 sourcesRef,
+                credentialMaterialRef,
+                credentialWiring,
                 ...(opts.substrateWriteBridge !== undefined
                     ? { substrateWriteBridge: opts.substrateWriteBridge }
                     : {}),
@@ -320,16 +461,16 @@ async function handleControlPayload(payload, ctx) {
         case "trigger.fire": {
             // One driver per runId. If this child is already driving this
             // runId -- self-discovery resumed it, or an earlier trigger opened
-            // it -- the supervisor's re-fire (which carries `runId = messageId`
-            // and no resumeFromEvents) must NOT spawn a second `runtimeRun`. A
+            // it -- a duplicate/stale trigger frame (which carries the local part
+            // of the deployment's mail address as the runId and no resumeFromEvents)
+            // must NOT spawn a second `runtimeRun`. A
             // second concurrent driver would race the live one to settle the
             // same residual and the loser throws an uncaught TransitionError,
             // and even a driver that avoided the throw would double-emit the
             // terminal. The live driver's completion continuation owns the
             // single terminal emission; the supervisor's terminal-event-driven
-            // `markConsumed` consumes the message off that one terminal, so no
-            // work is dropped by declining here. Record the runId (the
-            // supervisor did fire a trigger and it was accepted) and signal
+            // `markConsumed` consumes the original message off that one terminal,
+            // so no work is dropped by declining here. Record the runId and signal
             // "handled, not shutdown" the same way the normal trigger case
             // returns, without awaiting the live handle's `complete` inline
             // (that would block the control loop).
@@ -360,16 +501,20 @@ async function handleControlPayload(payload, ctx) {
                 runtimeRepoStore: ctx.runtimeRepoStore,
                 authorize: ctx.authorize,
                 directors: ctx.directors,
+                suspendableChildHost: ctx.suspendableChildHost,
+                spawnChild: ctx.spawnChild,
                 clock: ctx.clock,
                 newId: ctx.newId,
                 drainController: ctx.drainController,
                 warmCache: ctx.warmCache,
                 sourcesRef: ctx.sourcesRef,
+                credentialWiring: ctx.credentialWiring,
                 onEvent: (event) => {
                     void ctx.eventSender.send(event).catch((cause) => {
                         logger.error `event-channel send failed during run ${payload.data.runId}: ${String(cause)}`;
                     });
                 },
+                upstreamSender: ctx.upstreamSender,
             });
             const handle = runtimeRun(ctx.definition, env, {
                 runId: payload.data.runId,
@@ -392,13 +537,12 @@ async function handleControlPayload(payload, ctx) {
                     cleanupRunStorage: ctx.bindings.cleanupRunStorage,
                     runId: payload.data.runId,
                 });
+                ctx.runsInFlight.delete(payload.data.runId);
                 return emitTerminalEvent(ctx.upstreamSender, result);
             })
                 .catch((cause) => {
-                logger.error `triggered run ${payload.data.runId} failed: ${String(cause)}`;
-            })
-                .finally(() => {
                 ctx.runsInFlight.delete(payload.data.runId);
+                logger.error `triggered run ${payload.data.runId} failed: ${String(cause)}`;
             });
             ctx.triggeredRunIds.push(payload.data.runId);
             return false;
@@ -432,7 +576,26 @@ async function handleControlPayload(payload, ctx) {
             ctx.credentialsRef.current = snapshot;
             return false;
         }
+        case "credentials-updated": {
+            // Replace the in-memory credential material wholesale. A revoked
+            // credential arrives by omission -- its material entry is absent from
+            // the delivery -- so the swap evicts it. Atomic whole-object assignment,
+            // so a concurrent reader never observes a torn cell. The secret stays on
+            // this ref only; nothing here copies it into a snapshot, event, or state.
+            ctx.credentialMaterialRef.current = payload.data.delivery;
+            return false;
+        }
         case "signal.deliver": {
+            // Drop a delivery for a run this child is not driving. The dispatch path
+            // only ever targets a live run id, but a stale or mis-routed frame -- a
+            // synthetic body-child id, or a run that crashed and has not been
+            // re-discovered -- must not commit an orphan `SignalReceived` to a log no
+            // awaiter is tailing. `runsInFlight` is the one-driver authority on which
+            // runs this child drives.
+            if (!ctx.runsInFlight.has(payload.data.runId)) {
+                logger.warn `signal.deliver for run ${payload.data.runId} which is not in flight; dropping (signalName=${payload.data.signalName})`;
+                return false;
+            }
             // Land the signal as a `SignalReceived` commit on the run's
             // event log. The signal-channel substrate's `subscribeKind`
             // peer (the per-run signal channel installed at run start) is
@@ -566,6 +729,13 @@ async function handleControlPayload(payload, ctx) {
             // `ready` or `recycle.request`.
             throw new Error("workflow-child received a `terminal.event` frame on its inbound control channel; this is a child-only upstream payload");
         }
+        case "park.notify": {
+            // `park.notify` is the child->supervisor suspension-notification
+            // frame; receiving one on the child's downstream side is a
+            // protocol violation in the same shape as a downstream
+            // `terminal.event`.
+            throw new Error("workflow-child received a `park.notify` frame on its inbound control channel; this is a child-only upstream payload");
+        }
         case "outbound.message": {
             // `outbound.message` is the child->supervisor outbound-mail
             // request frame; receiving one on the child's downstream side is a
@@ -609,6 +779,42 @@ async function handleControlPayload(payload, ctx) {
             ctx.substrateWriteBridge.handleWriteResponse(payload.data);
             return false;
         }
+        case "parked-correlations.request": {
+            // Answer the supervisor's re-registration enumeration from durable
+            // state. Awaiting inline is safe -- unlike `signal.deliver`, this
+            // reads (self-discovery + the snapshot binding) and sends one upstream
+            // reply without awaiting any downstream frame, so it cannot deadlock
+            // the iterator against a response it is itself blocking. A store
+            // inconsistency (an enumerated park with no durable snapshot, or no
+            // binding to recover one) throws out of the loop like the other
+            // invariant-violation arms rather than dropping a correlation the hub
+            // is waiting to register.
+            const parked = await collectParkedApprovalCorrelations({
+                substrate: ctx.bindings.substrate,
+                repoId: ctx.bindings.workflowRunRepoId,
+                runtimeRepoStore: ctx.runtimeRepoStore,
+                ...(ctx.bindings.loadParkedApproval !== undefined
+                    ? { loadParkedApproval: ctx.bindings.loadParkedApproval }
+                    : {}),
+            });
+            await ctx.upstreamSender.send({
+                type: "parked-correlations.response",
+                data: { requestId: payload.data.requestId, parked },
+            });
+            return false;
+        }
+        case "resumed.runs": {
+            // `resumed.runs` is the child->supervisor self-discovery report;
+            // receiving one on the child's downstream side is a protocol
+            // violation in the same shape as a downstream `ready`.
+            throw new Error("workflow-child received a `resumed.runs` frame on its inbound control channel; this is a child-only upstream payload");
+        }
+        case "parked-correlations.response": {
+            // `parked-correlations.response` is the child->supervisor reply frame;
+            // receiving one on the child's downstream side is a protocol violation
+            // in the same shape as a downstream `substrate.merge.response`.
+            throw new Error("workflow-child received a `parked-correlations.response` frame on its inbound control channel; this is a child-only upstream payload");
+        }
     }
 }
 /**
@@ -643,8 +849,18 @@ function buildRuntimeEnv(args) {
     // `ChildStepInvoker` shape (carries onEvent), so the workflow-
     // runtime never has to know an event firehose exists.
     const invokeStep = async (req) => {
-        return args.bindings.invokeStep(req, args.onEvent, args.authorize, args.warmCache, args.sourcesRef);
+        return args.bindings.invokeStep(req, args.onEvent, args.authorize, args.warmCache, args.sourcesRef, args.credentialWiring);
     };
+    // Adapt the host binding (which takes the run's `onEvent` sink) down to the
+    // runtime's narrow `SpawnSuspendableChild` by injecting THIS run's event
+    // funnel -- the same closure `invokeStep` forwards -- so a body's live
+    // inference events ride the parent run's event channel to the hub stream
+    // (and inherit its loud-on-failure logging), while the runtime env keeps the
+    // narrow contract with no event slot.
+    const hostSuspendable = args.suspendableChildHost;
+    const spawnSuspendableChild = hostSuspendable === undefined
+        ? undefined
+        : (spawnInput) => hostSuspendable(spawnInput, args.onEvent);
     return {
         repoStore: args.runtimeRepoStore,
         scheduler: args.bindings.scheduler,
@@ -653,12 +869,62 @@ function buildRuntimeEnv(args) {
         directors: args.directors,
         authorize: args.authorize,
         invokeStep,
-        spawnChild: args.bindings.spawnChild,
+        spawnChild: args.spawnChild,
+        // Wire the suspendable-child seam only when the host supplied it; a child
+        // that never runs an onTrigger section omits the binding, and the runtime
+        // body fails loud if a workflow reaches a section the env did not wire.
+        ...(spawnSuspendableChild !== undefined ? { spawnSuspendableChild } : {}),
         clock: args.clock,
         newId: args.newId,
         drain: args.drainController,
+        // Forward a control-plane suspension up the same upstream control
+        // channel `terminal.event` rides, so the supervisor can stamp the
+        // deployment identity and register the correlation at the hub. The
+        // runtime body fires this once per fresh park on a reserved
+        // `signalName(correlationId)` channel.
+        onPark: (park) => {
+            void emitParkNotify(args.upstreamSender, park);
+        },
+        // Let the resume classifier recover a step that crashed across the park
+        // boundary. Absent (tests, the recursive child-workflow adapter) leaves a
+        // crashed invocation a terminal failure.
+        ...(args.bindings.readParkedApprovalOps !== undefined
+            ? { readParkedApprovalOps: args.bindings.readParkedApprovalOps }
+            : {}),
     };
 }
+/**
+ * Forward a control-plane suspension to the supervisor over the upstream
+ * control channel. Fired from `env.onPark` each time a workflow agent step
+ * parks on a reserved `signalName(correlationId)` channel. The supervisor's
+ * `park.notify` arm stamps the deployment identity it owns and sends a
+ * `signal.correlation.register` frame to the hub.
+ *
+ * Best-effort like `emitTerminalEvent`'s send: a transport failure is logged,
+ * not rethrown. A lost frame means the correlation is not registered and the
+ * parked run cannot be resumed until it is re-registered; the failure surfaces
+ * structurally as a run that never resumes rather than a silent lifecycle
+ * corruption. The register at the hub is idempotent, so a re-park resume's
+ * re-emit is safe.
+ */
+export function emitParkNotify(upstreamSender, park) {
+    return upstreamSender
+        .send({
+        type: "park.notify",
+        data: {
+            runId: park.runId,
+            correlationId: park.correlationId,
+            parkKind: park.parkKind,
+            ...(park.approvalSnapshot !== undefined
+                ? { snapshot: park.approvalSnapshot }
+                : {}),
+        },
+    })
+        .catch((cause) => {
+        const message = cause instanceof Error ? cause.message : String(cause);
+        logger.error `park.notify upstream send failed for runId=${park.runId} correlationId=${park.correlationId}: ${message}`;
+    });
+}
 /**
  * Mirror a run's terminal status back to the supervisor over the
  * upstream control channel. Fired once per run from the resume and
@@ -804,90 +1070,6 @@ async function resolveTriggerPayload(args) {
     const raw = base64Decode(rawMessageBase64);
     return extractConversationText(raw, args.messageId);
 }
-/**
- * Extract the conversation body text from a raw inbound MIME message.
- *
- * Three on-wire shapes are handled, matching every producer the mail
- * bus accepts:
- *   1. The Interchange assembler's `multipart/signed` envelope whose
- *      first part is a `multipart/mixed` body carrying the text at part
- *      path `1.1`.
- *   2. A `multipart/signed` envelope wrapping a bare `text/plain` part
- *      (a sender that signs without the `multipart/mixed` wrapper); the
- *      text is at part path `1`.
- *   3. A flat top-level `text/plain` message (no multipart structure at
- *      all); the body is the bytes after the header section.
- *
- * The top-level `Content-Type` selects the shape: only a `multipart/*`
- * root walks into parts; anything else reads the single body directly.
- * This mirrors the conversation branch of mail-memory's `fetchFull`
- * while also tolerating the flat single-part case the in-process agent
- * accepts, so a non-standard inbound mail still delivers its text to
- * the agent rather than crashing the run.
- */
-function extractConversationText(raw, messageId) {
-    const { headers, bodyOffset } = parseHeaderSection(raw);
-    const rootMime = (headers.get("content-type") ?? "")
-        .split(";")[0]
-        ?.trim()
-        .toLowerCase();
-    if (rootMime === undefined || !rootMime.startsWith("multipart/")) {
-        // Flat single-part message: the body is everything after the
-        // header section.
-        return new TextDecoder("utf-8", { fatal: false }).decode(raw.subarray(bodyOffset));
-    }
-    let part1;
-    try {
-        part1 = parseMimePart(extractPartByPath(raw, "1"));
-    }
-    catch (cause) {
-        throw new Error(`workflow-child trigger.fire: cannot parse inbound mail part 1 for messageId ${messageId}`, { cause });
-    }
-    const part1Mime = (part1.contentType.split(";")[0] ?? "")
-        .trim()
-        .toLowerCase();
-    const bodyBytes = part1Mime.startsWith("multipart/")
-        ? parseMimePart(extractPartByPath(raw, "1.1")).body
-        : part1.body;
-    return new TextDecoder("utf-8", { fatal: false }).decode(bodyBytes);
-}
-/**
- * Load the `WorkflowDefinition` from the workflow asset repo's deploy
- * ref. Mirrors the sibling `spawn-child` adapter's working-tree-read
- * pattern -- the deploy orchestrator's `writeTree` materializes
- * `workflow.json` under the substrate's repo dir, so a flat
- * `fs.readFile` returns the bytes without round-tripping through git.
- */
-async function loadWorkflowDefinition(bindings) {
-    const fs = await import("node:fs/promises");
-    const path = await import("node:path");
-    const dir = bindings.substrate.getRepoDir(bindings.workflowDefinitionRepoId);
-    const workflowPath = path.join(dir, WORKFLOW_JSON_PATH);
-    let raw;
-    try {
-        raw = await fs.readFile(workflowPath, "utf8");
-    }
-    catch (cause) {
-        throw new Error(`workflow-child: cannot read ${WORKFLOW_JSON_PATH} for ${bindings.workflowDefinitionRepoId.kind}/${bindings.workflowDefinitionRepoId.id} on ${bindings.workflowDefinitionRef}`, { cause });
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch (cause) {
-        throw new Error(`workflow-child: ${WORKFLOW_JSON_PATH} for ${bindings.workflowDefinitionRepoId.kind}/${bindings.workflowDefinitionRepoId.id} on ${bindings.workflowDefinitionRef} is not valid JSON`, { cause });
-    }
-    const validated = workflowDefinitionEnvelopeSchema(parsed);
-    if (validated instanceof type.errors) {
-        throw new Error(`workflow-child: ${WORKFLOW_JSON_PATH} for ${bindings.workflowDefinitionRepoId.kind}/${bindings.workflowDefinitionRepoId.id} on ${bindings.workflowDefinitionRef} failed envelope validation: ${validated.summary}`);
-    }
-    // The envelope schema enforces the structural shape; the
-    // discriminated narrow over every primitive variant lives downstream
-    // in the runtime body. The sibling `spawn-child` adapter follows the
-    // same pattern at the same boundary.
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- envelope schema enforces structural shape; primitive narrows live downstream in the runtime body
-    return validated;
-}
 function defaultClock() {
     return new Date();
 }

package/dist/child/self-discovery.d.ts

@@ -25,5 +25,15 @@ export interface DiscoverRunsOpts {
  * terminal event. Runs that already terminated are skipped because
  * resume against a terminal log would still settle without progress
  * but would generate spurious "resume seed" reads for no benefit.
+ *
+ * Child runs are excluded. A run spawned by another run -- a
+ * `childWorkflow` step's child or an `onTrigger` section's per-event body,
+ * whichever committed a `ChildSpawned` naming it -- is driven by its
+ * PARENT's runtime, not on its own. Resuming a child here would re-run it
+ * under the deployment definition rather than the child's own definition,
+ * and for a body approval park it would hub-register the child's internal
+ * park that the parent already proxies up on the shared correlation. A
+ * child run is identified structurally, by appearing as a
+ * `ChildSpawned.childRunId` in some log, rather than by its id shape.
  */
 export declare function discoverInFlightRuns(opts: DiscoverRunsOpts): Promise<readonly DiscoveredRun[]>;

package/dist/child/self-discovery.js

@@ -22,6 +22,16 @@ const RUNS_PREFIX = "runs";
  * terminal event. Runs that already terminated are skipped because
  * resume against a terminal log would still settle without progress
  * but would generate spurious "resume seed" reads for no benefit.
+ *
+ * Child runs are excluded. A run spawned by another run -- a
+ * `childWorkflow` step's child or an `onTrigger` section's per-event body,
+ * whichever committed a `ChildSpawned` naming it -- is driven by its
+ * PARENT's runtime, not on its own. Resuming a child here would re-run it
+ * under the deployment definition rather than the child's own definition,
+ * and for a body approval park it would hub-register the child's internal
+ * park that the parent already proxies up on the shared correlation. A
+ * child run is identified structurally, by appearing as a
+ * `ChildSpawned.childRunId` in some log, rather than by its id shape.
  */
 export async function discoverInFlightRuns(opts) {
     const fs = await import("node:fs/promises");
@@ -37,11 +47,25 @@ export async function discoverInFlightRuns(opts) {
             return [];
         throw cause;
     }
-    const out = [];
+    // Read every run's log once, and collect the set of run ids that any log
+    // spawned as a child. The scan spans every run (terminal ones included) so
+    // a child whose parent already completed is still recognized as a child.
+    const logs = new Map();
+    const childRunIds = new Set();
     for (const runId of runDirs) {
         const events = await opts.runtimeRepoStore.read(runId);
         if (events.length === 0)
             continue;
+        logs.set(runId, events);
+        for (const event of events) {
+            if (event.kind === "ChildSpawned")
+                childRunIds.add(event.childRunId);
+        }
+    }
+    const out = [];
+    for (const [runId, events] of logs) {
+        if (childRunIds.has(runId))
+            continue;
         const resumed = resumeFromLog(runId, events);
         if (isTerminalRunPhase(resumed.phase))
             continue;