@oisincoveney/pipeline 2.7.0 → 2.8.1

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

@@ -1,4 +1,6 @@
+import { OpencodeSdkService, OpencodeSdkServiceLive } from "./services/opencode-sdk-service.js";
 import { opencodeAgentName } from "./opencode-agent-name.js";
+import { Effect } from "effect";
 //#region src/runtime/opencode-session-executor.ts
 function createOpencodeSessionRegistry() {
 	return { sessions: /* @__PURE__ */ new Map() };
@@ -18,45 +20,69 @@ const EXIT_INFRA = 70;
 */
 function createOpencodeExecutor(deps) {
 	return async function execute(plan, options = {}) {
-		if (plan.type !== "opencode") throw new Error(`opencode executor cannot drive runner type '${plan.type}'`);
-		try {
-			return successResult(plan, await driveSession(deps, plan, options));
-		} catch (error) {
-			return failureResult(plan, error);
-		}
+		return await Effect.runPromise(Effect.provide(executeOpencodeEffect(deps, plan, options), OpencodeSdkServiceLive));
 	};
 }
+function executeOpencodeEffect(deps, plan, options) {
+	return Effect.gen(function* () {
+		yield* validateOpencodePlan(plan);
+		return yield* executeOpencodeSession(deps, plan, options);
+	});
+}
+function executeOpencodeSession(deps, plan, options) {
+	return Effect.gen(function* () {
+		return successResult(plan, yield* driveSession(deps, plan, options));
+	}).pipe(Effect.catchAll((error) => Effect.succeed(failureResult(plan, error))));
+}
+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;
 }
