@oisincoveney/pipeline 3.3.3 → 3.4.1

package/defaults/profiles.yaml

@@ -151,7 +151,7 @@ profiles:
     runner: opencode
     scheduling_roles: [implementation]
     description: Add focused failing tests for the requested behavior.
-    instructions: { inline: "Add focused failing tests for the requested behavior only. Do not change production code. Only edit files matching test paths such as **/*.test.*, **/*.spec.*, **/*_test.*, **/__tests__/**, test/**, or tests/**. Return only valid JSON with top-level changes and verification. Every changes entry must include summary, why, and files. Include risks, followups, and lessons when present. Do not use Markdown fences or prose outside the JSON object." }
+    instructions: { inline: "Add focused failing tests for the requested behavior only. Do not change production code. Only edit files matching test paths such as **/*.test.*, **/*.spec.*, **/*_test.*, **/__tests__/**, test/**, or tests/**. NEVER silence lint, type, complexity, or dead-code findings with suppression comments (no // fallow-ignore, // biome-ignore, eslint-disable, oxlint-disable, @ts-ignore, or @ts-expect-error); fix the underlying cause — if a gate flags your test, restructure the test (e.g. move restricted imports into shared support/fixture helpers) rather than suppressing it. Return only valid JSON with top-level changes and verification. Every changes entry must include summary, why, and files. Include risks, followups, and lessons when present. Do not use Markdown fences or prose outside the JSON object." }
     skills: [test]
     mcp_servers: [pipeline-gateway]
     tools: [read, list, grep, glob, bash, edit, write]
@@ -165,7 +165,7 @@ profiles:
     runner: opencode
     scheduling_roles: [implementation]
     description: Implement production code until the failing tests pass.
-    instructions: { inline: "Implement the smallest production change that satisfies the failing tests. Return only valid JSON with top-level changes and verification. Every changes entry must include summary, why, and files. Include risks, followups, and lessons when present. Do not use Markdown fences or prose outside the JSON object." }
+    instructions: { inline: "Implement the smallest production change that satisfies the failing tests. NEVER silence lint, type, complexity, or dead-code findings with suppression comments (no // fallow-ignore, // biome-ignore, eslint-disable, oxlint-disable, @ts-ignore, or @ts-expect-error); fix the underlying cause — reduce complexity by extracting helpers, remove genuinely dead code, and migrate off deprecated APIs rather than suppressing the warning. Return only valid JSON with top-level changes and verification. Every changes entry must include summary, why, and files. Include risks, followups, and lessons when present. Do not use Markdown fences or prose outside the JSON object." }
     skills: [trace, test, fix, library-first-development]
     mcp_servers: [pipeline-gateway]
     tools: [read, list, grep, glob, bash, edit, write]

package/dist/cli/run-resolver.js

