@oisincoveney/pipeline 2.8.2 → 2.8.4

package/defaults/pipeline.yaml

@@ -15,18 +15,10 @@ repo_map:
 # last passed node without re-running (or re-spending tokens on) finished work.
 durability:
   enabled: true
-# best_of_n / parallel_worktrees: the verifier-pattern dial. Schedule generation
-# + selection are validated/tested, BUT a live end-to-end run (2026-06-16) proved
-# the EXECUTION is not yet production-ready, so it stays OFF by default (on-by-
-# default made real runs hang). Two runtime gaps remain — see PIPE-83.14:
-#   1. The leased opencode server is rooted at the main worktree and throws
-#      "Unexpected server error" when a candidate session runs with directory set
-#      to its isolated worktree → candidates exit 70, retries exhaust, green loops.
-#      Fix: lease a per-worktree opencode server for each candidate.
-#   2. The winning candidate's file changes live in its worktree and are never
-#      merged back to the main tree, so downstream nodes wouldn't see them.
-# Enable explicitly (best_of_n.enabled + n:2 + categories:[green] + parallel_
-# worktrees.enabled) once those land; n=2 also ~doubles green-node spend.
+# parallel_worktrees: opt-in git-worktree isolation for parallel child nodes —
+# each parallel child runs on its own branch with its own per-worktree opencode
+# server so concurrent edits and sessions can't collide. OFF by default; enable
+# explicitly with parallel_worktrees.enabled.
 token_budget:
   default_context_window: 200000
   max_context_pct: 50
@@ -62,6 +54,15 @@ runner_command:
     setup:
       - command: bun
         args: [install, --frozen-lockfile]
+      # Set up package-owned pipeline support + the opencode model registration
+      # (.opencode/opencode.json, which declares the gpt-5.5-* reasoning selectors)
+      # on every run, so opencode-backed agents in the pod resolve their models
+      # instead of failing with "Model not found". Both commands are idempotent
+      # and write no repo-local pipeline config.
+      - command: moka
+        args: [init]
+      - command: moka
+        args: [install-commands]
 scheduler:
   commands:
     quick:

package/dist/config/load.js