-async function driveSession(deps, plan, options) {
-	const sessionId = await resolveSessionId(deps, plan);
-	deps.onSession?.(plan.nodeId, sessionId);
-	const stream = await streamEventsToOutput(deps, sessionId, plan, options);
-	try {
-		const data = unwrap(await deps.client.session.prompt({
-			body: promptBody(plan),
-			path: { id: sessionId },
-			query: { directory: sessionDirectory(deps, plan) }
-		}));
+function driveSession(deps, plan, options) {
+	return Effect.gen(function* () {
+		const sessionId = yield* resolveSessionId(deps, plan);
+		recordSession(deps, plan.nodeId, sessionId);
+		const stream = yield* streamEventsToOutput(deps, sessionId, plan, options);
+		return yield* promptSessionResult(deps, plan, sessionId).pipe(Effect.ensuring(stopStream(stream)));
+	});
+}
+function promptSessionResult(deps, plan, sessionId) {
+	return Effect.gen(function* () {
+		const data = unwrap(yield* (yield* OpencodeSdkService).promptSession(deps.client, promptRequest(deps, plan, sessionId)));
 		return {
 			...data.info ? { assistant: data.info } : {},
 			parts: data.parts ?? [],
 			sessionId
 		};
-	} finally {
-		await stream.stop();
-	}
+	});
+}
+function promptRequest(deps, plan, sessionId) {
+	return {
+		body: promptBody(plan),
+		path: { id: sessionId },
+		query: { directory: sessionDirectory(deps, plan) }
+	};
+}
+function stopStream(stream) {
+	return Effect.tryPromise(() => stream.stop()).pipe(Effect.asVoid, Effect.catchAll(() => Effect.void));
 }
-async function resolveSessionId(deps, plan) {
+function recordSession(deps, nodeId, sessionId) {
+	deps.onSession?.(nodeId, sessionId);
+}
+function resolveSessionId(deps, plan) {
 	const existing = deps.registry.sessions.get(plan.nodeId);
-	if (existing) return existing;
-	const session = unwrap(await deps.client.session.create({
-		body: { title: `moka:${plan.nodeId}` },
-		query: { directory: plan.cwd ?? deps.directory }
-	}));
-	deps.registry.sessions.set(plan.nodeId, session.id);
-	return session.id;
+	if (existing) return Effect.succeed(existing);
+	return Effect.gen(function* () {
+		const session = unwrap(yield* (yield* OpencodeSdkService).createSession(deps.client, {
+			body: { title: `moka:${plan.nodeId}` },
+			query: { directory: plan.cwd ?? deps.directory }
+		}));
+		deps.registry.sessions.set(plan.nodeId, session.id);
+		return session.id;
+	});
 }
 function promptBody(plan) {
 	const prompt = promptText(plan);
@@ -95,24 +121,55 @@ function parseModel(model) {
 		providerID: model.slice(0, slash)
 	};
 }
-async function streamEventsToOutput(deps, sessionId, plan, options) {
-	if (!options.onOutput) return { stop: () => Promise.resolve() };
-	const iterator = (await deps.client.event.subscribe()).stream;
-	const pump = (async () => {
-		try {
-			for await (const event of iterator) forwardEvent(event, sessionId, plan, options);
-		} catch (error) {
-			options.onOutput?.({
-				chunk: `opencode event stream dropped: ${errorMessage(error)}\n`,
-				nodeId: plan.nodeId,
-				stream: "stderr"
-			});
+function streamEventsToOutput(deps, sessionId, plan, options) {
+	if (!options.onOutput) return Effect.succeed({ stop: () => Promise.resolve() });
+	return Effect.gen(function* () {
+		const iterator = (yield* (yield* OpencodeSdkService).subscribeEvents(deps.client)).stream;
+		const pump = Effect.runPromise(pumpEvents(iterator, sessionId, plan, options));
+		return { stop: () => stopIterator(iterator, pump) };
+	});
+}
+function pumpEvents(iterator, sessionId, plan, options) {
+	return Effect.gen(function* () {
+		let done = false;
+		while (!done) {
+			const next = yield* readNextEvent(iterator);
+			done = next.done === true;
+			if (!done) forwardEvent(next.value, sessionId, plan, options);
 		}
-	})();
-	return { stop: async () => {
-		await iterator.return?.(void 0);
-		await pump;
-	} };
+	}).pipe(Effect.catchAll((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.catchAll(() => Effect.void));
+	});
+}
+function requestIteratorReturn(iterator) {
+	const returnIterator = iterator.return;
+	if (!returnIterator) return Effect.void;
+	return Effect.tryPromise({
+		catch: (error) => error,
+		try: () => returnIterator.call(iterator, void 0)
+	}).pipe(Effect.asVoid, Effect.catchAll(() => Effect.void));
 }
 function forwardEvent(event, sessionId, plan, options) {
 	const forwarded = eventChunk(event, sessionId);

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

@@ -1,60 +1,116 @@
 import { childReporter } from "../events/events.js";
 import "../events/index.js";
-import { createChildWorktree, gcParallelWorktrees } from "../parallel-worktrees/parallel-worktrees.js";
-import pLimit from "p-limit";
+import { configUsesOpencode, leaseOpencodeRuntime } from "../opencode-runtime.js";
+import { WorktreeService, WorktreeServiceLive } from "../services/worktree-service.js";
+import { Effect } from "effect";
 //#region src/runtime/parallel-node/parallel-node.ts
-async function executeParallelNode(node, context, runtime) {
+function executeParallelNode(node, context, runtime) {
+	return Effect.runPromise(Effect.provide(parallelNodeProgram(node, context, runtime), WorktreeServiceLive));
+}
+function parallelNodeProgram(node, context, runtime) {
 	const children = node.children ?? [];
-	if (children.length === 0) return {
+	if (children.length === 0) return Effect.succeed({
 		evidence: [`parallel node '${node.id}' has no children`],
 		exitCode: 1,
 		output: ""
+	});
+	return Effect.gen(function* () {
+		yield* gcStaleWorktrees(context);
+		const failFast = context.plan.execution.failFast;
+		const linkedAbort = createLinkedAbortController(context.signal);
+		const childContext = createParallelChildContext(context, node.id, children, failFast ? linkedAbort.controller.signal : context.signal);
+		const gate = failFast ? makeFailFastGate(linkedAbort.controller) : void 0;
+		for (const child of children) runtime.markNodeReady(childContext, child.id);
+		const settled = yield* runAllChildren(children, childContext, runtime, yield* makeCategorySemaphores(childContext), gate).pipe(Effect.ensuring(Effect.sync(linkedAbort.cleanup)));
+		return aggregateParallelResult(node.id, children, settled);
+	});
+}
+function makeFailFastGate(controller) {
+	return {
+		abort: () => controller.abort(),
+		aborted: () => controller.signal.aborted
 	};
-	gcStaleWorktrees(context);
-	const linkedAbort = createLinkedAbortController(context.signal);
-	const childContext = createParallelChildContext(context, node.id, children, context.plan.execution.failFast ? linkedAbort.controller.signal : context.signal);
-	try {
-		const results = context.plan.execution.failFast ? await executeFailFastParallelChildren(children, childContext, linkedAbort.controller, runtime) : await executeParallelChildren(children, childContext, runtime);
-		const failed = results.filter((result) => result.status === "failed");
-		return {
-			evidence: parallelEvidence(node.id, results, failed),
-			exitCode: failed.length > 0 ? 1 : 0,
-			output: parallelOutput(children, results)
-		};
-	} finally {
-		linkedAbort.cleanup();
-	}
+}
+function aggregateParallelResult(nodeId, children, settled) {
+	const results = settled.filter((result) => result !== void 0);
+	const failed = results.filter((result) => result.status === "failed");
+	return {
+		evidence: parallelEvidence(nodeId, results, failed),
+		exitCode: failed.length > 0 ? 1 : 0,
+		output: parallelOutput(children, results)
+	};
+}
+function runAllChildren(children, context, runtime, caps, gate) {
+	return Effect.forEach(children, (child) => runChildCapped(child, context, runtime, caps, gate), { concurrency: context.maxParallelNodes ?? "unbounded" });
+}
+function runChildCapped(child, context, runtime, caps, gate) {
+	return Effect.gen(function* () {
+		if (gate?.aborted()) return;
+		const result = yield* withCategoryCap(caps, child.id, context, runChildInWorktree(child, context, runtime));
+		if (gate && result.status === "failed") gate.abort();
+		return result;
+	});
+}
+function withCategoryCap(caps, childId, context, effect) {
+	const category = childCategory(childId, context.config.token_budget?.fan_out_width);
+	const semaphore = category ? caps.get(category) : void 0;
+	return semaphore ? semaphore.withPermits(1)(effect) : effect;
+}
+function makeCategorySemaphores(context) {
+	const fanOut = context.config.token_budget?.fan_out_width;
+	if (!fanOut) return Effect.succeed(/* @__PURE__ */ new Map());
+	return Effect.gen(function* () {
+		const caps = /* @__PURE__ */ new Map();
+		for (const [category, permits] of Object.entries(fanOut.by_category)) caps.set(category, yield* Effect.makeSemaphore(permits));
+		return caps;
+	});
 }
 function gcStaleWorktrees(context) {
-	if (context.config.parallel_worktrees?.enabled) gcParallelWorktrees(context.worktreePath);
+	return Effect.gen(function* () {
+		if (context.config.parallel_worktrees?.enabled) yield* (yield* WorktreeService).gc(context.worktreePath);
+	});
 }
 /**
 * PIPE-83.4: run a parallel child in its own git worktree when enabled, so
-* concurrent candidate edits can't collide. The lease is created inside the
-* per-child callback (not before scheduling) so failFast-cleared children never
-* allocate a worktree; release retains dirty/unpushed work for downstream
-* selection. Default-off path is byte-identical to the prior behaviour.
+* concurrent candidate edits can't collide. The worktree lease is acquired and
+* released as an Effect-scoped resource (released on success, failure, or
+* interruption); release retains dirty/unpushed work for downstream selection.
 */
 function runChildInWorktree(child, context, runtime) {
-	return context.config.parallel_worktrees?.enabled ? runInLease(child, context, runtime, createChildLease(child, context)) : runtime.executeNode(child, context);
+	if (!context.config.parallel_worktrees?.enabled) return executeChild(child, context, runtime);
+	return Effect.gen(function* () {
+		const worktree = yield* WorktreeService;
+		return yield* Effect.acquireUseRelease(worktree.createChild(childLeaseOptions(child, context)), (lease) => runChildWithWorktreeLease(child, context, runtime, lease.path), (lease) => Effect.sync(() => lease.release()));
+	});
+}
+function executeChild(child, context, runtime) {
+	return Effect.tryPromise(() => runtime.executeNode(child, context)).pipe(Effect.orDie);
 }
-function createChildLease(child, context) {
-	return createChildWorktree({
+function runChildWithWorktreeLease(child, context, runtime, worktreePath) {
+	const childContext = {
+		...context,
+		worktreePath
+	};
+	if (!configUsesOpencode(context.config)) return executeChild(child, childContext, runtime);
+	return Effect.acquireUseRelease(leaseChildOpencodeRuntime(context, worktreePath), (childRuntime) => executeChild(child, {
+		...childContext,
+		executor: childRuntime.executor
+	}, runtime), (childRuntime) => Effect.tryPromise(() => childRuntime.release()).pipe(Effect.orDie));
+}
+function leaseChildOpencodeRuntime(context, worktreePath) {
+	return Effect.tryPromise(() => leaseOpencodeRuntime({
+		config: context.config,
+		...context.signal ? { signal: context.signal } : {},
+		worktreePath
+	})).pipe(Effect.orDie);
+}
+function childLeaseOptions(child, context) {
+	return {
 		childNodeId: child.id,
 		parentNodeId: context.parentParallelNodeId ?? "parallel",
 		repoRoot: context.worktreePath,
 		...context.runId ? { runId: context.runId } : {}
-	});
-}
-async function runInLease(child, context, runtime, lease) {
-	try {
-		return await runtime.executeNode(child, {
-			...context,
-			worktreePath: lease.path
-		});
-	} finally {
-		lease.release();
-	}
+	};
 }
 function createParallelChildContext(context, parentNodeId, children, signal) {
 	return {
@@ -94,44 +150,6 @@ function createLinkedAbortController(signal) {
 function childCategory(childId, fanOut) {
 	return fanOut ? Object.keys(fanOut.by_category).find((category) => childId.includes(category)) : void 0;
 }
-function makeCategoryGate(context) {
-	const fanOut = context.config.token_budget?.fan_out_width;
-	const limits = /* @__PURE__ */ new Map();
-	return (childId, run) => {
-		const category = childCategory(childId, fanOut);
-		if (!(category && fanOut)) return run();
-		let limit = limits.get(category);
-		if (!limit) {
-			limit = pLimit(fanOut.by_category[category]);
-			limits.set(category, limit);
-		}
-		return limit(run);
-	};
-}
-function executeParallelChildren(children, context, runtime) {
-	for (const child of children) runtime.markNodeReady(context, child.id);
-	const gate = makeCategoryGate(context);
-	const runChild = (child) => gate(child.id, () => runChildInWorktree(child, context, runtime));
-	if (!context.maxParallelNodes) return Promise.all(children.map((child) => runChild(child)));
-	const limit = pLimit(context.maxParallelNodes);
-	return Promise.all(children.map((child) => limit(() => runChild(child))));
-}
-async function executeFailFastParallelChildren(children, context, abortController, runtime) {
-	for (const child of children) runtime.markNodeReady(context, child.id);
-	const gate = makeCategoryGate(context);
-	const limit = pLimit({
-		concurrency: context.maxParallelNodes ?? children.length,
-		rejectOnClear: true
-	});
-	return (await Promise.allSettled(children.map((child) => limit(async () => {
-		const result = await gate(child.id, () => runChildInWorktree(child, context, runtime));
-		if (result.status === "failed") {
-			abortController.abort();
-			limit.clearQueue();
-		}
-		return result;
-	})))).flatMap((result) => result.status === "fulfilled" ? [result.value] : []);
-}
 function parallelEvidence(nodeId, results, failed) {
 	if (failed.length === 0) return [`parallel node '${nodeId}' completed ${results.length} child nodes`];
 	return [`parallel node '${nodeId}' failed with ${failed.length} failed child nodes`, ...failed.flatMap((result) => result.evidence)];

package/dist/runtime/parallel-worktrees/parallel-worktrees.js

@@ -1,5 +1,5 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 import { execFileSync } from "node:child_process";
 //#region src/runtime/parallel-worktrees/parallel-worktrees.ts
 /**
@@ -13,6 +13,50 @@ import { execFileSync } from "node:child_process";
 const WORKTREE_ROOT = ".pipeline/worktrees";
 const REGISTRY_DIR = join(WORKTREE_ROOT, "registry");
 const OWNER = "oisin-pipeline";
+const GENERATED_WORKTREE_RESOURCES = [join(".opencode", "agents"), join(".opencode", "command")];
+function provisionGeneratedResources(repoRoot, worktreePath) {
+	for (const relativePath of GENERATED_WORKTREE_RESOURCES) {
+		const source = join(repoRoot, relativePath);
+		const target = join(worktreePath, relativePath);
+		if (existsSync(source) && !existsSync(target)) cpSync(source, target, { recursive: true });
+	}
+}
+function childWorktreeRelPath(runId, parentNodeId, childNodeId) {
+	return join(WORKTREE_ROOT, "trees", sanitize(runId ?? "local"), sanitize(parentNodeId), sanitize(childNodeId));
+}
+function changedWorktreeFiles(worktreePath) {
+	const modified = git(worktreePath, [
+		"diff",
+		"--name-only",
+		"HEAD"
+	]);
+	const untracked = git(worktreePath, [
+		"ls-files",
+		"--others",
+		"--exclude-standard"
+	]);
+	return [...modified.split("\n"), ...untracked.split("\n")].filter(Boolean);
+}
+function copyFileInto(fromRoot, toRoot, relativePath) {
+	const source = join(fromRoot, relativePath);
+	if (!existsSync(source)) return;
+	const dest = join(toRoot, relativePath);
+	mkdirSync(dirname(dest), { recursive: true });
+	cpSync(source, dest, { recursive: true });
+}
+/**
+* PIPE-83.14: promote a best-of-N winner's edits from its (retained) worktree
+* back into the main worktree, so downstream nodes (tests, verification) see the
+* selected candidate's changes. Copies modified + untracked files; no-op if the
+* worktree is gone. Returns the promoted file paths.
+*/
+function promoteWorktreeChanges(repoRoot, runId, parentNodeId, childNodeId) {
+	const worktreePath = join(repoRoot, childWorktreeRelPath(runId, parentNodeId, childNodeId));
+	if (!existsSync(worktreePath)) return [];
+	const files = changedWorktreeFiles(worktreePath);
+	for (const relativePath of files) copyFileInto(worktreePath, repoRoot, relativePath);
+	return files;
+}
 function git(cwd, args) {
 	return execFileSync("git", args, {
 		cwd,
@@ -33,7 +77,7 @@ function createChildWorktree(opts) {
 	const parentSeg = sanitize(opts.parentNodeId);
 	const childSeg = sanitize(opts.childNodeId);
 	const baseSha = git(opts.repoRoot, ["rev-parse", "HEAD"]);
-	const relPath = join(WORKTREE_ROOT, "trees", runSeg, parentSeg, childSeg);
+	const relPath = childWorktreeRelPath(opts.runId, opts.parentNodeId, opts.childNodeId);
 	const absPath = join(opts.repoRoot, relPath);
 	const branch = `pipeline/worktrees/${runSeg}/${parentSeg}/${childSeg}`;
 	const leaseId = `${runSeg}__${parentSeg}__${childSeg}`;
@@ -61,6 +105,7 @@ function createChildWorktree(opts) {
 		absPath,
 		baseSha
 	]);
+	provisionGeneratedResources(opts.repoRoot, absPath);
 	writeManifest(manifestPath, {
 		...manifest,
 		state: "active"
@@ -129,4 +174,4 @@ function gcParallelWorktrees(repoRoot) {
 	return results;
 }
 //#endregion
-export { createChildWorktree, gcParallelWorktrees };
+export { createChildWorktree, gcParallelWorktrees, promoteWorktreeChanges };

package/dist/runtime/run-journal.js

@@ -0,0 +1,21 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { dirname } from "node:path";
+//#region src/runtime/run-journal.ts
+function passedOnly(results) {
+	return results.filter((result) => result.status === "passed");
+}
+function readJournalFile(path) {
+	if (!existsSync(path)) return [];
+	return readFileSync(path, "utf8").split("\n").filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
+}
+function fileRunJournal(path) {
+	return {
+		record: (result) => {
+			mkdirSync(dirname(path), { recursive: true });
+			appendFileSync(path, `${JSON.stringify(result)}\n`);
+		},
+		resumeCompleted: () => passedOnly(readJournalFile(path))
+	};
+}
+//#endregion
+export { fileRunJournal };