@@ -10,8 +10,7 @@ function resolveMokaRun(input) {
 	const effort = flags.effort ?? "normal";
 	const target = flags.target ?? "local";
 	const mode = flags.readOnly ? "read" : "write";
-	if (flags.command && target !== "remote") throw new Error("--command requires --target remote");
-	if (flags.detach && target !== "local") throw new Error("--detach requires --target local");
+	assertFlagTargetCompatibility(flags, target);
 	return {
 		effort,
 		execution: target === "remote" ? resolveRemoteSubmit(flags, effort) : resolveLocalRuntime(flags, effort),
@@ -19,6 +18,10 @@ function resolveMokaRun(input) {
 		target
 	};
 }
+function assertFlagTargetCompatibility(flags, target) {
+	if (flags.command && target !== "remote") throw new Error("--command requires --target remote");
+	if (flags.detach && target !== "local") throw new Error("--detach requires --target local");
+}
 function resolveRemoteSubmit(flags, effort) {
 	return {
 		command: flags.command,
@@ -27,31 +30,37 @@ function resolveRemoteSubmit(flags, effort) {
 		schedule: flags.schedule
 	};
 }
-function resolveLocalRuntime(flags, effort) {
-	if (flags.schedule) return {
+const LOCAL_RUNTIME_RESOLVERS = [
+	(flags) => flags.schedule ? {
 		kind: "local-runtime",
 		schedule: flags.schedule
-	};
-	if (flags.workflow) return {
+	} : void 0,
+	(flags) => flags.workflow ? {
 		kind: "local-runtime",
 		workflow: flags.workflow
-	};
-	if (flags.readOnly) return {
+	} : void 0,
+	(flags) => flags.readOnly ? {
 		kind: "local-runtime",
 		workflow: "inspect"
-	};
-	if (flags.entrypoint) return {
+	} : void 0,
+	(flags) => flags.entrypoint ? {
 		entrypoint: flags.entrypoint,
 		kind: "local-runtime"
-	};
-	if (effort === "quick") return {
+	} : void 0,
+	(_flags, effort) => effort === "quick" ? {
 		entrypoint: "quick",
 		kind: "local-runtime"
-	};
-	if (effort === "thorough") return {
+	} : void 0,
+	(_flags, effort) => effort === "thorough" ? {
 		entrypoint: "execute",
 		kind: "local-runtime"
-	};
+	} : void 0
+];
+function resolveLocalRuntime(flags, effort) {
+	for (const resolve of LOCAL_RUNTIME_RESOLVERS) {
+		const resolved = resolve(flags, effort);
+		if (resolved) return resolved;
+	}
 	return { kind: "local-runtime" };
 }
 //#endregion

package/dist/config/load.js

@@ -35,6 +35,7 @@ function durabilityField(durability) {
 function pipe83Fields(pipeline) {
 	const keys = [
 		"context_handoff",
+		"delivery",
 		"parallel_worktrees",
 		"repo_map"
 	];

package/dist/config/schemas.d.ts

@@ -481,8 +481,8 @@ declare const configSchema: z.ZodObject<{
   schedules: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
     baseline: z.ZodEnum<{
-      execute: "execute";
       quick: "quick";
+      execute: "execute";
     }>;
     max_parallel_nodes: z.ZodOptional<z.ZodNumber>;
     node_catalog: z.ZodOptional<z.ZodString>;
@@ -505,6 +505,12 @@ declare const configSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
     model: z.ZodOptional<z.ZodString>;
   }, z.core.$strict>>;
+  delivery: z.ZodOptional<z.ZodObject<{
+    pull_request: z.ZodOptional<z.ZodObject<{
+      enabled: z.ZodDefault<z.ZodBoolean>;
+      label: z.ZodDefault<z.ZodString>;
+    }, z.core.$strict>>;
+  }, z.core.$strict>>;
   durability: z.ZodOptional<z.ZodObject<{
     dir: z.ZodDefault<z.ZodString>;
     enabled: z.ZodDefault<z.ZodBoolean>;

package/dist/config/schemas.js

@@ -475,14 +475,23 @@ const repoMapSchema = z.object({
 	enabled: z.boolean().default(false),
 	token_budget: z.number().int().positive().default(2e3)
 }).strict();
+const deliverySchema = z.object({ pull_request: z.object({
+	enabled: z.boolean().default(false),
+	label: z.string().min(1).default("preview")
+}).strict().optional() }).strict();
 const pipelineFileSchema = z.object({
 	default_workflow: z.string(),
+	context_handoff: contextHandoffSchema.optional(),
+	delivery: deliverySchema.optional(),
+	durability: durabilitySchema.optional(),
 	entrypoints: strictRecord(entrypointSchema).default({}),
 	hooks: hooksConfigSchema.default({
 		functions: {},
 		on: {}
 	}),
 	orchestrator: orchestratorSchema.optional(),
+	parallel_worktrees: parallelWorktreesSchema.optional(),
+	repo_map: repoMapSchema.optional(),
 	runner_command: runnerCommandConfigSchema.default({
 		environment: {
 			setup: [],
@@ -496,10 +505,6 @@ const pipelineFileSchema = z.object({
 	}),
 	schedules: strictRecord(schedulePolicySchema).default({}),
 	task_context: taskContextResolverSchema.optional(),
-	context_handoff: contextHandoffSchema.optional(),
-	durability: durabilitySchema.optional(),
-	parallel_worktrees: parallelWorktreesSchema.optional(),
-	repo_map: repoMapSchema.optional(),
 	token_budget: tokenBudgetSchema.default(DEFAULT_TOKEN_BUDGET),
 	workflows: strictRecord(workflowSchema).default({}),
 	version: z.literal(1)
@@ -532,6 +537,7 @@ const configSchema = z.object({
 	skills: strictRecord(pathRefSchema).default({}),
 	task_context: taskContextResolverSchema.optional(),
 	context_handoff: contextHandoffSchema.optional(),
+	delivery: deliverySchema.optional(),
 	durability: durabilitySchema.optional(),
 	parallel_worktrees: parallelWorktreesSchema.optional(),
 	repo_map: repoMapSchema.optional(),

package/dist/moka-submit.d.ts

@@ -160,8 +160,8 @@ declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   }, z.core.$strict>>;
   serviceAccountName: z.ZodOptional<z.ZodString>;
   mode: z.ZodEnum<{
-    quick: "quick";
     full: "full";
+    quick: "quick";
   }>;
   schedulePath: z.ZodOptional<z.ZodString>;
   scheduleYaml: z.ZodOptional<z.ZodString>;

package/dist/moka-submit.js

@@ -175,6 +175,15 @@ function configWithSubmitHooks(config, hooks) {
 		}
 	};
 }
+function withPullRequestDelivery(config, delivery) {
+	return {
+		...config,
+		delivery: { pull_request: {
+			enabled: delivery.pullRequest === true,
+			label: config.delivery?.pull_request?.label ?? "preview"
+		} }
+	};
+}
 function submitMoka(rawOptions, dependencies = {}) {
 	const { config, worktreePath, ...schemaOptions } = rawOptions;
 	const options = mokaSubmitOptionsSchema.parse(schemaOptions);
@@ -256,7 +265,7 @@ async function graphScheduleYaml(options, dependencies, runId, task) {
 	if (explicitScheduleYaml) return explicitScheduleYaml;
 	const worktreePath = requireScheduleWorktreePath(options);
 	return readScheduleFile(dependencies, resolve(worktreePath, (await (dependencies.generateSchedule ?? generateScheduleArtifact)({
-		config: options.config,
+		config: withPullRequestDelivery(options.config, options.delivery),
 		entrypointId: options.mode === "quick" ? "quick" : "execute",
 		runId,
 		task,

package/dist/pipeline-runtime.js

@@ -598,7 +598,7 @@ function remediateUpstreamImplementationFailure(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");
+		const implementationNodes = upstreamImplementationNodes(input.context, input.node);
 		if (implementationNodes.length === 0) return false;
 		let remediated = false;
 		for (const implementationNode of implementationNodes) if (yield* remediateImplementationAncestor(input, implementationNode)) remediated = true;
@@ -740,7 +740,19 @@ 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);
+	if (!nodeStatePassed(context, candidate.id)) return;
+	pushIfImplementation(context, ordered, candidate);
+	for (const child of candidate.children ?? []) appendPassedImplementationChild(context, ordered, child);
+}
+function appendPassedImplementationChild(context, ordered, child) {
+	pushIfImplementation(context, ordered, child);
+	for (const grandchild of child.children ?? []) appendPassedImplementationChild(context, ordered, grandchild);
+}
+function pushIfImplementation(context, ordered, node) {
+	if (hasSchedulingRole(context, node, "implementation")) ordered.push(node);
+}
+function nodeStatePassed(context, nodeId) {
+	return context.nodeStateStore.getNodeState(nodeId)?.status === "passed";
 }
 function hasSchedulingRole(context, node, role) {
 	return node.profile ? context.config.profiles[node.profile]?.scheduling_roles?.includes(role) ?? false : false;

package/dist/planning/generate.js

@@ -14,6 +14,7 @@ import { integrateParallelWriteFanout } from "../schedule/passes/drain-merge.js"
 import { canonicalizeGeneratedScheduleIds } from "../schedule/passes/ids.js";
 import { SCHEDULE_PASS_ORDER } from "../schedule/passes/index.js";
 import { applyNodeCatalogModelFallbacks } from "../schedule/passes/models.js";
+import { appendPullRequestDelivery } from "../schedule/passes/open-pull-request.js";
 import { namespaceScheduleWorkflows } from "../schedule/passes/references.js";
 import { plannerPrompt, plannerRepairPrompt } from "../schedule/prompts.js";
 import { parseDocument, stringify } from "yaml";
@@ -32,6 +33,7 @@ const SCHEDULE_BUILTINS = [
 	"duplication",
 	"fallow",
 	"lint",
+	"open-pull-request",
 	"semgrep",
 	"test",
 	"typecheck"
@@ -94,7 +96,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, integrateParallelWriteFanout(options.config, addGeneratedImplementationCoverage(options.config, generatedArtifact)))), planningContext);
+	const artifact = hydrateScheduleTaskContexts(canonicalizeGeneratedScheduleIds(applyNodeCatalogModelFallbacks(options.config, policy.node_catalog, appendPullRequestDelivery(options.config, integrateParallelWriteFanout(options.config, addGeneratedImplementationCoverage(options.config, generatedArtifact))))), planningContext);
 	validateScheduleArtifact(options.config, artifact, planningContext);
 	compileScheduleArtifact(options.config, artifact, options.worktreePath);
 	return {
@@ -106,6 +108,7 @@ function assertSchedulePassOrder() {
 	if (SCHEDULE_PASS_ORDER.join("\0") !== [
 		"coverage",
 		"drain-merge",
+		"delivery",
 		"models",
 		"ids",
 		"references"

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

@@ -43,8 +43,8 @@ declare const runnerDeliverySchema: z.ZodObject<{
 declare const mokaSubmissionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   kind: z.ZodLiteral<"graph">;
   mode: z.ZodEnum<{
-    quick: "quick";
     full: "full";
+    quick: "quick";
   }>;
 }, z.core.$strict>, z.ZodObject<{
   argv: z.ZodArray<z.ZodString>;
@@ -104,8 +104,8 @@ declare const runnerCommandPayloadSchema: z.ZodObject<{
   submission: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"graph">;
     mode: z.ZodEnum<{
-      quick: "quick";
       full: "full";
+      quick: "quick";
     }>;
   }, z.core.$strict>, z.ZodObject<{
     argv: z.ZodArray<z.ZodString>;

package/dist/runtime/builtins/builtins.js

@@ -3,6 +3,8 @@ import { acquireRunStateLock } from "../../run-control/run-state-lock.js";
 import { executeDrainMergeBuiltin } from "../drain-merge/drain-merge.js";
 import "../drain-merge/index.js";
 import { CommandExecutor, CommandExecutorLive } from "../services/command-executor-service.js";
+import { executeOpenPullRequestBuiltin } from "../open-pull-request/open-pull-request.js";
+import "../open-pull-request/index.js";
 import { Effect } from "effect";
 import { existsSync, readFileSync, renameSync } from "node:fs";
 import { join } from "node:path";
@@ -26,6 +28,7 @@ const JSCPD_DEFAULT_IGNORES = [
 const WHITESPACE_RE = /\s/;
 const BUILTIN_HANDLERS = {
 	"drain-merge": (context, node) => Effect.tryPromise(() => executeDrainMergeBuiltin(context, node)),
+	"open-pull-request": (context, node) => Effect.tryPromise(() => executeOpenPullRequestBuiltin(context, node)),
 	duplication: (context) => executeDuplicationBuiltinEffect(context),
 	fallow: (context) => executeFallowBuiltinEffect(context),
 	lint: (context) => executeScriptBuiltinEffect(context, "lint"),

package/dist/runtime/open-pull-request/index.js

@@ -0,0 +1,2 @@
+import "./open-pull-request.js";
+export {};

package/dist/runtime/open-pull-request/open-pull-request.js

@@ -0,0 +1,186 @@
+import { CommandExecutor, CommandExecutorLive } from "../services/command-executor-service.js";
+import { OpenPullRequestGitService, OpenPullRequestGitServiceLive } from "../services/open-pull-request-git-service.js";
+import { Effect, Layer } from "effect";
+//#region src/runtime/open-pull-request/open-pull-request.ts
+const INVALID_REF_CHAR_RE = /[^a-zA-Z0-9/_.-]/g;
+const PR_ALREADY_EXISTS_RE = /already exists/i;
+const NEWLINE_RE = /\r?\n/;
+function executeOpenPullRequestBuiltin(context, _node) {
+	const merged = Layer.merge(OpenPullRequestGitServiceLive, CommandExecutorLive);
+	return Effect.runPromise(Effect.provide(openPullRequestProgram(context), merged));
+}
+function openPullRequestProgram(context) {
+	return Effect.gen(function* () {
+		const git = yield* (yield* OpenPullRequestGitService).create(context.worktreePath);
+		const prCtx = yield* Effect.either(resolveOpenPrContext(git, context));
+		if (prCtx._tag === "Left") return openPrFailure(errorMessage(prCtx.left));
+		return yield* executeOpenPr(git, prCtx.right, context);
+	});
+}
+function resolveOpenPrContext(git, context) {
+	return Effect.gen(function* () {
+		const baseBranch = yield* resolveDefaultBranch(git, context);
+		const headBranch = resolveHeadBranch(context.runId);
+		return {
+			baseBranch,
+			committer: context.config.runner_command.git.committer,
+			headBranch,
+			label: context.config.delivery?.pull_request?.label ?? "preview",
+			runId: context.runId ?? "local",
+			task: context.task
+		};
+	});
+}
+function resolveDefaultBranch(git, context) {
+	return git.raw([
+		"symbolic-ref",
+		"--short",
+		"refs/remotes/origin/HEAD"
+	]).pipe(Effect.map((ref) => stripOriginPrefix(ref.trim())), Effect.catchAll(() => resolveCurrentBranch(git, context)));
+}
+function stripOriginPrefix(ref) {
+	return ref.startsWith("origin/") ? ref.slice(7) : ref;
+}
+function resolveCurrentBranch(git, context) {
+	return git.raw([
+		"rev-parse",
+		"--abbrev-ref",
+		"HEAD"
+	]).pipe(Effect.map((ref) => ref.trim()), Effect.catchAll(() => Effect.succeed(fallbackBranch(context))));
+}
+function fallbackBranch(context) {
+	return context.runId ? `moka/run/${context.runId}` : "main";
+}
+function resolveHeadBranch(runId) {
+	return `moka/run/${runId ?? "local"}`.replace(INVALID_REF_CHAR_RE, "-");
+}
+function executeOpenPr(git, prCtx, context) {
+	return Effect.gen(function* () {
+		const prepareResult = yield* Effect.either(prepareHeadBranch(git, prCtx));
+		if (prepareResult._tag === "Left") return openPrFailure(errorMessage(prepareResult.left));
+		const pushResult = yield* Effect.either(pushHeadBranch(git, prCtx.headBranch));
+		if (pushResult._tag === "Left") return openPrFailure(errorMessage(pushResult.left));
+		return yield* submitPullRequest(prCtx, context);
+	});
+}
+function prepareHeadBranch(git, prCtx) {
+	return checkoutOrCreateHeadBranch(git, prCtx.headBranch).pipe(Effect.flatMap(() => stageAndCommitChanges(git, prCtx)), Effect.asVoid);
+}
+function checkoutOrCreateHeadBranch(git, headBranch) {
+	return git.raw([
+		"checkout",
+		"-B",
+		headBranch
+	]).pipe(Effect.asVoid);
+}
+function stageAndCommitChanges(git, prCtx) {
+	return git.raw(["status", "--porcelain"]).pipe(Effect.flatMap((status) => commitIfDirty(git, status.trim(), prCtx)), Effect.asVoid);
+}
+function commitIfDirty(git, status, prCtx) {
+	if (status.length === 0) return Effect.void;
+	return configureCommitter(git, prCtx.committer).pipe(Effect.flatMap(() => git.raw(["add", "-A"])), Effect.flatMap(() => git.raw([
+		"commit",
+		"-m",
+		`open-pull-request: ${prCtx.runId}`
+	])), Effect.asVoid);
+}
+function configureCommitter(git, committer) {
+	return git.raw([
+		"config",
+		"--local",
+		"user.name",
+		committer.name
+	]).pipe(Effect.flatMap(() => git.raw([
+		"config",
+		"--local",
+		"user.email",
+		committer.email
+	])), Effect.asVoid);
+}
+function pushHeadBranch(git, headBranch) {
+	return git.raw([
+		"push",
+		"--force-with-lease",
+		"origin",
+		`HEAD:refs/heads/${headBranch}`
+	]).pipe(Effect.asVoid);
+}
+function submitPullRequest(prCtx, context) {
+	return Effect.gen(function* () {
+		const createResult = yield* runGhPrCreate(yield* CommandExecutor, prCtx, extractPrTitle(prCtx.task), context);
+		if (createResult.exitCode === 0) return openPrSuccess(extractPrUrl(createResult.output), "opened");
+		if (isPrAlreadyExistsError(createResult.output)) return yield* handleExistingPr(prCtx.headBranch, prCtx.label, context);
+		return createResult;
+	});
+}
+function runGhPrCreate(executor, prCtx, title, context) {
+	return executor.execute(buildGhPrCreateArgs(prCtx, title), context).pipe(Effect.catchAll((e) => Effect.succeed(openPrFailure(errorMessage(e)))));
+}
+function handleExistingPr(headBranch, label, context) {
+	return Effect.gen(function* () {
+		const editResult = yield* runGhPrEdit(yield* CommandExecutor, headBranch, label, context);
+		if (editResult.exitCode === 0) return openPrSuccess(headBranch, "updated");
+		return openPrFailure(editResult.output || `gh pr edit exited ${editResult.exitCode}`);
+	});
+}
+function runGhPrEdit(executor, headBranch, label, context) {
+	return executor.execute(buildGhPrEditArgs(headBranch, label), context).pipe(Effect.catchAll((e) => Effect.succeed(openPrFailure(errorMessage(e)))));
+}
+function extractPrTitle(task) {
+	return (task.split(NEWLINE_RE)[0] ?? task).trim() || "moka: open pull request";
+}
+function buildGhPrCreateArgs(prCtx, title) {
+	return [
+		"gh",
+		"pr",
+		"create",
+		"--base",
+		prCtx.baseBranch,
+		"--head",
+		prCtx.headBranch,
+		"--title",
+		title,
+		"--body",
+		`Opened by moka run ${prCtx.runId}`,
+		"--label",
+		prCtx.label
+	];
+}
+function buildGhPrEditArgs(headBranch, label) {
+	return [
+		"gh",
+		"pr",
+		"edit",
+		headBranch,
+		"--add-label",
+		label
+	];
+}
+function isPrAlreadyExistsError(output) {
+	return PR_ALREADY_EXISTS_RE.test(output);
+}
+function extractPrUrl(output) {
+	return output.split(NEWLINE_RE).map((l) => l.trim()).find((l) => l.startsWith("https://")) ?? output.trim();
+}
+function openPrSuccess(url, action) {
+	return {
+		evidence: [`open-pull-request: PR ${action} — ${url}`],
+		exitCode: 0,
+		output: JSON.stringify({
+			action,
+			url
+		})
+	};
+}
+function openPrFailure(reason) {
+	return {
+		evidence: [`open-pull-request failed: ${reason}`],
+		exitCode: 1,
+		output: JSON.stringify({ error: reason })
+	};
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+export { executeOpenPullRequestBuiltin, openPullRequestProgram };

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

@@ -169,4 +169,4 @@ function parallelOutput(children, results) {
 	return JSON.stringify({ children: Object.fromEntries(children.filter((child) => outputsByNode.has(child.id)).map((child) => [child.id, outputsByNode.get(child.id)])) });
 }
 //#endregion
-export { childCategory, executeParallelNode, parallelEvidence, parallelOutput };
+export { executeParallelNode };

package/dist/runtime/services/open-pull-request-git-service.js

@@ -0,0 +1,10 @@
+import { Context, Effect, Layer } from "effect";
+import simpleGit$1 from "simple-git";
+//#region src/runtime/services/open-pull-request-git-service.ts
+var OpenPullRequestGitService = class extends Context.Tag("OpenPullRequestGitService")() {};
+const OpenPullRequestGitServiceLive = Layer.succeed(OpenPullRequestGitService, { create: (baseDir) => Effect.sync(() => {
+	const git = simpleGit$1({ baseDir });
+	return { raw: (args) => Effect.tryPromise(() => git.raw(args)) };
+}) });
+//#endregion
+export { OpenPullRequestGitService, OpenPullRequestGitServiceLive };

package/dist/schedule/passes/index.js

@@ -2,6 +2,7 @@
 const SCHEDULE_PASS_ORDER = [
 	"coverage",
 	"drain-merge",
+	"delivery",
 	"models",
 	"ids",
 	"references"

package/dist/schedule/passes/open-pull-request.js

@@ -0,0 +1,49 @@
+import { uniqueGeneratedId } from "../../strings.js";
+import { dependentsByNeed } from "../../planning/graph.js";
+//#region src/schedule/passes/open-pull-request.ts
+const OPEN_PR_BUILTIN = "open-pull-request";
+/** True when pull_request delivery is opted in via config. */
+function isPullRequestDeliveryEnabled(config) {
+	return config.delivery?.pull_request?.enabled === true;
+}
+/** True when the node list already has an open-pull-request builtin. */
+function hasPullRequestNode(nodes) {
+	return nodes.some((node) => node.kind === "builtin" && node.builtin === OPEN_PR_BUILTIN);
+}
+/** Collect top-level node ids that no other top-level node depends on. */
+function terminalNodeIds(nodes) {
+	const dependents = dependentsByNeed(nodes);
+	return nodes.map((node) => node.id).filter((id) => !dependents.get(id)?.length);
+}
+/** Build a single open-pull-request builtin node depending on all terminals. */
+function buildPrNode(terminalIds, usedIds) {
+	return {
+		builtin: OPEN_PR_BUILTIN,
+		id: uniqueGeneratedId("generated-open-pull-request", usedIds, "generated-open-pull-request"),
+		kind: "builtin",
+		needs: terminalIds
+	};
+}
+/** Append a final open-pull-request node to the root workflow when enabled. */
+function appendPullRequestDelivery(config, artifact) {
+	if (!isPullRequestDeliveryEnabled(config)) return artifact;
+	const rootWorkflow = artifact.workflows[artifact.root_workflow];
+	if (!rootWorkflow) return artifact;
+	const nodes = rootWorkflow.nodes;
+	if (hasPullRequestNode(nodes)) return artifact;
+	const terminals = terminalNodeIds(nodes);
+	if (terminals.length === 0) return artifact;
+	const prNode = buildPrNode(terminals, new Set(nodes.map((node) => node.id)));
+	return {
+		...artifact,
+		workflows: {
+			...artifact.workflows,
+			[artifact.root_workflow]: {
+				...rootWorkflow,
+				nodes: [...nodes, prNode]
+			}
+		}
+	};
+}
+//#endregion
+export { appendPullRequestDelivery };

package/dist/schedule/prompts.js

@@ -5,6 +5,7 @@ const SCHEDULE_BUILTINS = [
 	"duplication",
 	"fallow",
 	"lint",
+	"open-pull-request",
 	"semgrep",
 	"test",
 	"typecheck"

package/package.json

@@ -126,7 +126,7 @@
     "prepack": "bun run build:cli"
   },
   "type": "module",
-  "version": "3.3.3",
+  "version": "3.4.1",
   "description": "Config-driven multi-agent pipeline runner for repository work",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",