@oisincoveney/pipeline 2.8.3 → 2.9.0

package/dist/install-commands/opencode.js

@@ -1,12 +1,13 @@
 import { DEFAULT_OPENCODE_ECOSYSTEM_MANIFEST } from "../config/defaults.js";
 import { resolvePackageAssetPath } from "../package-assets.js";
 import "../config.js";
-import { compileWorkflowPlan } from "../planning/compile.js";
-import { mergeOpenCodeProjectConfig } from "../opencode-project-config.js";
+import { RepoIoService, runRepoIoSync } from "../runtime/services/repo-io-service.js";
 import { renderOpenCodeGatewayConfig } from "../mcp/gateway.js";
+import { compileWorkflowPlan } from "../planning/compile.js";
 import { opencodeAgentName } from "../runtime/opencode-agent-name.js";
+import { mergeOpenCodeProjectConfig } from "../opencode-project-config.js";
 import { AGENTS_MD_END, AGENTS_MD_START, COMMAND_HOSTS, GENERATED_MARKER, GENERATED_TS_MARKER, OPENCODE_PROJECT_CONFIG_PATH, OWNER_MARKER_PREFIX, OWNER_TS_MARKER_PREFIX, SINGLE_OPENCODE_PLUGIN_ARRAY_RE, commandIdForHost, compactLines, entrypointDescription, entrypointEntries, instructionsPointer, invocationForHost, profileEntries } from "./shared.js";
-import { readFileSync } from "node:fs";
+import { Effect } from "effect";
 import { basename } from "node:path";
 import matter from "gray-matter";
 //#region src/install-commands/opencode.ts
@@ -116,110 +117,48 @@ function orchestratorBlock(config) {
 		instructionsPointer(profile)
 	].join("\n");
 }
