@oisincoveney/pipeline 2.1.1 → 2.3.0

package/dist/runner-event-schema.d.ts

@@ -0,0 +1,349 @@
+import { RunnerEventRecord } from "./runner-command-contract.js";
+import { z } from "zod";
+
+//#region src/runner-event-schema.d.ts
+/**
+ * Zod schema for a single runner event record — one item in the events array
+ * that the runner POSTs to /api/pipeline/runner-events.
+ */
+declare const runnerEventRecordSchema: z.ZodUnion<readonly [z.ZodObject<{
+  at: z.ZodOptional<z.ZodString>;
+  sequence: z.ZodNumber;
+  type: z.ZodEnum<{
+    "workflow.planned": "workflow.planned";
+    "workflow.start": "workflow.start";
+  }>;
+  workflowPlan: z.ZodObject<{
+    edges: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      source: z.ZodString;
+      target: z.ZodString;
+    }, z.core.$strip>>>;
+    nodeIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    nodes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      kind: z.ZodString;
+      needs: z.ZodArray<z.ZodString>;
+      profile: z.ZodOptional<z.ZodString>;
+      runnerId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    workflowId: z.ZodString;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  at: z.ZodOptional<z.ZodString>;
+  sequence: z.ZodNumber;
+  edge: z.ZodObject<{
+    id: z.ZodString;
+    source: z.ZodString;
+    target: z.ZodString;
+  }, z.core.$strip>;
+  type: z.ZodLiteral<"workflow.edge">;
+}, z.core.$strip>, z.ZodObject<{
+  at: z.ZodOptional<z.ZodString>;
+  sequence: z.ZodNumber;
+  node: z.ZodObject<{
+    attempt: z.ZodNumber;
+    exitCode: z.ZodOptional<z.ZodNumber>;
+    nodeId: z.ZodString;
+    profile: z.ZodOptional<z.ZodString>;
+    runnerId: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+      "agent-finished": "agent-finished";
+      "agent-running": "agent-running";
+      failed: "failed";
+      passed: "passed";
+      running: "running";
+    }>;
+  }, z.core.$strip>;
+  type: z.ZodEnum<{
+    "agent.finish": "agent.finish";
+    "agent.start": "agent.start";
+    "node.finish": "node.finish";
+    "node.start": "node.start";
+  }>;
+}, z.core.$strip>, z.ZodObject<{
+  at: z.ZodOptional<z.ZodString>;
+  sequence: z.ZodNumber;
+  gate: z.ZodObject<{
+    event: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    gateId: z.ZodOptional<z.ZodString>;
+    hookId: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    nodeId: z.ZodOptional<z.ZodString>;
+    passed: z.ZodOptional<z.ZodBoolean>;
+    reason: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    status: z.ZodEnum<{
+      failed: "failed";
+      passed: "passed";
+      running: "running";
+    }>;
+    workflowId: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  type: z.ZodEnum<{
+    "gate.finish": "gate.finish";
+    "gate.start": "gate.start";
+    "hook.finish": "hook.finish";
+    "hook.start": "hook.start";
+  }>;
+}, z.core.$strip>, z.ZodObject<{
+  at: z.ZodOptional<z.ZodString>;
+  sequence: z.ZodNumber;
+  hookResult: z.ZodObject<{
+    artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      contentType: z.ZodOptional<z.ZodString>;
+      name: z.ZodString;
+      path: z.ZodString;
+    }, z.core.$strip>>>;
+    event: z.ZodString;
+    functionId: z.ZodString;
+    gateId: z.ZodOptional<z.ZodString>;
+    hookId: z.ZodString;
+    nodeId: z.ZodOptional<z.ZodString>;
+    outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    status: z.ZodEnum<{
+      fail: "fail";
+      pass: "pass";
+      skip: "skip";
+    }>;
+    summary: z.ZodOptional<z.ZodString>;
+    workflowId: z.ZodString;
+  }, z.core.$strip>;
+  type: z.ZodLiteral<"hook.result">;
+}, z.core.$strip>, z.ZodObject<{
+  at: z.ZodOptional<z.ZodString>;
+  sequence: z.ZodNumber;
+  artifact: z.ZodObject<{
+    kind: z.ZodLiteral<"artifact">;
+    label: z.ZodString;
+    nodeId: z.ZodString;
+    passed: z.ZodOptional<z.ZodBoolean>;
+    path: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+    required: z.ZodBoolean;
+    status: z.ZodEnum<{
+      failed: "failed";
+      passed: "passed";
+      running: "running";
+    }>;
+    uri: z.ZodString;
+  }, z.core.$strip>;
+  type: z.ZodEnum<{
+    "artifact.check.finish": "artifact.check.finish";
+    "artifact.check.start": "artifact.check.start";
+  }>;
+}, z.core.$strip>, z.ZodObject<{
+  at: z.ZodOptional<z.ZodString>;
+  sequence: z.ZodNumber;
+  log: z.ZodObject<{
+    attempt: z.ZodOptional<z.ZodNumber>;
+    format: z.ZodOptional<z.ZodString>;
+    level: z.ZodEnum<{
+      info: "info";
+      warn: "warn";
+    }>;
+    message: z.ZodString;
+    nodeId: z.ZodOptional<z.ZodString>;
+    output: z.ZodOptional<z.ZodUnknown>;
+    passed: z.ZodOptional<z.ZodBoolean>;
+    reason: z.ZodOptional<z.ZodString>;
+    workflowId: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  type: z.ZodEnum<{
+    "node.output.recorded": "node.output.recorded";
+    "output.repair": "output.repair";
+    "run.cancelled": "run.cancelled";
+    "runner.command.phase": "runner.command.phase";
+    "runner.schema.validation": "runner.schema.validation";
+    "runtime.observability": "runtime.observability";
+  }>;
+}, z.core.$strip>, z.ZodObject<{
+  at: z.ZodOptional<z.ZodString>;
+  sequence: z.ZodNumber;
+  finalResult: z.ZodObject<{
+    outcome: z.ZodEnum<{
+      CANCELLED: "CANCELLED";
+      FAIL: "FAIL";
+      PASS: "PASS";
+    }>;
+    workflowId: z.ZodString;
+  }, z.core.$strip>;
+  type: z.ZodLiteral<"workflow.finish">;
+}, z.core.$strip>]>;
+/**
+ * Zod schema for the POST body of /api/pipeline/runner-events.
+ * The runner sends { events: RunnerEventRecord[] }.
+ */
+declare const runnerEventBatchSchema: z.ZodObject<{
+  events: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+    at: z.ZodOptional<z.ZodString>;
+    sequence: z.ZodNumber;
+    type: z.ZodEnum<{
+      "workflow.planned": "workflow.planned";
+      "workflow.start": "workflow.start";
+    }>;
+    workflowPlan: z.ZodObject<{
+      edges: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        target: z.ZodString;
+      }, z.core.$strip>>>;
+      nodeIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      nodes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodString;
+        needs: z.ZodArray<z.ZodString>;
+        profile: z.ZodOptional<z.ZodString>;
+        runnerId: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>>;
+      workflowId: z.ZodString;
+    }, z.core.$strip>;
+  }, z.core.$strip>, z.ZodObject<{
+    at: z.ZodOptional<z.ZodString>;
+    sequence: z.ZodNumber;
+    edge: z.ZodObject<{
+      id: z.ZodString;
+      source: z.ZodString;
+      target: z.ZodString;
+    }, z.core.$strip>;
+    type: z.ZodLiteral<"workflow.edge">;
+  }, z.core.$strip>, z.ZodObject<{
+    at: z.ZodOptional<z.ZodString>;
+    sequence: z.ZodNumber;
+    node: z.ZodObject<{
+      attempt: z.ZodNumber;
+      exitCode: z.ZodOptional<z.ZodNumber>;
+      nodeId: z.ZodString;
+      profile: z.ZodOptional<z.ZodString>;
+      runnerId: z.ZodOptional<z.ZodString>;
+      status: z.ZodEnum<{
+        "agent-finished": "agent-finished";
+        "agent-running": "agent-running";
+        failed: "failed";
+        passed: "passed";
+        running: "running";
+      }>;
+    }, z.core.$strip>;
+    type: z.ZodEnum<{
+      "agent.finish": "agent.finish";
+      "agent.start": "agent.start";
+      "node.finish": "node.finish";
+      "node.start": "node.start";
+    }>;
+  }, z.core.$strip>, z.ZodObject<{
+    at: z.ZodOptional<z.ZodString>;
+    sequence: z.ZodNumber;
+    gate: z.ZodObject<{
+      event: z.ZodOptional<z.ZodString>;
+      evidence: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      gateId: z.ZodOptional<z.ZodString>;
+      hookId: z.ZodOptional<z.ZodString>;
+      kind: z.ZodOptional<z.ZodString>;
+      label: z.ZodOptional<z.ZodString>;
+      nodeId: z.ZodOptional<z.ZodString>;
+      passed: z.ZodOptional<z.ZodBoolean>;
+      reason: z.ZodOptional<z.ZodString>;
+      required: z.ZodOptional<z.ZodBoolean>;
+      status: z.ZodEnum<{
+        failed: "failed";
+        passed: "passed";
+        running: "running";
+      }>;
+      workflowId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type: z.ZodEnum<{
+      "gate.finish": "gate.finish";
+      "gate.start": "gate.start";
+      "hook.finish": "hook.finish";
+      "hook.start": "hook.start";
+    }>;
+  }, z.core.$strip>, z.ZodObject<{
+    at: z.ZodOptional<z.ZodString>;
+    sequence: z.ZodNumber;
+    hookResult: z.ZodObject<{
+      artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        contentType: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        path: z.ZodString;
+      }, z.core.$strip>>>;
+      event: z.ZodString;
+      functionId: z.ZodString;
+      gateId: z.ZodOptional<z.ZodString>;
+      hookId: z.ZodString;
+      nodeId: z.ZodOptional<z.ZodString>;
+      outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+      status: z.ZodEnum<{
+        fail: "fail";
+        pass: "pass";
+        skip: "skip";
+      }>;
+      summary: z.ZodOptional<z.ZodString>;
+      workflowId: z.ZodString;
+    }, z.core.$strip>;
+    type: z.ZodLiteral<"hook.result">;
+  }, z.core.$strip>, z.ZodObject<{
+    at: z.ZodOptional<z.ZodString>;
+    sequence: z.ZodNumber;
+    artifact: z.ZodObject<{
+      kind: z.ZodLiteral<"artifact">;
+      label: z.ZodString;
+      nodeId: z.ZodString;
+      passed: z.ZodOptional<z.ZodBoolean>;
+      path: z.ZodString;
+      reason: z.ZodOptional<z.ZodString>;
+      required: z.ZodBoolean;
+      status: z.ZodEnum<{
+        failed: "failed";
+        passed: "passed";
+        running: "running";
+      }>;
+      uri: z.ZodString;
+    }, z.core.$strip>;
+    type: z.ZodEnum<{
+      "artifact.check.finish": "artifact.check.finish";
+      "artifact.check.start": "artifact.check.start";
+    }>;
+  }, z.core.$strip>, z.ZodObject<{
+    at: z.ZodOptional<z.ZodString>;
+    sequence: z.ZodNumber;
+    log: z.ZodObject<{
+      attempt: z.ZodOptional<z.ZodNumber>;
+      format: z.ZodOptional<z.ZodString>;
+      level: z.ZodEnum<{
+        info: "info";
+        warn: "warn";
+      }>;
+      message: z.ZodString;
+      nodeId: z.ZodOptional<z.ZodString>;
+      output: z.ZodOptional<z.ZodUnknown>;
+      passed: z.ZodOptional<z.ZodBoolean>;
+      reason: z.ZodOptional<z.ZodString>;
+      workflowId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type: z.ZodEnum<{
+      "node.output.recorded": "node.output.recorded";
+      "output.repair": "output.repair";
+      "run.cancelled": "run.cancelled";
+      "runner.command.phase": "runner.command.phase";
+      "runner.schema.validation": "runner.schema.validation";
+      "runtime.observability": "runtime.observability";
+    }>;
+  }, z.core.$strip>, z.ZodObject<{
+    at: z.ZodOptional<z.ZodString>;
+    sequence: z.ZodNumber;
+    finalResult: z.ZodObject<{
+      outcome: z.ZodEnum<{
+        CANCELLED: "CANCELLED";
+        FAIL: "FAIL";
+        PASS: "PASS";
+      }>;
+      workflowId: z.ZodString;
+    }, z.core.$strip>;
+    type: z.ZodLiteral<"workflow.finish">;
+  }, z.core.$strip>]>>;
+}, z.core.$strict>;
+type RunnerEventRecordSchema = typeof runnerEventRecordSchema;
+type RunnerEventBatchSchema = typeof runnerEventBatchSchema;
+declare const _runnerEventRecordTypeCheck: z.ZodType<RunnerEventRecord>;
+//#endregion
+export { RunnerEventBatchSchema, type RunnerEventRecord, RunnerEventRecordSchema, _runnerEventRecordTypeCheck, runnerEventBatchSchema, runnerEventRecordSchema };

