@oisincoveney/pipeline 1.12.0 → 1.13.0

package/dist/config.d.ts

@@ -231,10 +231,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>;
@@ -274,10 +274,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>;

package/dist/pipeline-init.js

@@ -734,6 +734,7 @@ const SCAFFOLD_FILES = {
 		"",
 		"Use the provided backlog work units as the source of truth when present. Assign each work unit to explicit generated agent nodes with only its `task_context.id`, use only allowed configured profiles, and ensure implementation work has downstream acceptance, verification, or review coverage. Do not invent profiles or node-level skill overrides.",
 		"Do not copy backlog descriptions or acceptance criteria into output; the scheduler hydrates them from the assigned `task_context.id` after parsing.",
+		"Preserve Backlog dependency ids as schedule needs edges. A node assigned a dependent work unit must depend on the nodes assigned its prerequisite work units, directly or through an explicit path.",
 		"",
 		"Shape the graph by intent, not by ticket count. Do not create a full RED/GREEN/ACCEPTANCE/VERIFY chain for each backlog ticket unless each step needs ticket-specific evidence. Use one RED node for a group of tickets when they share a test strategy, fan out to parallel GREEN implementation nodes where the work can be implemented independently, and fan back in to shared acceptance or verifier nodes when the same acceptance checklist or real repository commands prove the group. Only serialize ticket nodes when the backlog, a shared migration/schema/API dependency, or implementation risk requires it.",
 		"",

package/dist/schedule-planner.js

@@ -372,6 +372,7 @@ function plannerPrompt(entrypointId, task, baseline, config, planningContext) {
 		"Assign each backlog work unit to explicit generated agent nodes with task_context.id. The scheduler hydrates title, description, and acceptance_criteria after parsing.",
 		"Do not copy backlog descriptions or acceptance criteria into task_context output.",
 		"Implementation work must have downstream acceptance, verification, or review coverage in the generated DAG.",
+		"Preserve Backlog dependency ids as schedule needs edges. A node assigned a dependent work unit must depend on the nodes assigned its prerequisite work units, directly or through an explicit path.",
 		"Shape the graph by intent, not by ticket count. Do not create a full RED/GREEN/ACCEPTANCE/VERIFY chain for each backlog ticket unless each step needs ticket-specific evidence.",
 		"Use one RED node for a group of tickets when they share a test strategy, then fan out to parallel GREEN implementation nodes where the work can be implemented independently.",
 		"Use one acceptance or verifier node for multiple GREEN nodes when the same acceptance checklist or real repository commands prove the group.",
@@ -402,6 +403,7 @@ function validateScheduleArtifact(config, artifact, planningContext) {
 		...workflowReferenceNodeIssues(artifact),
 		...workflowAssignedWorkUnitIssues(artifact, planningContext.workUnits),
 		...missingAssignedWorkUnitIssues(artifact, planningContext.workUnits),
+		...workUnitDependencyIssues(artifact, planningContext.workUnits),
 		...invalidWorkflowPrimitiveIssues(config, artifact),
 		...implementationCoverageIssues(artifact)
 	];
@@ -464,6 +466,47 @@ function missingAssignedWorkUnitIssues(artifact, workUnits) {
 	const missing = workUnits.map((unit) => unit.id).filter((id) => !assigned.has(id));
 	return missing.length > 0 ? [`missing assigned backlog work units: ${missing.join(", ")}`] : [];
 }
+function workUnitDependencyIssues(artifact, workUnits) {
+	if (workUnits.length === 0) return [];
+	const workUnitIds = new Set(workUnits.map((unit) => unit.id));
+	const dependenciesByUnit = new Map(workUnits.map((unit) => [unit.id, (unit.dependencies ?? []).filter((id) => workUnitIds.has(id))]));
+	return Object.entries(artifact.workflows).flatMap(([workflowId, workflow]) => {
+		const nodes = workflow.nodes.flatMap(flattenWorkflowNode);
+		const dependentsByNeed = workflowDependentsByNeed(nodes);
+		const nodesByWorkUnit = nodesByAssignedWorkUnit(nodes);
+		return nodes.filter(isImplementationNode).flatMap((node) => {
+			const dependentId = node.task_context?.id;
+			if (!dependentId) return [];
+			return (dependenciesByUnit.get(dependentId) ?? []).flatMap((prerequisiteId) => {
+				const prerequisiteNodes = nodesByWorkUnit.get(prerequisiteId) ?? [];
+				return prerequisiteNodes.some((source) => hasPathToNode(source.id, node.id, dependentsByNeed)) ? [] : [`work unit dependency edge missing in '${workflowId}': '${dependentId}' node '${node.id}' must depend on prerequisite '${prerequisiteId}' nodes ${prerequisiteNodes.map((prerequisite) => `'${prerequisite.id}'`).join(", ")}`];
+			});
+		});
+	});
+}
+function nodesByAssignedWorkUnit(nodes) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const node of nodes) {
+		const id = node.task_context?.id;
+		if (!id) continue;
+		const current = grouped.get(id) ?? [];
+		current.push(node);
+		grouped.set(id, current);
+	}
+	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;
+}
 function invalidWorkflowPrimitiveIssues(config, artifact) {
 	const allowed = new Set(Object.keys(config.workflows));
 	return allWorkflowNodes(artifact.workflows).flatMap((node) => {
@@ -543,6 +586,7 @@ function readBacklogTaskFile(path) {
 		parentTaskId: stringFrontmatter(parsed.data.parent_task_id),
 		workUnit: {
 			acceptance_criteria: acceptanceCriteriaFromMarkdown(parsed.content),
+			...optionalStringArrayField("dependencies", stringArrayFrontmatter(parsed.data.dependencies)),
 			...optionalStringField("description", descriptionFromMarkdown(parsed.content)),
 			id,
 			...optionalStringField("title", stringFrontmatter(parsed.data.title))
@@ -552,9 +596,16 @@ function readBacklogTaskFile(path) {
 function stringFrontmatter(value) {
 	return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
+function stringArrayFrontmatter(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean);
+}
 function optionalStringField(key, value) {
 	return value ? { [key]: value } : {};
 }
+function optionalStringArrayField(key, value) {
+	return value.length > 0 ? { [key]: value } : {};
+}
 function descriptionFromMarkdown(content) {
 	const marked = betweenMarkers(content, "<!-- SECTION:DESCRIPTION:BEGIN -->", "<!-- SECTION:DESCRIPTION:END -->");
 	if (marked) return marked;

package/package.json

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