@oisincoveney/pipeline 2.1.0 → 2.2.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

@@ -5,6 +5,8 @@ type AgentRole = "researcher" | "test-writer" | "code-writer" | "verifier";
 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;

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/contracts/contracts.d.ts

@@ -79,6 +79,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;
 }

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);
 	}

package/dist/runtime/opencode-adapter.js

@@ -1,11 +1,31 @@
 import { isRecord } from "../safe-json.js";
 import { jsonLineValues } from "../json-line-values.js";
 //#region src/runtime/opencode-adapter.ts
-const opencodeCliRuntimeAdapter = {
-	continuation() {
-		return Promise.reject(/* @__PURE__ */ new Error("OpenCode CLI runtime adapter does not expose native continuation yet"));
+/**
+* Output-parsing seam for opencode runner output. The SDK executor
+* (opencode-session-executor.ts) re-serializes assistant text parts into the
+* same `{ part: { type: "text", text } }` JSONL the legacy CLI emitted, so this
+* parser is transport-agnostic and the structured-output / repair passes work
+* unchanged on top of SDK responses.
+*
+* The session lifecycle, event-stream forwarding, and per-message agent/model
+* selection live in opencode-session-executor.ts + opencode-server.ts; this
+* adapter only normalizes output and reports capabilities.
+*/
+const opencodeSdkRuntimeAdapter = {
+	continuation(request) {
+		return Promise.resolve({ metadata: {
+			adapterId: "opencode-sdk",
+			continuationApi: "session-reuse",
+			nodeId: request.sessionId,
+			outputFormat: "text",
+			pluginEvents: "server-event-stream",
+			runnerId: "opencode",
+			sessionInspectionApi: "sdk",
+			worktreePath: ""
+		} });
 	},
-	id: "opencode-cli-subprocess",
+	id: "opencode-sdk",
 	launch(plan) {
 		assertOpenCodePlan(plan);
 		return {
@@ -37,13 +57,13 @@ const opencodeCliRuntimeAdapter = {
 		assertOpenCodePlan(plan);
 		return {
 			adapterId: this.id,
-			continuationApi: "unavailable",
+			continuationApi: "session-reuse",
 			nodeId: plan.nodeId,
 			outputFormat: plan.outputFormat,
-			pluginEvents: "project-local",
+			pluginEvents: "server-event-stream",
 			profileId: plan.profileId,
 			runnerId: plan.runnerId,
-			sessionInspectionApi: "unavailable",
+			sessionInspectionApi: "sdk",
 			worktreePath: plan.cwd
 		};
 	}
@@ -57,4 +77,4 @@ function opencodeTextPart(value) {
 	if (isRecord(part) && part.type === "text") return typeof part.text === "string" ? part.text : void 0;
 }
 //#endregion
-export { opencodeCliRuntimeAdapter };
+export { opencodeSdkRuntimeAdapter };

package/dist/runtime/opencode-agent-name.js

@@ -0,0 +1,18 @@
+//#region src/runtime/opencode-agent-name.ts
+const MOKA_PROFILE_PREFIX = "moka-";
+/**
+* Map a pipeline profile id to the opencode agent name a served instance
+* exposes (e.g. `moka-code-writer` -> `MoKa Code Writer`). Shared by the slash
+* command installer and the SDK runtime so per-message agent selection targets
+* the same `.opencode/agent/*` definition the host projects.
+*/
+function opencodeAgentName(profileId) {
+	if (!profileId.startsWith(MOKA_PROFILE_PREFIX)) return profileId;
+	return `MoKa ${profileId.slice(5).split("-").map(opencodeAgentNamePart).join(" ")}`;
+}
+function opencodeAgentNamePart(part) {
+	if (part === "opencode") return "OpenCode";
+	return `${part.charAt(0).toUpperCase()}${part.slice(1)}`;
+}
+//#endregion
+export { opencodeAgentName };