@oisincoveney/pipeline 2.7.0 → 2.8.0

package/dist/pipeline-runtime.js

@@ -18,12 +18,14 @@ import "./runtime/builtins/index.js";
 import { diffChangedFiles, snapshotChangedFiles } from "./runtime/changed-files/changed-files.js";
 import { evaluateNodeGates } from "./runtime/gates/gates.js";
 import "./runtime/gates/index.js";
+import { LocalScheduler } from "./runtime/local-scheduler.js";
 import { NodeStateTracker } from "./runtime/node-state-tracker.js";
 import { configUsesOpencode, leaseOpencodeRuntime } from "./runtime/opencode-runtime.js";
 import { executeParallelNode } from "./runtime/parallel-node/parallel-node.js";
 import "./runtime/parallel-node/index.js";
 import { decideNodeRetry, nodeRetryPolicy } from "./runtime/retry.js";
-import { LocalScheduler } from "./runtime/scheduler.js";
+import { fileRunJournal } from "./runtime/run-journal.js";
+import { join } from "node:path";
 //#region src/pipeline-runtime.ts
 function runPipelineFromConfig(options) {
 	return withOpencodeRuntime(options, (resolved) => runPipelineWithContext(createRuntimeContext(resolved)));
@@ -78,6 +80,14 @@ async function runWithLeasedOpencode(options, config, worktreePath, run) {
 		await lease.release();
 	}
 }
