@oisincoveney/pipeline 2.8.0 → 2.8.2

package/dist/pipeline-runtime.js

@@ -1,11 +1,11 @@
 import { loadPipelineConfig } from "./config/load.js";
 import "./config.js";
-import { executeCommand } from "./runtime/command-executor/command-executor.js";
-import "./runtime/command-executor/index.js";
 import { parseJsonObject } from "./runtime/json-validation/json-validation.js";
 import "./runtime/json-validation/index.js";
 import { emitNodeFinish, emitNodeOutputRecorded, emitNodeStart, emitWorkflowFinish, emitWorkflowPlanned, emitWorkflowStarted, runtimeNodeActorDescriptor } from "./runtime/events/events.js";
 import "./runtime/events/index.js";
+import { executeCommand } from "./runtime/command-executor/command-executor.js";
+import "./runtime/command-executor/index.js";
 import { dispatchHooks } from "./runtime/hooks/hooks.js";
 import "./runtime/hooks/index.js";
 import { findPlannedNode } from "./planned-node.js";
@@ -16,6 +16,7 @@ import "./runtime/context/index.js";
 import { executeBuiltin } from "./runtime/builtins/builtins.js";
 import "./runtime/builtins/index.js";
 import { diffChangedFiles, snapshotChangedFiles } from "./runtime/changed-files/changed-files.js";
+import "./runtime/changed-files/index.js";
 import { evaluateNodeGates } from "./runtime/gates/gates.js";
 import "./runtime/gates/index.js";
 import { LocalScheduler } from "./runtime/local-scheduler.js";
@@ -25,14 +26,15 @@ import { executeParallelNode } from "./runtime/parallel-node/parallel-node.js";
 import "./runtime/parallel-node/index.js";
 import { decideNodeRetry, nodeRetryPolicy } from "./runtime/retry.js";
 import { fileRunJournal } from "./runtime/run-journal.js";
+import { Effect } from "effect";
 import { join } from "node:path";
 //#region src/pipeline-runtime.ts
 function runPipelineFromConfig(options) {
-	return withOpencodeRuntime(options, (resolved) => runPipelineWithContext(createRuntimeContext(resolved)));
+	return Effect.runPromise(withOpencodeRuntime(options, (resolved) => runPipelineWithContext(createRuntimeContext(resolved))));
 }
 function runScheduledWorkflowTask(options) {
 	const { dependencyOutputs, nodeId, ...runtimeOptions } = options;
-	return withOpencodeRuntime(runtimeOptions, (resolved) => {
+	return Effect.runPromise(withOpencodeRuntime(runtimeOptions, (resolved) => Effect.gen(function* () {
 		const context = createRuntimeContext(resolved);
 		hydrateScheduledDependencyStates(context, nodeId);
 		hydrateDependencyOutputs(context, dependencyOutputs);
@@ -40,8 +42,8 @@ function runScheduledWorkflowTask(options) {
 			at: now(),
 			type: "READY"
 		});
-		return executePlannedNode(nodeId, context);
-	});
+		return yield* executePlannedNode(nodeId, context);
+	})));
 }
 /**
 * When the config uses opencode and the caller did not inject an executor,
@@ -49,12 +51,15 @@ function runScheduledWorkflowTask(options) {
 * and tear the server down afterward. Command-only configs and callers that
 * supply their own executor (tests, embedders) are passed through untouched.
 */