package/dist/runner-event-schema.js

@@ -0,0 +1,185 @@
+import { z } from "zod";
+//#region src/runner-event-schema.ts
+const runnerEventEnvelopeSchema = z.object({
+	at: z.string().optional(),
+	sequence: z.number().int().positive()
+});
+const runnerWorkflowNodeDetailsSchema = z.object({
+	id: z.string().min(1),
+	kind: z.string().min(1),
+	needs: z.array(z.string()),
+	profile: z.string().optional(),
+	runnerId: z.string().optional()
+});
+const runnerWorkflowEdgeDetailsSchema = z.object({
+	source: z.string().min(1),
+	target: z.string().min(1)
+});
+const runnerWorkflowPlanDetailsSchema = z.object({
+	edges: z.array(runnerWorkflowEdgeDetailsSchema).optional(),
+	nodeIds: z.array(z.string().min(1)).optional(),
+	nodes: z.array(runnerWorkflowNodeDetailsSchema).optional(),
+	workflowId: z.string().min(1)
+});
+const runnerWorkflowEdgeRecordDetailsSchema = z.object({
+	id: z.string().min(1),
+	source: z.string().min(1),
+	target: z.string().min(1)
+});
+const runnerNodeDetailsSchema = z.object({
+	attempt: z.number().int().nonnegative(),
+	exitCode: z.number().int().optional(),
+	nodeId: z.string().min(1),
+	profile: z.string().optional(),
+	runnerId: z.string().optional(),
+	status: z.enum([
+		"agent-finished",
+		"agent-running",
+		"failed",
+		"passed",
+		"running"
+	])
+});
+const runnerGateDetailsSchema = z.object({
+	event: z.string().optional(),
+	evidence: z.array(z.string()).optional(),
+	gateId: z.string().optional(),
+	hookId: z.string().optional(),
+	kind: z.string().optional(),
+	label: z.string().optional(),
+	nodeId: z.string().optional(),
+	passed: z.boolean().optional(),
+	reason: z.string().optional(),
+	required: z.boolean().optional(),
+	status: z.enum([
+		"failed",
+		"passed",
+		"running"
+	]),
+	workflowId: z.string().optional()
+});
+const runnerHookResultDetailsSchema = z.object({
+	artifacts: z.array(z.object({
+		contentType: z.string().optional(),
+		name: z.string().min(1),
+		path: z.string().min(1)
+	})).optional(),
+	event: z.string().min(1),
+	functionId: z.string().min(1),
+	gateId: z.string().optional(),
+	hookId: z.string().min(1),
+	nodeId: z.string().optional(),
+	outputs: z.record(z.string(), z.unknown()).optional(),
+	status: z.enum([
+		"fail",
+		"pass",
+		"skip"
+	]),
+	summary: z.string().optional(),
+	workflowId: z.string().min(1)
+});
+const runnerArtifactDetailsSchema = z.object({
+	kind: z.literal("artifact"),
+	label: z.string().min(1),
+	nodeId: z.string().min(1),
+	passed: z.boolean().optional(),
+	path: z.string().min(1),
+	reason: z.string().optional(),
+	required: z.boolean(),
+	status: z.enum([
+		"failed",
+		"passed",
+		"running"
+	]),
+	uri: z.string().min(1)
+});
+const runnerLogDetailsSchema = z.object({
+	attempt: z.number().int().nonnegative().optional(),
+	format: z.string().optional(),
+	level: z.enum(["info", "warn"]),
+	message: z.string(),
+	nodeId: z.string().optional(),
+	output: z.unknown().optional(),
+	passed: z.boolean().optional(),
+	reason: z.string().optional(),
+	workflowId: z.string().optional()
+});
+const runnerFinalResultDetailsSchema = z.object({
+	outcome: z.enum([
+		"CANCELLED",
+		"FAIL",
+		"PASS"
+	]),
+	workflowId: z.string().min(1)
+});
+const workflowPlanEventSchema = runnerEventEnvelopeSchema.extend({
+	type: z.enum(["workflow.planned", "workflow.start"]),
+	workflowPlan: runnerWorkflowPlanDetailsSchema
+});
+const workflowEdgeEventSchema = runnerEventEnvelopeSchema.extend({
+	edge: runnerWorkflowEdgeRecordDetailsSchema,
+	type: z.literal("workflow.edge")
+});
+const nodeEventSchema = runnerEventEnvelopeSchema.extend({
+	node: runnerNodeDetailsSchema,
+	type: z.enum([
+		"agent.finish",
+		"agent.start",
+		"node.finish",
+		"node.start"
+	])
+});
+const gateEventSchema = runnerEventEnvelopeSchema.extend({
+	gate: runnerGateDetailsSchema,
+	type: z.enum([
+		"gate.finish",
+		"gate.start",
+		"hook.finish",
+		"hook.start"
+	])
+});
+const hookResultEventSchema = runnerEventEnvelopeSchema.extend({
+	hookResult: runnerHookResultDetailsSchema,
+	type: z.literal("hook.result")
+});
+const artifactEventSchema = runnerEventEnvelopeSchema.extend({
+	artifact: runnerArtifactDetailsSchema,
+	type: z.enum(["artifact.check.finish", "artifact.check.start"])
+});
+const logEventSchema = runnerEventEnvelopeSchema.extend({
+	log: runnerLogDetailsSchema,
+	type: z.enum([
+		"node.output.recorded",
+		"output.repair",
+		"run.cancelled",
+		"runner.command.phase",
+		"runner.schema.validation",
+		"runtime.observability"
+	])
+});
+const finalResultEventSchema = runnerEventEnvelopeSchema.extend({
+	finalResult: runnerFinalResultDetailsSchema,
+	type: z.literal("workflow.finish")
+});
+/**
+* Zod schema for a single runner event record — one item in the events array
+* that the runner POSTs to /api/pipeline/runner-events.
+*/
+const runnerEventRecordSchema = z.union([
+	workflowPlanEventSchema,
+	workflowEdgeEventSchema,
+	nodeEventSchema,
+	gateEventSchema,
+	hookResultEventSchema,
+	artifactEventSchema,
+	logEventSchema,
+	finalResultEventSchema
+]);
+/**
+* Zod schema for the POST body of /api/pipeline/runner-events.
+* The runner sends { events: RunnerEventRecord[] }.
+*/
+const runnerEventBatchSchema = z.object({ events: z.array(runnerEventRecordSchema).min(1) }).strict();
+const _runnerEventRecordTypeCheck = runnerEventRecordSchema;
+//#endregion
+export { _runnerEventRecordTypeCheck, runnerEventBatchSchema, runnerEventRecordSchema };

