@oisincoveney/pipeline 2.6.0 → 2.8.0

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

@@ -1,60 +1,97 @@
 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 { 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 Effect.promise(() => runtime.executeNode(child, context));
+	return Effect.gen(function* () {
+		const worktree = yield* WorktreeService;
+		return yield* Effect.acquireUseRelease(worktree.createChild(childLeaseOptions(child, context)), (lease) => Effect.promise(() => runtime.executeNode(child, {
+			...context,
+			worktreePath: lease.path
+		})), (lease) => Effect.sync(() => lease.release()));
+	});
 }
-function createChildLease(child, context) {
-	return createChildWorktree({
+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 {
@@ -91,26 +128,8 @@ function createLinkedAbortController(signal) {
 		controller
 	};
 }
-function executeParallelChildren(children, context, runtime) {
-	for (const child of children) runtime.markNodeReady(context, child.id);
-	if (!context.maxParallelNodes) return Promise.all(children.map((child) => runChildInWorktree(child, context, runtime)));
-	const limit = pLimit(context.maxParallelNodes);
-	return Promise.all(children.map((child) => limit(() => runChildInWorktree(child, context, runtime))));
-}
-async function executeFailFastParallelChildren(children, context, abortController, runtime) {
-	for (const child of children) runtime.markNodeReady(context, child.id);
-	const limit = pLimit({
-		concurrency: context.maxParallelNodes ?? children.length,
-		rejectOnClear: true
-	});
-	return (await Promise.allSettled(children.map((child) => limit(async () => {
-		const result = await runChildInWorktree(child, context, runtime);
-		if (result.status === "failed") {
-			abortController.abort();
-			limit.clearQueue();
-		}
-		return result;
-	})))).flatMap((result) => result.status === "fulfilled" ? [result.value] : []);
+function childCategory(childId, fanOut) {
+	return fanOut ? Object.keys(fanOut.by_category).find((category) => childId.includes(category)) : void 0;
 }
 function parallelEvidence(nodeId, results, failed) {
 	if (failed.length === 0) return [`parallel node '${nodeId}' completed ${results.length} child nodes`];
@@ -121,4 +140,4 @@ function parallelOutput(children, results) {
 	return JSON.stringify({ children: Object.fromEntries(children.filter((child) => outputsByNode.has(child.id)).map((child) => [child.id, outputsByNode.get(child.id)])) });
 }
 //#endregion
-export { executeParallelNode, parallelEvidence, parallelOutput };
+export { childCategory, executeParallelNode, parallelEvidence, parallelOutput };

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

package/dist/runtime/scheduler.js

@@ -1,44 +1,16 @@
 import { uniqueStrings } from "../strings.js";
-import { runWorkflowLifecycle } from "./workflow-lifecycle.js";
+import { Effect, Fiber, Queue } from "effect";
 //#region src/runtime/scheduler.ts
-var LocalScheduler = class {
-	options;
-	constructor(options) {
-		this.options = options;
-	}
-	async runWorkflow(plan, context) {
-		const options = this.options;
-		if (!options) throw new Error("LocalScheduler requires runtime options to run workflow");
-		return (await runWorkflowLifecycle({
-			buildResult: options.buildResult,
-			emitWorkflowPlanned: () => options.emitWorkflowPlanned(context),
-			emitWorkflowStarted: () => options.emitWorkflowStarted(context),
-			executeWorkflow: () => runWorkflowScheduler({
-				failFast: plan.execution.failFast,
-				fanOutWidth: context.config.token_budget?.fan_out_width,
-				isCancelled: () => options.isCancelled(context),
-				markNodeReady: (nodeId) => options.markNodeReady(nodeId, context),
-				maxParallelNodes: context.maxParallelNodes,
-				nodes: plan.topologicalOrder.map((node) => ({
-					category: node.category,
-					dependents: node.dependents,
-					id: node.id,
-					index: node.index,
-					needs: node.needs
-				})),
-				runNode: (nodeId) => options.executeNode(nodeId, context),
-				shouldContinueAfterNodeResult: (result) => options.shouldContinueAfterNodeResult(result, context),
-				skipNode: (nodeId, reason) => options.skipNode(nodeId, reason, context)
-			}),
-			isCancelled: () => options.isCancelled(context),
-			runWorkflowHook: (event, failure) => options.runWorkflowHook(event, failure, context)
-		})).result;
-	}
-};
-async function runWorkflowScheduler(input) {
-	const state = {
+function resumeFromJournal(input) {
+	return input.journal?.resumeCompleted() ?? [];
+}
+function recordToJournal(input, result) {
+	input.journal?.record(result);
+}
+function initialSchedulerState(input) {
+	return {
 		blocked: [],
-		completed: [],
+		completed: resumeFromJournal(input),
 		failFast: input.failFast,
 		fanOutWidth: input.fanOutWidth,
 		maxParallelNodes: input.maxParallelNodes,
@@ -46,50 +18,120 @@ async function runWorkflowScheduler(input) {
 		running: [],
 		shouldContinueAfterNodeResult: input.shouldContinueAfterNodeResult
 	};
-	const running = /* @__PURE__ */ new Map();
-	let failure;
-	while (true) {
-		if (input.isCancelled()) return {
-			completed: state.completed,
-			outcome: "CANCELLED"
-		};
-		launchReadyNodes(input, state, running);
-		if (running.size === 0) return {
-			completed: state.completed,
-			failure,
-			outcome: failure ? "FAIL" : "PASS"
-		};
-		let result;
-		try {
-			result = await Promise.race([...running.values()].map(({ promise }) => promise));
-		} catch (error) {
-			return {
-				completed: state.completed,
-				failure: workflowServiceFailure(error, "workflow.node"),
-				outcome: "FAIL"
-			};
-		}
-		running.delete(result.nodeId);
-		state.running = state.running.filter((nodeId) => nodeId !== result.nodeId);
-		state.completed = [...state.completed, result];
-		if (!isBlockingFailure(result, state)) continue;
-		failure ??= nodeRuntimeFailure(result);
-		if (input.failFast) {
-			const reason = `skipped because workflow fail_fast stopped after node '${result.nodeId}' failed`;
-			const skipped = unstartedNodeIds(state);
-			state.blocked = uniqueStrings([...state.blocked, ...skipped]);
-			for (const nodeId of skipped) input.skipNode(nodeId, reason);
-			continue;
+}
+function cancelledResult(state) {
+	return {
+		completed: state.completed,
+		outcome: "CANCELLED"
+	};
+}
+function terminalResult(state, failure) {
+	return {
+		completed: state.completed,
+		failure,
+		outcome: failure ? "FAIL" : "PASS"
+	};
+}
+function nodeErrorResult(state, error) {
+	return {
+		completed: state.completed,
+		failure: workflowServiceFailure(error, "workflow.node"),
+		outcome: "FAIL"
+	};
+}
+function runNodeFiber(ctx, nodeId) {
+	return Effect.tryPromise({
+		catch: (error) => error,
+		try: () => ctx.input.runNode(nodeId)
+	}).pipe(Effect.matchEffect({
+		onFailure: (error) => Queue.offer(ctx.completions, {
+			error,
+			kind: "error"
+		}),
+		onSuccess: (result) => Queue.offer(ctx.completions, {
+			kind: "ok",
+			result
+		})
+	}));
+}
+function launchReady(ctx) {
+	return Effect.gen(function* () {
+		const capacity = workflowNodeCapacity(ctx.state);
+		if (capacity <= 0) return;
+		for (const nodeId of selectLaunchableNodes(ctx.state, capacity)) {
+			ctx.input.markNodeReady(nodeId);
+			ctx.state.running = [...ctx.state.running, nodeId];
+			const fiber = yield* Effect.fork(runNodeFiber(ctx, nodeId));
+			ctx.running.set(nodeId, fiber);
 		}
-		const blocked = unstartedBlockingDescendants(result.nodeId, state);
-		state.blocked = uniqueStrings([...state.blocked, ...blocked]);
+	});
+}
+function applyFailFastSkip(ctx, result) {
+	const reason = `skipped because workflow fail_fast stopped after node '${result.nodeId}' failed`;
+	const skipped = unstartedNodeIds(ctx.state);
+	ctx.state.blocked = uniqueStrings([...ctx.state.blocked, ...skipped]);
+	for (const nodeId of skipped) ctx.input.skipNode(nodeId, reason);
+}
+function applyCompletion(ctx, result) {
+	ctx.running.delete(result.nodeId);
+	ctx.state.running = ctx.state.running.filter((id) => id !== result.nodeId);
+	ctx.state.completed = [...ctx.state.completed, result];
+	recordToJournal(ctx.input, result);
+	if (!isBlockingFailure(result, ctx.state)) return;
+	ctx.failure ??= nodeRuntimeFailure(result);
+	if (ctx.input.failFast) {
+		applyFailFastSkip(ctx, result);
+		return;
 	}
+	const blocked = unstartedBlockingDescendants(result.nodeId, ctx.state);
+	ctx.state.blocked = uniqueStrings([...ctx.state.blocked, ...blocked]);
+}
+function applyOutcome(ctx, outcome) {
+	return Effect.gen(function* () {
+		if (outcome.kind === "error") {
+			yield* Fiber.interruptAll(ctx.running.values());
+			return nodeErrorResult(ctx.state, outcome.error);
+		}
+		applyCompletion(ctx, outcome.result);
+	});
+}
+function schedulerTick(ctx) {
+	return Effect.gen(function* () {
+		if (ctx.input.isCancelled()) {
+			yield* Fiber.interruptAll(ctx.running.values());
+			return cancelledResult(ctx.state);
+		}
+		yield* launchReady(ctx);
+		if (ctx.running.size === 0) return terminalResult(ctx.state, ctx.failure);
+		return yield* applyOutcome(ctx, yield* Queue.take(ctx.completions));
+	});
+}
+function schedulerProgram(input) {
+	return Effect.gen(function* () {
+		const ctx = {
+			completions: yield* Queue.unbounded(),
+			input,
+			running: /* @__PURE__ */ new Map(),
+			state: initialSchedulerState(input)
+		};
+		while (true) {
+			const done = yield* schedulerTick(ctx);
+			if (done) return done;
+		}
+	});
+}
+function runWorkflowScheduler(input) {
+	return Effect.runPromise(schedulerProgram(input));
+}
+function settledNodeIds(context) {
+	const ids = new Set((context.completed ?? []).map((result) => result.nodeId));
+	for (const nodeId of context.running) ids.add(nodeId);
+	return ids;
 }
 function readyNodeIds(context) {
+	const settled = settledNodeIds(context);
 	const blocked = new Set(context.blocked ?? []);
-	const completed = new Set((context.completed ?? []).map((result) => result.nodeId));
-	const running = new Set(context.running);
-	return orderedNodes(context.nodes).filter((node) => !completed.has(node.id)).filter((node) => !running.has(node.id)).filter((node) => !blocked.has(node.id)).filter((node) => node.needs.every((need) => dependencyPassed(need, context))).map((node) => node.id);
+	return orderedNodes(context.nodes).filter((node) => !(settled.has(node.id) || blocked.has(node.id))).filter((node) => node.needs.every((need) => dependencyPassed(need, context))).map((node) => node.id);
 }
 function workflowNodeCapacity(context) {
 	const limit = context.failFast ? 1 : context.maxParallelNodes ?? context.nodes.length;
@@ -107,18 +149,6 @@ function unstartedBlockingDescendants(nodeId, context) {
 	}
 	return orderedNodes(context.nodes).map((node) => node.id).filter((descendantId) => descendants.has(descendantId)).filter((descendantId) => unstarted.has(descendantId));
 }
-function launchReadyNodes(input, state, running) {
-	const capacity = workflowNodeCapacity(state);
-	if (capacity <= 0) return;
-	for (const nodeId of selectLaunchableNodes(state, capacity)) {
-		input.markNodeReady(nodeId);
-		state.running = [...state.running, nodeId];
-		running.set(nodeId, {
-			nodeId,
-			promise: input.runNode(nodeId)
-		});
-	}
-}
 /**
 * Choose which ready nodes to launch this tick within the global capacity and
 * the per-category fan-out caps. A category at its cap defers its remaining
@@ -171,9 +201,8 @@ function isBlockingFailure(result, context) {
 	return result.status === "failed" && !(context.shouldContinueAfterNodeResult?.(result) ?? false);
 }
 function unstartedNodeIds(context) {
-	const completed = new Set((context.completed ?? []).map((result) => result.nodeId));
-	const running = new Set(context.running);
-	return orderedNodes(context.nodes).map((node) => node.id).filter((nodeId) => !completed.has(nodeId)).filter((nodeId) => !running.has(nodeId));
+	const settled = settledNodeIds(context);
+	return orderedNodes(context.nodes).map((node) => node.id).filter((nodeId) => !settled.has(nodeId));
 }
 function directDependents(nodeId, nodes) {
 	const declared = nodes.find((node) => node.id === nodeId)?.dependents ?? [];
@@ -201,4 +230,4 @@ function workflowServiceFailure(error, gate) {
 	};
 }
 //#endregion
-export { LocalScheduler };
+export { runWorkflowScheduler };

package/dist/runtime/select-candidate/select-candidate.js

@@ -2,6 +2,7 @@ import { createRunnerLaunchPlan } from "../../runner.js";
 import { normalizeRunnerOutput } from "../../runner-output.js";
 import { parseJsonObject } from "../json-validation/json-validation.js";
 import "../json-validation/index.js";
+import { promoteWorktreeChanges } from "../parallel-worktrees/parallel-worktrees.js";
 //#region src/runtime/select-candidate/select-candidate.ts
 const SCORE_RE = /-?\d+(?:\.\d+)?/;
 function selectBestCandidate(candidates) {
@@ -17,12 +18,23 @@ async function executeSelectCandidateBuiltin(context, node) {
 		exitCode: 1,
 		output: ""
 	};
+	const promoted = promoteWinner(context, node, selected.nodeId);
 	return {
-		evidence: [`select-candidate: selected '${selected.nodeId}' (judge=${selected.judgeScore ?? "n/a"}) from ${candidates.length} candidates`],
+		evidence: selectionEvidence(selected, candidates.length, promoted),
 		exitCode: 0,
 		output: selected.output
 	};
 }
+function selectionEvidence(selected, candidateCount, promoted) {
+	const lines = [`select-candidate: selected '${selected.nodeId}' (judge=${selected.judgeScore ?? "n/a"}) from ${candidateCount} candidates`];
+	if (promoted.length > 0) lines.push(`promoted ${promoted.length} file(s) from the winning worktree`);
+	return lines;
+}
+function promoteWinner(context, node, winnerNodeId) {
+	const parentNodeId = node?.needs.at(0);
+	if (!(context.config.parallel_worktrees?.enabled && parentNodeId)) return [];
+	return promoteWorktreeChanges(context.worktreePath, context.runId, parentNodeId, winnerNodeId);
+}
 async function scoreCandidates(context, candidates) {
 	const model = context.config.best_of_n?.judge_model;
 	const runner = Object.keys(context.config.runners).at(0);

package/dist/runtime/services/worktree-service.js

@@ -0,0 +1,18 @@
+import { createChildWorktree, gcParallelWorktrees } from "../parallel-worktrees/parallel-worktrees.js";
+import { Context, Effect, Layer } from "effect";
+//#region src/runtime/services/worktree-service.ts
+/**
+* Effect service over the git-worktree lifecycle (PIPE-83 follow-up). The Live
+* layer delegates to the synchronous porcelain helpers in parallel-worktrees;
+* the Effect-native parallel-node runtime composes `createChild`/`gc` through
+* this injectable seam instead of calling the helpers directly. This is the
+* canonical service shape for the Effect conversion: a `Context.Tag` whose Live
+* `Layer` wraps the underlying IO, provided once at the runPromise boundary.
+*/
+var WorktreeService = class extends Context.Tag("WorktreeService")() {};
+const WorktreeServiceLive = Layer.succeed(WorktreeService, {
+	createChild: (opts) => Effect.sync(() => createChildWorktree(opts)),
+	gc: (repoRoot) => Effect.sync(() => gcParallelWorktrees(repoRoot))
+});
+//#endregion
+export { WorktreeService, WorktreeServiceLive };

package/dist/schedule/passes/candidates.js

@@ -19,24 +19,33 @@ function expandBestOfNCandidates(config, artifact) {
 		}]))
 	};
 }
+function candidateChild(node, index) {
+	const child = {
+		...node,
+		id: `${node.id}--c${index + 1}`,
+		needs: []
+	};
+	child.task_context = void 0;
+	return child;
+}
 function expandNode(node, categories, n) {
 	if (node.kind !== "agent" || !categories.some((category) => node.id.includes(category))) return [node];
 	const candidatesId = `${node.id}--candidates`;
 	return [{
 		id: candidatesId,
 		kind: "parallel",
-		nodes: Array.from({ length: n }, (_, index) => ({
-			...node,
-			id: `${node.id}--c${index + 1}`,
-			needs: []
-		})),
+		nodes: Array.from({ length: n }, (_, index) => candidateChild(node, index)),
 		...node.needs ? { needs: node.needs } : {}
-	}, {
+	}, selectCandidateNode(node, candidatesId)];
+}
+function selectCandidateNode(node, candidatesId) {
+	return {
 		builtin: "select-candidate",
 		id: node.id,
 		kind: "builtin",
-		needs: [candidatesId]
-	}];
+		needs: [candidatesId],
+		...node.task_context ? { task_context: node.task_context } : {}
+	};
 }
 //#endregion
 export { expandBestOfNCandidates };