-async function withOpencodeRuntime(options, run) {
-	if (options.executor) return await run(options);
-	const { config, worktreePath } = resolveConfigForRun(options);
-	return configUsesOpencode(config) ? await runWithLeasedOpencode(options, config, worktreePath, run) : await run({
-		...options,
-		config
+function withOpencodeRuntime(options, run) {
+	return Effect.gen(function* () {
+		if (options.executor) return yield* run(options);
+		const { config, worktreePath } = resolveConfigForRun(options);
+		if (configUsesOpencode(config)) return yield* runWithLeasedOpencode(options, config, worktreePath, run);
+		return yield* run({
+			...options,
+			config
+		});
 	});
 }
 function resolveConfigForRun(options) {
@@ -64,21 +69,19 @@ function resolveConfigForRun(options) {
 		worktreePath
 	};
 }
-async function runWithLeasedOpencode(options, config, worktreePath, run) {
-	const lease = await leaseOpencodeRuntime({
-		config,
-		...options.signal ? { signal: options.signal } : {},
-		worktreePath
-	});
-	try {
-		return await run({
+function runWithLeasedOpencode(options, config, worktreePath, run) {
+	return Effect.scoped(Effect.gen(function* () {
+		const lease = yield* Effect.acquireRelease(Effect.tryPromise(() => leaseOpencodeRuntime({
+			config,
+			...options.signal ? { signal: options.signal } : {},
+			worktreePath
+		})), (lease) => Effect.promise(() => lease.release()));
+		return yield* run({
 			...options,
 			config,
 			executor: lease.executor
 		});
-	} finally {
-		await lease.release();
-	}
+	}));
 }
 function runJournalPath(context, dir) {
 	return join(context.worktreePath ?? process.cwd(), dir, `${context.runId}.jsonl`);
@@ -88,41 +91,60 @@ function resolveRunJournal(context) {
 	if (!(durability?.enabled && context.runId)) return;
 	return fileRunJournal(runJournalPath(context, durability.dir));
 }
-async function runPipelineWithContext(context) {
-	return finishRuntime(context, await new LocalScheduler({
+function runPipelineWithContext(context) {
+	const scheduler = new LocalScheduler({
 		buildResult: (outcome, nodes, failure) => workflowRuntimeResult(context, outcome, nodes, failure),
 		emitWorkflowPlanned: (nextContext) => emitWorkflowPlanned(nextContext),
 		emitWorkflowStarted: (nextContext) => emitWorkflowStarted(nextContext),
-		executeNode: (nodeId, nextContext) => executePlannedNode(nodeId, nextContext),
+		executeNode: (nodeId, nextContext) => Effect.runPromise(executePlannedNode(nodeId, nextContext)),
 		isCancelled: (nextContext) => isCancelled(nextContext),
 		markNodeReady: (nodeId, nextContext) => recordNodeEvent(nextContext, nodeId, {
 			at: now(),
 			type: "READY"
 		}),
 		resolveJournal: (nextContext) => resolveRunJournal(nextContext),
-		runWorkflowHook: (event, failure, nextContext) => dispatchHooks(nextContext, event, failure),
+		runWorkflowHook: (event, failure, nextContext) => Effect.runPromise(dispatchHooksEffect(nextContext, event, failure)),
 		shouldContinueAfterNodeResult: (result, nextContext) => shouldContinueAfterNodeResult(result, nextContext),
 		skipNode: (nodeId, reason, nextContext) => recordSkippedNodeState(nextContext, nodeId, reason, now())
-	}).runWorkflow(context.plan, context));
+	});
+	return Effect.gen(function* () {
+		return finishRuntime(context, yield* Effect.tryPromise(() => scheduler.runWorkflow(context.plan, context)));
+	});
 }
 function shouldContinueAfterNodeResult(result, context) {
 	if (result.status !== "failed") return true;
-	const node = context.plan.graph.node(result.nodeId);
-	if (node?.kind !== "parallel" || !parallelOutputHasChildren(result.output)) return false;
-	return node.dependents.length > 0 && node.dependents.every((dependentId) => isDrainMergeNode(context.plan.graph.node(dependentId)));
+	return isRecoverableParallelFailure(context.plan.graph.node(result.nodeId), result.output, context);
+}
+function isRecoverableParallelFailure(node, output, context) {
+	if (!isParallelWithChildren(node, output)) return false;
+	return hasOnlyDrainMergeDependents(node, context);
+}
+function isParallelWithChildren(node, output) {
+	if (!node) return false;
+	return node.kind === "parallel" ? parallelOutputHasChildren(output) : false;
+}
+function hasOnlyDrainMergeDependents(node, context) {
+	if (node.dependents.length === 0) return false;
+	return node.dependents.every((dependentId) => isDrainMergeNode(context.plan.graph.node(dependentId)));
 }
 function parallelOutputHasChildren(output) {
 	return Object.keys(parseJsonObject(parseJsonObject(output).children)).length > 0;
 }
 function isDrainMergeNode(node) {
-	return node?.kind === "builtin" && node.builtin === "drain-merge";
+	if (!node) return false;
+	return node.kind === "builtin" ? node.builtin === "drain-merge" : false;
+}
+function executePlannedNode(nodeId, context) {
+	return Effect.gen(function* () {
+		const node = plannedNodeById(context, nodeId);
+		if (!node) return yield* Effect.fail(/* @__PURE__ */ new Error(`workflow scheduler referenced unknown node '${nodeId}'`));
+		const result = yield* executeNode(node, context);
+		yield* dispatchHooksEffect(context, "node.finish", result.status === "failed" ? nodeRuntimeFailure(result) : void 0, node);
+		return result;
+	});
 }
-async function executePlannedNode(nodeId, context) {
-	const node = plannedNodeById(context, nodeId);
-	if (!node) throw new Error(`workflow scheduler referenced unknown node '${nodeId}'`);
-	const result = await executeNode(node, context);
-	await dispatchHooks(context, "node.finish", result.status === "failed" ? nodeRuntimeFailure(result) : void 0, node);
-	return result;
+function dispatchHooksEffect(...args) {
+	return Effect.tryPromise(() => dispatchHooks(...args));
 }
 function plannedNodeById(context, nodeId) {
 	return context.plan.graph.node(nodeId) ?? findPlannedNode(context.plan.topologicalOrder, nodeId);
@@ -197,24 +219,46 @@ function runtimeStructuredOutputs(context) {
 	return context.nodeStateStore.structuredOutputList();
 }
 function hydrateDependencyOutputs(context, dependencyOutputs) {
-	const outputs = dependencyOutputs instanceof Map ? dependencyOutputs : new Map(Object.entries(dependencyOutputs ?? {}));
+	const outputs = dependencyOutputMap(dependencyOutputs);
 	const finishedAt = now();
 	for (const [nodeId, output] of outputs) {
-		const existing = context.nodeStateStore.getNodeState(nodeId);
 		context.nodeStateStore.recordOutput(nodeId, output);
 		context.nodeStateStore.markInheritedOutput(nodeId);
-		context.nodeStateStore.setNodeState(nodeId, {
-			attempts: existing?.attempts ?? 1,
-			evidence: [...existing?.evidence ?? [], "dependency output inherited from Argo artifact"],
-			exitCode: existing?.exitCode ?? 0,
-			finishedAt: existing?.finishedAt ?? finishedAt,
-			gates: existing?.gates ?? [],
-			id: nodeId,
-			output,
-			status: "passed"
-		});
+		context.nodeStateStore.setNodeState(nodeId, inheritedDependencyOutputState(context, nodeId, output, finishedAt));
 	}
 }
+function dependencyOutputMap(dependencyOutputs) {
+	if (dependencyOutputs instanceof Map) return dependencyOutputs;
+	return new Map(Object.entries(dependencyOutputs ?? {}));
+}
+function inheritedDependencyOutputState(context, nodeId, output, finishedAt) {
+	const existing = context.nodeStateStore.getNodeState(nodeId);
+	return {
+		attempts: existingAttempts(existing),
+		evidence: inheritedOutputEvidence(existing),
+		exitCode: existingExitCode(existing),
+		finishedAt: existingFinishedAt(existing, finishedAt),
+		gates: existingGates(existing),
+		id: nodeId,
+		output,
+		status: "passed"
+	};
+}
+function existingAttempts(existing) {
+	return existing ? existing.attempts : 1;
+}
+function inheritedOutputEvidence(existing) {
+	return [...existing ? existing.evidence : [], "dependency output inherited from Argo artifact"];
+}
+function existingExitCode(existing) {
+	return existing ? existing.exitCode ?? 0 : 0;
+}
+function existingFinishedAt(existing, fallback) {
+	return existing ? existing.finishedAt ?? fallback : fallback;
+}
+function existingGates(existing) {
+	return existing ? existing.gates : [];
+}
 function hydrateScheduledDependencyStates(context, nodeId) {
 	const finishedAt = now();
 	for (const dependencyId of scheduledDependencyNodeIds(context, nodeId)) {
@@ -290,38 +334,89 @@ function now() {
 function isCancelled(context) {
 	return context.signal?.aborted === true;
 }
-async function executeNode(node, context) {
-	const retryPolicy = nodeRetryPolicy(node);
-	let last = {
+function executeNode(node, context) {
+	return Effect.gen(function* () {
+		const retryPolicy = nodeRetryPolicy(node);
+		const state = initialAttemptLoopState();
+		const result = yield* runNodeAttempts(node, context, retryPolicy, state);
+		if (result) return result;
+		const finalRetry = state.retry ?? exhaustedRetry(node, retryPolicy.maxAttempts, state.last);
+		return yield* finishFailedNode(node, context, state.last, finalRetry);
+	});
+}
+function initialAttemptLoopState() {
+	return { last: {
 		evidence: [],
 		exitCode: 1,
 		output: ""
-	};
-	let retry;
-	for (let attempt = 1;; attempt += 1) try {
-		const cycle = await executeNodeAttemptCycle(node, context, attempt, last);
-		last = cycle.last;
-		if (cycle.result) {
-			emitNodeFinish(context, cycle.result);
-			return cycle.result;
+	} };
+}
+function runNodeAttempts(node, context, retryPolicy, state) {
+	return Effect.gen(function* () {
+		for (let attempt = 1;; attempt += 1) {
+			const step = yield* runSingleNodeAttempt(node, context, retryPolicy, state, attempt);
+			if (step === "retry") continue;
+			return step === "failed" ? null : step;
+		}
+	});
+}
+function runSingleNodeAttempt(node, context, retryPolicy, state, attempt) {
+	return Effect.gen(function* () {
+		const outcome = yield* nodeAttemptCycleOrError(node, context, attempt, state.last);
+		if ("error" in outcome) {
+			state.retry = retryFromAttemptError(node, context, attempt, state.last, outcome.error);
+			return "failed";
 		}
-		retry = retryCandidateForCycle(node, cycle, last, attempt);
-		const remediation = await remediateFailedNode({
+		state.last = outcome.last;
+		return yield* continueAfterAttemptCycle(node, context, retryPolicy, state, attempt, outcome);
+	});
+}
+function nodeAttemptCycleOrError(node, context, attempt, last) {
+	return Effect.catchAll(executeNodeAttemptCycle(node, context, attempt, last), (error) => Effect.succeed({ error }));
+}
+function continueAfterAttemptCycle(node, context, retryPolicy, state, attempt, cycle) {
+	if (cycle.result) {
+		emitNodeFinish(context, cycle.result);
+		return Effect.succeed(cycle.result);
+	}
+	state.retry = retryCandidateForCycle(node, cycle, state.last, attempt);
+	return continueAfterRetryCandidate(node, context, retryPolicy, state.retry, attempt);
+}
+function continueAfterRetryCandidate(node, context, retryPolicy, retry, attempt) {
+	return Effect.gen(function* () {
+		const remediation = yield* remediateFailedNode({
 			attempt,
 			context,
 			node,
 			retry
 		});
-		if (remediation?.result) {
-			recordNodeEvent(context, node.id, {
-				at: now(),
-				result: remediation.result,
-				type: "PASSED"
-			});
-			emitNodeFinish(context, remediation.result);
-			return remediation.result;
+		const passed = remediationPassedResult(remediation);
+		if (passed) {
+			emitRemediationPass(context, node.id, passed);
+			return passed;
 		}
-		if (remediation?.retryNode) continue;
+		if (remediationRequestsRetry(remediation)) return "retry";
+		return yield* scheduleNodeRetry(node, context, retryPolicy, retry, attempt);
+	});
+}
+function remediationPassedResult(remediation) {
+	if (!remediation) return null;
+	return remediation.result ?? null;
+}
+function remediationRequestsRetry(remediation) {
+	if (!remediation) return false;
+	return remediation.retryNode === true;
+}
+function emitRemediationPass(context, nodeId, result) {
+	recordNodeEvent(context, nodeId, {
+		at: now(),
+		result,
+		type: "PASSED"
+	});
+	emitNodeFinish(context, result);
+}
+function scheduleNodeRetry(node, context, retryPolicy, retry, attempt) {
+	return Effect.gen(function* () {
 		const retryDecision = decideNodeRetry({
 			attempt,
 			evidence: retry.evidence,
@@ -330,61 +425,77 @@ async function executeNode(node, context) {
 			reason: retry.reason,
 			retryReason: retry.retryReason
 		});
-		recordNodeEvent(context, node.id, {
-			at: now(),
-			attempt,
-			evidence: retry.evidence,
-			gate: retry.gate,
-			reason: retry.reason,
-			retry: retryDecision,
-			retryReason: retry.retryReason,
-			type: "RETRYING"
-		});
+		recordRetryingNodeEvent(context, node.id, attempt, retry, retryDecision);
 		emitRuntimeRetry(context, node.id, retryDecision, retry.retryReason);
-		if (!retryDecision?.scheduled) break;
-		await waitForRetryDelay(retryDecision.delayMs, context.signal);
-	} catch (err) {
-		if (isCancelled(context)) {
-			retry = {
-				attempt,
-				evidence: [...last.evidence, ...cancelledFailure().evidence],
-				gate: node.id,
-				reason: "pipeline cancelled",
-				retryReason: "timeout"
-			};
-			break;
-		}
-		retry = {
-			attempt,
-			evidence: [...last.evidence, err instanceof Error ? err.message : String(err)],
-			gate: node.id,
-			reason: err instanceof Error ? err.message : "node retry failed",
-			retryReason: nodeRetryReason(last)
-		};
-		break;
-	}
-	retry ??= {
-		attempt: Math.max(1, retryPolicy.maxAttempts),
+		if (!retryDecision?.scheduled) return "failed";
+		yield* waitForRetryDelay(retryDecision.delayMs, context.signal);
+		return "retry";
+	});
+}
+function recordRetryingNodeEvent(context, nodeId, attempt, retry, retryDecision) {
+	recordNodeEvent(context, nodeId, {
+		at: now(),
+		attempt,
+		evidence: retry.evidence,
+		gate: retry.gate,
+		reason: retry.reason,
+		retry: retryDecision,
+		retryReason: retry.retryReason,
+		type: "RETRYING"
+	});
+}
+function retryFromAttemptError(node, context, attempt, last, err) {
+	return isCancelled(context) ? cancelledRetry(node.id, attempt, last) : failedAttemptRetry(node.id, attempt, last, err);
+}
+function cancelledRetry(nodeId, attempt, last) {
+	return {
+		attempt,
+		evidence: [...last.evidence, ...cancelledFailure().evidence],
+		gate: nodeId,
+		reason: "pipeline cancelled",
+		retryReason: "timeout"
+	};
+}
+function failedAttemptRetry(nodeId, attempt, last, err) {
+	const message = err instanceof Error ? err.message : String(err);
+	return {
+		attempt,
+		evidence: [...last.evidence, message],
+		gate: nodeId,
+		reason: err instanceof Error ? err.message : "node retry failed",
+		retryReason: nodeRetryReason(last)
+	};
+}
+function exhaustedRetry(node, maxAttempts, last) {
+	return {
+		attempt: Math.max(1, maxAttempts),
 		evidence: last.evidence,
 		gate: node.id,
 		reason: `node exited with code ${last.exitCode}`,
 		retryReason: nodeRetryReason(last)
 	};
-	await dispatchHooks(context, "node.error", {
+}
+function finishFailedNode(node, context, last, retry) {
+	return Effect.gen(function* () {
+		yield* dispatchHooksEffect(context, "node.error", nodeRetryFailure(node, retry), node);
+		const result = nodeFailure(node.id, retry.attempt, retry.evidence, last.output);
+		recordNodeEvent(context, node.id, {
+			at: now(),
+			failure: nodeRuntimeFailure(result),
+			result,
+			type: "FAILED"
+		});
+		emitNodeFinish(context, result);
+		return result;
+	});
+}
+function nodeRetryFailure(node, retry) {
+	return {
 		evidence: retry.evidence,
 		gate: retry.gate,
 		nodeId: node.id,
 		reason: retry.reason
-	}, node);
-	const result = nodeFailure(node.id, retry.attempt, retry.evidence, last.output);
-	recordNodeEvent(context, node.id, {
-		at: now(),
-		failure: nodeRuntimeFailure(result),
-		result,
-		type: "FAILED"
-	});
-	emitNodeFinish(context, result);
-	return result;
+	};
 }
 function emitRuntimeRetry(context, nodeId, retry, reason) {
 	context.observability?.({
@@ -396,113 +507,132 @@ function emitRuntimeRetry(context, nodeId, retry, reason) {
 		type: retry.scheduled ? "runtime.retry.scheduled" : "runtime.retry.exhausted"
 	});
 }
-async function remediateFailedNode(input) {
-	const selfRemediation = await remediateWritableNodeFailure(input);
-	if (selfRemediation) return { result: selfRemediation };
-	if (await remediateCoverageFailure(input)) return { retryNode: true };
-	if (await remediateUpstreamImplementationFailure(input)) return { retryNode: true };
-	return null;
-}
-async function remediateWritableNodeFailure(input) {
-	if (input.retry.retryReason !== "gate_failure" || isRemediationNode(input.node) || !nodeCanWrite(input.context, input.node)) return null;
-	const beforeSnapshot = await snapshotChangedFiles(input.context.worktreePath);
-	const beforeOutput = input.context.nodeStateStore.getOutput(input.node.id);
-	const result = await executeSelfRemediation(input);
-	if (result.status !== "passed") return null;
-	const changed = diffChangedFiles(beforeSnapshot, await snapshotChangedFiles(input.context.worktreePath), input.context.worktreePath);
-	if (changed.files.size === 0 && result.output === beforeOutput) return null;
-	input.context.nodeStateStore.setSnapshot(input.node.id, changed);
-	input.context.nodeStateStore.recordOutput(input.node.id, result.output);
-	return {
-		attempts: input.attempt + 1,
-		evidence: result.evidence,
-		exitCode: result.exitCode,
-		nodeId: input.node.id,
-		output: result.output,
-		status: "passed"
-	};
+function remediateFailedNode(input) {
+	return Effect.gen(function* () {
+		const selfRemediation = yield* remediateWritableNodeFailure(input);
+		if (selfRemediation) return { result: selfRemediation };
+		if (yield* remediateCoverageFailure(input)) return { retryNode: true };
+		if (yield* remediateUpstreamImplementationFailure(input)) return { retryNode: true };
+		return null;
+	});
 }
-async function executeSelfRemediation(input) {
-	const node = {
-		...input.node,
-		artifacts: void 0,
-		dependents: [],
-		id: `${input.node.id}:remediate:${input.retry.gate}:${input.attempt}`,
-		needs: [],
-		retries: void 0
-	};
-	const originalTask = input.context.task;
-	input.context.task = nodeRemediationTask({
-		node: input.node,
-		originalTask,
-		retry: input.retry
-	});
-	try {
-		return await executeNode(node, input.context);
-	} finally {
-		input.context.task = originalTask;
-	}
+function remediateWritableNodeFailure(input) {
+	return Effect.gen(function* () {
+		if (!canSelfRemediateWritableNode(input)) return null;
+		const beforeSnapshot = yield* snapshotChangedFilesEffect(input.context.worktreePath);
+		const beforeOutput = input.context.nodeStateStore.getOutput(input.node.id);
+		const result = yield* executeSelfRemediation(input);
+		if (result.status !== "passed") return null;
+		const changed = diffChangedFiles(beforeSnapshot, yield* snapshotChangedFilesEffect(input.context.worktreePath), input.context.worktreePath);
+		if (remediationChangedNothing(changed.files.size, result, beforeOutput)) return null;
+		input.context.nodeStateStore.setSnapshot(input.node.id, changed);
+		input.context.nodeStateStore.recordOutput(input.node.id, result.output);
+		return {
+			attempts: input.attempt + 1,
+			evidence: result.evidence,
+			exitCode: result.exitCode,
+			nodeId: input.node.id,
+			output: result.output,
+			status: "passed"
+		};
+	});
 }
-async function remediateCoverageFailure(input) {
-	if (input.retry.retryReason !== "gate_failure" || !hasSchedulingRole(input.context, input.node, "coverage")) return false;
-	return await remediatePassedImplementationAncestors(input);
-}
-async function remediateUpstreamImplementationFailure(input) {
-	if (isRemediationNode(input.node) || nodeCanWrite(input.context, input.node) || hasSchedulingRole(input.context, input.node, "coverage")) return false;
-	return await remediatePassedImplementationAncestors(input);
-}
-async function remediatePassedImplementationAncestors(input) {
-	const implementationNodes = upstreamImplementationNodes(input.context, input.node).filter((candidate) => input.context.nodeStateStore.getNodeState(candidate.id)?.status === "passed");
-	if (implementationNodes.length === 0) return false;
-	for (const implementationNode of implementationNodes) if (!await remediateImplementationAncestor(input, implementationNode)) return false;
-	return true;
-}
-async function remediateImplementationAncestor(input, implementationNode) {
-	if (isCancelled(input.context)) return false;
-	const beforeSnapshot = await snapshotChangedFiles(input.context.worktreePath);
-	const beforeOutput = input.context.nodeStateStore.getOutput(implementationNode.id);
-	const result = await executeImplementationRemediation({
-		attempt: input.attempt,
-		context: input.context,
-		coverageNode: input.node,
-		implementationNode,
-		retry: input.retry
-	});
-	if (result.status !== "passed") return false;
-	return await recordImplementationRemediationEffect({
-		beforeOutput,
-		beforeSnapshot,
-		context: input.context,
-		implementationNode,
-		result
+function canSelfRemediateWritableNode(input) {
+	if (input.retry.retryReason !== "gate_failure") return false;
+	if (isRemediationNode(input.node)) return false;
+	return nodeCanWrite(input.context, input.node);
+}
+function remediationChangedNothing(changedFileCount, result, beforeOutput) {
+	if (changedFileCount !== 0) return false;
+	return result.output === beforeOutput;
+}
+function executeSelfRemediation(input) {
+	return Effect.gen(function* () {
+		const node = {
+			...input.node,
+			artifacts: void 0,
+			dependents: [],
+			id: `${input.node.id}:remediate:${input.retry.gate}:${input.attempt}`,
+			needs: [],
+			retries: void 0
+		};
+		const originalTask = input.context.task;
+		input.context.task = nodeRemediationTask({
+			node: input.node,
+			originalTask,
+			retry: input.retry
+		});
+		return yield* Effect.ensuring(executeNode(node, input.context), Effect.sync(() => {
+			input.context.task = originalTask;
+		}));
 	});
 }
-async function recordImplementationRemediationEffect(input) {
-	if (diffChangedFiles(input.beforeSnapshot, await snapshotChangedFiles(input.context.worktreePath), input.context.worktreePath).files.size === 0 && input.result.output === input.beforeOutput) return false;
-	input.context.nodeStateStore.recordOutput(input.implementationNode.id, input.result.output);
-	return true;
-}
-async function executeImplementationRemediation(input) {
-	const node = {
-		...input.implementationNode,
-		artifacts: void 0,
-		dependents: [],
-		gates: void 0,
-		id: `${input.implementationNode.id}:remediate:${input.coverageNode.id}:${input.attempt}`,
-		needs: [],
-		retries: void 0
-	};
-	const originalTask = input.context.task;
-	input.context.task = remediationTask({
-		coverageNode: input.coverageNode,
-		originalTask,
-		retry: input.retry
-	});
-	try {
-		return await executeNode(node, input.context);
-	} finally {
-		input.context.task = originalTask;
-	}
+function remediateCoverageFailure(input) {
+	if (input.retry.retryReason !== "gate_failure" || !hasSchedulingRole(input.context, input.node, "coverage")) return Effect.succeed(false);
+	return remediatePassedImplementationAncestors(input);
+}
+function remediateUpstreamImplementationFailure(input) {
+	if (isRemediationNode(input.node) || nodeCanWrite(input.context, input.node) || hasSchedulingRole(input.context, input.node, "coverage")) return Effect.succeed(false);
+	return remediatePassedImplementationAncestors(input);
+}
+function remediatePassedImplementationAncestors(input) {
+	return Effect.gen(function* () {
+		const implementationNodes = upstreamImplementationNodes(input.context, input.node).filter((candidate) => input.context.nodeStateStore.getNodeState(candidate.id)?.status === "passed");
+		if (implementationNodes.length === 0) return false;
+		for (const implementationNode of implementationNodes) if (!(yield* remediateImplementationAncestor(input, implementationNode))) return false;
+		return true;
+	});
+}
+function remediateImplementationAncestor(input, implementationNode) {
+	return Effect.gen(function* () {
+		if (isCancelled(input.context)) return false;
+		const beforeSnapshot = yield* snapshotChangedFilesEffect(input.context.worktreePath);
+		const beforeOutput = input.context.nodeStateStore.getOutput(implementationNode.id);
+		const result = yield* executeImplementationRemediation({
+			attempt: input.attempt,
+			context: input.context,
+			coverageNode: input.node,
+			implementationNode,
+			retry: input.retry
+		});
+		if (result.status !== "passed") return false;
+		return yield* recordImplementationRemediationEffect({
+			beforeOutput,
+			beforeSnapshot,
+			context: input.context,
+			implementationNode,
+			result
+		});
+	});
+}
+function recordImplementationRemediationEffect(input) {
+	return Effect.gen(function* () {
+		if (diffChangedFiles(input.beforeSnapshot, yield* snapshotChangedFilesEffect(input.context.worktreePath), input.context.worktreePath).files.size === 0 && input.result.output === input.beforeOutput) return false;
+		input.context.nodeStateStore.recordOutput(input.implementationNode.id, input.result.output);
+		return true;
+	});
+}
+function executeImplementationRemediation(input) {
+	return Effect.gen(function* () {
+		const node = {
+			...input.implementationNode,
+			artifacts: void 0,
+			dependents: [],
+			gates: void 0,
+			id: `${input.implementationNode.id}:remediate:${input.coverageNode.id}:${input.attempt}`,
+			needs: [],
+			retries: void 0
+		};
+		const originalTask = input.context.task;
+		input.context.task = remediationTask({
+			coverageNode: input.coverageNode,
+			originalTask,
+			retry: input.retry
+		});
+		return yield* Effect.ensuring(executeNode(node, input.context), Effect.sync(() => {
+			input.context.task = originalTask;
+		}));
+	});
 }
 function remediationTask(input) {
 	return [
@@ -527,9 +657,22 @@ function remediationTask(input) {
 	].join("\n");
 }
 function nodeCanWrite(context, node) {
-	if (!node.profile) return false;
-	const profile = context.config.profiles[node.profile];
-	return profile?.filesystem?.mode === "workspace-write" || (profile?.tools ?? []).some((tool) => tool === "edit" || tool === "write");
+	const profileId = node.profile;
+	if (!profileId) return false;
+	return profileCanWrite(context.config.profiles[profileId]);
+}
+function profileCanWrite(profile) {
+	if (!profile) return false;
+	return hasWorkspaceWriteMode(profile) ? true : hasWriteTool(profile.tools ?? []);
+}
+function hasWorkspaceWriteMode(profile) {
+	return profile.filesystem?.mode === "workspace-write";
+}
+function hasWriteTool(tools) {
+	return tools.some(isWriteTool);
+}
+function isWriteTool(tool) {
+	return tool === "edit" ? true : tool === "write";
 }
 function isRemediationNode(node) {
 	return node.id.includes(":remediate:");
@@ -559,168 +702,222 @@ function nodeRemediationTask(input) {
 function upstreamImplementationNodes(context, node) {
 	const visited = /* @__PURE__ */ new Set();
 	const ordered = [];
-	const visit = (nodeId) => {
-		if (visited.has(nodeId)) return;
-		visited.add(nodeId);
-		const candidate = context.plan.graph.node(nodeId);
-		if (!candidate) return;
-		for (const need of candidate.needs) visit(need);
-		if (hasSchedulingRole(context, candidate, "implementation")) ordered.push(candidate);
-	};
+	const visit = (candidateId) => visitImplementationNode(context, visited, ordered, candidateId, visit);
 	for (const need of node.needs) visit(need);
 	return ordered;
 }
+function visitImplementationNode(context, visited, ordered, nodeId, visit) {
+	if (visited.has(nodeId)) return;
+	visited.add(nodeId);
+	const candidate = context.plan.graph.node(nodeId);
+	if (!candidate) return;
+	visitImplementationDependencies(candidate, visit);
+	appendImplementationNode(context, ordered, candidate);
+}
+function visitImplementationDependencies(candidate, visit) {
+	for (const need of candidate.needs) visit(need);
+}
+function appendImplementationNode(context, ordered, candidate) {
+	if (hasSchedulingRole(context, candidate, "implementation")) ordered.push(candidate);
+}
 function hasSchedulingRole(context, node, role) {
 	return node.profile ? context.config.profiles[node.profile]?.scheduling_roles?.includes(role) ?? false : false;
 }
-async function waitForRetryDelay(delayMs, signal) {
-	if (delayMs <= 0 || signal?.aborted) return;
-	await new Promise((resolve) => {
-		const timeout = setTimeout(resolve, delayMs);
-		timeout.unref?.();
-		signal?.addEventListener("abort", () => {
-			clearTimeout(timeout);
-			resolve();
-		}, { once: true });
+function waitForRetryDelay(delayMs, signal) {
+	if (delayMs <= 0 || signal?.aborted) return Effect.void;
+	return Effect.race(Effect.sleep(delayMs), waitForAbort(signal));
+}
+function waitForAbort(signal) {
+	if (!signal) return Effect.never;
+	return Effect.async((resume) => {
+		const onAbort = () => resume(Effect.void);
+		signal.addEventListener("abort", onAbort, { once: true });
+		return Effect.sync(() => signal.removeEventListener("abort", onAbort));
 	});
 }
-async function executeNodeAttemptCycle(node, context, attempt, previous) {
-	if (isCancelled(context)) return {
-		last: previous,
-		result: nodeFailure(node.id, attempt, cancelledFailure().evidence, previous.output)
-	};
-	emitNodeStart(context, node, attempt);
-	recordNodeEvent(context, node.id, {
-		at: now(),
-		attempt,
-		type: "STARTED"
+function executeNodeAttemptCycle(node, context, attempt, previous) {
+	return Effect.gen(function* () {
+		const startResult = yield* beginNodeAttempt(node, context, attempt, previous);
+		if (startResult) return startResult;
+		const last = yield* runNodeAttemptBody(node, context, attempt);
+		const cancelledAfterAttempt = cancelledNodeResult(context, node.id, attempt, last);
+		if (cancelledAfterAttempt) return {
+			last,
+			result: cancelledAfterAttempt
+		};
+		return yield* finishNodeAttemptAfterGates(node, context, attempt, last);
 	});
-	const startHook = await dispatchHooks(context, "node.start", void 0, node);
-	if (startHook) {
-		const result = nodeFailure(node.id, attempt, startHook.evidence, previous.output);
+}
+function beginNodeAttempt(node, context, attempt, previous) {
+	return Effect.gen(function* () {
+		if (isCancelled(context)) return cancelledCycle(node.id, attempt, previous);
+		emitNodeStart(context, node, attempt);
 		recordNodeEvent(context, node.id, {
 			at: now(),
-			failure: nodeRuntimeFailure(result),
-			result,
-			type: "FAILED"
+			attempt,
+			type: "STARTED"
 		});
-		return {
-			last: previous,
-			result
-		};
-	}
-	if (isCancelled(context)) return {
+		const startHook = yield* dispatchHooksEffect(context, "node.start", void 0, node);
+		if (startHook) return failedHookCycle(node.id, attempt, previous, startHook.evidence, context);
+		return isCancelled(context) ? cancelledCycle(node.id, attempt, previous) : null;
+	});
+}
+function cancelledCycle(nodeId, attempt, previous) {
+	return {
 		last: previous,
-		result: nodeFailure(node.id, attempt, cancelledFailure().evidence, previous.output)
+		result: nodeFailure(nodeId, attempt, cancelledFailure().evidence, previous.output)
 	};
-	recordNodeEvent(context, node.id, {
-		at: now(),
-		type: "START_HOOKS_FINISHED"
-	});
-	context.nodeStateStore.setSnapshot(node.id, await snapshotChangedFiles(context.worktreePath));
-	recordNodeEvent(context, node.id, {
+}
+function failedHookCycle(nodeId, attempt, previous, evidence, context) {
+	const result = nodeFailure(nodeId, attempt, evidence, previous.output);
+	recordNodeEvent(context, nodeId, {
 		at: now(),
-		type: "SNAPSHOT_BEFORE_FINISHED"
+		failure: nodeRuntimeFailure(result),
+		result,
+		type: "FAILED"
 	});
-	recordNodeEvent(context, node.id, {
-		at: now(),
-		type: "RUNNER_STARTED"
+	return {
+		last: previous,
+		result
+	};
+}
+function runNodeAttemptBody(node, context, attempt) {
+	return Effect.gen(function* () {
+		recordNodeEvent(context, node.id, {
+			at: now(),
+			type: "START_HOOKS_FINISHED"
+		});
+		context.nodeStateStore.setSnapshot(node.id, yield* snapshotChangedFilesEffect(context.worktreePath));
+		recordNodeEvent(context, node.id, {
+			at: now(),
+			type: "SNAPSHOT_BEFORE_FINISHED"
+		});
+		recordNodeEvent(context, node.id, {
+			at: now(),
+			type: "RUNNER_STARTED"
+		});
+		const last = yield* executeNodeAttempt(node, context, attempt);
+		recordNodeEvent(context, node.id, runnerFinishedEvent(last));
+		yield* recordAttemptOutput(node, context, attempt, last);
+		return last;
 	});
-	const last = await executeNodeAttempt(node, context, attempt);
-	recordNodeEvent(context, node.id, {
+}
+function runnerFinishedEvent(last) {
+	return {
 		at: now(),
 		evidence: last.evidence,
 		exitCode: last.exitCode,
 		output: last.output,
 		timedOut: last.timedOut,
 		type: "RUNNER_FINISHED"
-	});
-	const afterSnapshot = await snapshotChangedFiles(context.worktreePath);
-	const beforeSnapshot = context.nodeStateStore.getSnapshot(node.id);
-	if (beforeSnapshot) context.nodeStateStore.setSnapshot(node.id, diffChangedFiles(beforeSnapshot, afterSnapshot, context.worktreePath));
-	context.nodeStateStore.recordOutput(node.id, last.output);
-	context.nodeStateStore.recordHandoff(node.id, last.handoff);
-	emitNodeOutputRecorded(context, node, attempt, last.output);
-	recordNodeEvent(context, node.id, {
-		at: now(),
-		type: "OUTPUT_RECORDED"
-	});
-	recordNodeEvent(context, node.id, {
-		at: now(),
-		type: "SNAPSHOT_AFTER_FINISHED"
-	});
-	const cancelledAfterAttempt = cancelledNodeResult(context, node.id, attempt, last);
-	if (cancelledAfterAttempt) return {
-		last,
-		result: cancelledAfterAttempt
 	};
-	recordNodeEvent(context, node.id, {
-		at: now(),
-		type: "GATES_STARTED"
-	});
-	const gateResults = await evaluateNodeGates(node, context, last, (failedNode, result) => dispatchGateFailureHook(context, failedNode, result));
-	recordNodeEvent(context, node.id, {
-		at: now(),
-		gates: gateResults,
-		type: "GATES_FINISHED"
+}
+function recordAttemptOutput(node, context, attempt, last) {
+	return Effect.gen(function* () {
+		const afterSnapshot = yield* snapshotChangedFilesEffect(context.worktreePath);
+		const beforeSnapshot = context.nodeStateStore.getSnapshot(node.id);
+		if (beforeSnapshot) context.nodeStateStore.setSnapshot(node.id, diffChangedFiles(beforeSnapshot, afterSnapshot, context.worktreePath));
+		context.nodeStateStore.recordOutput(node.id, last.output);
+		context.nodeStateStore.recordHandoff(node.id, last.handoff);
+		emitNodeOutputRecorded(context, node, attempt, last.output);
+		recordNodeEvent(context, node.id, {
+			at: now(),
+			type: "OUTPUT_RECORDED"
+		});
+		recordNodeEvent(context, node.id, {
+			at: now(),
+			type: "SNAPSHOT_AFTER_FINISHED"
+		});
 	});
-	const cancelledAfterGates = cancelledNodeResult(context, node.id, attempt, last);
-	if (cancelledAfterGates) return {
-		last,
-		result: cancelledAfterGates
-	};
-	const failedGate = gateResults.find((gate) => !gate.passed);
-	if (!failedGate && last.exitCode === 0) {
-		const successHook = await dispatchHooks(context, "node.success", void 0, node);
-		if (successHook) {
-			const result = nodeFailure(node.id, attempt, successHook.evidence, last.output);
-			recordNodeEvent(context, node.id, {
-				at: now(),
-				failure: nodeRuntimeFailure(result),
-				result,
-				type: "FAILED"
-			});
-			return {
-				last,
-				result
-			};
-		}
-		const cancelledAfterHook = cancelledNodeResult(context, node.id, attempt, last);
-		if (cancelledAfterHook) return {
+}
+function finishNodeAttemptAfterGates(node, context, attempt, last) {
+	return Effect.gen(function* () {
+		const gateResults = yield* evaluateGatesForAttempt(node, context, last);
+		const cancelledAfterGates = cancelledNodeResult(context, node.id, attempt, last);
+		if (cancelledAfterGates) return {
 			last,
-			result: cancelledAfterHook
-		};
-		const result = {
-			attempts: attempt,
-			evidence: last.evidence,
-			exitCode: 0,
-			nodeId: node.id,
-			output: last.output,
-			status: "passed"
+			result: cancelledAfterGates
 		};
+		return yield* finishNodeAttemptWithGate(node, context, attempt, last, gateResults.find((gate) => !gate.passed));
+	});
+}
+function evaluateGatesForAttempt(node, context, last) {
+	return Effect.gen(function* () {
 		recordNodeEvent(context, node.id, {
 			at: now(),
-			result,
-			type: "PASSED"
+			type: "GATES_STARTED"
 		});
-		return {
+		const gateResults = yield* Effect.tryPromise(() => evaluateNodeGates(node, context, last, (failedNode, result) => Effect.runPromise(dispatchGateFailureHook(context, failedNode, result))));
+		recordNodeEvent(context, node.id, {
+			at: now(),
+			gates: gateResults,
+			type: "GATES_FINISHED"
+		});
+		return gateResults;
+	});
+}
+function finishNodeAttemptWithGate(node, context, attempt, last, failedGate) {
+	if (failedGate || last.exitCode !== 0) return Effect.succeed(retryCycle(node, attempt, last, failedGate));
+	return successfulAttemptCycle(node, context, attempt, last);
+}
+function successfulAttemptCycle(node, context, attempt, last) {
+	return Effect.gen(function* () {
+		const successHook = yield* dispatchHooksEffect(context, "node.success", void 0, node);
+		if (successHook) return failedHookCycle(node.id, attempt, last, successHook.evidence, context);
+		const cancelledAfterHook = cancelledNodeResult(context, node.id, attempt, last);
+		return cancelledAfterHook ? {
 			last,
-			result
-		};
-	}
-	const evidence = failedGate ? [...last.evidence, ...failedGate.evidence] : last.evidence.concat(`node exited with code ${last.exitCode}`);
-	const retryReason = nodeRetryReason(last, failedGate);
+			result: cancelledAfterHook
+		} : passedCycle(node.id, attempt, last, context);
+	});
+}
+function passedCycle(nodeId, attempt, last, context) {
+	const result = passedNodeResult(nodeId, attempt, last);
+	recordNodeEvent(context, nodeId, {
+		at: now(),
+		result,
+		type: "PASSED"
+	});
+	return {
+		last,
+		result
+	};
+}
+function passedNodeResult(nodeId, attempt, last) {
+	return {
+		attempts: attempt,
+		evidence: last.evidence,
+		exitCode: 0,
+		nodeId,
+		output: last.output,
+		status: "passed"
+	};
+}
+function retryCycle(node, attempt, last, failedGate) {
 	return {
 		last,
 		retry: {
 			attempt,
-			evidence,
-			gate: failedGate?.gateId ?? node.id,
-			reason: failedGate?.reason ?? `node exited with code ${last.exitCode}`,
-			retryReason
+			evidence: retryEvidence(last, failedGate),
+			gate: retryGateId(node.id, failedGate),
+			reason: retryReasonText(last.exitCode, failedGate),
+			retryReason: nodeRetryReason(last, failedGate)
 		}
 	};
 }
+function retryGateId(nodeId, failedGate) {
+	return failedGate ? failedGate.gateId : nodeId;
+}
+function retryReasonText(exitCode, failedGate) {
+	if (!failedGate) return `node exited with code ${exitCode}`;
+	return failedGate.reason ?? `node exited with code ${exitCode}`;
+}
+function retryEvidence(last, failedGate) {
+	return failedGate ? [...last.evidence, ...failedGate.evidence] : last.evidence.concat(`node exited with code ${last.exitCode}`);
+}
+function snapshotChangedFilesEffect(worktreePath) {
+	return Effect.sync(() => snapshotChangedFiles(worktreePath));
+}
 function nodeRetryReason(attempt, failedGate) {
 	if (attempt.timedOut) return "timeout";
 	if (failedGate) return "gate_failure";
@@ -763,35 +960,47 @@ function nodeFailure(nodeId, attempts, evidence, output) {
 	};
 }
 function executeNodeAttempt(node, context, attempt) {
-	switch (node.kind) {
-		case "agent": return executeAgentNode(node, context, attempt);
-		case "command": return executeCommand(node.command ?? [], context, { timeout: node.timeoutMs });
-		case "builtin": return executeBuiltin(node.builtin ?? "", context, node);
-		case "group": return {
-			evidence: [`group '${node.id}' completed`],
-			exitCode: 0,
-			output: ""
-		};
-		case "parallel": return executeParallelNode(node, context, {
-			executeNode,
-			markNodeReady: (childContext, childId) => recordNodeEvent(childContext, childId, {
-				at: now(),
-				type: "READY"
-			})
-		});
-		default: {
-			const _exhaustive = node.kind;
-			throw new Error(`Unsupported node kind: ${String(_exhaustive)}`);
-		}
-	}
+	return nodeAttemptExecutors[node.kind](node, context, attempt);
+}
+const nodeAttemptExecutors = {
+	agent: executeAgentAttempt,
+	builtin: executeBuiltinAttempt,
+	command: executeCommandAttempt,
+	group: executeGroupAttempt,
+	parallel: executeParallelAttempt
+};
+function executeAgentAttempt(node, context, attempt) {
+	return Effect.tryPromise(() => executeAgentNode(node, context, attempt));
+}
+function executeCommandAttempt(node, context) {
+	return Effect.tryPromise(() => executeCommand(node.command ?? [], context, { timeout: node.timeoutMs }));
+}
+function executeBuiltinAttempt(node, context) {
+	return Effect.tryPromise(() => executeBuiltin(node.builtin ?? "", context, node));
+}
+function executeGroupAttempt(node) {
+	return Effect.succeed({
+		evidence: [`group '${node.id}' completed`],
+		exitCode: 0,
+		output: ""
+	});
+}
+function executeParallelAttempt(node, context) {
+	return Effect.tryPromise(() => executeParallelNode(node, context, {
+		executeNode: (child, childContext) => Effect.runPromise(executeNode(child, childContext)),
+		markNodeReady: (childContext, childId) => recordNodeEvent(childContext, childId, {
+			at: now(),
+			type: "READY"
+		})
+	}));
 }
-async function dispatchGateFailureHook(context, node, result) {
-	await dispatchHooks(context, "gate.failure", {
+function dispatchGateFailureHook(context, node, result) {
+	return Effect.asVoid(dispatchHooksEffect(context, "gate.failure", {
 		evidence: result.evidence,
 		gate: result.gateId,
 		nodeId: node.id,
 		reason: result.reason ?? "gate failed"
-	}, node, result.gateId);
+	}, node, result.gateId));
 }
 function formatConfigError(err) {
 	return [err.message, ...err.issues.map((issue) => issue.path ? `- ${issue.path}: ${issue.message}` : `- ${issue.message}`)].join("\n");