@oisincoveney/pipeline 2.5.0 → 2.7.0

package/dist/config/schemas.d.ts

@@ -221,8 +221,8 @@ declare const configSchema: z.ZodObject<{
     policy: z.ZodOptional<z.ZodObject<{
       commands: z.ZodOptional<z.ZodEnum<{
         allow: "allow";
-        "trusted-only": "trusted-only";
         deny: "deny";
+        "trusted-only": "trusted-only";
       }>>;
       modules: z.ZodOptional<z.ZodEnum<{
         allow: "allow";
@@ -246,8 +246,8 @@ declare const configSchema: z.ZodObject<{
     }, z.core.$strict>>>;
     default_profile: z.ZodOptional<z.ZodString>;
     mode: z.ZodEnum<{
-      hosted: "hosted";
       local: "local";
+      hosted: "hosted";
     }>;
     provider: z.ZodLiteral<"toolhive">;
     authorization_env: z.ZodDefault<z.ZodString>;
@@ -290,10 +290,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>;
@@ -311,6 +311,7 @@ declare const configSchema: z.ZodObject<{
     skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
     timeout_ms: z.ZodOptional<z.ZodNumber>;
     tools: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+      task: "task";
       read: "read";
       list: "list";
       grep: "grep";
@@ -318,7 +319,6 @@ declare const configSchema: z.ZodObject<{
       bash: "bash";
       edit: "edit";
       write: "write";
-      task: "task";
     }>>>;
   }, z.core.$strict>>>;
   runner_command: z.ZodDefault<z.ZodObject<{
@@ -344,8 +344,8 @@ declare const configSchema: z.ZodObject<{
   rules: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
     path: z.ZodString;
     source_root: z.ZodDefault<z.ZodEnum<{
-      package: "package";
       project: "project";
+      package: "package";
     }>>;
   }, z.core.$strict>>>;
   runners: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
@@ -362,14 +362,15 @@ 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>;
       tools: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        task: "task";
         read: "read";
         list: "list";
         grep: "grep";
@@ -377,7 +378,6 @@ declare const configSchema: z.ZodObject<{
         bash: "bash";
         edit: "edit";
         write: "write";
-        task: "task";
       }>>>;
     }, z.core.$strict>;
     command: z.ZodOptional<z.ZodString>;
@@ -472,8 +472,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>;
@@ -485,8 +485,8 @@ declare const configSchema: z.ZodObject<{
   skills: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
     path: z.ZodString;
     source_root: z.ZodDefault<z.ZodEnum<{
-      package: "package";
       project: "project";
+      package: "package";
     }>>;
   }, z.core.$strict>>>;
   task_context: z.ZodOptional<z.ZodObject<{
@@ -495,6 +495,7 @@ declare const configSchema: z.ZodObject<{
   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<{

package/dist/config/schemas.js

@@ -469,6 +469,7 @@ const parallelWorktreesSchema = z.object({ enabled: z.boolean().default(false) }
 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 pipelineFileSchema = z.object({

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/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/parallel-node/parallel-node.js

@@ -91,20 +91,40 @@ function createLinkedAbortController(signal) {
 		controller
 	};
 }
+function childCategory(childId, fanOut) {
+	return fanOut ? Object.keys(fanOut.by_category).find((category) => childId.includes(category)) : void 0;
+}
+function makeCategoryGate(context) {
+	const fanOut = context.config.token_budget?.fan_out_width;
+	const limits = /* @__PURE__ */ new Map();
+	return (childId, run) => {
+		const category = childCategory(childId, fanOut);
+		if (!(category && fanOut)) return run();
+		let limit = limits.get(category);
+		if (!limit) {
+			limit = pLimit(fanOut.by_category[category]);
+			limits.set(category, limit);
+		}
+		return limit(run);
+	};
+}
 function executeParallelChildren(children, context, runtime) {
 	for (const child of children) runtime.markNodeReady(context, child.id);
-	if (!context.maxParallelNodes) return Promise.all(children.map((child) => runChildInWorktree(child, context, runtime)));
+	const gate = makeCategoryGate(context);
+	const runChild = (child) => gate(child.id, () => runChildInWorktree(child, context, runtime));
+	if (!context.maxParallelNodes) return Promise.all(children.map((child) => runChild(child)));
 	const limit = pLimit(context.maxParallelNodes);
-	return Promise.all(children.map((child) => limit(() => runChildInWorktree(child, context, runtime))));
+	return Promise.all(children.map((child) => limit(() => runChild(child))));
 }
 async function executeFailFastParallelChildren(children, context, abortController, runtime) {
 	for (const child of children) runtime.markNodeReady(context, child.id);
+	const gate = makeCategoryGate(context);
 	const limit = pLimit({
 		concurrency: context.maxParallelNodes ?? children.length,
 		rejectOnClear: true
 	});
 	return (await Promise.allSettled(children.map((child) => limit(async () => {
-		const result = await runChildInWorktree(child, context, runtime);
+		const result = await gate(child.id, () => runChildInWorktree(child, context, runtime));
 		if (result.status === "failed") {
 			abortController.abort();
 			limit.clearQueue();
@@ -121,4 +141,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 { executeParallelNode, parallelEvidence, parallelOutput };
+export { childCategory, executeParallelNode, parallelEvidence, parallelOutput };

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

@@ -1,13 +1,16 @@
+import { createRunnerLaunchPlan } from "../../runner.js";
+import { normalizeRunnerOutput } from "../../runner-output.js";
 import { parseJsonObject } from "../json-validation/json-validation.js";
 import "../json-validation/index.js";
 //#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);
 }
-function executeSelectCandidateBuiltin(context, node) {
-	const candidates = readCandidates(context, node?.needs.at(0) ?? null);
+async function executeSelectCandidateBuiltin(context, node) {
+	const candidates = await scoreCandidates(context, readCandidates(context, node?.needs.at(0) ?? null));
 	const selected = selectBestCandidate(candidates);
 	if (!selected) return {
 		evidence: [`select-candidate: no passing candidate among ${candidates.length}`, ...candidates.map((candidate) => `- ${candidate.nodeId}: FAIL`)],
@@ -20,6 +23,61 @@ function executeSelectCandidateBuiltin(context, node) {
 		output: selected.output
 	};
 }
+async 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 candidates;
+	return await Promise.all(candidates.map((candidate) => scoreCandidate(context, candidate, runner, model)));
+}
+async function scoreCandidate(context, candidate, runner, model) {
+	const plan = judgePlan(context, candidate, runner, model);
+	context.agentInvocations.push(plan);
+	const judgeScore = parseScore(normalizeRunnerOutput(plan, (await 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);

package/package.json

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