package/dist/runner-output.js

@@ -1,4 +1,4 @@
-import { opencodeCliRuntimeAdapter } from "./runtime/opencode-adapter.js";
+import { opencodeSdkRuntimeAdapter } from "./runtime/opencode-adapter.js";
 //#region src/runner-output.ts
 function normalizeRunnerOutput(plan, stdout) {
 	const latest = runnerTextCandidates(plan, stdout).at(-1);
@@ -12,7 +12,7 @@ function normalizeRunnerOutput(plan, stdout) {
 	};
 }
 function runnerTextCandidates(plan, stdout) {
-	if (plan.type === "opencode") return opencodeCliRuntimeAdapter.outputCandidates(stdout);
+	if (plan.type === "opencode") return opencodeSdkRuntimeAdapter.outputCandidates(stdout);
 	return [];
 }
 //#endregion

package/dist/runner.d.ts

@@ -2,18 +2,47 @@ import { PipelineConfig, RunnerType } from "./config/schemas.js";
 //#region src/runner.d.ts
 type Harness = "opencode";
 type AgentRole = "researcher" | "test-writer" | "code-writer" | "verifier";
+/**
+ * Agent-output boundary, layer 1 of 4 (PIPE-74 B3). `AgentResult` is the RAW
+ * terminal result of one runner subprocess/session: exit code, accumulated
+ * stdout/stderr, and execution metadata. It carries no parsing or semantic
+ * interpretation — downstream layers refine it:
+ *   1. {@link AgentResult}            — raw subprocess result (this type)
+ *   2. {@link RunnerOutputEvent}      — a live stream chunk during execution
+ *   3. RuntimeNormalizedOutput        — adapter-extracted text + evidence
+ *      (src/runtime/opencode-adapter.ts)
+ *   4. RuntimeStructuredOutput        — parsed + schema-validated output
+ *      (src/runtime/contracts/contracts.ts)
+ */
 interface AgentResult {
   argv?: string[];
   exitCode: number;
+  /** opencode session id when driven through the SDK executor (PIPE-73). */
+  sessionId?: string;
   stderr?: string;
   stdout: string;
   timedOut?: boolean;
 }