+function runJournalPath(context, dir) {
+	return join(context.worktreePath ?? process.cwd(), dir, `${context.runId}.jsonl`);
+}
+function resolveRunJournal(context) {
+	const durability = context.config.durability;
+	if (!(durability?.enabled && context.runId)) return;
+	return fileRunJournal(runJournalPath(context, durability.dir));
+}
 async function runPipelineWithContext(context) {
 	return finishRuntime(context, await new LocalScheduler({
 		buildResult: (outcome, nodes, failure) => workflowRuntimeResult(context, outcome, nodes, failure),
@@ -89,6 +99,7 @@ async function runPipelineWithContext(context) {
 			at: now(),
 			type: "READY"
 		}),
+		resolveJournal: (nextContext) => resolveRunJournal(nextContext),
 		runWorkflowHook: (event, failure, nextContext) => dispatchHooks(nextContext, event, failure),
 		shouldContinueAfterNodeResult: (result, nextContext) => shouldContinueAfterNodeResult(result, nextContext),
 		skipNode: (nodeId, reason, nextContext) => recordSkippedNodeState(nextContext, nodeId, reason, now())

package/dist/planning/compile.d.ts

@@ -7,9 +7,14 @@ interface WorkflowPlannerIssue {
   message: string;
   path?: string;
 }
-declare class WorkflowPlannerError extends Error {
-  code: WorkflowPlannerErrorCode;
-  issues: WorkflowPlannerIssue[];
+declare const WorkflowPlannerError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "WorkflowPlannerError";
+} & Readonly<A>;
+declare class WorkflowPlannerError extends WorkflowPlannerError_base<{
+  readonly code: WorkflowPlannerErrorCode;
+  readonly message: string;
+  readonly issues: WorkflowPlannerIssue[];
+}> {
   constructor(code: WorkflowPlannerErrorCode, message: string, issues?: WorkflowPlannerIssue[]);
 }
 interface PlannedWorkflowNode {

package/dist/planning/compile.js

@@ -1,15 +1,15 @@
 import { uniqueStrings } from "../strings.js";
 import { findDependencyCycles } from "./graph.js";
+import { Data } from "effect";
 import { Graph } from "@dagrejs/graphlib";
 //#region src/planning/compile.ts
-var WorkflowPlannerError = class extends Error {
-	code;
-	issues;
+var WorkflowPlannerError = class extends Data.TaggedError("WorkflowPlannerError") {
 	constructor(code, message, issues = []) {
-		super(message);
-		this.name = "WorkflowPlannerError";
-		this.code = code;
-		this.issues = issues;
+		super({
+			code,
+			message,
+			issues
+		});
 	}
 };
 function compileWorkflowPlan(config, workflowId = config.default_workflow) {

package/dist/planning/generate.d.ts

@@ -1594,7 +1594,12 @@ interface SchedulePlanningContext {
   workUnits: BacklogWorkUnit[];
 }
 declare function parseScheduleArtifact(source: string, sourcePath?: string): ScheduleArtifact;
-declare class ScheduleArtifactError extends Error {
+declare const ScheduleArtifactError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "ScheduleArtifactError";
+} & Readonly<A>;
+declare class ScheduleArtifactError extends ScheduleArtifactError_base<{
+  readonly message: string;
+}> {
   constructor(message: string);
 }
 declare function compileScheduleArtifact(config: PipelineConfig, artifact: ScheduleArtifact, projectRoot?: string): CompiledScheduleArtifact;

package/dist/planning/generate.js

@@ -17,6 +17,7 @@ import { plannerPrompt, plannerRepairPrompt } from "../schedule/prompts.js";
 import { compileWorkflowPlan } from "./compile.js";
 import { parseDocument, stringify } from "yaml";
 import { z } from "zod";
+import { Data } from "effect";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 //#region src/planning/generate.ts
@@ -30,10 +31,12 @@ const SCHEDULE_BUILTINS = [
 	"duplication",
 	"fallow",
 	"lint",
+	"select-candidate",
 	"semgrep",
 	"test",
 	"typecheck"
 ];
+const PARALLEL_MERGE_BUILTINS = new Set(["drain-merge", "select-candidate"]);
 const scheduleArtifactSchema = z.object({
 	generated_at: z.string().datetime(),
 	kind: z.literal(SCHEDULE_KIND),
@@ -54,10 +57,9 @@ function parseScheduleArtifact(source, sourcePath = "schedule.yaml") {
 	if (!parsed.success) throw new ScheduleArtifactError([`Invalid schedule artifact ${sourcePath}:`, ...parsed.error.issues.map((issue) => issue.path.length > 0 ? `- ${issue.path.join(".")}: ${issue.message}` : `- ${issue.message}`)].join("\n"));
 	return parsed.data;
 }
-var ScheduleArtifactError = class extends Error {
+var ScheduleArtifactError = class extends Data.TaggedError("ScheduleArtifactError") {
 	constructor(message) {
-		super(message);
-		this.name = "ScheduleArtifactError";
+		super({ message });
 	}
 };
 function compileScheduleArtifact(config, artifact, projectRoot) {
@@ -255,11 +257,28 @@ function unsafeParallelWorktreeIssues(config, artifact) {
 		return [`parallel node '${workflowId}.${node.id}' has write-capable children sharing a worktree without isolated worktree roots or drain-merge integration`];
 	}));
 }
+function registerContainmentEdge(parent, child, index) {
+	const dependents = index.get(child.id) ?? [];
+	dependents.push(parent);
+	index.set(child.id, dependents);
+}
+function addParallelContainmentEdges(nodes, index) {
+	for (const node of nodes) {
+		if (node.kind !== "parallel") continue;
+		for (const child of node.nodes) registerContainmentEdge(node, child, index);
+		addParallelContainmentEdges(node.nodes, index);
+	}
+}
+function dependentsByNeedWithContainment(nested, flat) {
+	const index = dependentsByNeed(flat);
+	addParallelContainmentEdges(nested, index);
+	return index;
+}
 function workflowNodeIssues(artifact, collectIssues) {
 	return Object.entries(artifact.workflows).flatMap(([workflowId, workflow]) => {
 		const nodes = flattenWorkflowNodes(workflow.nodes);
 		return collectIssues({
-			dependentsByNeed: dependentsByNeed(nodes),
+			dependentsByNeed: dependentsByNeedWithContainment(workflow.nodes, nodes),
 			nodes,
 			workflowId
 		});
@@ -272,7 +291,7 @@ function isWriteCapableParallelChild(config, node) {
 	return false;
 }
 function hasDownstreamDrainMerge(nodeId, index) {
-	return hasReachableDependent(nodeId, index, (node) => node.kind === "builtin" && node.builtin === "drain-merge");
+	return hasReachableDependent(nodeId, index, (node) => node.kind === "builtin" && PARALLEL_MERGE_BUILTINS.has(node.builtin));
 }
 function generatedRootWorkflowIssues(artifact) {
 	const workflowIds = Object.keys(artifact.workflows);
@@ -324,9 +343,9 @@ function workUnitDependencyIssues(config, artifact, workUnits) {
 	const dependenciesByUnit = new Map(workUnits.map((unit) => [unit.id, (unit.dependencies ?? []).filter((id) => workUnitIds.has(id))]));
 	return Object.entries(artifact.workflows).flatMap(([workflowId, workflow]) => {
 		const nodes = flattenWorkflowNodes(workflow.nodes);
-		const index = dependentsByNeed(nodes);
+		const index = dependentsByNeedWithContainment(workflow.nodes, nodes);
 		const nodesByWorkUnit = nodesByAssignedWorkUnit(nodes);
-		return nodes.filter((node) => isImplementationNode(config, node)).flatMap((node) => {
+		return nodes.filter((node) => isImplementationNode(config, node) || isSelectCandidateNode(node)).flatMap((node) => {
 			const dependentId = node.task_context?.id;
 			if (!dependentId) return [];
 			return (dependenciesByUnit.get(dependentId) ?? []).flatMap((prerequisiteId) => {
@@ -336,6 +355,9 @@ function workUnitDependencyIssues(config, artifact, workUnits) {
 		});
 	});
 }
+function isSelectCandidateNode(node) {
+	return node.kind === "builtin" && node.builtin === "select-candidate";
+}
 function nodesByAssignedWorkUnit(nodes) {
 	const grouped = /* @__PURE__ */ new Map();
 	for (const node of nodes) {

package/dist/runner-command-contract.d.ts

@@ -43,8 +43,8 @@ declare const runnerDeliverySchema: z.ZodObject<{
 declare const mokaSubmissionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   kind: z.ZodLiteral<"graph">;
   mode: z.ZodEnum<{
-    full: "full";
     quick: "quick";
+    full: "full";
   }>;
 }, z.core.$strict>, z.ZodObject<{
   argv: z.ZodArray<z.ZodString>;
@@ -104,8 +104,8 @@ declare const runnerCommandPayloadSchema: z.ZodObject<{
   submission: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"graph">;
     mode: z.ZodEnum<{
-      full: "full";
       quick: "quick";
+      full: "full";
     }>;
   }, z.core.$strict>, z.ZodObject<{
     argv: z.ZodArray<z.ZodString>;
@@ -140,8 +140,13 @@ interface RunnerCommandPayloadValidationIssue {
   message: string;
   path: string;
 }
-declare class RunnerCommandPayloadValidationError extends Error {
+declare const RunnerCommandPayloadValidationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "RunnerCommandPayloadValidationError";
+} & Readonly<A>;
+declare class RunnerCommandPayloadValidationError extends RunnerCommandPayloadValidationError_base<{
+  readonly message: string;
   readonly issues: RunnerCommandPayloadValidationIssue[];
+}> {
   constructor(message: string, issues: RunnerCommandPayloadValidationIssue[]);
 }
 interface BuildRunnerCommandPayloadOptions {

package/dist/runner-command-contract.js

@@ -1,5 +1,6 @@
 import { parseJson } from "./safe-json.js";
 import { z } from "zod";
+import { Data } from "effect";
 import { readFileSync } from "node:fs";
 import parseGitUrl from "git-url-parse";
 //#region src/runner-command-contract.ts
@@ -71,12 +72,12 @@ const runnerCommandPayloadSchema = z.object({
 	task: runnerTaskSchema,
 	workflow: runnerWorkflowIdentitySchema
 }).strict();
-var RunnerCommandPayloadValidationError = class extends Error {
-	issues;
+var RunnerCommandPayloadValidationError = class extends Data.TaggedError("RunnerCommandPayloadValidationError") {
 	constructor(message, issues) {
-		super(message);
-		this.name = "RunnerCommandPayloadValidationError";
-		this.issues = issues;
+		super({
+			message,
+			issues
+		});
 	}
 };
 function resolveRunnerEventSinkAuthToken(options) {

package/dist/runner-event-sink.js

@@ -1,4 +1,5 @@
 import { mapRuntimeEventToRunnerEventRecords } from "./runner-command-contract.js";
+import { Data } from "effect";
 import ky, { isHTTPError } from "ky";
 //#region src/runner-event-sink.ts
 const DEFAULT_BATCH_SIZE = 50;
@@ -20,12 +21,12 @@ const RETRYABLE_STATUS_CODES = [
 	510,
 	511
 ];
-var EventSinkHttpError = class extends Error {
-	status;
+var EventSinkHttpError = class extends Data.TaggedError("EventSinkHttpError") {
 	constructor(status, message) {
-		super(message);
-		this.name = "EventSinkHttpError";
-		this.status = status;
+		super({
+			status,
+			message
+		});
 	}
 };
 function createRunnerEventSink(options) {

package/dist/runner.d.ts

@@ -80,7 +80,12 @@ interface RunnerLaunchInput {
   prompt: string;
   worktreePath: string;
 }
-declare class RunnerCapabilityError extends Error {
+declare const RunnerCapabilityError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "RunnerCapabilityError";
+} & Readonly<A>;
+declare class RunnerCapabilityError extends RunnerCapabilityError_base<{
+  readonly message: string;
+}> {
   constructor(message: string);
 }
 /**

package/dist/runner.js

@@ -1,11 +1,11 @@
+import { Data } from "effect";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { execa } from "execa";
 //#region src/runner.ts
-var RunnerCapabilityError = class extends Error {
+var RunnerCapabilityError = class extends Data.TaggedError("RunnerCapabilityError") {
 	constructor(message) {
-		super(message);
-		this.name = "RunnerCapabilityError";
+		super({ message });
 	}
 };
 const OPENCODE_EXCLUDES = [

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

@@ -6,9 +6,10 @@ import { normalizeJsonSource, readJsonSchemaSource, validateJsonSchemaSource } f
 import "../json-validation/index.js";
 import { emit, emitAgentFinish, emitAgentStart } from "../events/events.js";
 import "../events/index.js";
+import { estimateTokens } from "../../token-estimator.js";
+import { buildRepoMapContext } from "../../context/repo-map.js";
 import { gatewayServerForProfile } from "../../mcp/gateway.js";
 import { selectNodeModel } from "../../model-resolver.js";
-import { estimateTokens } from "../../token-estimator.js";
 import { handoffFinalizerPrompt, parseHandoff, renderHandoff, synthesizeMinimalHandoff } from "../handoff.js";
 import { readFileSync } from "node:fs";
 //#region src/runtime/agent-node/agent-node.ts
@@ -18,7 +19,7 @@ async function executeAgentNode(node, context, attempt) {
 		exitCode: 1,
 		output: ""
 	};
-	const prompt = renderAgentPrompt(node, context);
+	const prompt = await renderAgentPrompt(node, context);
 	const decision = decideNodeModel(prompt, node, context.config.token_budget);
 	if (decision.overBudget) return {
 		evidence: [
@@ -307,11 +308,28 @@ function createOutputRepairPlan(inputs) {
 function normalizeAgentOutput(plan, stdout) {
 	return normalizeRunnerOutput(plan, stdout);
 }
-function renderAgentPrompt(node, context) {
+async function repoMapSection(node, context) {
+	const repoMap = context.config.repo_map;
+	if (!repoMap?.enabled) return "";
+	try {
+		return (await buildRepoMapContext({
+			artifacts: node.needs.flatMap((need) => context.nodeStateStore.handoff(need)?.artifacts ?? []),
+			taskText: context.task,
+			tokenBudget: repoMap.token_budget,
+			worktreePath: context.worktreePath
+		})).context;
+	} catch {
+		return "";
+	}
+}
+async function renderAgentPrompt(node, context) {
 	const profile = node.profile ? context.config.profiles[node.profile] : void 0;
+	const instructions = profile ? readInstructions(context.worktreePath, profile.instructions) : "";
+	const repoMap = await repoMapSection(node, context);
 	return [
-		(profile ? readInstructions(context.worktreePath, profile.instructions) : "").trim(),
+		instructions.trim(),
 		"",
+		repoMap,
 		`Task: ${context.task}`,
 		`Workflow: ${context.workflowId}`,
 		`Node: ${node.id}`,

package/dist/runtime/local-scheduler.js

@@ -0,0 +1,45 @@
+import { runWorkflowLifecycle } from "./workflow-lifecycle.js";
+import { runWorkflowScheduler } from "./scheduler.js";
+//#region src/runtime/local-scheduler.ts
+/**
+* The local, in-process scheduler seam. It owns workflow lifecycle hooks and
+* delegates the topological fan-out/gating loop to `runWorkflowScheduler`,
+* passing the durability journal (PIPE-83.10) through to it.
+*/
+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),
+				journal: options.resolveJournal?.(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;
+	}
+};
+//#endregion
+export { LocalScheduler };

package/dist/runtime/opencode-server.js

@@ -1,10 +1,13 @@
+import { Data } from "effect";
 import { createOpencode, createOpencodeClient } from "@opencode-ai/sdk";
 //#region src/runtime/opencode-server.ts
 const DEFAULT_STARTUP_TIMEOUT_MS = 3e4;
-var OpencodeServerStartupError = class extends Error {
+var OpencodeServerStartupError = class extends Data.TaggedError("OpencodeServerStartupError") {
 	constructor(message, options) {
-		super(message, options);
-		this.name = "OpencodeServerStartupError";
+		super({
+			message,
+			cause: options?.cause
+		});
 	}
 };
 async function openOpencodeServer(options) {

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 {
@@ -94,44 +131,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)];