@@ -34,7 +34,6 @@ function durabilityField(durability) {
 }
 function pipe83Fields(pipeline) {
 	const keys = [
-		"best_of_n",
 		"context_handoff",
 		"parallel_worktrees",
 		"repo_map"

package/dist/config/schemas.d.ts

@@ -501,12 +501,6 @@ declare const configSchema: z.ZodObject<{
   task_context: z.ZodOptional<z.ZodObject<{
     type: z.ZodString;
   }, z.core.$loose>>;
-  best_of_n: z.ZodOptional<z.ZodObject<{
-    categories: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    enabled: z.ZodDefault<z.ZodBoolean>;
-    judge_model: z.ZodOptional<z.ZodString>;
-    n: z.ZodDefault<z.ZodNumber>;
-  }, z.core.$strict>>;
   context_handoff: z.ZodOptional<z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
     model: z.ZodOptional<z.ZodString>;

package/dist/config/schemas.js

@@ -471,12 +471,6 @@ const durabilitySchema = z.object({
 	dir: z.string().min(1).default(".pipeline/journal"),
 	enabled: z.boolean().default(false)
 }).strict();
-const bestOfNSchema = z.object({
-	categories: z.array(z.string()).default(["green"]),
-	enabled: z.boolean().default(false),
-	judge_model: z.string().optional(),
-	n: z.number().int().positive().default(1)
-}).strict();
 const repoMapSchema = z.object({
 	enabled: z.boolean().default(false),
 	token_budget: z.number().int().positive().default(2e3)
@@ -502,7 +496,6 @@ const pipelineFileSchema = z.object({
 	}),
 	schedules: strictRecord(schedulePolicySchema).default({}),
 	task_context: taskContextResolverSchema.optional(),
-	best_of_n: bestOfNSchema.optional(),
 	context_handoff: contextHandoffSchema.optional(),
 	durability: durabilitySchema.optional(),
 	parallel_worktrees: parallelWorktreesSchema.optional(),
@@ -538,7 +531,6 @@ const configSchema = z.object({
 	schedules: strictRecord(schedulePolicySchema).default({}),
 	skills: strictRecord(pathRefSchema).default({}),
 	task_context: taskContextResolverSchema.optional(),
-	best_of_n: bestOfNSchema.optional(),
 	context_handoff: contextHandoffSchema.optional(),
 	durability: durabilitySchema.optional(),
 	parallel_worktrees: parallelWorktreesSchema.optional(),

package/dist/moka-submit.d.ts

@@ -5,13 +5,13 @@ import { z } from "zod";
 //#region src/moka-submit.d.ts
 declare const mokaSubmitDirectHooksSchema: z.ZodRecord<z.ZodEnum<{
   "workflow.start": "workflow.start";
-  "node.finish": "node.finish";
-  "node.start": "node.start";
   "workflow.success": "workflow.success";
   "workflow.failure": "workflow.failure";
   "workflow.complete": "workflow.complete";
+  "node.start": "node.start";
   "node.success": "node.success";
   "node.error": "node.error";
+  "node.finish": "node.finish";
   "gate.failure": "gate.failure";
 }> & z.core.$partial, z.ZodDiscriminatedUnion<[z.ZodObject<{
   failure: z.ZodDefault<z.ZodEnum<{
@@ -94,13 +94,13 @@ declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   }, z.core.$strict>>;
   hooks: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
     "workflow.start": "workflow.start";
-    "node.finish": "node.finish";
-    "node.start": "node.start";
     "workflow.success": "workflow.success";
     "workflow.failure": "workflow.failure";
     "workflow.complete": "workflow.complete";
+    "node.start": "node.start";
     "node.success": "node.success";
     "node.error": "node.error";
+    "node.finish": "node.finish";
     "gate.failure": "gate.failure";
   }> & z.core.$partial, z.ZodDiscriminatedUnion<[z.ZodObject<{
     failure: z.ZodDefault<z.ZodEnum<{
@@ -206,13 +206,13 @@ declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   }, z.core.$strict>>;
   hooks: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
     "workflow.start": "workflow.start";
-    "node.finish": "node.finish";
-    "node.start": "node.start";
     "workflow.success": "workflow.success";
     "workflow.failure": "workflow.failure";
     "workflow.complete": "workflow.complete";
+    "node.start": "node.start";
     "node.success": "node.success";
     "node.error": "node.error";
+    "node.finish": "node.finish";
     "gate.failure": "gate.failure";
   }> & z.core.$partial, z.ZodDiscriminatedUnion<[z.ZodObject<{
     failure: z.ZodDefault<z.ZodEnum<{

package/dist/pipeline-runtime.js

@@ -456,13 +456,22 @@ function cancelledRetry(nodeId, attempt, last) {
 		retryReason: "timeout"
 	};
 }
+function unwrapAttemptError(error) {
+	const inner = error?.error;
+	return inner !== void 0 && inner !== error ? inner : error;
+}
+function attemptErrorMessage(error) {
+	const inner = unwrapAttemptError(error);
+	if (inner !== error) return attemptErrorMessage(inner);
+	return error instanceof Error && error.message ? error.message : String(error);
+}
 function failedAttemptRetry(nodeId, attempt, last, err) {
-	const message = err instanceof Error ? err.message : String(err);
+	const message = attemptErrorMessage(err);
 	return {
 		attempt,
 		evidence: [...last.evidence, message],
 		gate: nodeId,
-		reason: err instanceof Error ? err.message : "node retry failed",
+		reason: message,
 		retryReason: nodeRetryReason(last)
 	};
 }
@@ -970,13 +979,22 @@ const nodeAttemptExecutors = {
 	parallel: executeParallelAttempt
 };
 function executeAgentAttempt(node, context, attempt) {
-	return Effect.tryPromise(() => executeAgentNode(node, context, attempt));
+	return Effect.tryPromise({
+		catch: (error) => error,
+		try: () => executeAgentNode(node, context, attempt)
+	});
 }
 function executeCommandAttempt(node, context) {
-	return Effect.tryPromise(() => executeCommand(node.command ?? [], context, { timeout: node.timeoutMs }));
+	return Effect.tryPromise({
+		catch: (error) => error,
+		try: () => executeCommand(node.command ?? [], context, { timeout: node.timeoutMs })
+	});
 }
 function executeBuiltinAttempt(node, context) {
-	return Effect.tryPromise(() => executeBuiltin(node.builtin ?? "", context, node));
+	return Effect.tryPromise({
+		catch: (error) => error,
+		try: () => executeBuiltin(node.builtin ?? "", context, node)
+	});
 }
 function executeGroupAttempt(node) {
 	return Effect.succeed({

package/dist/planning/generate.js

@@ -5,7 +5,6 @@ import { createRunnerLaunchPlan, runLaunchPlan } from "../runner.js";
 import { normalizeRunnerOutput } from "../runner-output.js";
 import { loadBacklogPlanningContext } from "../schedule/backlog-context.js";
 import { baselineScheduleArtifact } from "../schedule/baseline.js";
-import { expandBestOfNCandidates } from "../schedule/passes/candidates.js";
 import { dependentsByNeed, flattenNodes, hasReachableDependent } from "./graph.js";
 import { isCoverageNode, isImplementationNode } from "../schedule/scheduling-roles.js";
 import { addGeneratedImplementationCoverage } from "../schedule/passes/coverage.js";
@@ -31,12 +30,11 @@ const SCHEDULE_BUILTINS = [
 	"duplication",
 	"fallow",
 	"lint",
-	"select-candidate",
 	"semgrep",
 	"test",
 	"typecheck"
 ];
-const PARALLEL_MERGE_BUILTINS = new Set(["drain-merge", "select-candidate"]);
+const PARALLEL_MERGE_BUILTINS = new Set(["drain-merge"]);
 const scheduleArtifactSchema = z.object({
 	generated_at: z.string().datetime(),
 	kind: z.literal(SCHEDULE_KIND),
@@ -94,7 +92,7 @@ async function generateScheduleArtifact(options) {
 	const planningContext = { ...loadBacklogPlanningContext(options.task, options.worktreePath) };
 	const generatedArtifact = await planScheduleArtifact(baseline, policy.planner_profile, options, planningContext);
 	assertSchedulePassOrder();
-	const artifact = hydrateScheduleTaskContexts(canonicalizeGeneratedScheduleIds(applyNodeCatalogModelFallbacks(options.config, policy.node_catalog, expandBestOfNCandidates(options.config, addGeneratedImplementationCoverage(options.config, generatedArtifact)))), planningContext);
+	const artifact = hydrateScheduleTaskContexts(canonicalizeGeneratedScheduleIds(applyNodeCatalogModelFallbacks(options.config, policy.node_catalog, addGeneratedImplementationCoverage(options.config, generatedArtifact))), planningContext);
 	validateScheduleArtifact(options.config, artifact, planningContext);
 	compileScheduleArtifact(options.config, artifact, options.worktreePath);
 	return {
@@ -105,7 +103,6 @@ async function generateScheduleArtifact(options) {
 function assertSchedulePassOrder() {
 	if (SCHEDULE_PASS_ORDER.join("\0") !== [
 		"coverage",
-		"candidates",
 		"models",
 		"ids",
 		"references"
@@ -345,7 +342,7 @@ function workUnitDependencyIssues(config, artifact, workUnits) {
 		const nodes = flattenWorkflowNodes(workflow.nodes);
 		const index = dependentsByNeedWithContainment(workflow.nodes, nodes);
 		const nodesByWorkUnit = nodesByAssignedWorkUnit(nodes);
-		return nodes.filter((node) => isImplementationNode(config, node) || isSelectCandidateNode(node)).flatMap((node) => {
+		return nodes.filter((node) => isImplementationNode(config, node)).flatMap((node) => {
 			const dependentId = node.task_context?.id;
 			if (!dependentId) return [];
 			return (dependenciesByUnit.get(dependentId) ?? []).flatMap((prerequisiteId) => {
@@ -355,9 +352,6 @@ 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-event-schema.d.ts

@@ -10,8 +10,8 @@ declare const runnerEventRecordSchema: z.ZodUnion<readonly [z.ZodObject<{
   at: z.ZodOptional<z.ZodString>;
   sequence: z.ZodNumber;
   type: z.ZodEnum<{
-    "workflow.planned": "workflow.planned";
     "workflow.start": "workflow.start";
+    "workflow.planned": "workflow.planned";
   }>;
   workflowPlan: z.ZodObject<{
     edges: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -55,10 +55,10 @@ declare const runnerEventRecordSchema: z.ZodUnion<readonly [z.ZodObject<{
     }>;
   }, z.core.$strip>;
   type: z.ZodEnum<{
+    "node.start": "node.start";
+    "node.finish": "node.finish";
     "agent.finish": "agent.finish";
     "agent.start": "agent.start";
-    "node.finish": "node.finish";
-    "node.start": "node.start";
   }>;
 }, z.core.$strip>, z.ZodObject<{
   at: z.ZodOptional<z.ZodString>;
@@ -180,8 +180,8 @@ declare const runnerEventBatchSchema: z.ZodObject<{
     at: z.ZodOptional<z.ZodString>;
     sequence: z.ZodNumber;
     type: z.ZodEnum<{
-      "workflow.planned": "workflow.planned";
       "workflow.start": "workflow.start";
+      "workflow.planned": "workflow.planned";
     }>;
     workflowPlan: z.ZodObject<{
       edges: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -225,10 +225,10 @@ declare const runnerEventBatchSchema: z.ZodObject<{
       }>;
     }, z.core.$strip>;
     type: z.ZodEnum<{
+      "node.start": "node.start";
+      "node.finish": "node.finish";
       "agent.finish": "agent.finish";
       "agent.start": "agent.start";
-      "node.finish": "node.finish";
-      "node.start": "node.start";
     }>;
   }, z.core.$strip>, z.ZodObject<{
     at: z.ZodOptional<z.ZodString>;

package/dist/runtime/builtins/builtins.js

@@ -2,7 +2,6 @@ import { parseJson } from "../../safe-json.js";
 import { CommandExecutor, CommandExecutorLive } from "../services/command-executor-service.js";
 import { executeDrainMergeBuiltin } from "../drain-merge/drain-merge.js";
 import "../drain-merge/index.js";
-import { executeSelectCandidateBuiltin } from "../select-candidate/select-candidate.js";
 import { Effect } from "effect";
 import { existsSync, readFileSync, renameSync } from "node:fs";
 import { join } from "node:path";
@@ -29,7 +28,6 @@ const BUILTIN_HANDLERS = {
 	duplication: (context) => executeDuplicationBuiltinEffect(context),
 	fallow: (context) => executeFallowBuiltinEffect(context),
 	lint: (context) => executeScriptBuiltinEffect(context, "lint"),
-	"select-candidate": (context, node) => Effect.tryPromise(() => executeSelectCandidateBuiltin(context, node)),
 	semgrep: (context) => executeSemgrepBuiltinEffect(context),
 	test: (context) => executeTestBuiltinEffect(context),
 	typecheck: (context) => executeScriptBuiltinEffect(context, "typecheck")

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

@@ -1,5 +1,5 @@
 import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { join } from "node:path";
 import { execFileSync } from "node:child_process";
 //#region src/runtime/parallel-worktrees/parallel-worktrees.ts
 /**
@@ -24,39 +24,6 @@ function provisionGeneratedResources(repoRoot, worktreePath) {
 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,
@@ -174,4 +141,4 @@ function gcParallelWorktrees(repoRoot) {
 	return results;
 }
 //#endregion
-export { createChildWorktree, gcParallelWorktrees, promoteWorktreeChanges };
+export { createChildWorktree, gcParallelWorktrees };

package/dist/schedule/passes/index.js

@@ -1,7 +1,6 @@
 //#region src/schedule/passes/index.ts
 const SCHEDULE_PASS_ORDER = [
 	"coverage",
-	"candidates",
 	"models",
 	"ids",
 	"references"

package/docs/config-architecture.md

@@ -359,13 +359,11 @@ The toposort uses `@dagrejs/graphlib` for the graph model but an iterative
 traversal for the topological sort, because graphlib's recursive topsort can
 overflow the call stack on deep generated workflow chains.
 
-## Context, durability & best-of-N features (PIPE-83)
+## Context & durability features (PIPE-83)
 
-The shipped `defaults/pipeline.yaml` turns **`context_handoff`, `repo_map`,
-`durability`, `best_of_n` (n=2 on green), and `parallel_worktrees` ON** — moka
-uses its architecture by default. `best_of_n` is the cost/quality dial: n=2
-~doubles green-node spend, so lower `n` or set `enabled: false` to spend the
-minimum. Each block can be overridden in `pipeline.yaml`; the per-block
+The shipped `defaults/pipeline.yaml` turns **`context_handoff`, `repo_map`, and
+`durability` ON** — moka uses its architecture by default; `parallel_worktrees`
+is opt-in. Each block can be overridden in `pipeline.yaml`; the per-block
 `# default …` notes below mark the *schema* default that applies when a block is
 omitted entirely.
 
@@ -400,26 +398,6 @@ worktrees are GC'd on the next parallel node under the same guard. A worktree is
 *not* a sandbox (node_modules/build state are shared) — real isolation remains
 k8s mode. SDK-runner nodes honour the per-child directory via `plan.cwd`.
 
-### `best_of_n` — generate N candidates and select the winner
-
-```yaml
-best_of_n:
-  enabled: true          # default false
-  n: 3                   # candidates per matching node (default 1 = off)
-  categories: [green]    # which node categories fan out (id-substring match)
-  judge_model: openai/gpt-5.5   # optional LLM judge; omit for status-only
-```
-
-When enabled with `n > 1`, the `candidates` schedule pass expands each matching
-agent node into a `kind: parallel` of N candidate children
-(`<node>--candidates`) feeding a `select-candidate` builtin that keeps the
-original node id. Each candidate builds in its own worktree (pair with
-`parallel_worktrees`) and is throttled by its category's
-`token_budget.fan_out_width` cap. The selector scores candidates by a hybrid of
-execution status (PASS/FAIL) and, when `judge_model` is set, a 0..1 LLM judge
-score; it emits the winner's output and **never self-fixes** — if no candidate
-passes, the node fails with evidence.
-
 ### `durability` — durable crash-resume
 
 ```yaml

package/package.json

@@ -28,6 +28,7 @@
   },
   "devDependencies": {
     "@biomejs/biome": "2.4.15",
+    "@effect/vitest": "^0.29.0",
     "@semantic-release/commit-analyzer": "^13.0.1",
     "@semantic-release/github": "^12.0.8",
     "@semantic-release/npm": "^13.1.5",
@@ -126,7 +127,7 @@
     "prepack": "bun run build:cli"
   },
   "type": "module",
-  "version": "2.8.2",
+  "version": "2.8.4",
   "description": "Config-driven multi-agent pipeline runner for repository work",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

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

@@ -1,144 +0,0 @@
-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 { SelectCandidateService, SelectCandidateServiceLive } from "../services/select-candidate-service.js";
-import { Effect } from "effect";
-//#region src/runtime/select-candidate/select-candidate.ts
-const SCORE_RE = /-?\d+(?:\.\d+)?/;
-function selectBestCandidate(candidates) {
-	const passing = candidates.filter((candidate) => candidate.status === "PASS");
-	if (passing.length === 0) return null;
-	return passing.reduce((best, candidate) => (candidate.judgeScore ?? 0) > (best.judgeScore ?? 0) ? candidate : best);
-}
-async function executeSelectCandidateBuiltin(context, node) {
-	const program = executeSelectCandidateBuiltinProgram(context, node);
-	return await Effect.runPromise(Effect.provide(program, SelectCandidateServiceLive));
-}
-function executeSelectCandidateBuiltinProgram(context, node) {
-	return Effect.gen(function* () {
-		const candidates = yield* scoreCandidates(context, readCandidates(context, firstNeed(node)));
-		const selected = selectBestCandidate(candidates);
-		if (!selected) return {
-			evidence: [`select-candidate: no passing candidate among ${candidates.length}`, ...candidates.map((candidate) => `- ${candidate.nodeId}: FAIL`)],
-			exitCode: 1,
-			output: ""
-		};
-		const promoted = yield* promoteWinner(context, node, selected.nodeId);
-		return {
-			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 = firstNeed(node);
-	if (!shouldPromoteWinner(context, parentNodeId)) return Effect.succeed([]);
-	return SelectCandidateService.pipe(Effect.flatMap((service) => service.promoteWinner(context.worktreePath, context.runId, parentNodeId, winnerNodeId)));
-}
-function shouldPromoteWinner(context, parentNodeId) {
-	const parallelWorktrees = context.config.parallel_worktrees;
-	return Boolean(parallelWorktrees?.enabled) && parentNodeId !== null;
-}
-function firstNeed(node) {
-	return node?.needs.at(0) ?? null;
-}
-function scoreCandidates(context, candidates) {
-	const model = context.config.best_of_n?.judge_model;
-	const runner = Object.keys(context.config.runners).at(0);
-	if (!(model && runner)) return Effect.succeed(candidates);
-	return Effect.forEach(candidates, (candidate) => scoreCandidate(context, candidate, runner, model), { concurrency: "unbounded" });
-}
-function scoreCandidate(context, candidate, runner, model) {
-	return Effect.gen(function* () {
-		const plan = judgePlan(context, candidate, runner, model);
-		context.agentInvocations.push(plan);
-		const judgeScore = parseScore(normalizeRunnerOutput(plan, (yield* (yield* SelectCandidateService).executeRunner(context.executor, plan, { signal: context.signal })).stdout).output);
-		return judgeScore === null ? candidate : {
-			...candidate,
-			judgeScore
-		};
-	});
-}
-function judgePlan(context, candidate, runner, model) {
-	const profileId = `select-candidate:judge:${candidate.nodeId}`;
-	return createRunnerLaunchPlan({
-		...context.config,
-		profiles: {
-			...context.config.profiles,
-			[profileId]: {
-				filesystem: { mode: "read-only" },
-				instructions: { inline: "Score the candidate implementation." },
-				network: { mode: "disabled" },
-				output: { format: "text" },
-				runner,
-				tools: []
-			}
-		}
-	}, {
-		model,
-		nodeId: profileId,
-		profileId,
-		prompt: judgePrompt(context.task, candidate.output),
-		worktreePath: context.worktreePath
-	});
-}
-function judgePrompt(task, output) {
-	return [
-		"Score how well this candidate implementation satisfies the task.",
-		"Return ONLY a number between 0 and 1 (1 = best). No prose, no fences.",
-		"",
-		`Task: ${task}`,
-		"",
-		"Candidate result:",
-		output
-	].join("\n");
-}
-function parseScore(text) {
-	const match = SCORE_RE.exec(text);
-	if (!match) return null;
-	const value = Number(match[0]);
-	return Number.isFinite(value) ? Math.max(0, Math.min(1, value)) : null;
-}
-function readCandidates(context, upstreamNodeId) {
-	if (!upstreamNodeId) return [];
-	const upstream = context.plan.graph.node(upstreamNodeId);
-	const childrenOutput = parseJsonObject(parseJsonObject(context.nodeStateStore.getOutput(upstreamNodeId)).children);
-	return (upstream?.children ?? []).flatMap((child) => {
-		const raw = childrenOutput[child.id];
-		return raw === void 0 ? [] : [parseCandidate(child.id, raw)];
-	});
-}
-function parseCandidate(nodeId, raw) {
-	const output = typeof raw === "string" ? raw : JSON.stringify(raw);
-	const parsed = safeParseObject(output);
-	return {
-		judgeScore: candidateJudgeScore(parsed),
-		nodeId,
-		output,
-		status: candidateStatus(parsed)
-	};
-}
-function candidateStatus(parsed) {
-	if (!parsed) return "PASS";
-	return parsed.verdict === "FAIL" || parsed.status === "FAIL" ? "FAIL" : "PASS";
-}
-function candidateJudgeScore(parsed) {
-	return typeof parsed?.judge_score === "number" ? parsed.judge_score : null;
-}
-function safeParseObject(text) {
-	try {
-		const value = JSON.parse(text);
-		return value && typeof value === "object" ? value : null;
-	} catch {
-		return null;
-	}
-}
-//#endregion
-export { executeSelectCandidateBuiltin };

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

@@ -1,13 +0,0 @@
-import { promoteWorktreeChanges } from "../parallel-worktrees/parallel-worktrees.js";
-import { Context, Effect, Layer } from "effect";
-//#region src/runtime/services/select-candidate-service.ts
-var SelectCandidateService = class extends Context.Tag("SelectCandidateService")() {};
-const SelectCandidateServiceLive = Layer.succeed(SelectCandidateService, {
-	executeRunner: (executor, plan, options) => Effect.tryPromise({
-		catch: (error) => error,
-		try: () => Promise.resolve(executor(plan, options))
-	}),
-	promoteWinner: (repoRoot, runId, parentNodeId, childNodeId) => Effect.sync(() => promoteWorktreeChanges(repoRoot, runId, parentNodeId, childNodeId))
-});
-//#endregion
-export { SelectCandidateService, SelectCandidateServiceLive };

package/dist/schedule/passes/candidates.js

@@ -1,51 +0,0 @@
-//#region src/schedule/passes/candidates.ts
-/**
-* PIPE-83.7: best-of-N candidate generation. When config.best_of_n is enabled
-* with n > 1, each agent node whose id carries a configured category (e.g.
-* "green") is expanded into a kind:parallel node holding N candidate children
-* (each a full copy with a fresh id and no inter-candidate deps). The wrapper
-* keeps the original id + upstream needs, so downstream consumers and the
-* PIPE-83.9 selector see a single dependency. Default off / n=1 is identity, so
-* generated schedules and the PIPE-57 goldens are unchanged.
-*/
-function expandBestOfNCandidates(config, artifact) {
-	const bestOfN = config.best_of_n;
-	if (!bestOfN?.enabled || bestOfN.n <= 1) return artifact;
-	return {
-		...artifact,
-		workflows: Object.fromEntries(Object.entries(artifact.workflows).map(([id, workflow]) => [id, {
-			...workflow,
-			nodes: workflow.nodes.flatMap((node) => expandNode(node, bestOfN.categories, bestOfN.n))
-		}]))
-	};
-}
-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) => 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],
-		...node.task_context ? { task_context: node.task_context } : {}
-	};
-}
-//#endregion
-export { expandBestOfNCandidates };