ryco-cli 0.1.24 → 0.1.26

package/dist/{OpenCodeDriver-CDcvPT9v.cjs → OpenCodeDriver-CckbFEQJ.cjs}

@@ -1,16 +1,19 @@
 #!/usr/bin/env node
 
 const require_rolldown_runtime = require("./rolldown-runtime-LGfotAqq.cjs");
-const require_collectUint8StreamText = require("./collectUint8StreamText-DStwNTTK.cjs");
-const require_Metrics = require("./Metrics-Bcb9vCAe.cjs");
+const require_src = require("./src-BlzIcnVG.cjs");
+const require_Metrics = require("./Metrics-DCKbdeoH.cjs");
+const require_git = require("./git-irmB8_k7.cjs");
 const require_bin = require("./bin.cjs");
-const require_makeManagedServerProvider = require("./makeManagedServerProvider-VzxWN-04.cjs");
-const require_sourceControlContextFormatter = require("./sourceControlContextFormatter-BDZqn-4T.cjs");
+const require_runtimeSession = require("./runtimeSession-Bj0OUcNJ.cjs");
 const require_ProviderDriver = require("./ProviderDriver--rNeAi3B.cjs");
+const require_sourceControlContextFormatter = require("./sourceControlContextFormatter-BDZqn-4T.cjs");
+const require_makeManagedServerProvider = require("./makeManagedServerProvider-DGbd8BhM.cjs");
 let effect = require("effect");
 let effect_unstable_http = require("effect/unstable/http");
 let node_path = require("node:path");
 node_path = require_rolldown_runtime.__toESM(node_path, 1);
+let node_crypto = require("node:crypto");
 let node_os = require("node:os");
 node_os = require_rolldown_runtime.__toESM(node_os, 1);
 let node_fs_promises = require("node:fs/promises");