+/**
+ * Agent-output boundary, layer 2 of 4 (PIPE-74 B3). A single incremental chunk
+ * of a runner's live output stream, surfaced via
+ * {@link RunnerExecutionOptions.onOutput} while the subprocess is still
+ * running — distinct from {@link AgentResult}, which is the final accumulated
+ * result.
+ */
 interface RunnerOutputEvent {
   chunk: string;
   nodeId: string;
   stream: "stderr" | "stdout";
 }
+/**
+ * Lowest layer of the runtime-options stack (PIPE-74 B3): the per-invocation
+ * controls a runner executor needs — cancellation and live-output streaming.
+ * Widened by the runtime layers above it:
+ *   RunnerExecutionOptions (this type)
+ *     < PipelineRuntimeOptions (src/runtime/contracts/contracts.ts)
+ *     < ScheduledWorkflowTaskRuntimeOptions (src/pipeline-runtime.ts)
+ */
 interface RunnerExecutionOptions {
   onOutput?: (event: RunnerOutputEvent) => void;
   signal?: AbortSignal;

package/dist/runtime/agent-node/agent-node.js

@@ -43,6 +43,7 @@ async function executeAgentNode(node, context, attempt) {
 		signal: context.signal
 	});
 	emitAgentFinish(context, plan, attempt, result);
