@oisincoveney/pipeline 1.27.10 → 1.27.12

package/dist/config.d.ts

@@ -485,8 +485,8 @@ declare const configSchema: z.ZodObject<{
   rules: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
     path: z.ZodString;
     source_root: z.ZodDefault<z.ZodEnum<{
-      project: "project";
       package: "package";
+      project: "project";
     }>>;
   }, z.core.$strict>>>;
   runners: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
@@ -613,8 +613,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>;
@@ -626,8 +626,8 @@ declare const configSchema: z.ZodObject<{
   skills: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
     path: z.ZodString;
     source_root: z.ZodDefault<z.ZodEnum<{
-      project: "project";
       package: "package";
+      project: "project";
     }>>;
   }, z.core.$strict>>>;
   task_context: z.ZodOptional<z.ZodObject<{

package/dist/moka-submit.d.ts

@@ -160,8 +160,8 @@ declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   }, z.core.$strict>>;
   serviceAccountName: z.ZodDefault<z.ZodString>;
   mode: z.ZodEnum<{
-    full: "full";
     quick: "quick";
+    full: "full";
   }>;
   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<{
-    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/runtime/agent-node/agent-node.js

@@ -4,7 +4,7 @@ import { normalizeRunnerOutput, runnerTextCandidates } from "../../runner-output
 import { gatewayServerForProfile } from "../../mcp/gateway.js";
 import { selectNodeModel } from "../../model-resolver.js";
 import { resolvePackageAssetPath } from "../../package-assets.js";
-import { readJsonSchemaSource, validateJsonSchemaSource } from "../json-validation/json-validation.js";
+import { normalizeJsonSource, readJsonSchemaSource, validateJsonSchemaSource } from "../json-validation/json-validation.js";
 import "../json-validation/index.js";
 import { emit, emitAgentFinish, emitAgentStart } from "../events/events.js";
 import "../events/index.js";
@@ -54,22 +54,33 @@ async function executeAgentNode(node, context, attempt) {
 }
 async function finalizeAgentOutput(inputs) {
 	const { attempt, context, node, normalized, plan, result } = inputs;
-	const validStructuredOutput = selectValidStructuredOutput(context, node, plan, result.stdout);
+	const validStructuredOutput = selectValidStructuredOutput(context, node, normalized, plan, result.stdout);
 	if (validStructuredOutput) return validStructuredOutput;
 	const repairContext = outputRepairContext(context, node, normalized, result);
 	if (!repairContext) return normalized;
 	return await runOutputRepair(context, node, normalized, repairContext, attempt);
 }
-function selectValidStructuredOutput(context, node, plan, stdout) {
+function selectValidStructuredOutput(context, node, normalized, plan, stdout) {
 	const output = (node.profile ? context.config.profiles[node.profile] : void 0)?.output;
 	if (output?.format !== "json_schema" || !output.schema_path) return null;
-	const candidates = runnerTextCandidates(plan, stdout);
-	for (const candidate of [...candidates].reverse()) if (validateJsonSchemaSource(candidate.output, output.schema_path, context.worktreePath).passed) return {
-		evidence: [candidate.evidence, `selected valid structured output for ${node.id}`],
-		output: candidate.output
-	};
+	const candidates = structuredOutputCandidates(plan, stdout, normalized);
+	for (const candidate of candidates) {
+		const candidateOutput = normalizeJsonSource(candidate.output);
+		if (validateJsonSchemaSource(candidateOutput, output.schema_path, context.worktreePath).passed) return {
+			evidence: [candidate.evidence, `selected valid structured output for ${node.id}`],
+			output: candidateOutput
+		};
+	}
 	return null;
 }
+function structuredOutputCandidates(plan, stdout, normalized) {
+	const candidates = runnerTextCandidates(plan, stdout);
+	if (candidates.length > 0) return [...candidates].reverse();
+	return [{
+		evidence: normalized.evidence.join("; ") || "selected runner stdout",
+		output: normalized.output
+	}];
+}
 function outputRepairContext(context, node, normalized, result) {
 	if (result.exitCode !== 0 || result.timedOut) return null;
 	const profile = node.profile ? context.config.profiles[node.profile] : void 0;
@@ -110,14 +121,15 @@ async function runOutputRepair(context, node, normalized, repairContext, nodeAtt
 		const repairResult = await context.executor(repairPlan, { signal: context.signal });
 		emitAgentFinish(context, repairPlan, nodeAttempt, repairResult);
 		const repaired = normalizeAgentOutput(repairPlan, repairResult.stdout);
-		const repairedValidation = validateJsonSchemaSource(repaired.output, repairContext.schemaPath, context.worktreePath);
+		const repairedOutput = normalizeJsonSource(repaired.output);
+		const repairedValidation = validateJsonSchemaSource(repairedOutput, repairContext.schemaPath, context.worktreePath);
 		latest = {
 			evidence: [
 				...repaired.evidence,
 				...repairResult.stderr ? [`repair stderr: ${repairResult.stderr}`] : [],
 				...repairResult.timedOut ? ["output repair timed out"] : []
 			],
-			output: repaired.output
+			output: repairedOutput
 		};
 		latestValidation = repairedValidation;
 		const passed = repairResult.exitCode === 0 && repairedValidation.passed;
@@ -131,7 +143,7 @@ async function runOutputRepair(context, node, normalized, repairContext, nodeAtt
 		});
 		if (passed) return {
 			evidence,
-			output: repaired.output
+			output: repairedOutput
 		};
 	}
 	return {

package/dist/runtime/json-validation/json-validation.js

@@ -6,6 +6,7 @@ import Ajv from "ajv";
 import addFormats from "ajv-formats";
 //#region src/runtime/json-validation/json-validation.ts
 const LINE_RE = /\r?\n/;
+const MARKDOWN_JSON_FENCE_RE = /^\s*```(?:json)?\s*\r?\n([\s\S]*?)\r?\n```\s*$/i;
 const jsonSchemaValidator = addFormats(new Ajv({
 	allErrors: true,
 	strict: false
@@ -15,7 +16,7 @@ function parseRuntimeOutput(format, output) {
 	if (!(format === "json" || format === "json_schema" || format === "jsonl")) return { output };
 	try {
 		if (format === "jsonl") return { output: output.split(LINE_RE).filter((line) => line.trim().length > 0).map((line) => parseJson(line, "runtime JSONL line")) };
-		return { output: parseJson(output, "runtime JSON output") };
+		return { output: parseJson(normalizeJsonSource(output), "runtime JSON output") };
 	} catch (err) {
 		return {
 			error: err instanceof Error ? err.message : "failed to parse output",
@@ -26,7 +27,7 @@ function parseRuntimeOutput(format, output) {
 function validateJsonSchemaSource(source, schemaPath, worktreePath) {
 	try {
 		const schemaSource = readJsonSchemaSource(schemaPath, worktreePath);
-		const value = parseJson(source, "JSON schema gate value");
+		const value = parseJson(normalizeJsonSource(source), "JSON schema gate value");
 		const validate = compiledJsonSchemaValidator(schemaPath, schemaSource);
 		const errors = validate(value) ? [] : formatJsonSchemaErrors(validate.errors ?? []);
 		return {
@@ -42,6 +43,10 @@ function validateJsonSchemaSource(source, schemaPath, worktreePath) {
 		};
 	}
 }
+function normalizeJsonSource(source) {
+	const trimmed = source.trim();
+	return MARKDOWN_JSON_FENCE_RE.exec(trimmed)?.[1].trim() ?? trimmed;
+}
 function readJsonSchemaSource(schemaPath, worktreePath) {
 	const standardName = standardOutputSchemaNameFromPath(schemaPath);
 	if (standardName) return standardOutputSchemaJson(standardName);
@@ -82,4 +87,4 @@ function parseJsonObject(value) {
 	}
 }
 //#endregion
-export { parseJsonObject, parseRuntimeOutput, readJsonSchemaSource, readOptionalFile, validateJsonSchemaSource };
+export { normalizeJsonSource, parseJsonObject, parseRuntimeOutput, readJsonSchemaSource, readOptionalFile, validateJsonSchemaSource };

package/dist/schedule-planner.js

@@ -485,35 +485,71 @@ function executeBaselineWorkflow() {
 	} };
 }
 async function planScheduleArtifact(baseline, plannerProfile, options, planningContext) {
-	if (!plannerProfile) throw new ScheduleArtifactError(`schedule '${options.entrypointId}' requires planner_profile`);
-	const source = await runSchedulePlanner(plannerProfile, plannerPrompt(options.entrypointId, options.task, baseline, options.config, planningContext), options);
-	if (!source) throw new ScheduleArtifactError("schedule planner returned empty output");
+	const requiredPlannerProfile = requireSchedulePlannerProfile(plannerProfile, options.entrypointId);
+	const source = requireSchedulePlannerSource(await runSchedulePlanner(requiredPlannerProfile, plannerPrompt(options.entrypointId, options.task, baseline, options.config, planningContext), options));
 	const initial = acceptedGeneratedSchedule(parseGeneratedSchedule(source, "planner output"));
 	if (initial.ok) return initial.artifact;
-	let latestFailure = initial.error;
-	let latestSource = source;
+	return scheduleArtifactAfterRepair(await repairInvalidScheduleArtifact({
+		baseline,
+		initialFailure: initial.error,
+		initialSource: source,
+		options,
+		plannerProfile: requiredPlannerProfile
+	}), baseline, initial.error, source);
+}
+function requireSchedulePlannerProfile(plannerProfile, entrypointId) {
+	if (plannerProfile) return plannerProfile;
+	throw new ScheduleArtifactError(`schedule '${entrypointId}' requires planner_profile`);
+}
+function requireSchedulePlannerSource(source) {
+	if (source) return source;
+	throw new ScheduleArtifactError("schedule planner returned empty output");
+}
+function scheduleArtifactAfterRepair(repair, baseline, initialFailure, initialSource) {
+	if (repair.kind === "accepted") return repair.artifact;
+	if (repair.kind === "fallback") return baseline;
+	throw new ScheduleArtifactError([
+		"Schedule planner produced invalid output after repair.",
+		initialFailure.message,
+		"Original planner output:",
+		initialSource,
+		repair.latestFailure.message,
+		"Planner repair output:",
+		repair.latestSource
+	].join("\n"));
+}
+async function repairInvalidScheduleArtifact(input) {
+	let latestFailure = input.initialFailure;
+	let latestSource = input.initialSource;
 	for (let attempt = 1; attempt <= SCHEDULE_PLANNER_REPAIR_ATTEMPTS; attempt += 1) {
-		const repairedSource = await runSchedulePlanner(plannerProfile, plannerRepairPrompt({
-			attempt,
-			baseline,
-			error: latestFailure,
-			source: latestSource
-		}), options, "schedule-plan-repair");
-		if (!repairedSource) throw new ScheduleArtifactError(`schedule planner repair returned empty output after invalid schedule\n${latestFailure.message}\nPlanner output:\n${latestSource}`);
+		const repairedSource = await runScheduleRepair(input, latestFailure, latestSource, attempt);
+		if (!repairedSource) return { kind: "fallback" };
 		const repaired = acceptedGeneratedSchedule(parseGeneratedSchedule(repairedSource, "planner repair output"));
-		if (repaired.ok) return repaired.artifact;
+		if (repaired.ok) return {
+			artifact: repaired.artifact,
+			kind: "accepted"
+		};
 		latestFailure = repaired.error;
 		latestSource = repairedSource;
 	}
-	throw new ScheduleArtifactError([
-		"Schedule planner produced invalid output after repair.",
-		initial.error.message,
-		"Original planner output:",
-		source,
-		latestFailure.message,
-		"Planner repair output:",
+	return {
+		kind: "invalid",
+		latestFailure,
 		latestSource
-	].join("\n"));
+	};
+}
+async function runScheduleRepair(input, latestFailure, latestSource, attempt) {
+	try {
+		return await runSchedulePlanner(input.plannerProfile, plannerRepairPrompt({
+			attempt,
+			baseline: input.baseline,
+			error: latestFailure,
+			source: latestSource
+		}), input.options, "schedule-plan-repair");
+	} catch (err) {
+		if (err instanceof ScheduleArtifactError) return;
+		throw err;
+	}
 }
 function parseGeneratedSchedule(source, sourcePath) {
 	const parseableSource = normalizeGeneratedScheduleSource(source);
@@ -644,18 +680,43 @@ function plannerRepairPrompt(inputs) {
 function allowedProfilePromptLine(config, id) {
 	const profile = config.profiles[id];
 	const runner = config.runners[profile.runner];
-	const roles = effectiveSchedulingRoles(config, id);
-	const model = profile.model ?? runner?.model;
-	return `- ${id} (${[
-		`runner: ${profile.runner}`,
-		model ? `model: ${model}` : "",
-		roles.length > 0 ? `scheduling_roles: ${roles.join(", ")}` : "",
-		profile.description ? `description: ${profile.description}` : "",
-		profile.tools?.length ? `tools: ${profile.tools.join(", ")}` : "",
-		profile.filesystem?.mode ? `filesystem: ${profile.filesystem.mode}` : "",
-		profile.network?.mode ? `network: ${profile.network.mode}` : "",
-		`output: ${profile.output?.format ?? "text"}`
-	].filter(Boolean).join("; ")})`;
+	return `- ${id} (${profilePromptFields(config, id, profile, runner).join("; ")})`;
+}
+function profilePromptFields(config, id, profile, runner) {
+	return definedProfilePromptFields([
+		requiredProfilePromptField("runner", profile.runner),
+		optionalProfilePromptField("model", profileModel(profile, runner)),
+		optionalProfilePromptField("scheduling_roles", effectiveSchedulingRoles(config, id).join(", ")),
+		optionalProfilePromptField("description", profile.description),
+		optionalProfilePromptField("tools", profileTools(profile)),
+		optionalProfilePromptField("filesystem", profileFilesystemMode(profile)),
+		optionalProfilePromptField("network", profileNetworkMode(profile)),
+		requiredProfilePromptField("output", profileOutputFormat(profile))
+	]);
+}
+function profileModel(profile, runner) {
+	return profile.model ?? runner?.model;
+}
+function profileTools(profile) {
+	return profile.tools?.join(", ");
+}
+function profileFilesystemMode(profile) {
+	return profile.filesystem?.mode;
+}
+function profileNetworkMode(profile) {
+	return profile.network?.mode;
+}
+function profileOutputFormat(profile) {
+	return profile.output?.format ?? "text";
+}
+function requiredProfilePromptField(label, value) {
+	return `${label}: ${value}`;
+}
+function optionalProfilePromptField(label, value) {
+	return value ? requiredProfilePromptField(label, value) : void 0;
+}
+function definedProfilePromptFields(fields) {
+	return fields.filter((field) => Boolean(field));
 }
 function schedulerCatalogPrompt(config, entrypointId) {
 	const catalog = resolveSchedulerCatalog(config, entrypointId);
@@ -837,16 +898,7 @@ function nodesByAssignedWorkUnit(nodes) {
 	return grouped;
 }
 function hasPathToNode(sourceId, targetId, dependentsByNeed) {
-	const queue = [...dependentsByNeed.get(sourceId) ?? []];
-	const seen = /* @__PURE__ */ new Set();
-	while (queue.length > 0) {
-		const node = queue.shift();
-		if (!node || seen.has(node.id)) continue;
-		if (node.id === targetId) return true;
-		seen.add(node.id);
-		queue.push(...dependentsByNeed.get(node.id) ?? []);
-	}
-	return false;
+	return hasReachableDependent(sourceId, dependentsByNeed, (node) => node.id === targetId);
 }
 function unsupportedGeneratedBuiltinIssues(artifact) {
 	const allowed = new Set(SCHEDULE_BUILTINS);

package/package.json

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