@oisincoveney/pipeline 3.3.2 → 3.4.0

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

@@ -226,8 +226,8 @@ declare const configSchema: z.ZodObject<{
     policy: z.ZodOptional<z.ZodObject<{
       commands: z.ZodOptional<z.ZodEnum<{
         allow: "allow";
-        deny: "deny";
         "trusted-only": "trusted-only";
+        deny: "deny";
       }>>;
       modules: z.ZodOptional<z.ZodEnum<{
         allow: "allow";
@@ -255,8 +255,8 @@ declare const configSchema: z.ZodObject<{
       global: "global";
     }>>;
     mode: z.ZodEnum<{
-      local: "local";
       hosted: "hosted";
+      local: "local";
     }>;
     provider: z.ZodLiteral<"toolhive">;
     authorization_env: z.ZodDefault<z.ZodString>;
@@ -299,10 +299,10 @@ declare const configSchema: z.ZodObject<{
     }, z.core.$strict>>;
     output: z.ZodOptional<z.ZodObject<{
       format: z.ZodEnum<{
-        json_schema: "json_schema";
         text: "text";
         json: "json";
         jsonl: "jsonl";
+        json_schema: "json_schema";
       }>;
       repair: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodOptional<z.ZodBoolean>;
@@ -371,10 +371,10 @@ declare const configSchema: z.ZodObject<{
         disabled: "disabled";
       }>>>;
       output_formats: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        json_schema: "json_schema";
         text: "text";
         json: "json";
         jsonl: "jsonl";
+        json_schema: "json_schema";
       }>>>;
       rules: z.ZodOptional<z.ZodBoolean>;
       skills: z.ZodOptional<z.ZodBoolean>;
@@ -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<{
-      quick: "quick";
       execute: "execute";
+      quick: "quick";
     }>;
     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/hooks.d.ts

@@ -13,8 +13,8 @@ declare const hookResultSchema: z.ZodObject<{
     taskContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
   }, z.core.$strict>>;
   status: z.ZodEnum<{
-    pass: "pass";
     fail: "fail";
+    pass: "pass";
     skip: "skip";
   }>;
   summary: z.ZodOptional<z.ZodString>;

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<{
-    full: "full";
     quick: "quick";
+    full: "full";
   }>;
   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,10 +598,11 @@ 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;
-		for (const implementationNode of implementationNodes) if (!(yield* remediateImplementationAncestor(input, implementationNode))) return false;
-		return true;
+		let remediated = false;
+		for (const implementationNode of implementationNodes) if (yield* remediateImplementationAncestor(input, implementationNode)) remediated = true;
+		return remediated;
 	});
 }
 function remediateImplementationAncestor(input, implementationNode) {
@@ -739,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<{
-    full: "full";
     quick: "quick";
+    full: "full";
   }>;
 }, z.core.$strict>, z.ZodObject<{
   argv: z.ZodArray<z.ZodString>;
@@ -104,8 +104,8 @@ declare const runnerCommandPayloadSchema: z.ZodObject<{
   submission: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"graph">;
     mode: z.ZodEnum<{
-      full: "full";
       quick: "quick";
+      full: "full";
     }>;
   }, z.core.$strict>, z.ZodObject<{
     argv: z.ZodArray<z.ZodString>;

package/dist/runner-event-schema.d.ts

@@ -103,8 +103,8 @@ declare const runnerEventRecordSchema: z.ZodUnion<readonly [z.ZodObject<{
     nodeId: z.ZodOptional<z.ZodString>;
     outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     status: z.ZodEnum<{
-      pass: "pass";
       fail: "fail";
+      pass: "pass";
       skip: "skip";
     }>;
     summary: z.ZodOptional<z.ZodString>;
@@ -273,8 +273,8 @@ declare const runnerEventBatchSchema: z.ZodObject<{
       nodeId: z.ZodOptional<z.ZodString>;
       outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
       status: z.ZodEnum<{
-        pass: "pass";
         fail: "fail";
+        pass: "pass";
         skip: "skip";
       }>;
       summary: z.ZodOptional<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.2",
+  "version": "3.4.0",
   "description": "Config-driven multi-agent pipeline runner for repository work",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",