@@ -105,14 +108,14 @@ const makeOpenCodeTextGeneration = effect.Effect.fn("makeOpenCodeTextGeneration"
 	const serverOwner = options?.serverOwner ?? (openCodeSettings.serverUrl.trim().length === 0 ? yield* makeOpenCodeServerOwner(openCodeSettings, environment) : void 0);
 	const runOpenCodeJson = effect.Effect.fn("runOpenCodeJson")(function* (input) {
 		const parsedModel = require_bin.parseOpenCodeModelSlug(input.modelSelection.model);
-		if (!parsedModel) return yield* new require_collectUint8StreamText.TextGenerationError({
+		if (!parsedModel) return yield* new require_src.TextGenerationError({
 			operation: input.operation,
 			detail: "OpenCode model selection must use the 'provider/model' format."
 		});
 		const declaredAttachmentBytes = (input.attachments ?? []).reduce((total, attachment) => total + (attachment.sizeBytes ?? 0), 0);
-		if (declaredAttachmentBytes > 52428800) return yield* new require_collectUint8StreamText.TextGenerationError({
+		if (declaredAttachmentBytes > 52428800) return yield* new require_src.TextGenerationError({
 			operation: input.operation,
-			detail: `Attachments total ${declaredAttachmentBytes} bytes; limit is ${require_collectUint8StreamText.PROVIDER_SEND_TURN_MAX_ATTACHMENT_TOTAL_BYTES} bytes.`
+			detail: `Attachments total ${declaredAttachmentBytes} bytes; limit is ${require_src.PROVIDER_SEND_TURN_MAX_ATTACHMENT_TOTAL_BYTES} bytes.`
 		});
 		const attachmentUrlById = /* @__PURE__ */ new Map();
 		let attachmentTotalBytes = 0;
@@ -133,14 +136,14 @@ const makeOpenCodeTextGeneration = effect.Effect.fn("makeOpenCodeTextGeneration"
 				attachmentsDir: serverConfig.attachmentsDir,
 				attachment
 			});
-			if (!persisted.ok) return yield* new require_collectUint8StreamText.TextGenerationError({
+			if (!persisted.ok) return yield* new require_src.TextGenerationError({
 				operation: input.operation,
 				detail: persisted.reason
 			});
 			attachmentTotalBytes += persisted.sizeBytes;
-			if (attachmentTotalBytes > 52428800) return yield* new require_collectUint8StreamText.TextGenerationError({
+			if (attachmentTotalBytes > 52428800) return yield* new require_src.TextGenerationError({
 				operation: input.operation,
-				detail: `Attachments total ${attachmentTotalBytes} bytes; limit is ${require_collectUint8StreamText.PROVIDER_SEND_TURN_MAX_ATTACHMENT_TOTAL_BYTES} bytes.`
+				detail: `Attachments total ${attachmentTotalBytes} bytes; limit is ${require_src.PROVIDER_SEND_TURN_MAX_ATTACHMENT_TOTAL_BYTES} bytes.`
 			});
 			attachmentUrlById.set(attachment.id, `data:${attachment.mimeType};base64,${persisted.bytes.toString("base64")}`);
 		}
@@ -148,18 +151,18 @@ const makeOpenCodeTextGeneration = effect.Effect.fn("makeOpenCodeTextGeneration"
 			attachments: input.attachments,
 			resolveAttachmentUrl: (attachment) => attachment.id === void 0 ? null : attachmentUrlById.get(attachment.id) ?? null
 		});
-		const finalPrompt = require_makeManagedServerProvider.appendAttachmentPathLines(input.prompt, require_makeManagedServerProvider.formatAttachmentPathLines(pathLineEntries)) ?? input.prompt;
+		const finalPrompt = require_runtimeSession.appendAttachmentPathLines(input.prompt, require_runtimeSession.formatAttachmentPathLines(pathLineEntries)) ?? input.prompt;
 		const runAgainstServer = (server) => effect.Effect.gen(function* () {
 			const client = yield* openCodeRuntime.createOpenCodeSdkClient({
 				baseUrl: server.url,
 				directory: input.cwd,
 				...server.serverPassword ? { serverPassword: server.serverPassword } : {}
-			}).pipe(effect.Effect.mapError((cause) => new require_collectUint8StreamText.TextGenerationError({
+			}).pipe(effect.Effect.mapError((cause) => new require_src.TextGenerationError({
 				operation: input.operation,
 				detail: require_bin.openCodeRuntimeErrorDetail(cause),
 				cause
 			})));
-			yield* require_bin.verifyOpenCodeServerVersion(client).pipe(effect.Effect.mapError((cause) => new require_collectUint8StreamText.TextGenerationError({
+			yield* require_bin.verifyOpenCodeServerVersion(client).pipe(effect.Effect.mapError((cause) => new require_src.TextGenerationError({
 				operation: input.operation,
 				detail: require_bin.openCodeRuntimeErrorDetail(cause),
 				cause
@@ -194,7 +197,7 @@ const makeOpenCodeTextGeneration = effect.Effect.fn("makeOpenCodeTextGeneration"
 					if (rawText.length === 0) throw new Error("OpenCode returned empty output.");
 					return rawText;
 				},
-				catch: (cause) => new require_collectUint8StreamText.TextGenerationError({
+				catch: (cause) => new require_src.TextGenerationError({
 					operation: input.operation,
 					detail: require_bin.openCodeRuntimeErrorDetail(cause),
 					cause
@@ -204,117 +207,126 @@ const makeOpenCodeTextGeneration = effect.Effect.fn("makeOpenCodeTextGeneration"
 		const rawOutput = openCodeSettings.serverUrl.length > 0 ? yield* runAgainstServer({
 			url: openCodeSettings.serverUrl,
 			...openCodeSettings.serverPassword ? { serverPassword: openCodeSettings.serverPassword } : {}
-		}) : yield* effect.Effect.scoped(serverOwner.acquire.pipe(effect.Effect.mapError((cause) => new require_collectUint8StreamText.TextGenerationError({
+		}) : yield* effect.Effect.scoped(serverOwner.acquire.pipe(effect.Effect.mapError((cause) => new require_src.TextGenerationError({
 			operation: input.operation,
 			detail: require_bin.openCodeRuntimeErrorDetail(cause),
 			cause
 		})), effect.Effect.flatMap(runAgainstServer)));
-		return yield* effect.Schema.decodeEffect(effect.Schema.fromJsonString(input.outputSchemaJson))(require_bin.extractJsonObject(rawOutput)).pipe(effect.Effect.catchTag("SchemaError", (cause) => effect.Effect.fail(new require_collectUint8StreamText.TextGenerationError({
+		return yield* effect.Schema.decodeEffect(effect.Schema.fromJsonString(input.outputSchemaJson))(require_bin.extractJsonObject(rawOutput)).pipe(effect.Effect.catchTag("SchemaError", (cause) => effect.Effect.fail(new require_src.TextGenerationError({
 			operation: input.operation,
 			detail: "OpenCode returned invalid structured output.",
 			cause
 		}))));
 	});
-	return {
-		generateCommitMessage: effect.Effect.fn("OpenCodeTextGeneration.generateCommitMessage")(function* (input) {
-			const { prompt, outputSchema } = require_bin.buildCommitMessagePrompt({
-				branch: input.branch,
-				stagedSummary: input.stagedSummary,
-				stagedPatch: input.stagedPatch,
-				includeBranch: input.includeBranch === true
+	const generateCommitMessage = effect.Effect.fn("OpenCodeTextGeneration.generateCommitMessage")(function* (input) {
+		const { prompt, outputSchema } = require_bin.buildCommitMessagePrompt({
+			branch: input.branch,
+			stagedSummary: input.stagedSummary,
+			stagedPatch: input.stagedPatch,
+			includeBranch: input.includeBranch === true
+		});
+		const generated = yield* runOpenCodeJson({
+			operation: "generateCommitMessage",
+			cwd: input.cwd,
+			prompt,
+			outputSchemaJson: outputSchema,
+			modelSelection: input.modelSelection
+		});
+		return {
+			subject: require_bin.sanitizeCommitSubject(generated.subject),
+			body: generated.body.trim(),
+			..."branch" in generated && typeof generated.branch === "string" ? { branch: require_git.sanitizeFeatureBranchName(generated.branch) } : {}
+		};
+	});
+	const generatePrContent = effect.Effect.fn("OpenCodeTextGeneration.generatePrContent")(function* (input) {
+		const { prompt, outputSchema } = require_bin.buildPrContentPrompt({
+			baseBranch: input.baseBranch,
+			headBranch: input.headBranch,
+			commitSummary: input.commitSummary,
+			diffSummary: input.diffSummary,
+			diffPatch: input.diffPatch
+		});
+		const generated = yield* runOpenCodeJson({
+			operation: "generatePrContent",
+			cwd: input.cwd,
+			prompt,
+			outputSchemaJson: outputSchema,
+			modelSelection: input.modelSelection
+		});
+		return {
+			title: require_bin.sanitizePrTitle(generated.title),
+			body: generated.body.trim()
+		};
+	});
+	const generateBranchName = effect.Effect.fn("OpenCodeTextGeneration.generateBranchName")(function* (input) {
+		const { prompt, outputSchema } = require_bin.buildBranchNamePrompt({
+			message: input.message,
+			attachments: input.attachments
+		});
+		const generated = yield* runOpenCodeJson({
+			operation: "generateBranchName",
+			cwd: input.cwd,
+			prompt,
+			outputSchemaJson: outputSchema,
+			modelSelection: input.modelSelection,
+			attachments: input.attachments
+		});
+		return { branch: require_git.sanitizeBranchFragment(generated.branch) };
+	});
+	const generateThreadTitle = effect.Effect.fn("OpenCodeTextGeneration.generateThreadTitle")(function* (input) {
+		const { prompt, outputSchema } = require_bin.buildThreadTitlePrompt({
+			message: input.message,
+			attachments: input.attachments
+		});
+		const generated = yield* runOpenCodeJson({
+			operation: "generateThreadTitle",
+			cwd: input.cwd,
+			prompt,
+			outputSchemaJson: outputSchema,
+			modelSelection: input.modelSelection,
+			attachments: input.attachments
+		});
+		return { title: require_bin.sanitizeThreadTitle(generated.title) };
+	});
+	const generateIssueContent = effect.Effect.fn("OpenCodeTextGeneration.generateIssueContent")(function* (input) {
+		if (input.mode === "polish") {
+			const { prompt, outputSchema } = require_bin.buildIssueContentPolishPrompt({
+				rough: input.rough ?? "",
+				...input.currentTitle ? { currentTitle: input.currentTitle } : {},
+				...input.customInstructions ? { customInstructions: input.customInstructions } : {}
 			});
-			const generated = yield* runOpenCodeJson({
-				operation: "generateCommitMessage",
+			const decoded = yield* runOpenCodeJson({
+				operation: "generateIssueContent",
 				cwd: input.cwd,
 				prompt,
 				outputSchemaJson: outputSchema,
 				modelSelection: input.modelSelection
 			});
 			return {
-				subject: require_bin.sanitizeCommitSubject(generated.subject),
-				body: generated.body.trim(),
-				..."branch" in generated && typeof generated.branch === "string" ? { branch: require_Metrics.sanitizeFeatureBranchName(generated.branch) } : {}
+				title: decoded.title.trim(),
+				body: decoded.body.trim()
 			};
-		}),
-		generatePrContent: effect.Effect.fn("OpenCodeTextGeneration.generatePrContent")(function* (input) {
-			const { prompt, outputSchema } = require_bin.buildPrContentPrompt({
-				baseBranch: input.baseBranch,
-				headBranch: input.headBranch,
-				commitSummary: input.commitSummary,
-				diffSummary: input.diffSummary,
-				diffPatch: input.diffPatch
-			});
-			const generated = yield* runOpenCodeJson({
-				operation: "generatePrContent",
+		} else {
+			const { prompt, outputSchema } = require_bin.buildIssueContentTitlePrompt({ body: input.body ?? "" });
+			return { title: (yield* runOpenCodeJson({
+				operation: "generateIssueContent",
 				cwd: input.cwd,
 				prompt,
 				outputSchemaJson: outputSchema,
 				modelSelection: input.modelSelection
-			});
-			return {
-				title: require_bin.sanitizePrTitle(generated.title),
-				body: generated.body.trim()
-			};
-		}),
-		generateBranchName: effect.Effect.fn("OpenCodeTextGeneration.generateBranchName")(function* (input) {
-			const { prompt, outputSchema } = require_bin.buildBranchNamePrompt({
-				message: input.message,
-				attachments: input.attachments
-			});
-			const generated = yield* runOpenCodeJson({
-				operation: "generateBranchName",
-				cwd: input.cwd,
-				prompt,
-				outputSchemaJson: outputSchema,
-				modelSelection: input.modelSelection,
-				attachments: input.attachments
-			});
-			return { branch: require_Metrics.sanitizeBranchFragment(generated.branch) };
-		}),
-		generateThreadTitle: effect.Effect.fn("OpenCodeTextGeneration.generateThreadTitle")(function* (input) {
-			const { prompt, outputSchema } = require_bin.buildThreadTitlePrompt({
-				message: input.message,
-				attachments: input.attachments
-			});
-			const generated = yield* runOpenCodeJson({
-				operation: "generateThreadTitle",
-				cwd: input.cwd,
-				prompt,
-				outputSchemaJson: outputSchema,
-				modelSelection: input.modelSelection,
-				attachments: input.attachments
-			});
-			return { title: require_bin.sanitizeThreadTitle(generated.title) };
-		}),
-		generateIssueContent: effect.Effect.fn("OpenCodeTextGeneration.generateIssueContent")(function* (input) {
-			if (input.mode === "polish") {
-				const { prompt, outputSchema } = require_bin.buildIssueContentPolishPrompt({
-					rough: input.rough ?? "",
-					...input.currentTitle ? { currentTitle: input.currentTitle } : {},
-					...input.customInstructions ? { customInstructions: input.customInstructions } : {}
-				});
-				const decoded = yield* runOpenCodeJson({
-					operation: "generateIssueContent",
-					cwd: input.cwd,
-					prompt,
-					outputSchemaJson: outputSchema,
-					modelSelection: input.modelSelection
-				});
-				return {
-					title: decoded.title.trim(),
-					body: decoded.body.trim()
-				};
-			} else {
-				const { prompt, outputSchema } = require_bin.buildIssueContentTitlePrompt({ body: input.body ?? "" });
-				return { title: (yield* runOpenCodeJson({
-					operation: "generateIssueContent",
-					cwd: input.cwd,
-					prompt,
-					outputSchemaJson: outputSchema,
-					modelSelection: input.modelSelection
-				})).title.trim() };
-			}
-		}),
+			})).title.trim() };
+		}
+	});
+	const answerSideQuestion = () => effect.Effect.fail(new require_src.TextGenerationError({
+		operation: "answerSideQuestion",
+		detail: "OpenCode cannot isolate configured server plugins for a tool-free side question. Select Codex, Claude, or GitHub Copilot for side chat."
+	}));
+	return {
+		generateCommitMessage,
+		generatePrContent,
+		generateBranchName,
+		generateThreadTitle,
+		generateIssueContent,
 		rankInboxThreads: effect.Effect.fn("OpenCodeTextGeneration.rankInboxThreads")(function* (input) {
 			const { prompt, outputSchema } = require_bin.buildThreadPriorityPrompt({ serializedCandidates: input.chunk.serializedCandidates });
 			const generated = yield* runOpenCodeJson({
@@ -325,12 +337,179 @@ const makeOpenCodeTextGeneration = effect.Effect.fn("makeOpenCodeTextGeneration"
 				modelSelection: input.modelSelection
 			});
 			return yield* require_bin.validateRankInboxThreadsResult(input, generated.rankings);
-		})
+		}),
+		answerSideQuestion
 	};
 });
 //#endregion
+//#region src/provider/openCodeTaskLifecycle.ts
+const text = (value) => typeof value === "string" && value.trim() ? value.trim() : void 0;
+const record = (value) => value !== null && typeof value === "object" ? value : {};
+const terminal = (status) => status === "completed" || status === "failed" || status === "stopped";
+function resultText(output) {
+	const result = output.match(/<task_result>\s*([\s\S]*?)\s*<\/task_result>/)?.[1];
+	return text(result ?? output.split("\n").filter((line) => !line.trimStart().startsWith("task_id:")).join("\n"));
+}
+/** Native Task lifecycle state stays here; clients consume the shared subagent events. */
+var OpenCodeTaskLifecycle = class {
+	tasks = /* @__PURE__ */ new Map();
+	calls = /* @__PURE__ */ new Map();
+	sessions = /* @__PURE__ */ new Map();
+	emitted = /* @__PURE__ */ new Set();
+	notifications = /* @__PURE__ */ new Set();
+	values() {
+		return Array.from(this.tasks.values(), (task) => task.ref);
+	}
+	hasSession(id) {
+		return this.sessions.has(id);
+	}
+	refForSession(id) {
+		return this.sessions.get(id)?.ref;
+	}
+	transition(task, type, source) {
+		const eventKey = JSON.stringify([
+			task.ref.subagentId,
+			task.callId ?? source,
+			type,
+			task.status,
+			task.summary,
+			task.ref
+		]);
+		if (this.emitted.has(eventKey)) return [];
+		this.emitted.add(eventKey);
+		return [{
+			type,
+			subagent: task.ref,
+			status: task.status,
+			...task.summary ? { summary: task.summary } : {},
+			eventKey
+		}];
+	}
+	stop() {
+		return Array.from(this.tasks.values()).flatMap((task) => {
+			if (terminal(task.status)) return [];
+			task.status = "stopped";
+			return this.transition(task, "completed", "stop");
+		});
+	}
+	project(part, existingRef) {
+		if (part.type === "text") {
+			if (part.synthetic !== true) return [];
+			const envelope = part.text.match(/<task id="([^"]+)" state="(completed|error|interrupted|cancelled)">/);
+			const sessionId = text(envelope?.[1]);
+			if (!sessionId) return [];
+			const notificationKey = JSON.stringify([
+				part.sessionID,
+				part.id,
+				part.text
+			]);
+			if (this.notifications.has(notificationKey)) return [];
+			this.notifications.add(notificationKey);
+			let task = this.sessions.get(sessionId);
+			if (task && terminal(task.status)) return [];
+			const events = [];
+			if (!task) {
+				task = {
+					ref: existingRef ?? this.makeRef(sessionId, part.sessionID),
+					callId: void 0,
+					status: "running",
+					summary: void 0,
+					seenCalls: /* @__PURE__ */ new Set()
+				};
+				this.tasks.set(String(task.ref.subagentId), task);
+				this.sessions.set(sessionId, task);
+				events.push(...this.transition(task, "started", part.id));
+			}
+			task.status = envelope?.[2] === "error" ? "failed" : envelope?.[2] === "completed" ? "completed" : "stopped";
+			task.summary = task.status === "failed" ? text(part.text.match(/<task_error>\s*([\s\S]*?)\s*<\/task_error>/)?.[1]) : resultText(part.text);
+			return [...events, ...this.transition(task, "completed", part.id)];
+		}
+		if (part.type !== "tool" || part.tool.toLowerCase() !== "task") return [];
+		const callKey = JSON.stringify([part.sessionID, part.callID]);
+		const previousCall = this.calls.get(callKey);
+		const metadata = "metadata" in part.state ? record(part.state.metadata) : {};
+		const input = record(part.state.input);
+		const output = part.state.status === "completed" ? part.state.output : "";
+		const sessionId = text(metadata.sessionId) ?? text(metadata.sessionID) ?? text(input.task_id) ?? text(metadata.jobId) ?? text(output.match(/<task id="([^"]+)"/)?.[1]) ?? text(output.match(/(?:^|\n)\s*task_id:\s*(\S+)/)?.[1]);
+		if (part.state.status === "pending" && !sessionId && !previousCall) return [];
+		let task = previousCall ?? (sessionId ? this.sessions.get(sessionId) : void 0);
+		if (!task && !sessionId && part.state.status !== "error") return [];
+		if (task && task.callId !== void 0 && task.callId !== callKey && task.seenCalls.has(callKey)) return [];
+		if (task && task.callId === callKey && task.status !== "starting" && part.state.status === "pending") return [];
+		const newTask = !task;
+		if (!task) {
+			task = {
+				ref: existingRef ?? this.makeRef(sessionId, part.sessionID, part.callID),
+				callId: callKey,
+				status: "starting",
+				summary: void 0,
+				seenCalls: /* @__PURE__ */ new Set()
+			};
+			this.tasks.set(String(task.ref.subagentId), task);
+		}
+		const reopen = task.callId !== void 0 && task.callId !== callKey;
+		const terminalBeforeTool = task.callId === void 0 && terminal(task.status);
+		const priorRef = task.ref;
+		const priorStatus = task.status;
+		if (reopen) {
+			task.status = "starting";
+			task.summary = void 0;
+		}
+		task.callId = callKey;
+		task.seenCalls.add(callKey);
+		this.calls.set(callKey, task);
+		const modelRecord = record(metadata.model);
+		const provider = text(modelRecord.providerID);
+		const model = text(modelRecord.modelID);
+		task.ref = {
+			...task.ref,
+			...sessionId ? {
+				providerSessionId: sessionId,
+				providerThreadId: sessionId
+			} : {},
+			...text(input.description) ? { description: text(input.description) } : {},
+			...text(input.subagent_type) ? { label: text(input.subagent_type) } : {},
+			...provider && model ? { model: `${provider}/${model}` } : {},
+			parentProviderItemId: require_src.ProviderItemId.make(part.callID),
+			metadata: {
+				...task.ref.metadata,
+				...metadata,
+				source: "opencode.task",
+				parentSessionId: part.sessionID
+			}
+		};
+		if (sessionId) this.sessions.set(sessionId, task);
+		const outputState = output.match(/<task id="[^"]+" state="([^"]+)">/)?.[1];
+		const interrupted = outputState === "interrupted" || outputState === "cancelled";
+		const background = metadata.background === true || outputState === "running";
+		const events = [];
+		if (newTask) events.push(...this.transition(task, "started", part.id));
+		if (!terminalBeforeTool && (!terminal(task.status) || reopen)) {
+			task.status = interrupted ? "stopped" : part.state.status === "error" ? "failed" : part.state.status === "completed" && !background ? "completed" : part.state.status === "pending" ? "starting" : "running";
+			task.summary = part.state.status === "error" ? text(part.state.error) : task.status === "completed" ? resultText(output) : void 0;
+			events.push(...this.transition(task, terminal(task.status) ? "completed" : "updated", part.id));
+		} else if (JSON.stringify(priorRef) !== JSON.stringify(task.ref) || priorStatus !== task.status) events.push(...this.transition(task, "updated", part.id));
+		return events;
+	}
+	makeRef(sessionId, parentSessionId, callId) {
+		return {
+			subagentId: require_src.RuntimeSubagentId.make(sessionId ? `opencode:session:${sessionId}` : `opencode:task:${parentSessionId}:${callId}`),
+			origin: "native",
+			capability: "summary",
+			...sessionId ? {
+				providerSessionId: sessionId,
+				providerThreadId: sessionId
+			} : {},
+			metadata: {
+				source: "opencode.task",
+				parentSessionId
+			}
+		};
+	}
+};
+//#endregion
 //#region src/provider/Layers/OpenCodeAdapter.ts
-const PROVIDER$1 = require_collectUint8StreamText.ProviderDriverKind.make("opencode");
+const PROVIDER$1 = require_src.ProviderDriverKind.make("opencode");
 const OPENCODE_RESUME_VERSION = 1;
 function nowIso() {
 	return (/* @__PURE__ */ new Date()).toISOString();
@@ -352,7 +531,7 @@ function scopedOpenCodeId(sessionId, id) {
 	return `${sessionId}:${id}`;
 }
 function openCodeSubagentId(kind, id) {
-	return require_collectUint8StreamText.RuntimeSubagentId.make(`opencode:${kind}:${id}`);
+	return require_src.RuntimeSubagentId.make(`opencode:${kind}:${id}`);
 }
 function subagentKey(subagentId) {
 	return String(subagentId);
@@ -381,7 +560,7 @@ function makeSubtaskSubagentRef(part) {
 		...label ? { label } : {},
 		...description ? { description } : {},
 		...model ? { model } : {},
-		parentProviderItemId: require_collectUint8StreamText.ProviderItemId.make(part.id),
+		parentProviderItemId: require_src.ProviderItemId.make(part.id),
 		metadata: metadataWithEntries([
 			["source", "opencode.subtask"],
 			["prompt", nonEmptyString(part.prompt)],
@@ -445,13 +624,13 @@ const abortOpenCodeSession = (context, sessionID) => require_bin.runOpenCodeSdk(
 	}))
 }));
 const buildEventBase = (input) => effect.Effect.sync(() => crypto.randomUUID()).pipe(effect.Effect.map((uuid) => ({
-	eventId: require_collectUint8StreamText.EventId.make(uuid),
+	eventId: require_src.EventId.make(uuid),
 	provider: PROVIDER$1,
 	threadId: input.threadId,
 	createdAt: input.createdAt ?? nowIso(),
 	...input.turnId ? { turnId: input.turnId } : {},
-	...input.itemId ? { itemId: require_collectUint8StreamText.RuntimeItemId.make(input.itemId) } : {},
-	...input.requestId ? { requestId: require_collectUint8StreamText.RuntimeRequestId.make(input.requestId) } : {},
+	...input.itemId ? { itemId: require_src.RuntimeItemId.make(input.itemId) } : {},
+	...input.requestId ? { requestId: require_src.RuntimeRequestId.make(input.requestId) } : {},
 	...input.raw !== void 0 ? { raw: {
 		source: "opencode.sdk.event",
 		payload: input.raw
@@ -652,7 +831,7 @@ const stopOpenCodeContext = effect.Effect.fn("stopOpenCodeContext")(function* (c
 });
 function makeOpenCodeAdapter(openCodeSettings, options) {
 	return effect.Effect.gen(function* () {
-		const boundInstanceId = options?.instanceId ?? require_collectUint8StreamText.ProviderInstanceId.make("opencode");
+		const boundInstanceId = options?.instanceId ?? require_src.ProviderInstanceId.make("opencode");
 		const serverConfig = yield* require_Metrics.ServerConfig;
 		const openCodeRuntime = yield* require_bin.OpenCodeRuntime;
 		const nativeEventLogger = options?.nativeEventLogger ?? (options?.nativeEventLogPath !== void 0 ? yield* require_bin.makeEventNdjsonLogger(options.nativeEventLogPath, { stream: "native" }) : void 0);
@@ -676,7 +855,7 @@ function makeOpenCodeAdapter(openCodeSettings, options) {
 		}).pipe(effect.Effect.ensuring(runtimeEventQueueMetrics.reset), effect.Effect.ensuring(effect.Queue.shutdown(runtimeEvents))));
 		const emitForContext = (context, event) => {
 			if (context.session.runtimeSessionId === void 0) return effect.Effect.die(/* @__PURE__ */ new Error(`OpenCodeAdapter emitted '${event.type}' without a runtime session for thread '${event.threadId}'.`));
-			return effect.Queue.offer(runtimeEvents, require_makeManagedServerProvider.stampRuntimeEvent(event, {
+			return effect.Queue.offer(runtimeEvents, require_runtimeSession.stampRuntimeEvent(event, {
 				providerInstanceId: boundInstanceId,
 				runtimeSessionId: context.session.runtimeSessionId
 			})).pipe(effect.Effect.andThen(runtimeEventQueueMetrics.recordEnqueued()), effect.Effect.asVoid);
@@ -698,6 +877,7 @@ function makeOpenCodeAdapter(openCodeSettings, options) {
 			});
 		});
 		const emitOpenCodeSubagentUpdated = effect.Effect.fn("emitOpenCodeSubagentUpdated")(function* (context, input) {
+			if (context.completedSubagentIds.has(subagentKey(input.subagent.subagentId))) return;
 			yield* emitOpenCodeSubagentStarted(context, input.subagent, input.raw);
 			yield* emitForContext(context, {
 				...yield* buildEventBase({
@@ -733,7 +913,98 @@ function makeOpenCodeAdapter(openCodeSettings, options) {
 				}
 			});
 		});
+		const emitOpenCodeTaskTransition = effect.Effect.fn("emitOpenCodeTaskTransition")(function* (context, transition, raw) {
+			const nativeRef = transition.subagent;
+			const existing = nativeRef.providerSessionId ? context.subagentBySessionId.get(nativeRef.providerSessionId) : void 0;
+			const subagent = {
+				...existing,
+				...nativeRef,
+				subagentId: existing?.subagentId ?? nativeRef.subagentId,
+				capability: existing?.capability === "transcript" ? "transcript" : nativeRef.capability,
+				metadata: {
+					...existing?.metadata,
+					...nativeRef.metadata,
+					providerInstanceId: boundInstanceId
+				}
+			};
+			if (subagent.providerSessionId) {
+				context.childSessionIds.add(subagent.providerSessionId);
+				context.subagentBySessionId.set(subagent.providerSessionId, subagent);
+			}
+			const key = subagentKey(subagent.subagentId);
+			const base = {
+				...yield* buildEventBase({
+					threadId: context.session.threadId,
+					turnId: context.activeTurnId,
+					raw
+				}),
+				eventId: require_src.EventId.make((0, node_crypto.createHash)("sha256").update(JSON.stringify([
+					context.session.threadId,
+					context.openCodeSessionId,
+					transition.eventKey
+				])).digest("hex"))
+			};
+			if (transition.type === "started") {
+				if (context.startedSubagentIds.has(key)) yield* emitForContext(context, {
+					...base,
+					type: "subagent.updated",
+					payload: {
+						subagent,
+						status: transition.status
+					}
+				});
+				else {
+					context.startedSubagentIds.add(key);
+					yield* emitForContext(context, {
+						...base,
+						type: "subagent.started",
+						payload: { subagent }
+					});
+				}
+				context.completedSubagentIds.delete(key);
+			} else if (transition.type === "completed") {
+				context.startedSubagentIds.add(key);
+				context.completedSubagentIds.add(key);
+				yield* emitForContext(context, {
+					...base,
+					type: "subagent.completed",
+					payload: {
+						subagent,
+						status: transition.status,
+						...transition.summary ? { summary: transition.summary } : {}
+					}
+				});
+			} else {
+				if (transition.status === "running" || transition.status === "starting") context.completedSubagentIds.delete(key);
+				yield* emitForContext(context, {
+					...base,
+					type: "subagent.updated",
+					payload: {
+						subagent,
+						status: transition.status,
+						...transition.summary ? { summary: transition.summary } : {}
+					}
+				});
+			}
+		});
+		const projectOpenCodeTask = effect.Effect.fn("projectOpenCodeTask")(function* (context, part) {
+			for (const transition of context.tasks.project(part)) yield* emitOpenCodeTaskTransition(context, transition, part);
+		});
+		const loadOpenCodeTasks = effect.Effect.fn("loadOpenCodeTasks")(function* (context) {
+			const messages = yield* require_bin.runOpenCodeSdk("session.messages", () => context.client.session.messages({ sessionID: context.openCodeSessionId }));
+			const latest = /* @__PURE__ */ new Map();
+			for (const entry of messages.data ?? []) for (const part of entry.parts) {
+				if (part.sessionID !== context.openCodeSessionId) continue;
+				if (entry.info.role !== "assistant" && !(part.type === "text" && part.synthetic)) continue;
+				for (const transition of context.tasks.project(part)) latest.set(String(transition.subagent.subagentId), {
+					transition,
+					part
+				});
+			}
+			return [...latest.values()];
+		});
 		const emitStoppedOpenCodeChildren = effect.Effect.fn("emitStoppedOpenCodeChildren")(function* (context, raw) {
+			for (const transition of context.tasks.stop()) yield* emitOpenCodeTaskTransition(context, transition, raw);
 			for (const subagent of context.subagentBySessionId.values()) yield* emitOpenCodeSubagentCompleted(context, {
 				subagent,
 				status: subagentCompletionStatus("stopped"),
@@ -762,10 +1033,12 @@ function makeOpenCodeAdapter(openCodeSettings, options) {
 		};
 		const registerOpenCodeChildSession = effect.Effect.fn("registerOpenCodeChildSession")(function* (context, session, raw) {
 			if (session.parentID !== context.openCodeSessionId && (session.parentID === void 0 || !context.childSessionIds.has(session.parentID))) return;
-			const subagent = mergeOpenCodeChildSessionRef(context.subagentBySessionId.get(session.id) ?? takeUnboundOpenCodeSubtask(context), session, session.parentID ?? context.openCodeSessionId);
+			const taskRef = context.tasks.refForSession(session.id);
+			const subagent = mergeOpenCodeChildSessionRef(context.subagentBySessionId.get(session.id) ?? taskRef ?? takeUnboundOpenCodeSubtask(context), session, session.parentID ?? context.openCodeSessionId);
 			const known = context.childSessionIds.has(session.id);
 			context.childSessionIds.add(session.id);
 			context.subagentBySessionId.set(session.id, subagent);
+			if (taskRef) return subagent;
 			if (known) {
 				yield* emitOpenCodeSubagentUpdated(context, {
 					subagent,
@@ -891,6 +1164,7 @@ function makeOpenCodeAdapter(openCodeSettings, options) {
 		});
 		const emitUnexpectedExit = effect.Effect.fn("emitUnexpectedExit")(function* (context, message) {
 			if (yield* effect.Ref.getAndSet(context.stopped, true)) return;
+			yield* emitStoppedOpenCodeChildren(context, { reason: "transport-exit" });
 			const turnId = context.activeTurnId;
 			yield* emitForContext(context, {
 				...yield* buildEventBase({
@@ -987,6 +1261,7 @@ function makeOpenCodeAdapter(openCodeSettings, options) {
 			}
 		});
 		const handleSubscribedEvent = effect.Effect.fn("handleSubscribedEvent")(function* (context, event) {
+			if (yield* effect.Ref.get(context.stopped)) return;
 			const payloadSessionId = "properties" in event ? event.properties.sessionID : void 0;
 			const eventSessionId = typeof payloadSessionId === "string" ? payloadSessionId : void 0;
 			const isRootSessionEvent = eventSessionId === context.openCodeSessionId;
@@ -1104,14 +1379,17 @@ function makeOpenCodeAdapter(openCodeSettings, options) {
 				case "message.part.updated": {
 					const part = event.properties.part;
 					context.partById.set(scopedOpenCodeId(part.sessionID, part.id), part);
-					if (messageRoleForPart(context, part) === "assistant") yield* emitAssistantTextDelta(context, part, turnId, event);
+					const messageRole = messageRoleForPart(context, part);
+					if (part.sessionID === context.openCodeSessionId && messageRole !== "user") yield* projectOpenCodeTask(context, part);
+					else if (part.sessionID === context.openCodeSessionId && part.type === "text" && part.synthetic) yield* projectOpenCodeTask(context, part);
+					if (messageRole === "assistant") yield* emitAssistantTextDelta(context, part, turnId, event);
 					if (part.type === "subtask" && part.sessionID === context.openCodeSessionId) yield* bindOpenCodeSubtaskPart(context, part, event);
 					if (part.type === "tool") {
 						const itemType = toToolLifecycleItemType(part.tool);
 						const title = part.state.status === "running" ? part.state.title ?? part.tool : part.tool;
 						const detail = detailFromToolPart(part);
 						const childSubagent = context.subagentBySessionId.get(part.sessionID);
-						if (childSubagent) yield* emitOpenCodeSubagentUpdated(context, {
+						if (childSubagent && !context.tasks.hasSession(part.sessionID)) yield* emitOpenCodeSubagentUpdated(context, {
 							subagent: childSubagent,
 							status: statusFromOpenCodeSubagentState("running"),
 							summary: title,
@@ -1228,6 +1506,7 @@ function makeOpenCodeAdapter(openCodeSettings, options) {
 					});
 					break;
 				case "session.status": {
+					if (context.tasks.hasSession(event.properties.sessionID)) break;
 					const childSubagent = context.subagentBySessionId.get(event.properties.sessionID);
 					if (childSubagent) {
 						if (event.properties.status.type === "idle") {
@@ -1295,6 +1574,7 @@ function makeOpenCodeAdapter(openCodeSettings, options) {
 					break;
 				}
 				case "session.idle": {
+					if (context.tasks.hasSession(event.properties.sessionID)) break;
 					const childSubagent = context.subagentBySessionId.get(event.properties.sessionID);
 					if (childSubagent) yield* emitOpenCodeSubagentCompleted(context, {
 						subagent: childSubagent,
@@ -1304,6 +1584,7 @@ function makeOpenCodeAdapter(openCodeSettings, options) {
 					break;
 				}
 				case "session.error": {
+					if (event.properties.sessionID && context.tasks.hasSession(event.properties.sessionID)) break;
 					const message = sessionErrorMessage(event.properties.error);
 					const childSubagent = event.properties.sessionID !== void 0 ? context.subagentBySessionId.get(event.properties.sessionID) : void 0;
 					if (childSubagent) {
@@ -1356,14 +1637,41 @@ function makeOpenCodeAdapter(openCodeSettings, options) {
 				}
 			}
 		});
-		const startEventPump = effect.Effect.fn("startEventPump")(function* (context) {
+		const prepareEventSubscription = effect.Effect.fn("prepareEventSubscription")(function* (context) {
 			const eventsAbortController = new AbortController();
 			yield* effect.Scope.addFinalizer(context.sessionScope, effect.Effect.sync(() => eventsAbortController.abort()));
-			yield* effect.Effect.flatMap(require_bin.runOpenCodeSdk("event.subscribe", () => context.client.event.subscribe(void 0, { signal: eventsAbortController.signal })), (subscription) => effect.Stream.fromAsyncIterable(subscription.stream, (cause) => new require_bin.OpenCodeRuntimeError({
+			const iterator = (yield* require_bin.runOpenCodeSdk("event.subscribe", () => context.client.event.subscribe(void 0, { signal: eventsAbortController.signal }))).stream[Symbol.asyncIterator]();
+			const first = yield* require_bin.runOpenCodeSdk("event.subscribe", () => iterator.next()).pipe(effect.Effect.timeoutOrElse({
+				duration: "10 seconds",
+				orElse: () => effect.Effect.fail(new require_bin.OpenCodeRuntimeError({
+					operation: "event.subscribe",
+					detail: "Timed out opening OpenCode event stream."
+				}))
+			}));
+			return {
+				subscription: { stream: (async function* () {
+					try {
+						if (!first.done) yield first.value;
+						if (first.done) return;
+						while (true) {
+							const next = await iterator.next();
+							if (next.done) return;
+							yield next.value;
+						}
+					} finally {
+						await iterator.return?.();
+					}
+				})() },
+				eventsAbortController
+			};
+		});
+		const startEventPump = effect.Effect.fn("startEventPump")(function* (context, prepared) {
+			const { subscription, eventsAbortController } = prepared;
+			yield* effect.Stream.fromAsyncIterable(subscription.stream, (cause) => new require_bin.OpenCodeRuntimeError({
 				operation: "event.subscribe",
 				detail: require_bin.openCodeRuntimeErrorDetail(cause),
 				cause
-			})).pipe(effect.Stream.runForEach((event) => handleSubscribedEvent(context, event)))).pipe(effect.Effect.exit, effect.Effect.flatMap((exit) => effect.Effect.gen(function* () {
+			})).pipe(effect.Stream.runForEach((event) => handleSubscribedEvent(context, event))).pipe(effect.Effect.exit, effect.Effect.flatMap((exit) => effect.Effect.gen(function* () {
 				if (eventsAbortController.signal.aborted || (yield* effect.Ref.get(context.stopped))) return;
 				if (effect.Exit.isFailure(exit)) yield* emitUnexpectedExit(context, require_bin.openCodeRuntimeErrorDetail(effect.Cause.squash(exit.cause)));
 			})), effect.Effect.forkIn(context.sessionScope));
@@ -1383,7 +1691,7 @@ function makeOpenCodeAdapter(openCodeSettings, options) {
 				operation: "startSession",
 				issue: `Expected provider instance '${boundInstanceId}' but received '${input.providerInstanceId}'.`
 			});
-			const runtimeSessionId = yield* require_makeManagedServerProvider.requireRuntimeSessionId(PROVIDER$1, input);
+			const runtimeSessionId = yield* require_runtimeSession.requireRuntimeSessionId(PROVIDER$1, input);
 			const binaryPath = openCodeSettings.binaryPath;
 			const serverUrl = openCodeSettings.serverUrl;
 			const serverPassword = openCodeSettings.serverPassword;
@@ -1452,7 +1760,8 @@ function makeOpenCodeAdapter(openCodeSettings, options) {
 						sessionScope,
 						server,
 						client,
-						openCodeSession: openCodeSession.data
+						openCodeSession: openCodeSession.data,
+						adopted: adoptedSession !== void 0
 					};
 				}).pipe(effect.Effect.provideService(effect.Scope.Scope, sessionScope)));
 				if (effect.Exit.isFailure(startedExit)) {
@@ -1461,12 +1770,6 @@ function makeOpenCodeAdapter(openCodeSettings, options) {
 				}
 				return startedExit.value;
 			});
-			const raceWinner = sessions.get(input.threadId);
-			if (raceWinner) {
-				yield* require_bin.runOpenCodeSdk("session.abort", () => started.client.session.abort({ sessionID: started.openCodeSession.id })).pipe(effect.Effect.ignore);
-				yield* effect.Scope.close(started.sessionScope, effect.Exit.void).pipe(effect.Effect.ignore);
-				return raceWinner.session;
-			}
 			const createdAt = nowIso();
 			const tokenMode = input.tokenMode ?? "balanced";
 			const session = {
@@ -1505,6 +1808,7 @@ function makeOpenCodeAdapter(openCodeSettings, options) {
 				unboundSubtaskPartIds: [],
 				startedSubagentIds: /* @__PURE__ */ new Set(),
 				completedSubagentIds: /* @__PURE__ */ new Set(),
+				tasks: new OpenCodeTaskLifecycle(),
 				turns: [],
 				activeTurnId: void 0,
 				activeAgent: void 0,
@@ -1518,6 +1822,19 @@ function makeOpenCodeAdapter(openCodeSettings, options) {
 				stopped: yield* effect.Ref.make(false),
 				sessionScope: started.sessionScope
 			};
+			const prepared = yield* effect.Effect.exit(prepareEventSubscription(context));
+			if (effect.Exit.isFailure(prepared)) {
+				if (!started.adopted) yield* require_bin.runOpenCodeSdk("session.abort", () => started.client.session.abort({ sessionID: started.openCodeSession.id })).pipe(effect.Effect.ignore);
+				yield* effect.Scope.close(started.sessionScope, effect.Exit.void).pipe(effect.Effect.ignore);
+				return yield* toProcessError(input.threadId, effect.Cause.squash(prepared.cause));
+			}
+			const storedTasks = started.adopted ? yield* loadOpenCodeTasks(context).pipe(effect.Effect.catch((error) => effect.Effect.logWarning("OpenCode Task history reconstruction failed", error).pipe(effect.Effect.as([])))) : [];
+			const raceWinner = sessions.get(input.threadId);
+			if (raceWinner) {
+				if (!started.adopted) yield* require_bin.runOpenCodeSdk("session.abort", () => started.client.session.abort({ sessionID: started.openCodeSession.id })).pipe(effect.Effect.ignore);
+				yield* effect.Scope.close(started.sessionScope, effect.Exit.void).pipe(effect.Effect.ignore);
+				return raceWinner.session;
+			}
 			deviceToolContext = context;
 			sessions.set(input.threadId, context);
 			yield* emitForContext(context, {
@@ -1530,7 +1847,8 @@ function makeOpenCodeAdapter(openCodeSettings, options) {
 				type: "thread.started",
 				payload: { providerThreadId: started.openCodeSession.id }
 			});
-			yield* startEventPump(context);
+			for (const { transition, part } of storedTasks) yield* emitOpenCodeTaskTransition(context, transition, part);
+			yield* startEventPump(context, prepared.value);
 			yield* effect.Effect.gen(function* () {
 				yield* hydrateOpenCodeChildSessions(context);
 				yield* recoverPendingOpenCodeRequests(context);
@@ -1544,7 +1862,7 @@ function makeOpenCodeAdapter(openCodeSettings, options) {
 					provider: PROVIDER$1,
 					threadId: input.threadId
 				});
-				const turnId = require_collectUint8StreamText.TurnId.make(`opencode-turn-${yield* effect.Effect.sync(() => crypto.randomUUID())}`);
+				const turnId = require_src.TurnId.make(`opencode-turn-${yield* effect.Effect.sync(() => crypto.randomUUID())}`);
 				const modelSelection = input.modelSelection ?? (context.session.model ? {
 					instanceId: boundInstanceId,
 					model: context.session.model
@@ -1567,7 +1885,7 @@ function makeOpenCodeAdapter(openCodeSettings, options) {
 				if (declaredAttachmentBytes > 52428800) return yield* new require_bin.ProviderAdapterRequestError({
 					provider: PROVIDER$1,
 					method: "session.prompt",
-					detail: `Attachments total ${declaredAttachmentBytes} bytes; limit is ${require_collectUint8StreamText.PROVIDER_SEND_TURN_MAX_ATTACHMENT_TOTAL_BYTES} bytes.`
+					detail: `Attachments total ${declaredAttachmentBytes} bytes; limit is ${require_src.PROVIDER_SEND_TURN_MAX_ATTACHMENT_TOTAL_BYTES} bytes.`
 				});
 				let attachmentTotalBytes = 0;
 				const pathLineEntries = [];
@@ -1596,10 +1914,10 @@ function makeOpenCodeAdapter(openCodeSettings, options) {
 					if (attachmentTotalBytes > 52428800) return yield* new require_bin.ProviderAdapterRequestError({
 						provider: PROVIDER$1,
 						method: "session.prompt",
-						detail: `Attachments total ${attachmentTotalBytes} bytes; limit is ${require_collectUint8StreamText.PROVIDER_SEND_TURN_MAX_ATTACHMENT_TOTAL_BYTES} bytes.`
+						detail: `Attachments total ${attachmentTotalBytes} bytes; limit is ${require_src.PROVIDER_SEND_TURN_MAX_ATTACHMENT_TOTAL_BYTES} bytes.`
 					});
 				}
-				text = require_makeManagedServerProvider.appendAttachmentPathLines(text, require_makeManagedServerProvider.formatAttachmentPathLines(pathLineEntries));
+				text = require_runtimeSession.appendAttachmentPathLines(text, require_runtimeSession.formatAttachmentPathLines(pathLineEntries));
 				const fileParts = require_bin.toOpenCodeFileParts({
 					attachments: input.attachments,
 					resolveAttachmentUrl: (attachment) => attachment.id === void 0 ? null : attachmentUrlById.get(attachment.id) ?? null
@@ -1699,6 +2017,10 @@ function makeOpenCodeAdapter(openCodeSettings, options) {
 			const context = ensureSessionContext(sessions, threadId);
 			const interruptedTurnId = turnId ?? context.activeTurnId;
 			if (turnId !== void 0 && context.activeTurnId !== void 0 && turnId !== context.activeTurnId) return;
+			yield* emitStoppedOpenCodeChildren(context, {
+				method: "session.abort",
+				reason: "turn-interrupted"
+			});
 			const pendingPrompt = context.pendingPrompt;
 			if (pendingPrompt && pendingPrompt.turnId === interruptedTurnId) {
 				context.pendingPrompt = void 0;
@@ -1706,10 +2028,6 @@ function makeOpenCodeAdapter(openCodeSettings, options) {
 			}
 			const rootAbortExit = yield* abortOpenCodeSession(context, context.openCodeSessionId).pipe(effect.Effect.mapError(toRequestError), effect.Effect.exit);
 			yield* effect.Effect.forEach(context.childSessionIds, (sessionID) => abortOpenCodeSession(context, sessionID).pipe(effect.Effect.ignore({ log: true })), { discard: true });
-			yield* emitStoppedOpenCodeChildren(context, {
-				method: "session.abort",
-				reason: "turn-interrupted"
-			});
 			if (effect.Exit.isFailure(rootAbortExit)) return yield* effect.Effect.failCause(rootAbortExit.cause);
 			if (interruptedTurnId) {
 				if (context.activeTurnId === interruptedTurnId) {
@@ -1787,7 +2105,7 @@ function makeOpenCodeAdapter(openCodeSettings, options) {
 			return {
 				threadId,
 				turns: ((yield* require_bin.runOpenCodeSdk("session.messages", () => context.client.session.messages({ sessionID: context.openCodeSessionId })).pipe(effect.Effect.mapError(toRequestError))).data ?? []).filter((entry) => entry.info.role === "assistant").map((entry) => ({
-					id: require_collectUint8StreamText.TurnId.make(entry.info.id),
+					id: require_src.TurnId.make(entry.info.id),
 					items: [entry.info, ...entry.parts]
 				}))
 			};
@@ -1918,7 +2236,7 @@ const probeOpenCodeGoUsageRateLimits = effect.Effect.fn("probeOpenCodeGoUsageRat
 });
 //#endregion
 //#region src/provider/Layers/OpenCodeProvider.ts
-const PROVIDER = require_collectUint8StreamText.ProviderDriverKind.make("opencode");
+const PROVIDER = require_src.ProviderDriverKind.make("opencode");
 const OPENCODE_PRESENTATION = {
 	displayName: "OpenCode",
 	showInteractionModeToggle: false
@@ -2222,7 +2540,7 @@ const checkOpenCodeProviderStatus = effect.Effect.fn("checkOpenCodeProviderStatu
 *
 * @module provider/Drivers/OpenCodeDriver
 */
-const DRIVER_KIND = require_collectUint8StreamText.ProviderDriverKind.make("opencode");
+const DRIVER_KIND = require_src.ProviderDriverKind.make("opencode");
 function isOpenCodeNativeCommandPath(commandPath) {
 	const normalized = require_bin.normalizeCommandPath(commandPath);
 	return normalized.endsWith("/.opencode/bin/opencode") || normalized.endsWith("/.opencode/bin/opencode.exe");
@@ -2252,8 +2570,8 @@ const OpenCodeDriver = {
 		displayName: "OpenCode",
 		supportsMultipleInstances: true
 	},
-	configSchema: require_collectUint8StreamText.OpenCodeSettings,
-	defaultConfig: () => effect.Schema.decodeSync(require_collectUint8StreamText.OpenCodeSettings)({}),
+	configSchema: require_src.OpenCodeSettings,
+	defaultConfig: () => effect.Schema.decodeSync(require_src.OpenCodeSettings)({}),
 	create: ({ instanceId, displayName, accentColor, environment, enabled, config }) => effect.Effect.gen(function* () {
 		const openCodeRuntime = yield* require_bin.OpenCodeRuntime;
 		const serverConfig = yield* require_Metrics.ServerConfig;