+	if (result.sessionId) context.nodeStateStore.recordSessionId(node.id, result.sessionId);
 	const finalized = await finalizeAgentOutput({
 		context,
 		node,

package/dist/runtime/context/context.js

@@ -1,7 +1,7 @@
 import { loadPipelineConfig } from "../../config/load.js";
 import "../../config.js";
 import { runLaunchPlan } from "../../runner.js";
-import { compileWorkflowPlan } from "../../workflow-planner.js";
+import { compileWorkflowPlan } from "../../planning/compile.js";
 import { createPublicRuntimeObservabilityEmitter } from "../events/events.js";
 import "../events/index.js";
 import { initialNodeStateStore } from "../node-state-store.js";

package/dist/runtime/contracts/contracts.d.ts

@@ -1,5 +1,5 @@
 import { HookEvent, PipelineConfig } from "../../config/schemas.js";
-import { PlannedWorkflowNode, WorkflowExecutionPlan } from "../../workflow-planner.js";
+import { PlannedWorkflowNode, WorkflowExecutionPlan } from "../../planning/compile.js";
 import { HookResult } from "../../hooks.js";
 import { AgentResult, RunnerExecutionOptions, RunnerLaunchPlan } from "../../runner.js";
 import { RuntimeActorDescriptor, RuntimeObservabilityEvent } from "../actor-ids.js";
@@ -44,6 +44,13 @@ interface RuntimeNodeResult {
   output: string;
   status: "failed" | "passed";
 }
+/**
+ * Agent-output boundary, layer 4 of 4 (PIPE-74 B3). The terminal, structured
+ * form of agent output: the layer-3 RuntimeNormalizedOutput text
+ * (src/runtime/opencode-adapter.ts) parsed into a typed `output` value and
+ * validated against the node's declared schema. This is what downstream nodes
+ * and gates consume.
+ */
 interface RuntimeStructuredOutput {
   attempt: number;
   format: "json" | "json_schema" | "jsonl";
@@ -79,6 +86,8 @@ interface NodeExecutionState {
     retryReason: string;
     scheduled: boolean;
   };
+  /** opencode session id when the node ran through the SDK executor (PIPE-73). */
+  sessionId?: string;
   startedAt?: string;
   status: NodeStatus;
 }
@@ -226,6 +235,14 @@ type PipelineRuntimeEvent = {
   type: "workflow.finish";
   workflowId: string;
 });
+/**
+ * Middle layer of the runtime-options stack (PIPE-74 B3): everything needed to
+ * run one pipeline workflow from config — the config/entrypoint to run, the
+ * task, reporting, and the executor (whose per-call controls come from the
+ * layer below, {@link RunnerExecutionOptions} in src/runner.ts). Extended by
+ * ScheduledWorkflowTaskRuntimeOptions (src/pipeline-runtime.ts) for the
+ * single-node, schedule-driven execution path.
+ */
 interface PipelineRuntimeOptions {
   config?: PipelineConfig;
   entrypoint?: string;

package/dist/runtime/node-state-store.js

@@ -50,6 +50,13 @@ var NodeStateStore = class NodeStateStore {
 	recordOutput(nodeId, output) {
 		this.lastOutputByNode.set(nodeId, output);
 	}
+	recordSessionId(nodeId, sessionId) {
+		const existing = this.nodeStates.get(nodeId);
+		if (existing) this.nodeStates.set(nodeId, {
+			...existing,
+			sessionId
+		});
+	}
 	recordStructuredOutput(output) {
 		this.structuredOutputs.push(output);
 	}