@oisincoveney/pipeline 3.24.2 → 4.0.0

package/dist/runtime/opencode-session-executor.js

@@ -1,138 +1,60 @@
+import { isNumberValue, isStringValue } from "../schema-boundary.js";
 import { isRecord } from "../safe-json.js";
 import { raceDetached } from "./detached-race.js";
+import { promptText } from "./launch-plan-args.js";
 import { opencodeAgentName } from "./opencode-agent-name.js";
 import { OpencodeSdkService, OpencodeSdkServiceLive } from "./services/opencode-sdk-service.js";
-import { Duration, Effect } from "effect";
+import { Duration, Effect, Option } from "effect";
 //#region src/runtime/opencode-session-executor.ts
-function createOpencodeSessionRegistry() {
-	return { sessions: /* @__PURE__ */ new Map() };
-}
-/**
-* SDK-backed replacement for the subprocess `runLaunchPlan`. Conforms to the
-* RuntimeContext.executor seam so agent-node never learns the transport.
-*/
-function createOpencodeExecutor(deps) {
-	return async function execute(plan, options = {}) {
-		return await Effect.runPromise(Effect.provide(executeOpencodeEffect(deps, plan, options), OpencodeSdkServiceLive), options.signal ? { signal: options.signal } : void 0);
-	};
-}
-function executeOpencodeEffect(deps, plan, options) {
-	return Effect.gen(function* () {
-		yield* validateOpencodePlan(plan);
-		return yield* executeOpencodeSession(deps, plan, options);
-	});
-}
-function executeOpencodeSession(deps, plan, options) {
-	const activity = { last: Date.now() };
-	return Effect.gen(function* () {
-		return successResult(plan, yield* driveSession(deps, plan, options, activity));
-	}).pipe(boundByIdle(deps, plan, options, activity), boundByAgentTimeout(plan), Effect.catch((error) => Effect.succeed(failureResult(plan, error))));
-}
-function boundByAgentTimeout(plan) {
-	return (effect) => {
-		const timeoutMs = plan.timeoutMs;
-		if (!timeoutMs || timeoutMs <= 0) return effect;
-		return raceDetached(effect, timeoutFailure(timeoutMs, `agent session timed out after ${timeoutMs}ms`));
-	};
-}
-function boundByIdle(deps, plan, options, activity) {
-	return (effect) => {
-		const idleMs = plan.idleTimeoutMs;
-		if (!idleMs || idleMs <= 0 || !options.onOutput) return effect;
-		if (plan.timeoutMs && idleMs >= plan.timeoutMs) return effect;
-		return raceDetached(effect, idleWatchdog(deps, plan, options, activity, idleMs));
-	};
-}
-function timeoutFailure(milliseconds, message) {
-	return Effect.sleep(Duration.millis(milliseconds)).pipe(Effect.andThen(Effect.fail(new Error(message))));
-}
-function idleWatchdog(deps, plan, options, activity, idleMs) {
-	const loop = Effect.suspend(() => {
-		const remaining = idleMs - (Date.now() - activity.last);
-		if (remaining <= 0) return onIdleTimeout(deps, plan, options, idleMs);
-		return Effect.sleep(Duration.millis(remaining)).pipe(Effect.andThen(loop));
-	});
-	return loop;
-}
-function onIdleTimeout(deps, plan, options, idleMs) {
-	return Effect.sync(() => {
-		options.onOutput?.({
-			chunk: `opencode session idle for ${idleMs}ms (no progress); aborting\n`,
-			nodeId: plan.nodeId,
-			stream: "stderr"
-		});
-	}).pipe(Effect.andThen(abortBestEffort(deps, plan)), Effect.andThen(Effect.fail(/* @__PURE__ */ new Error(`agent session idle for ${idleMs}ms (no progress)`))));
-}
-function abortBestEffort(deps, plan) {
+const createOpencodeSessionRegistry = () => ({ sessions: /* @__PURE__ */ new Map() });
+const timeoutFailure = (milliseconds, message) => Effect.sleep(Duration.millis(milliseconds)).pipe(Effect.andThen(Effect.fail(new Error(message))));
+const boundByAgentTimeout = (plan) => (effect) => {
+	const { timeoutMs } = plan;
+	if (timeoutMs === void 0 || timeoutMs <= 0) return effect;
+	return raceDetached(effect, timeoutFailure(timeoutMs, `agent session timed out after ${timeoutMs}ms`));
+};
+const validateOpencodePlan = (plan) => {
+	if (plan.type === "opencode") return Effect.void;
+	return Effect.fail(/* @__PURE__ */ new Error(`opencode executor cannot drive runner type '${plan.type}'`));
+};
+const sessionDirectory = (deps, plan) => plan.cwd;
+const abortBestEffort = (deps, plan) => {
 	const sessionId = deps.registry.sessions.get(plan.nodeId);
-	if (!sessionId) return Effect.void;
-	return Effect.gen(function* () {
+	if (sessionId === void 0) return Effect.void;
+	return Effect.gen(function* effectBody() {
 		yield* (yield* OpencodeSdkService).abortSession(deps.client, {
 			directory: sessionDirectory(deps, plan),
 			sessionID: sessionId
 		});
 	}).pipe(Effect.timeout(Duration.millis(5e3)), Effect.asVoid, Effect.catch(() => Effect.void));
-}
-function validateOpencodePlan(plan) {
-	if (plan.type === "opencode") return Effect.void;
-	return Effect.fail(/* @__PURE__ */ new Error(`opencode executor cannot drive runner type '${plan.type}'`));
-}
-function sessionDirectory(deps, plan) {
-	return plan.cwd ?? deps.directory;
-}
-function driveSession(deps, plan, options, activity) {
-	return Effect.gen(function* () {
-		const sessionId = yield* resolveSessionId(deps, plan, options);
-		recordSession(deps, plan.nodeId, sessionId);
-		const stream = yield* streamEventsToOutput(deps, sessionId, plan, options, activity);
-		return yield* promptSessionResult(deps, plan, sessionId, options).pipe(Effect.ensuring(stopStream(stream)));
+};
+const onIdleTimeout = (deps, plan, options, idleMs) => Effect.sync(() => {
+	options.onOutput?.({
+		chunk: `opencode session idle for ${idleMs}ms (no progress); aborting\n`,
+		nodeId: plan.nodeId,
+		stream: "stderr"
 	});
-}
-function promptSessionResult(deps, plan, sessionId, options) {
-	return retryTransientTransport(() => Effect.gen(function* () {
-		const data = yield* unwrapEffect(yield* (yield* OpencodeSdkService).promptSession(deps.client, promptRequest(deps, plan, sessionId)));
-		return {
-			...data.info ? { assistant: data.info } : {},
-			parts: data.parts ?? [],
-			sessionId
-		};
-	}), {
-		label: "session.prompt",
-		options,
-		plan
+}).pipe(Effect.andThen(abortBestEffort(deps, plan)), Effect.andThen(Effect.fail(/* @__PURE__ */ new Error(`agent session idle for ${idleMs}ms (no progress)`))));
+const idleWatchdog = (deps, plan, options, activity, idleMs) => {
+	const loop = Effect.suspend(() => {
+		const remaining = idleMs - (Date.now() - activity.last);
+		if (remaining <= 0) return onIdleTimeout(deps, plan, options, idleMs);
+		return Effect.sleep(Duration.millis(remaining)).pipe(Effect.andThen(loop));
 	});
-}
-function promptRequest(deps, plan, sessionId) {
-	return {
-		directory: sessionDirectory(deps, plan),
-		sessionID: sessionId,
-		...promptBody(plan)
-	};
-}
-function stopStream(stream) {
-	return Effect.tryPromise(() => stream.stop()).pipe(Effect.asVoid, Effect.catch(() => Effect.void));
-}
-function recordSession(deps, nodeId, sessionId) {
+	return loop;
+};
+const boundByIdle = (deps, plan, options, activity) => (effect) => {
+	const idleMs = plan.idleTimeoutMs;
+	if (idleMs === void 0 || idleMs <= 0 || options.onOutput === void 0) return effect;
+	if (plan.timeoutMs !== void 0 && idleMs >= plan.timeoutMs) return effect;
+	return raceDetached(effect, idleWatchdog(deps, plan, options, activity, idleMs));
+};
+const stopStream = (stream) => Effect.tryPromise(async () => {
+	await stream.stop();
+}).pipe(Effect.asVoid, Effect.catch(() => Effect.void));
+const recordSession = (deps, nodeId, sessionId) => {
 	deps.onSession?.(nodeId, sessionId);
-}
-function resolveSessionId(deps, plan, options) {
-	const existing = deps.registry.sessions.get(plan.nodeId);
-	if (existing) return Effect.succeed(existing);
-	return Effect.gen(function* () {
-		const session = yield* retryTransientTransport(() => Effect.gen(function* () {
-			return yield* unwrapEffect(yield* (yield* OpencodeSdkService).createSession(deps.client, {
-				directory: plan.cwd ?? deps.directory,
-				title: `moka:${plan.nodeId}`
-			}));
-		}), {
-			label: "session.create",
-			options,
-			plan
-		});
-		deps.registry.sessions.set(plan.nodeId, session.id);
-		return session.id;
-	});
-}
+};
 /**
 * Bounded retry for transient OpenCode transport failures at the SDK boundary.
 * Distinct from the node-level retry in retry.ts (which reprompts on gate
@@ -143,182 +65,133 @@ function resolveSessionId(deps, plan, options) {
 */
 const MAX_TRANSIENT_RETRIES = 2;
 const TRANSIENT_RETRY_BASE_MS = 250;
-function retryTransientTransport(make, ctx, attempt = 0) {
-	return make().pipe(Effect.catch((error) => attempt < MAX_TRANSIENT_RETRIES && isTransientTransportError(error) ? scheduleTransientRetry(make, ctx, attempt, error) : Effect.fail(error)));
-}
-function scheduleTransientRetry(make, ctx, attempt, error) {
-	const nextAttempt = attempt + 1;
-	const delay = Duration.millis(TRANSIENT_RETRY_BASE_MS * 2 ** attempt);
-	return emitTransientRetry(ctx, error, nextAttempt, delay).pipe(Effect.andThen(Effect.sleep(delay)), Effect.andThen(retryTransientTransport(make, ctx, nextAttempt)));
-}
-function emitTransientRetry(ctx, error, attempt, delay) {
-	return Effect.sync(() => {
-		ctx.options.onOutput?.({
-			chunk: `opencode ${ctx.label} transient failure: ${errorMessage(error)}; retry ${attempt}/${MAX_TRANSIENT_RETRIES} in ${Duration.toMillis(delay)}ms\n`,
-			nodeId: ctx.plan.nodeId,
-			stream: "stderr"
-		});
-	});
-}
-const TRANSIENT_TRANSPORT_RE = /fetch failed|econnreset|etimedout|enotfound|eai_again|socket hang ?up|network|connection (?:reset|closed|refused)|aborterror|operation was aborted|timed? ?out/i;
-/**
-* Retry only failures that prove the turn was NOT accepted: transport errors
-* (no completed round trip) and HTTP 429/5xx rejections. Deterministic agent
-* outcomes (output-length, aborted message, schema/contract problems) and gate
-* failures are out of scope and never reach this classifier as retryable.
-*/
-function isTransientTransportError(error) {
-	if (TRANSIENT_TRANSPORT_RE.test(errorMessage(error))) return true;
-	const status = httpStatusFromError(error);
-	return status !== void 0 && (status === 429 || status >= 500);
-}
-function numericField(container, key) {
+const TRANSIENT_TRANSPORT_RE = /fetch failed|econnreset|etimedout|enotfound|eai_again|socket hang ?up|network|connection (?:reset|closed|refused)|aborterror|operation was aborted|timed? ?out/iu;
+const numericField = (container, key) => {
 	const value = isRecord(container) ? container[key] : void 0;
-	return typeof value === "number" ? value : void 0;
-}
-function httpStatusFromError(error) {
+	return isNumberValue(value) ? Option.some(value) : Option.none();
+};
+const httpStatusFromError = (error) => {
 	const response = isRecord(error) ? error.response : void 0;
-	return numericField(error, "status") ?? numericField(error, "statusCode") ?? numericField(response, "status");
-}
-function unwrapEffect(response) {
-	return Effect.try({
-		catch: (error) => error,
-		try: () => unwrap(response)
+	return Option.orElse(numericField(error, "status"), () => Option.orElse(numericField(error, "statusCode"), () => numericField(response, "status")));
+};
+const parseModel = (model) => {
+	if (model === void 0 || model.length === 0) return Option.none();
+	const slash = model.indexOf("/");
+	if (slash === -1) return Option.none();
+	return Option.some({
+		modelID: model.slice(slash + 1),
+		providerID: model.slice(0, slash)
 	});
-}
-function promptBody(plan) {
+};
+const promptBody = (plan) => {
 	const prompt = promptText(plan);
 	const model = parseModel(plan.model);
-	const agent = plan.profileId ? opencodeAgentName(plan.profileId) : void 0;
+	const agent = plan.profileId === void 0 || plan.profileId.length === 0 ? Option.none() : Option.some(opencodeAgentName(plan.profileId));
 	return {
 		parts: [{
 			text: prompt,
 			type: "text"
 		}],
-		...agent ? { agent } : {},
-		...model ? { model } : {},
-		...plan.variant ? { variant: plan.variant } : {}
-	};
-}
-const FLAGS_TAKING_VALUE = /* @__PURE__ */ new Set([
-	"--agent",
-	"--dir",
-	"--file",
-	"--format",
-	"--model",
-	"--variant"
-]);
-/**
-* The launch plan carries the prompt inside the CLI argv (`run <prompt>` or
-* `run <prompt> --file <ctx>`). Recover it as the trailing positional arg
-* (skipping flags and their values) so the adapter boundary is identical
-* regardless of transport.
-*/
-function promptText(plan) {
-	return plan.args.filter((arg, index) => index > 0 && !arg.startsWith("-") && !FLAGS_TAKING_VALUE.has(plan.args[index - 1] ?? "")).at(-1) ?? "";
-}
-function parseModel(model) {
-	if (!model) return;
-	const slash = model.indexOf("/");
-	if (slash === -1) return;
-	return {
-		modelID: model.slice(slash + 1),
-		providerID: model.slice(0, slash)
+		...Option.match(agent, {
+			onNone: () => ({}),
+			onSome: (value) => ({ agent: value })
+		}),
+		...Option.match(model, {
+			onNone: () => ({}),
+			onSome: (value) => ({ model: value })
+		}),
+		...plan.variant === void 0 || plan.variant.length === 0 ? {} : { variant: plan.variant }
 	};
-}
-function streamEventsToOutput(deps, sessionId, plan, options, activity) {
-	if (!options.onOutput) return Effect.succeed({ stop: () => Promise.resolve() });
-	return Effect.gen(function* () {
-		const iterator = (yield* (yield* OpencodeSdkService).subscribeEvents(deps.client)).stream;
-		activity.last = Date.now();
-		const pump = Effect.runPromise(pumpEvents(iterator, sessionId, plan, options, activity));
-		return { stop: () => stopIterator(iterator, pump) };
-	});
-}
-function pumpEvents(iterator, sessionId, plan, options, activity) {
-	return Effect.gen(function* () {
-		let done = false;
-		while (!done) {
-			const next = yield* readNextEvent(iterator);
-			done = next.done === true;
-			if (!done) {
-				activity.last = Date.now();
-				forwardEvent(next.value, sessionId, plan, options);
-			}
-		}
-	}).pipe(Effect.catch((error) => reportStreamDrop(error, plan, options)));
-}
-function readNextEvent(iterator) {
-	return Effect.tryPromise({
-		catch: (error) => error,
-		try: () => iterator.next()
-	});
-}
-function reportStreamDrop(error, plan, options) {
-	return Effect.sync(() => {
-		options.onOutput?.({
-			chunk: `opencode event stream dropped: ${errorMessage(error)}\n`,
-			nodeId: plan.nodeId,
-			stream: "stderr"
-		});
-	});
-}
-function stopIterator(iterator, pump) {
-	return Effect.runPromise(stopIteratorEffect(iterator, pump));
-}
-function stopIteratorEffect(iterator, pump) {
-	return Effect.gen(function* () {
-		yield* requestIteratorReturn(iterator);
-		yield* Effect.tryPromise(() => pump).pipe(Effect.catch(() => Effect.void));
-	});
-}
-function requestIteratorReturn(iterator) {
-	const returnIterator = iterator.return;
-	if (!returnIterator) return Effect.void;
+};
+const promptRequest = (deps, plan, sessionId) => ({
+	directory: sessionDirectory(deps, plan),
+	sessionID: sessionId,
+	...promptBody(plan)
+});
+const readNextEvent = (iterator) => Effect.tryPromise({
+	catch: (error) => error,
+	try: async () => await iterator.next()
+});
+const requestIteratorReturn = (iterator) => {
+	if (iterator.return === void 0) return Effect.void;
 	return Effect.tryPromise({
 		catch: (error) => error,
-		try: () => returnIterator.call(iterator, void 0)
+		try: async () => {
+			await iterator.return?.();
+		}
 	}).pipe(Effect.asVoid, Effect.catch(() => Effect.void));
-}
-function forwardEvent(event, sessionId, plan, options) {
-	const forwarded = eventChunk(event, sessionId);
-	if (forwarded) options.onOutput?.({
-		chunk: forwarded.chunk,
-		nodeId: plan.nodeId,
-		stream: forwarded.stream
-	});
-}
-function eventChunk(event, sessionId) {
-	if (event.type === "message.part.updated") return partChunk(event.properties.part, sessionId);
-	if (event.type === "session.error" && belongsToSession(event, sessionId)) return {
-		chunk: `opencode session error: ${describeMessageError(event.properties.error)}\n`,
-		stream: "stderr"
-	};
-}
-function belongsToSession(event, sessionId) {
-	return event.properties.sessionID === void 0 || event.properties.sessionID === sessionId;
-}
-function partChunk(part, sessionId) {
-	if (part.sessionID !== sessionId) return;
-	if (part.type === "text") return {
+};
+const stopIteratorEffect = (iterator, pump) => Effect.gen(function* effectBody() {
+	yield* requestIteratorReturn(iterator);
+	yield* Effect.tryPromise(async () => {
+		await pump;
+	}).pipe(Effect.catch(() => Effect.void));
+});
+const stopIterator = async (iterator, pump) => {
+	await Effect.runPromise(stopIteratorEffect(iterator, pump));
+};
+const belongsToSession = (event, sessionId) => event.properties.sessionID === void 0 || event.properties.sessionID === sessionId;
+const partChunk = (part, sessionId) => {
+	if (part.sessionID !== sessionId) return Option.none();
+	if (part.type === "text") return Option.some({
 		chunk: `${JSON.stringify({ part: {
 			text: part.text,
 			type: "text"
 		} })}\n`,
 		stream: "stdout"
-	};
-	if (part.type === "tool") return {
+	});
+	if (part.type === "tool") return Option.some({
 		chunk: `opencode tool ${part.tool} ${part.state.status}\n`,
 		stream: "stderr"
-	};
-}
+	});
+	return Option.none();
+};
+/**
+* Map opencode message errors to the runner's infra-vs-agent exit convention.
+* Output-length / aborted are agent-task outcomes (exit 1, gate territory);
+* provider-auth, API, and unknown are infra (exit 70, retry-eligible).
+*/
+const infraErrorExitCode = (error) => {
+	switch (error.name) {
+		case "MessageOutputLengthError":
+		case "MessageAbortedError": return 1;
+		case "ContentFilterError":
+		case "ContextOverflowError":
+		case "StructuredOutputError": return 1;
+		case "APIError":
+		case "ProviderAuthError":
+		case "UnknownError": return 70;
+	}
+};
+const describeMessageError = (error) => {
+	if (error === void 0) return "unknown opencode error";
+	const data = isRecord(error.data) ? error.data : void 0;
+	const detail = data !== void 0 && isStringValue(data.message) ? `: ${data.message}` : "";
+	return `${error.name}${detail}`;
+};
+const eventChunk = (event, sessionId) => {
+	if (event.type === "message.part.updated") return partChunk(event.properties.part, sessionId);
+	if (event.type === "session.error" && belongsToSession(event, sessionId)) return Option.some({
+		chunk: `opencode session error: ${describeMessageError(event.properties.error)}\n`,
+		stream: "stderr"
+	});
+	return Option.none();
+};
+const forwardEvent = (event, sessionId, plan, options) => {
+	const forwarded = eventChunk(event, sessionId);
+	if (Option.isSome(forwarded)) options.onOutput?.({
+		chunk: forwarded.value.chunk,
+		nodeId: plan.nodeId,
+		stream: forwarded.value.stream
+	});
+};
 /**
 * Reconstruct the JSONL stdout the existing normalizeOutput/outputCandidates
 * parser already understands, so the structured-output and repair passes work
 * unchanged on top of SDK responses.
 */
-function successResult(plan, drive) {
-	const stdout = drive.parts.filter((part) => part.type === "text").map((part) => JSON.stringify({ part: {
+const successResult = (plan, drive) => {
+	const stdout = drive.parts.filter((part) => part.type === "text" && isStringValue(part.text)).map((part) => JSON.stringify({ part: {
 		text: part.text,
 		type: "text"
 	} })).join("\n");
@@ -336,38 +209,40 @@ function successResult(plan, drive) {
 		sessionId: drive.sessionId,
 		stdout
 	};
-}
-function failureResult(plan, error) {
-	return {
-		argv: plan.args,
-		exitCode: 70,
-		stderr: `opencode session failed: ${errorMessage(error)}`,
-		stdout: ""
-	};
-}
-/**
-* Map opencode message errors to the runner's infra-vs-agent exit convention.
-* Output-length / aborted are agent-task outcomes (exit 1, gate territory);
-* provider-auth, API, and unknown are infra (exit 70, retry-eligible).
-*/
-function infraErrorExitCode(error) {
-	switch (error.name) {
-		case "MessageOutputLengthError":
-		case "MessageAbortedError": return 1;
-		default: return 70;
-	}
-}
-function describeMessageError(error) {
-	if (!error) return "unknown opencode error";
-	const data = error.data;
-	const detail = data && typeof data.message === "string" ? `: ${data.message}` : "";
-	return `${error.name}${detail}`;
-}
-function unwrap(result) {
-	if (result.error) throw new Error(resultErrorMessage(result));
-	if (result.data === void 0) throw new Error(`opencode response contained no data${httpContext(result)}`);
-	return result.data;
-}
+};
+const nonEmptyString = (error) => isStringValue(error) && error.length > 0 ? Option.some(error) : Option.none();
+const nonEmptyJson = (error) => {
+	if (error === void 0) return Option.none();
+	const json = JSON.stringify(error);
+	return json.length > 0 && json !== "{}" ? Option.some(json) : Option.none();
+};
+const requestTarget = (request) => `${request?.method ?? "?"} ${request?.url ?? "?"}`;
+const hasRequestTarget = (request) => request?.method !== void 0 && request.method.length > 0 || request?.url !== void 0 && request.url.length > 0;
+const isHttpStatus = (status) => status !== void 0 && status !== 0 && !Number.isNaN(status);
+const statusSuffix = (status) => isHttpStatus(status) ? ` → HTTP ${status}` : "";
+const httpStatusLine = (result) => {
+	const status = result.response?.status;
+	const { request } = result;
+	if (!(hasRequestTarget(request) || isHttpStatus(status))) return Option.none();
+	return Option.some(`${requestTarget(request)}${statusSuffix(status)}`);
+};
+const httpContext = (result) => {
+	const status = httpStatusLine(result);
+	return Option.match(status, {
+		onNone: () => "",
+		onSome: (value) => ` (${value})`
+	});
+};
+const stringField = (value, field) => {
+	const fieldValue = isRecord(value) ? value[field] : void 0;
+	if (isStringValue(fieldValue)) return fieldValue.length > 0 ? Option.some(fieldValue) : Option.none();
+	return Option.none();
+};
+const bodyMessage = (error) => {
+	if (!isRecord(error)) return Option.none();
+	return Option.orElse(stringField(error.data, "message"), () => Option.orElse(stringField(error, "message"), () => stringField(error, "name")));
+};
+const errorDetail = (error) => Option.orElse(bodyMessage(error), () => Option.orElse(nonEmptyString(error), () => nonEmptyJson(error)));
 /**
 * Build the richest available message for a failed opencode result tuple. The
 * runner reads the result-tuple path (not throwOnError), so the SDK leaves
@@ -377,47 +252,140 @@ function unwrap(result) {
 * surfaces as "POST …/prompt → 504 Gateway Timeout" instead of "{}". Mirrors the
 * SDK's own error-interceptor describe().
 */
-function resultErrorMessage(result) {
+const resultErrorMessage = (result) => {
 	const detail = errorDetail(result.error);
-	if (detail) return `${detail}${httpContext(result)}`;
-	return httpStatusLine(result) ?? "opencode error with empty response body";
-}
-function errorDetail(error) {
-	return bodyMessage(error) ?? nonEmptyString(error) ?? nonEmptyJson(error);
-}
-function bodyMessage(error) {
-	if (!isRecord(error)) return;
-	return stringField(error.data, "message") ?? stringField(error, "message") ?? stringField(error, "name");
-}
-function nonEmptyString(error) {
-	return typeof error === "string" && error.length > 0 ? error : void 0;
-}
-function nonEmptyJson(error) {
-	if (error === void 0) return;
-	const json = JSON.stringify(error);
-	return json && json !== "{}" ? json : void 0;
-}
-function httpContext(result) {
-	const status = httpStatusLine(result);
-	return status ? ` (${status})` : "";
-}
-function httpStatusLine(result) {
-	const status = result.response?.status;
-	const { request } = result;
-	if (!(request?.method || request?.url || status)) return;
-	return `${requestTarget(request)}${statusSuffix(status)}`;
-}
-function requestTarget(request) {
-	return `${request?.method ?? "?"} ${request?.url ?? "?"}`;
-}
-function statusSuffix(status) {
-	return status ? ` → HTTP ${status}` : "";
-}
-function stringField(value, field) {
-	if (isRecord(value) && typeof value[field] === "string" && value[field]) return value[field];
-}
-function errorMessage(error) {
-	return error instanceof Error ? error.message : String(error);
-}
+	if (Option.isSome(detail)) return `${detail.value}${httpContext(result)}`;
+	return Option.getOrElse(httpStatusLine(result), () => "opencode error with empty response body");
+};
+const unwrap = (result) => {
+	if (result.error !== void 0) throw new Error(resultErrorMessage(result));
+	if (result.data === void 0) throw new Error(`opencode response contained no data${httpContext(result)}`);
+	return result.data;
+};
+const unwrapEffect = (response) => Effect.try({
+	catch: (error) => error,
+	try: () => unwrap(response)
+});
+const errorMessage = (error) => error instanceof Error ? error.message : String(error);
+const emitTransientRetry = (ctx, error, attempt, delay) => Effect.sync(() => {
+	ctx.options.onOutput?.({
+		chunk: `opencode ${ctx.label} transient failure: ${errorMessage(error)}; retry ${attempt}/${MAX_TRANSIENT_RETRIES} in ${Duration.toMillis(delay)}ms\n`,
+		nodeId: ctx.plan.nodeId,
+		stream: "stderr"
+	});
+});
+/**
+* Retry only failures that prove the turn was NOT accepted: transport errors
+* (no completed round trip) and HTTP 429/5xx rejections. Deterministic agent
+* outcomes (output-length, aborted message, schema/contract problems) and gate
+* failures are out of scope and never reach this classifier as retryable.
+*/
+const isTransientTransportError = (error) => {
+	if (TRANSIENT_TRANSPORT_RE.test(errorMessage(error))) return true;
+	const status = httpStatusFromError(error);
+	return Option.match(status, {
+		onNone: () => false,
+		onSome: (value) => value === 429 || value >= 500
+	});
+};
+const retryTransientTransport = function retryTransientTransport(make, ctx, attempt = 0) {
+	return make().pipe(Effect.catch((error) => {
+		if (!(attempt < MAX_TRANSIENT_RETRIES && isTransientTransportError(error))) return Effect.fail(error);
+		const nextAttempt = attempt + 1;
+		const delay = Duration.millis(TRANSIENT_RETRY_BASE_MS * 2 ** attempt);
+		return emitTransientRetry(ctx, error, nextAttempt, delay).pipe(Effect.andThen(Effect.sleep(delay)), Effect.andThen(retryTransientTransport(make, ctx, nextAttempt)));
+	}));
+};
+const promptSessionResult = (deps, plan, sessionId, options) => retryTransientTransport(() => Effect.gen(function* effectBody() {
+	const response = yield* (yield* OpencodeSdkService).promptSession(deps.client, promptRequest(deps, plan, sessionId));
+	const data = yield* unwrapEffect(response);
+	return {
+		assistant: data.info,
+		parts: data.parts,
+		sessionId
+	};
+}), {
+	label: "session.prompt",
+	options,
+	plan
+});
+const resolveSessionId = (deps, plan, options) => {
+	const existing = deps.registry.sessions.get(plan.nodeId);
+	if (existing !== void 0 && existing.length > 0) return Effect.succeed(existing);
+	return Effect.gen(function* effectBody() {
+		const session = yield* retryTransientTransport(() => Effect.gen(function* session() {
+			const created = yield* (yield* OpencodeSdkService).createSession(deps.client, {
+				directory: plan.cwd,
+				title: `moka:${plan.nodeId}`
+			});
+			return yield* unwrapEffect(created);
+		}), {
+			label: "session.create",
+			options,
+			plan
+		});
+		deps.registry.sessions.set(plan.nodeId, session.id);
+		return session.id;
+	});
+};
+const reportStreamDrop = (error, plan, options) => Effect.sync(() => {
+	options.onOutput?.({
+		chunk: `opencode event stream dropped: ${errorMessage(error)}\n`,
+		nodeId: plan.nodeId,
+		stream: "stderr"
+	});
+});
+const pumpEvents = (iterator, sessionId, plan, options, activity) => Effect.gen(function* effectBody() {
+	let done = false;
+	while (!done) {
+		const next = yield* readNextEvent(iterator);
+		done = next.done === true;
+		if (!done) {
+			activity.last = Date.now();
+			forwardEvent(next.value, sessionId, plan, options);
+		}
+	}
+}).pipe(Effect.catch((error) => reportStreamDrop(error, plan, options)));
+const streamEventsToOutput = (deps, sessionId, plan, options, activity) => {
+	if (options.onOutput === void 0) return Effect.succeed({ stop: async () => {} });
+	return Effect.gen(function* effectBody() {
+		const iterator = (yield* (yield* OpencodeSdkService).subscribeEvents(deps.client)).stream;
+		activity.last = Date.now();
+		const pump = Effect.runPromise(pumpEvents(iterator, sessionId, plan, options, activity));
+		return { stop: async () => {
+			await stopIterator(iterator, pump);
+		} };
+	});
+};
+const driveSession = (deps, plan, options, activity) => Effect.gen(function* effectBody() {
+	const sessionId = yield* resolveSessionId(deps, plan, options);
+	recordSession(deps, plan.nodeId, sessionId);
+	const stream = yield* streamEventsToOutput(deps, sessionId, plan, options, activity);
+	return yield* promptSessionResult(deps, plan, sessionId, options).pipe(Effect.ensuring(stopStream(stream)));
+});
+const failureResult = (plan, error) => ({
+	argv: plan.args,
+	exitCode: 70,
+	stderr: `opencode session failed: ${errorMessage(error)}`,
+	stdout: ""
+});
+const executeOpencodeSession = (deps, plan, options) => {
+	const activity = { last: Date.now() };
+	return Effect.gen(function* effectBody() {
+		const drive = yield* driveSession(deps, plan, options, activity);
+		return successResult(plan, drive);
+	}).pipe(boundByIdle(deps, plan, options, activity), boundByAgentTimeout(plan), Effect.catch((error) => Effect.succeed(failureResult(plan, error))));
+};
+const executeOpencodeEffect = (deps, plan, options) => Effect.gen(function* effectBody() {
+	yield* validateOpencodePlan(plan);
+	return yield* executeOpencodeSession(deps, plan, options);
+});
+/**
+* SDK-backed replacement for the subprocess `runLaunchPlan`. Conforms to the
+* RuntimeContext.executor seam so agent-node never learns the transport.
+*/
+const createOpencodeExecutor = (deps) => async function execute(plan, options = {}) {
+	return await Effect.runPromise(Effect.provide(executeOpencodeEffect(deps, plan, options), OpencodeSdkServiceLive), options.signal ? { signal: options.signal } : void 0);
+};
 //#endregion
 export { createOpencodeExecutor, createOpencodeSessionRegistry };