-function dispatchBlock(host, config, workflowId = config.default_workflow) {
-	const routes = agentDispatchRoutes(host, config, workflowId);
-	if (routes.length === 0) return;
-	const plan = compileWorkflowPlan(config, workflowId);
-	const nativeRoutes = routes.filter((route) => route.kind !== "cli");
-	const cliRoutes = routes.filter((route) => route.kind === "cli");
-	return [
-		`Run workflow \`${plan.workflowId}\` for the user task.`,
-		"",
-		nativeDispatchBlock(host, nativeRoutes),
-		cliDispatchBlock(host, cliRoutes),
-		nodePromptContract(plan.workflowId, routes),
-		"Only package-configured gates are blocking. Do not invent RED, GREEN, full-suite, typecheck, or unrelated-drift gates.",
-		"If a node returns targeted evidence and has no configured blocking gate, advance to the next node.",
-		"Do not bypass configured runner subprocesses or package-configured gates when executing nodes.",
-		"Use the listed Task tool routes for native nodes, and run nodes with satisfied dependencies in parallel whenever the host supports concurrent subagent work.",
-		hostSpecificDispatchGuard(host, nativeRoutes, cliRoutes)
-	].filter((line) => Boolean(line)).join("\n");
-}
-function entrypointDispatchBlock(host, config, id, entrypoint) {
-	if ("workflow" in entrypoint) return dispatchBlock(host, config, entrypoint.workflow);
+function entrypointDispatchBlock(_host, _config, id, entrypoint) {
 	return [
-		`Generate a schedule for entrypoint \`${id}\` and the user task.`,
-		`The schedule policy is \`${entrypoint.schedule}\`.`,
-		id === "quick" ? "Run `moka submit --quick <task description>` to submit the graph as an Argo Workflow." : `Run \`moka submit <task description>\` to submit the \`${id}\` graph as an Argo Workflow.`,
-		"The pipeline runtime executes as Argo DAG tasks using the package-owned runner image.",
-		"Configure the target in `~/.config/moka/config.yaml`; use `--kubeconfig <path>` and `--namespace <namespace>` only for explicit command overrides.",
-		"Use `moka submit --schedule <schedule.yaml> <task description>` only when rerunning an existing schedule artifact."
+		`Run \`${canonicalLocalRunCommand(id, entrypoint)}\` for local supervised execution.`,
+		`Configured entrypoint target: ${entrypointTargetId(entrypoint)}.`,
+		"This compatibility slash command delegates to the canonical `moka run` supervisor instead of reimplementing orchestration in the host.",
+		"The supervisor owns schedule generation, node execution, run state, and configured gates.",
+		"Keep reporting clear that this path is CLI/supervised runtime, not host-native Task execution."
 	].join("\n");
 }
-function scheduledEntrypointK8sNote(entrypoint) {
-	if ("workflow" in entrypoint) return;
-	return "Submit Momokaya work as Argo Workflows through `moka submit` and `moka submit --quick`.";
+function entrypointTargetId(entrypoint) {
+	return "workflow" in entrypoint ? entrypoint.workflow : entrypoint.schedule;
+}
+function canonicalLocalRunCommand(id, entrypoint) {
+	return [
+		"moka",
+		"run",
+		...canonicalLocalRunFlags(id, entrypoint),
+		"<task description>"
+	].join(" ");
+}
+function canonicalLocalRunFlags(id, entrypoint) {
+	if (id === "quick") return ["--effort", "quick"];
+	if (id === "execute") return ["--effort", "thorough"];
+	if (id === "inspect") return ["--read-only"];
+	if ("workflow" in entrypoint) return ["--workflow", entrypoint.workflow];
+	return ["--entrypoint", id];
 }
 function localRosterAgentIds(config) {
 	return nativeProfileEntries("opencode", config).map(([id]) => nativeAgentIdForHost("opencode", id));
 }
 function localOrchestratorDispatchBlock(config) {
 	return [
-		"Orchestrate locally. Load and follow the `orchestrate` skill.",
-		"Do not submit to Argo or run `moka submit`. Spawn the roster as native Task subagents on this machine and run nodes with satisfied dependencies in parallel.",
+		"Orchestrate through the canonical local `moka run` supervisor. Load and follow the `orchestrate` skill.",
+		"For compatibility slash commands, run the `moka run` command and flags shown in the command body.",
+		"Treat execution as CLI/supervised runtime, not OpenCode-native Task execution.",
 		"",
-		"Roster (Task tool subagent_type):",
+		"Configured roster:",
 		...localRosterAgentIds(config).map((id) => `- ${id}`),
 		"",
-		"Gather each subagent's structured output, enforce only package-configured gates, and report only the evidence the subagents returned."
-	].join("\n");
-}
-function nativeDispatchBlock(host, routes) {
-	if (routes.length === 0) return;
-	return [
-		`${hostDisplayName(host)} native routes:`,
-		...routes.map(nativeDispatchLine),
-		""
+		"Report the supervisor's evidence and configured-gate results; do not invent extra gates."
 	].join("\n");
 }
-function nativeDispatchLine(route) {
-	const needs = needsSummary(route.needs);
-	const model = route.model ? ` model=${route.model}` : "";
-	return `- ${route.nodeId}: Task tool subagent_type=${route.nativeAgentId}${model} runner=${route.runnerId} needs=${needs}`;
-}
-function cliDispatchBlock(host, routes) {
-	if (routes.length === 0) return;
-	return [
-		`These nodes are not ${hostDisplayName(host)} native routes.`,
-		"CLI routes:",
-		...routes.map(cliDispatchLine),
-		""
-	].join("\n");
-}
-function cliDispatchLine(route) {
-	return `- ${route.nodeId}: ${route.runnerId} CLI profile=${route.profileId} command=\`${runnerCliCommand(route)}\` needs=${needsSummary(route.needs)}`;
-}
-function runnerCliCommand(route) {
-	if (route.runnerId === "opencode") return `opencode run --agent "${opencodeAgentName(route.profileId)}" --format json --dir <repo-root> <node prompt>`;
-	throw new Error(`runner '${route.runnerId}' cannot be represented as a supported native or CLI route`);
-}
-function nodePromptContract(workflowId, routes) {
-	return [
-		routes.some((route) => route.kind === "cli") ? "For each CLI node prompt include:" : "For each native node prompt include:",
-		"- user task",
-		`- workflow id: ${workflowId}`,
-		"- node id",
-		"- profile id",
-		"- runner id",
-		"- profile instructions reference",
-		"- profile grants",
-		"- dependency outputs",
-		""
-	].join("\n");
-}
-function hostSpecificDispatchGuard(host, nativeRoutes, cliRoutes) {
-	if (cliRoutes.length > 0 && nativeRoutes.length > 0) return `Do not claim CLI routes are ${hostDisplayName(host)} native routes.`;
-	if (cliRoutes.length > 0 && nativeRoutes.length === 0) return `Do not claim these nodes are ${hostDisplayName(host)} subagents.`;
-}
-function hostDisplayName(host) {
-	return {
-		opencode: "OpenCode",
-		"claude-code": "Claude Code"
-	}[host];
-}
-function needsSummary(needs) {
-	return needs.length > 0 ? needs.join(",") : "none";
-}
 const OPENCODE_PERMISSION_TOOLS = [
 	"bash",
 	"edit",
@@ -293,10 +232,17 @@ function npmPluginPackage(item) {
 function formatOpenCodeProjectJson(value) {
 	return `${JSON.stringify(value, null, 2).replace(SINGLE_OPENCODE_PLUGIN_ARRAY_RE, "\n  \"plugin\": [$1]")}\n`;
 }
-function localPluginDefinitions() {
-	return DEFAULT_OPENCODE_ECOSYSTEM_MANIFEST.ecosystem_code.flatMap((item) => {
-		if (item.plugin?.kind !== "local") return [];
-		const plugin = readFileSync(resolvePackageAssetPath(item.plugin.source_path), "utf8").trimEnd();
+function localPluginDefinitionsEffect() {
+	return Effect.gen(function* () {
+		return (yield* Effect.all(DEFAULT_OPENCODE_ECOSYSTEM_MANIFEST.ecosystem_code.map(localPluginDefinitionEffect))).flat();
+	});
+}
+function localPluginDefinitionEffect(item) {
+	const pluginConfig = item.plugin;
+	if (pluginConfig?.kind !== "local") return Effect.succeed([]);
+	const source = resolvePackageAssetPath(pluginConfig.source_path);
+	return Effect.gen(function* () {
+		const plugin = (yield* (yield* RepoIoService).readText(source)).trimEnd();
 		return [{
 			content: [
 				GENERATED_TS_MARKER,
@@ -307,80 +253,81 @@ function localPluginDefinitions() {
 			].join("\n"),
 			host: "opencode",
 			invocation: invocationForHost("opencode"),
-			path: item.plugin.target_path
+			path: pluginConfig.target_path
 		}];
 	});
 }
-function opencodeDefinitions(config, cwd) {
-	const orchestrator = orchestratorProfile(config);
-	return [
-		...entrypointCommandDefinitions("opencode", config, (id, entrypoint) => ({
-			content: markdown({
-				...orchestrator ? { agent: OPENCODE_ORCHESTRATOR_AGENT_ID } : {},
-				description: entrypointDescription(id, entrypoint)
-			}, compactLines([
-				header("opencode").trimEnd(),
-				"",
-				`Invoke this command with \`${invocationForHost("opencode", id)}\`.`,
-				"",
-				orchestratorBlock(config),
-				"",
-				scheduledEntrypointK8sNote(entrypoint),
-				scheduledEntrypointK8sNote(entrypoint) ? "" : void 0,
-				entrypointDispatchBlock("opencode", config, id, entrypoint)
-			]).join("\n")),
-			host: "opencode",
-			invocation: invocationForHost("opencode", id),
-			path: `.opencode/commands/${commandIdForHost("opencode", id)}.md`
-		})),
-		{
-			content: renderOpenCodeProjectConfig(config),
-			host: "opencode",
-			invocation: invocationForHost("opencode"),
-			path: ".opencode/opencode.json"
-		},
-		...orchestrator ? [{
-			content: markdown({
-				description: "Orchestrate the configured pipeline and enforce gates.",
-				mode: "primary",
-				name: OPENCODE_ORCHESTRATOR_AGENT_ID,
-				permission: opencodePermission(orchestrator, { allowedTaskAgents: localRosterAgentIds(config) })
-			}, compactLines([
-				header("opencode").trimEnd(),
-				"",
-				orchestratorBlock(config),
-				"",
-				localOrchestratorDispatchBlock(config)
-			]).join("\n")),
-			host: "opencode",
-			invocation: invocationForHost("opencode"),
-			path: `.opencode/agents/${OPENCODE_ORCHESTRATOR_AGENT_ID}.md`
-		}] : [],
-		...nativeProfileEntries("opencode", config).map(([id, profile]) => ({
-			content: markdown({
-				name: nativeAgentIdForHost("opencode", id),
-				description: profile.description ?? id,
-				hidden: false,
-				mode: "all",
-				...opencodeModelProjection(config, profile),
-				permission: opencodePermission(profile)
-			}, [
-				header("opencode").trimEnd(),
-				"",
-				profile.description ?? id,
-				"",
-				"Configured grants:",
-				grants(profile),
-				"",
-				instructionsPointer(profile)
-			].join("\n")),
-			host: "opencode",
-			invocation: invocationForHost("opencode"),
-			path: `.opencode/agents/${nativeAgentIdForHost("opencode", id)}.md`
-		})),
-		...localPluginDefinitions(),
-		projectAgentsMdDefinition(cwd, "opencode")
-	];
+function opencodeDefinitionsEffect(config, cwd) {
+	return Effect.gen(function* () {
+		const orchestrator = orchestratorProfile(config);
+		const pluginDefinitions = yield* localPluginDefinitionsEffect();
+		return [
+			...entrypointCommandDefinitions("opencode", config, (id, entrypoint) => ({
+				content: markdown({
+					...orchestrator ? { agent: OPENCODE_ORCHESTRATOR_AGENT_ID } : {},
+					description: entrypointDescription(id, entrypoint)
+				}, compactLines([
+					header("opencode").trimEnd(),
+					"",
+					`Invoke this command with \`${invocationForHost("opencode", id)}\`.`,
+					"",
+					orchestratorBlock(config),
+					"",
+					entrypointDispatchBlock("opencode", config, id, entrypoint)
+				]).join("\n")),
+				host: "opencode",
+				invocation: invocationForHost("opencode", id),
+				path: `.opencode/commands/${commandIdForHost("opencode", id)}.md`
+			})),
+			{
+				content: renderOpenCodeProjectConfig(config),
+				host: "opencode",
+				invocation: invocationForHost("opencode"),
+				path: ".opencode/opencode.json"
+			},
+			...orchestrator ? [{
+				content: markdown({
+					description: "Orchestrate the configured pipeline and enforce gates.",
+					mode: "primary",
+					name: OPENCODE_ORCHESTRATOR_AGENT_ID,
+					permission: opencodePermission(orchestrator, { allowedTaskAgents: localRosterAgentIds(config) })
+				}, compactLines([
+					header("opencode").trimEnd(),
+					"",
+					orchestratorBlock(config),
+					"",
+					localOrchestratorDispatchBlock(config)
+				]).join("\n")),
+				host: "opencode",
+				invocation: invocationForHost("opencode"),
+				path: `.opencode/agents/${OPENCODE_ORCHESTRATOR_AGENT_ID}.md`
+			}] : [],
+			...nativeProfileEntries("opencode", config).map(([id, profile]) => ({
+				content: markdown({
+					name: nativeAgentIdForHost("opencode", id),
+					description: profile.description ?? id,
+					hidden: false,
+					mode: "all",
+					...opencodeModelProjection(config, profile),
+					permission: opencodePermission(profile)
+				}, [
+					header("opencode").trimEnd(),
+					"",
+					profile.description ?? id,
+					"",
+					"Configured grants:",
+					grants(profile),
+					"",
+					instructionsPointer(profile)
+				].join("\n")),
+				host: "opencode",
+				invocation: invocationForHost("opencode"),
+				path: `.opencode/agents/${nativeAgentIdForHost("opencode", id)}.md`
+			})),
+			...pluginDefinitions,
+			projectAgentsMdDefinition(cwd, "opencode")
+		];
+	});
 }
 function projectAgentsMdDefinition(cwd, host) {
 	const repoName = basename(cwd);
@@ -398,7 +345,8 @@ function projectAgentsMdDefinition(cwd, host) {
 			"",
 			"This repository uses package-owned `@oisincoveney/pipeline` config.",
 			"",
-			"- Use `/moka-quick`, `/moka-execute`, or `/moka-inspect` for OpenCode slash-command entrypoints when available.",
+			"- Use `moka run \"<task>\"` first for local supervised execution from the package-owned pipeline config.",
+			"- Use `/moka-quick`, `/moka-execute`, or `/moka-inspect` as compatibility slash-command entrypoints when available.",
 			"- Load and follow the relevant skill from `.agents/skills` before doing specialized work.",
 			"- Prefer the package-defined pipeline profiles and generated command surfaces over ad hoc subagent prompts.",
 			"- When the user needs to run a command, copy the command into the clipboard and tell the user what needs to be returned.",
@@ -436,7 +384,7 @@ const opencodeAdapter = {
 		".opencode/skills"
 	],
 	definitions(config, cwd) {
-		return opencodeDefinitions(config, cwd);
+		return runRepoIoSync(opencodeDefinitionsEffect(config, cwd));
 	},
 	mergeDefinition(definition, existingContent) {
 		if (definition.path !== ".opencode/opencode.json") return;
@@ -455,4 +403,4 @@ const opencodeAdapter = {
 	}
 };
 //#endregion
-export { agentDispatchRoutes, entrypointDispatchBlock, grants, header, markdown, opencodeAdapter, projectAgentsMdDefinition, resolvedHostModel, scheduledEntrypointK8sNote };
+export { agentDispatchRoutes, entrypointDispatchBlock, grants, header, markdown, opencodeAdapter, projectAgentsMdDefinition, resolvedHostModel };

package/dist/mcp/repo-local-backends.js

@@ -1,4 +1,5 @@
-import { existsSync } from "node:fs";
+import { RepoIoService, runRepoIoSync } from "../runtime/services/repo-io-service.js";
+import { Effect } from "effect";
 import { join } from "node:path";
 //#region src/mcp/repo-local-backends.ts
 const BACKEND_TEMPLATES = {
@@ -23,45 +24,56 @@ const BACKEND_TEMPLATES = {
 	}
 };
 function resolveRepoLocalBackendSpecs(config, options) {
-	const gateway = config.mcp_gateway;
-	if (!gateway) return [];
-	const exists = options.exists ?? existsSync;
-	return Object.entries(gateway.backends).filter(([, backend]) => backend.locality === "repo-local").map(([id, backend]) => repoLocalBackendSpec(id, backend, {
-		cwd: options.cwd,
-		env: options.env ?? process.env,
-		exists
-	}));
+	return runRepoIoSync(resolveRepoLocalBackendSpecsEffect(config, options));
 }
-function repoLocalBackendSpec(id, backend, options) {
-	const workspacePath = workspacePathForBackend(backend, options);
-	const template = BACKEND_TEMPLATES[id] ?? {
-		args: () => [],
-		command: id,
-		requiredPath: "."
-	};
-	const requiredPath = join(workspacePath, template.requiredPath);
-	const ready = options.exists(requiredPath);
-	const readiness = ready ? { ok: true } : {
-		ok: false,
-		reason: `Missing ${template.requiredPath} in ${workspacePath}`
-	};
-	const enabled = ready || backend.required;
-	return {
-		args: template.args(workspacePath),
-		command: template.command,
-		cwd: workspacePath,
-		enabled,
-		env: { PIPELINE_TARGET_PATH: workspacePath },
-		id,
-		mount: {
-			containerPath: "/workspace",
-			hostPath: workspacePath
-		},
-		readiness,
-		required: backend.required,
-		toolPrefixes: backend.tool_prefixes,
-		workspacePath
-	};
+function resolveRepoLocalBackendSpecsEffect(config, options) {
+	return Effect.gen(function* () {
+		const gateway = config.mcp_gateway;
+		if (!gateway) return [];
+		return yield* Effect.all(Object.entries(gateway.backends).filter(([, backend]) => backend.locality === "repo-local").map(([id, backend]) => repoLocalBackendSpecEffect(id, backend, {
+			cwd: options.cwd,
+			env: options.env ?? process.env,
+			exists: options.exists
+		})));
+	});
+}
+function repoLocalBackendSpecEffect(id, backend, options) {
+	return Effect.gen(function* () {
+		const workspacePath = workspacePathForBackend(backend, options);
+		const template = BACKEND_TEMPLATES[id] ?? {
+			args: () => [],
+			command: id,
+			requiredPath: "."
+		};
+		const ready = yield* backendPathExists(join(workspacePath, template.requiredPath), options.exists);
+		const readiness = ready ? { ok: true } : {
+			ok: false,
+			reason: `Missing ${template.requiredPath} in ${workspacePath}`
+		};
+		const enabled = ready || backend.required;
+		return {
+			args: template.args(workspacePath),
+			command: template.command,
+			cwd: workspacePath,
+			enabled,
+			env: { PIPELINE_TARGET_PATH: workspacePath },
+			id,
+			mount: {
+				containerPath: "/workspace",
+				hostPath: workspacePath
+			},
+			readiness,
+			required: backend.required,
+			toolPrefixes: backend.tool_prefixes,
+			workspacePath
+		};
+	});
+}
+function backendPathExists(path, exists) {
+	if (exists) return Effect.sync(() => exists(path));
+	return Effect.gen(function* () {
+		return yield* (yield* RepoIoService).exists(path);
+	});
 }
 function workspacePathForBackend(backend, options) {
 	return backend.workspace_path_source === "PIPELINE_TARGET_PATH" ? options.env.PIPELINE_TARGET_PATH || options.cwd : options.cwd;

package/dist/moka-submit.js

@@ -1,14 +1,14 @@
+import { buildRunnerCommandPayload, runnerDeliverySchema, runnerHookPolicySchema, runnerRepositoryContextSchema, runnerRunIdentitySchema, runnerTaskSchema } from "./runner-command-contract.js";
 import { normalizeRunnerRepositoryForSubmit } from "./git-remote-url.js";
 import { compileScheduleArtifact, generateScheduleArtifact, parseScheduleArtifact } from "./planning/generate.js";
-import { buildRunnerCommandPayload, runnerDeliverySchema, runnerHookPolicySchema, runnerRepositoryContextSchema, runnerRunIdentitySchema, runnerTaskSchema } from "./runner-command-contract.js";
 import { workflowSubmitResultSchema } from "./workflow-submit-contract.js";
 import { buildCommandScheduleYaml, submitRunnerArgoWorkflow } from "./argo-submit.js";
 import { z } from "zod";
 import { readFileSync } from "node:fs";
-import { randomBytes } from "node:crypto";
-import parseGitUrl from "git-url-parse";
 import { resolve } from "node:path";
+import { randomBytes } from "node:crypto";
 import { simpleGit } from "simple-git";
+import parseGitUrl from "git-url-parse";
 //#region src/moka-submit.ts
 const imagePullPolicySchema = z.enum([
 	"Always",

package/dist/pipeline-runtime.js

@@ -1,24 +1,24 @@
 import { loadPipelineConfig } from "./config/load.js";
 import "./config.js";
+import { findPlannedNode } from "./planned-node.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";
 import { executeAgentNode } from "./runtime/agent-node/agent-node.js";
 import "./runtime/agent-node/index.js";
 import { createRuntimeContext } from "./runtime/context/context.js";
 import "./runtime/context/index.js";
+import { executeCommand } from "./runtime/command-executor/command-executor.js";
+import "./runtime/command-executor/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 { dispatchHooks } from "./runtime/hooks/hooks.js";
+import "./runtime/hooks/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";
@@ -73,6 +73,7 @@ function runWithLeasedOpencode(options, config, worktreePath, run) {
 	return Effect.scoped(Effect.gen(function* () {
 		const lease = yield* Effect.acquireRelease(Effect.tryPromise(() => leaseOpencodeRuntime({
 			config,
+			...options.reporter ? { onSession: opencodeSessionReporter(options.reporter) } : {},
 			...options.signal ? { signal: options.signal } : {},
 			worktreePath
 		})), (lease) => Effect.promise(() => lease.release()));
@@ -83,6 +84,15 @@ function runWithLeasedOpencode(options, config, worktreePath, run) {
 		});
 	}));
 }
+function opencodeSessionReporter(reporter) {
+	return (nodeId, sessionId) => {
+		reporter({
+			nodeId,
+			sessionId,
+			type: "node.session"
+		});
+	};
+}
 function runJournalPath(context, dir) {
 	return join(context.worktreePath ?? process.cwd(), dir, `${context.runId}.jsonl`);
 }

package/dist/planning/generate.js

@@ -1,12 +1,12 @@
 import { workflowSchema } from "../config/schemas.js";
 import { validatePipelineConfig } from "../config/validate.js";
 import "../config.js";
+import { dependentsByNeed, flattenNodes, hasReachableDependent } from "./graph.js";
 import { createRunnerLaunchPlan, runLaunchPlan } from "../runner.js";
 import { normalizeRunnerOutput } from "../runner-output.js";
+import { compileWorkflowPlan } from "./compile.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";
 import { canonicalizeGeneratedScheduleIds } from "../schedule/passes/ids.js";
@@ -14,7 +14,6 @@ import { SCHEDULE_PASS_ORDER } from "../schedule/passes/index.js";
 import { applyNodeCatalogModelFallbacks } from "../schedule/passes/models.js";
 import { namespaceScheduleWorkflows } from "../schedule/passes/references.js";
 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";
@@ -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) {