@oisincoveney/pipeline 2.2.0 → 2.3.1

package/dist/cli/program.js

@@ -2,9 +2,8 @@ import { PipelineConfigError } from "../config/schemas.js";
 import { loadPipelineConfig } from "../config/load.js";
 import "../config.js";
 import { createOrchestratorLaunchPlan, createRunnerLaunchPlan } from "../runner.js";
-import { compileWorkflowPlan } from "../workflow-planner.js";
-import { compileScheduleArtifact, generateScheduleArtifact, parseScheduleArtifact } from "../schedule/planner.js";
-import "../schedule-planner.js";
+import { compileWorkflowPlan } from "../planning/compile.js";
+import { compileScheduleArtifact, generateScheduleArtifact, parseScheduleArtifact } from "../planning/generate.js";
 import { loadMokaGlobalConfig } from "../moka-global-config.js";
 import { defaultClusterDoctorNamespace, runClusterDoctor } from "../cluster-doctor.js";
 import { formatCodexAuthSyncResult, syncLocalCodexAuth } from "../codex-auth-sync.js";

package/dist/cli/submit-options.js

@@ -48,7 +48,6 @@ function mokaCommonSubmitOptions(input) {
 		name: input.flags.name,
 		namespace: input.flags.namespace ?? momokaya?.kubernetes.namespace,
 		opencodeAuthSecretName: momokaya?.submit.opencodeAuthSecretName,
-		queueName: input.flags.queueName ?? momokaya?.submit.queueName,
 		serviceAccountName: input.flags.serviceAccount ?? momokaya?.submit.serviceAccountName,
 		worktreePath: input.cwd
 	};
@@ -77,7 +76,7 @@ function submitMokaGraphInput(input, flags, commonOptions) {
 function addRunnerArgoOptions(command, options = {}) {
 	command.option("--name <name>", "Workflow metadata.name").option("--generate-name <prefix>", "Workflow metadata.generateName").option("--namespace <namespace>", "Workflow namespace");
 	if (options.kubeconfig) command.option("--kubeconfig <path>", "kubeconfig path");
-	return command.option("--queue-name <name>", "Kueue LocalQueue label for Workflow pods").option("--service-account <name>", "Workflow service account").option("--image <image>", "runner image").addOption(new Option("--image-pull-policy <policy>", "runner image pull policy").choices([
+	return command.option("--service-account <name>", "Workflow service account").option("--image <image>", "runner image").addOption(new Option("--image-pull-policy <policy>", "runner image pull policy").choices([
 		"Always",
 		"IfNotPresent",
 		"Never"

package/dist/cluster-doctor.js

@@ -10,7 +10,6 @@ const DEFAULT_RESOURCES = {
 	githubAuthSecretName: "oisin-bot-github-auth",
 	imagePullSecretName: "ghcr-pull-secret",
 	opencodeAuthSecretName: "opencode-auth-1",
-	queueName: "pipeline-runner",
 	serviceAccountName: "pipeline-runner"
 };
 const FORBIDDEN_RE = /forbidden/i;
@@ -32,7 +31,6 @@ async function runClusterDoctor(options = {}) {
 			verb: "create",
 			...kubectlOptions
 		}),
-		checkLocalQueue(namespace, resources.queueName, kubectlOptions),
 		checkClusterResource("argo-workflow-crd", [
 			"get",
 			"crd",
@@ -63,7 +61,6 @@ function clusterResources() {
 		githubAuthSecretName: configured.githubAuthSecretName,
 		imagePullSecretName: configured.imagePullSecretName,
 		opencodeAuthSecretName: configured.opencodeAuthSecretName,
-		queueName: configured.queueName,
 		serviceAccountName: configured.serviceAccountName
 	} : DEFAULT_RESOURCES;
 }
@@ -169,15 +166,6 @@ async function checkWorkflowSubmitPermission(namespace, options) {
 		passed: false
 	};
 }
-function checkLocalQueue(namespace, queueName, kubectlOptions) {
-	return checkNamespacedResource(`localqueue/${queueName}`, [
-		"get",
-		"localqueue",
-		queueName,
-		"-n",
-		namespace
-	], `Kueue LocalQueue ${queueName} missing in ${namespace}; runner Workflow pods cannot be admitted to the expected queue.`, kubectlOptions);
-}
 async function checkClusterResource(name, args, kubectlOptions) {
 	const result = await kubectl(args, kubectlOptions);
 	return result.ok ? {

package/dist/commands/pipeline-command.js

@@ -17,7 +17,7 @@ function registerConfiguredEntrypointCommands(program, config, runEntrypoint) {
 	for (const [id, entrypoint] of Object.entries(config.entrypoints)) {
 		if (reservedCommands.has(id)) continue;
 		const command = program.command(id).description(entrypoint.description ?? `Run the ${id} workflow`).argument("<description...>", "task description");
-		if ("schedule" in entrypoint) command.option("--namespace <namespace>", "Workflow namespace").option("--schedule <path>", "approved schedule YAML to submit").option("--kubeconfig <path>", "kubeconfig path").option("--queue-name <name>", "Kueue LocalQueue label for Workflow pods").option("--service-account <name>", "Workflow service account").option("--image <image>", "runner image").option("--image-pull-policy <policy>", "runner image pull policy").option("--image-pull-secret <name>", "imagePullSecret name").option("--event-url <url>", "runner event sink URL");
+		if ("schedule" in entrypoint) command.option("--namespace <namespace>", "Workflow namespace").option("--schedule <path>", "approved schedule YAML to submit").option("--kubeconfig <path>", "kubeconfig path").option("--service-account <name>", "Workflow service account").option("--image <image>", "runner image").option("--image-pull-policy <policy>", "runner image pull policy").option("--image-pull-secret <name>", "imagePullSecret name").option("--event-url <url>", "runner event sink URL");
 		command.action(async (descriptionParts, flags) => {
 			await runEntrypoint(id, descriptionParts.join(" "), flags);
 		});

package/dist/config/schemas.d.ts

@@ -220,8 +220,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";
@@ -245,8 +245,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>;
@@ -289,10 +289,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>;
@@ -361,10 +361,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/install-commands/opencode.js

@@ -1,7 +1,7 @@
 import { DEFAULT_OPENCODE_ECOSYSTEM_MANIFEST } from "../config/defaults.js";
 import { resolvePackageAssetPath } from "../package-assets.js";
 import "../config.js";
-import { compileWorkflowPlan } from "../workflow-planner.js";
+import { compileWorkflowPlan } from "../planning/compile.js";
 import { mergeOpenCodeProjectConfig } from "../opencode-project-config.js";
 import { renderOpenCodeGatewayConfig } from "../mcp/gateway.js";
 import { opencodeAgentName } from "../runtime/opencode-agent-name.js";
@@ -93,12 +93,13 @@ function nativeAgentIdForHost(host, profileId) {
 	return host === "opencode" ? opencodeAgentName(profileId) : profileId;
 }
 function grants(actor) {
+	const listGrant = (values) => (values ?? []).join(", ") || "none";
 	return [
 		`model: ${actor.model ?? "default"}`,
-		`tools: ${(actor.tools ?? []).join(", ") || "none"}`,
-		`rules: ${(actor.rules ?? []).join(", ") || "none"}`,
-		`skills: ${(actor.skills ?? []).join(", ") || "none"}`,
-		`mcp_servers: ${(actor.mcp_servers ?? []).join(", ") || "none"}`,
+		`tools: ${listGrant(actor.tools)}`,
+		`rules: ${listGrant(actor.rules)}`,
+		`skills: ${listGrant(actor.skills)}`,
+		`mcp_servers: ${listGrant(actor.mcp_servers)}`,
 		`filesystem: ${actor.filesystem?.mode ?? "default"}`,
 		`network: ${actor.network?.mode ?? "default"}`,
 		..."output" in actor ? [`output: ${actor.output?.format ?? "text"}`] : []
@@ -149,10 +150,19 @@ function scheduledEntrypointK8sNote(entrypoint) {
 	if ("workflow" in entrypoint) return;
 	return "Submit Momokaya work as Argo Workflows through `moka submit` and `moka submit --quick`.";
 }
-function orchestratorEntrypointDispatchBlock(host, config) {
-	const scheduledEntrypoints = entrypointEntries(config).filter(([, entrypoint]) => !("workflow" in entrypoint));
-	if (scheduledEntrypoints.length === 0) return dispatchBlock(host, config);
-	return scheduledEntrypoints.map(([id, entrypoint]) => entrypointDispatchBlock(host, config, id, entrypoint)).filter((block) => Boolean(block)).join("\n\n");
+function localRosterAgentIds(config) {
+	return nativeProfileEntries("opencode", config).map(([id]) => nativeAgentIdForHost("opencode", id));
+}
+function localOrchestratorDispatchBlock(config) {
+	return [
+		"Orchestrate locally. Load and follow the `orchestrate` skill.",
+		"Do not submit to Argo or run `moka submit`. Spawn the roster as native Task subagents on this machine and run nodes with satisfied dependencies in parallel.",
+		"",
+		"Roster (Task tool subagent_type):",
+		...localRosterAgentIds(config).map((id) => `- ${id}`),
+		"",
+		"Gather each subagent's structured output, enforce only package-configured gates, and report only the evidence the subagents returned."
+	].join("\n");
 }
 function nativeDispatchBlock(host, routes) {
 	if (routes.length === 0) return;
@@ -325,13 +335,13 @@ function opencodeDefinitions(config, cwd) {
 				description: "Orchestrate the configured pipeline and enforce gates.",
 				mode: "primary",
 				name: OPENCODE_ORCHESTRATOR_AGENT_ID,
-				permission: opencodePermission(orchestrator, { allowedTaskAgents: agentDispatchRoutes("opencode", config).filter((route) => route.kind !== "cli").map((route) => route.nativeAgentId).filter((id) => Boolean(id)) })
+				permission: opencodePermission(orchestrator, { allowedTaskAgents: localRosterAgentIds(config) })
 			}, compactLines([
 				header("opencode").trimEnd(),
 				"",
 				orchestratorBlock(config),
 				"",
-				orchestratorEntrypointDispatchBlock("opencode", config)
+				localOrchestratorDispatchBlock(config)
 			]).join("\n")),
 			host: "opencode",
 			invocation: invocationForHost("opencode"),
@@ -382,6 +392,7 @@ function projectAgentsMdDefinition(cwd, host) {
 			"- Use `/moka-quick`, `/moka-execute`, or `/moka-inspect` for OpenCode slash-command entrypoints when available.",
 			"- Load and follow the relevant skill from `.agents/skills` before doing specialized work.",
 			"- Prefer the package-defined pipeline profiles and generated command surfaces over ad hoc subagent prompts.",
+			"- When the user needs to run a command, copy the command into the clipboard and tell the user what needs to be returned.",
 			"",
 			"## Pipeline Memory",
 			"",

package/dist/moka-global-config.d.ts

@@ -16,7 +16,6 @@ declare const mokaGlobalConfigSchema: z.ZodObject<{
       githubAuthSecretName: z.ZodString;
       imagePullSecretName: z.ZodString;
       opencodeAuthSecretName: z.ZodString;
-      queueName: z.ZodString;
       serviceAccountName: z.ZodString;
     }, z.core.$strict>;
   }, z.core.$strict>;

package/dist/moka-global-config.js

@@ -15,7 +15,6 @@ const mokaSubmitGlobalConfigSchema = z.object({
 	githubAuthSecretName: z.string().min(1),
 	imagePullSecretName: z.string().min(1),
 	opencodeAuthSecretName: z.string().min(1),
-	queueName: z.string().min(1),
 	serviceAccountName: z.string().min(1)
 }).strict();
 const mokaKubernetesGlobalConfigSchema = z.object({

package/dist/moka-submit.d.ts

@@ -1,17 +1,17 @@
 import { PipelineConfig } from "./config/schemas.js";
-import { generateScheduleArtifact } from "./schedule/planner.js";
+import { generateScheduleArtifact } from "./planning/generate.js";
 import { z } from "zod";
 
 //#region src/moka-submit.d.ts
 declare const mokaSubmitDirectHooksSchema: z.ZodRecord<z.ZodEnum<{
   "workflow.start": "workflow.start";
-  "node.finish": "node.finish";
-  "node.start": "node.start";
   "workflow.success": "workflow.success";
   "workflow.failure": "workflow.failure";
   "workflow.complete": "workflow.complete";
+  "node.start": "node.start";
   "node.success": "node.success";
   "node.error": "node.error";
+  "node.finish": "node.finish";
   "gate.failure": "gate.failure";
 }> & z.core.$partial, z.ZodDiscriminatedUnion<[z.ZodObject<{
   failure: z.ZodDefault<z.ZodEnum<{
@@ -94,13 +94,13 @@ declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   }, z.core.$strict>>;
   hooks: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
     "workflow.start": "workflow.start";
-    "node.finish": "node.finish";
-    "node.start": "node.start";
     "workflow.success": "workflow.success";
     "workflow.failure": "workflow.failure";
     "workflow.complete": "workflow.complete";
+    "node.start": "node.start";
     "node.success": "node.success";
     "node.error": "node.error";
+    "node.finish": "node.finish";
     "gate.failure": "gate.failure";
   }> & z.core.$partial, z.ZodDiscriminatedUnion<[z.ZodObject<{
     failure: z.ZodDefault<z.ZodEnum<{
@@ -148,7 +148,6 @@ declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   name: z.ZodOptional<z.ZodString>;
   namespace: z.ZodOptional<z.ZodString>;
   opencodeAuthSecretName: z.ZodOptional<z.ZodString>;
-  queueName: z.ZodOptional<z.ZodString>;
   repository: z.ZodOptional<z.ZodObject<{
     baseBranch: z.ZodString;
     sha: z.ZodOptional<z.ZodString>;
@@ -207,13 +206,13 @@ declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   }, z.core.$strict>>;
   hooks: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
     "workflow.start": "workflow.start";
-    "node.finish": "node.finish";
-    "node.start": "node.start";
     "workflow.success": "workflow.success";
     "workflow.failure": "workflow.failure";
     "workflow.complete": "workflow.complete";
+    "node.start": "node.start";
     "node.success": "node.success";
     "node.error": "node.error";
+    "node.finish": "node.finish";
     "gate.failure": "gate.failure";
   }> & z.core.$partial, z.ZodDiscriminatedUnion<[z.ZodObject<{
     failure: z.ZodDefault<z.ZodEnum<{
@@ -261,7 +260,6 @@ declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   name: z.ZodOptional<z.ZodString>;
   namespace: z.ZodOptional<z.ZodString>;
   opencodeAuthSecretName: z.ZodOptional<z.ZodString>;
-  queueName: z.ZodOptional<z.ZodString>;
   repository: z.ZodOptional<z.ZodObject<{
     baseBranch: z.ZodString;
     sha: z.ZodOptional<z.ZodString>;
@@ -327,7 +325,6 @@ interface MokaWorkflowSubmitOptions {
   namespace: string;
   opencodeAuthSecretName?: string;
   payloadJson: string;
-  queueName?: string;
   scheduleYaml: string;
   serviceAccountName?: string;
 }

package/dist/moka-submit.js

@@ -1,7 +1,6 @@
 import { normalizeRunnerRepositoryForSubmit } from "./git-remote-url.js";
+import { compileScheduleArtifact, generateScheduleArtifact, parseScheduleArtifact } from "./planning/generate.js";
 import { buildRunnerCommandPayload, runnerDeliverySchema, runnerHookPolicySchema, runnerRepositoryContextSchema, runnerRunIdentitySchema, runnerTaskSchema } from "./runner-command-contract.js";
-import { compileScheduleArtifact, generateScheduleArtifact, parseScheduleArtifact } from "./schedule/planner.js";
-import "./schedule-planner.js";
 import { workflowSubmitResultSchema } from "./workflow-submit-contract.js";
 import { buildCommandScheduleYaml, submitRunnerArgoWorkflow } from "./argo-submit.js";
 import { z } from "zod";
@@ -79,7 +78,6 @@ const mokaSubmitBaseOptionsSchema = z.object({
 	name: z.string().min(1).optional(),
 	namespace: z.string().min(1).optional(),
 	opencodeAuthSecretName: z.string().min(1).optional(),
-	queueName: z.string().min(1).optional(),
 	repository: runnerRepositoryContextSchema.optional(),
 	run: runnerRunIdentitySchema.optional(),
 	serviceAccountName: z.string().min(1).optional()
@@ -293,7 +291,6 @@ function workflowSubmitOptions(options) {
 		name: options.name,
 		namespace: requireSubmitOption(options.namespace, "namespace"),
 		opencodeAuthSecretName: options.opencodeAuthSecretName,
-		queueName: options.queueName,
 		serviceAccountName: options.serviceAccountName
 	};
 }

package/dist/pipeline-runtime.d.ts

@@ -1,6 +1,15 @@
 import { PipelineConfigError } from "./config/schemas.js";
 import { AcceptanceCriterion, HookRuntimePolicy, NodeExecutionState, NodeStatus, PipelineRuntimeEvent, PipelineRuntimeObservabilityLevel, PipelineRuntimeOptions, PipelineRuntimeResult, PipelineTaskContext, RuntimeFailure, RuntimeGateResult, RuntimeNodeResult, RuntimeStructuredOutput } from "./runtime/contracts/contracts.js";
 //#region src/pipeline-runtime.d.ts
+/**
+ * Top layer of the runtime-options stack (PIPE-74 B3). Extends
+ * {@link PipelineRuntimeOptions} for the schedule-driven path that runs a
+ * SINGLE workflow node (`nodeId`) in isolation, supplying that node's upstream
+ * `dependencyOutputs`. Full stack:
+ *   RunnerExecutionOptions (src/runner.ts)
+ *     < PipelineRuntimeOptions (src/runtime/contracts/contracts.ts)
+ *     < ScheduledWorkflowTaskRuntimeOptions (this type)
+ */
 interface ScheduledWorkflowTaskRuntimeOptions extends PipelineRuntimeOptions {
   dependencyOutputs?: Map<string, string> | Record<string, string>;
   nodeId: string;

package/dist/planned-node.js

@@ -1,10 +1,7 @@
+import { findNode } from "./planning/graph.js";
 //#region src/planned-node.ts
 function findPlannedNode(nodes, nodeId) {
-	for (const node of nodes) {
-		if (node.id === nodeId) return node;
-		const child = findPlannedNode(node.children ?? [], nodeId);
-		if (child) return child;
-	}
+	return findNode(nodes, nodeId, (node) => node.children);
 }
 //#endregion
 export { findPlannedNode };

package/dist/{workflow-planner.d.ts → planning/compile.d.ts}

@@ -1,7 +1,7 @@
-import { PipelineConfig, WorkflowNodeKind } from "./config/schemas.js";
+import { PipelineConfig, WorkflowNodeKind } from "../config/schemas.js";
 import { Graph } from "@dagrejs/graphlib";
 
-//#region src/workflow-planner.d.ts
+//#region src/planning/compile.d.ts
 type WorkflowPlannerErrorCode = "WORKFLOW_CYCLE" | "WORKFLOW_DUPLICATE_NODE" | "WORKFLOW_GROUP_REFERENCE" | "WORKFLOW_MISSING_DEPENDENCY" | "WORKFLOW_MISSING_WORKFLOW";
 interface WorkflowPlannerIssue {
   message: string;

package/dist/{workflow-planner.js → planning/compile.js}

@@ -1,6 +1,7 @@
-import { uniqueStrings } from "./strings.js";
+import { uniqueStrings } from "../strings.js";
+import { findDependencyCycles } from "./graph.js";
 import { Graph } from "@dagrejs/graphlib";
-//#region src/workflow-planner.ts
+//#region src/planning/compile.ts
 var WorkflowPlannerError = class extends Error {
 	code;
 	issues;
@@ -54,7 +55,7 @@ function validateNodeGraph(workflowId, nodes) {
 		...groupIssues(workflowId, nodes, nodeIds),
 		...dependencyIssues(workflowId, nodes, nodeIds)
 	];
-	if (duplicateIssues.length === 0) return [...issues, ...cycleIssues(workflowId, nodes, nodeIds)];
+	if (duplicateIssues.length === 0) return [...issues, ...cycleIssues(workflowId, nodes)];
 	return issues;
 }
 function duplicateNodeIssues(workflowId, nodes) {
@@ -100,92 +101,14 @@ function groupChildIssues(workflowId, node, nodeIds) {
 function isGroupNode(node) {
 	return node.kind === "group";
 }
-function cycleIssues(workflowId, nodes, nodeIds) {
-	return dependencyCycles(nodes, nodeIds).map((cycle) => {
+function cycleIssues(workflowId, nodes) {
+	return findDependencyCycles(nodes).map((cycle) => {
 		return {
 			path: `workflows.${workflowId}.nodes.${cycle[0] ?? "nodes"}.needs`,
 			message: `workflow '${workflowId}' contains dependency cycle: ${cycle.join(" -> ")}`
 		};
 	});
 }
-function dependencyCycles(nodes, nodeIds) {
-	const dependentsByNeed = dependentsByNeedMap(nodes, nodeIds);
-	const state = /* @__PURE__ */ new Map();
-	const path = [];
-	const pathIndex = /* @__PURE__ */ new Map();
-	const cycles = [];
-	const cycleKeys = /* @__PURE__ */ new Set();
-	for (const node of nodes) {
-		if (state.has(node.id)) continue;
-		visitForCycles(node.id, {
-			cycleKeys,
-			cycles,
-			dependentsByNeed,
-			path,
-			pathIndex,
-			state
-		});
-	}
-	return cycles;
-}
-function visitForCycles(startId, visitState) {
-	const frames = [{
-		index: 0,
-		nodeId: startId
-	}];
-	markVisiting(startId, visitState);
-	while (frames.length > 0) {
-		const frame = frames.at(-1);
-		if (!frame) return;
-		const dependentId = (visitState.dependentsByNeed.get(frame.nodeId) ?? [])[frame.index];
-		if (!dependentId) {
-			markDone(frame.nodeId, visitState);
-			frames.pop();
-			continue;
-		}
-		frame.index += 1;
-		const dependentState = visitState.state.get(dependentId);
-		if (dependentState === "visiting") {
-			recordCycle(dependentId, visitState);
-			continue;
-		}
-		if (dependentState === "done") continue;
-		markVisiting(dependentId, visitState);
-		frames.push({
-			index: 0,
-			nodeId: dependentId
-		});
-	}
-}
-function markVisiting(nodeId, visitState) {
-	visitState.state.set(nodeId, "visiting");
-	visitState.pathIndex.set(nodeId, visitState.path.length);
-	visitState.path.push(nodeId);
-}
-function markDone(nodeId, visitState) {
-	visitState.state.set(nodeId, "done");
-	visitState.pathIndex.delete(nodeId);
-	visitState.path.pop();
-}
-function recordCycle(nodeId, visitState) {
-	const startIndex = visitState.pathIndex.get(nodeId);
-	if (startIndex === void 0) return;
-	const cycle = visitState.path.slice(startIndex);
-	const key = [...cycle].sort().join("\0");
-	if (visitState.cycleKeys.has(key)) return;
-	visitState.cycleKeys.add(key);
-	visitState.cycles.push(cycle);
-}
-function dependentsByNeedMap(nodes, nodeIds) {
-	const dependentsByNeed = /* @__PURE__ */ new Map();
-	for (const node of nodes) for (const need of uniqueStrings(node.needs ?? [])) {
-		if (!nodeIds.has(need)) continue;
-		const dependents = dependentsByNeed.get(need) ?? [];
-		dependents.push(node.id);
-		dependentsByNeed.set(need, dependents);
-	}
-	return dependentsByNeed;
-}
 function topologicalOrderForPlan(graph) {
 	const visited = /* @__PURE__ */ new Set();
 	const inStack = /* @__PURE__ */ new Set();

package/dist/{schedule/planner.d.ts → planning/generate.d.ts}

@@ -1,9 +1,9 @@
 import { PipelineConfig } from "../config/schemas.js";
-import { WorkflowExecutionPlan } from "../workflow-planner.js";
+import { WorkflowExecutionPlan } from "./compile.js";
 import { AgentResult, RunnerExecutionOptions, RunnerLaunchPlan } from "../runner.js";
 import { z } from "zod";
 
-//#region src/schedule/planner.d.ts
+//#region src/planning/generate.d.ts
 declare const scheduleArtifactSchema: z.ZodObject<{
   generated_at: z.ZodString;
   kind: z.ZodLiteral<"pipeline-schedule">;
@@ -1575,6 +1575,20 @@ interface GenerateScheduleResult {
   artifact: ScheduleArtifact;
   path: string;
 }
+interface BacklogWorkUnit {
+  acceptance_criteria: Array<{
+    id: string;
+    text: string;
+  }>;
+  dependencies?: string[];
+  description?: string;
+  id: string;
+  title?: string;
+}
+interface SchedulePlanningContext {
+  parentWorkUnits: BacklogWorkUnit[];
+  workUnits: BacklogWorkUnit[];
+}
 declare function parseScheduleArtifact(source: string, sourcePath?: string): ScheduleArtifact;
 declare class ScheduleArtifactError extends Error {
   constructor(message: string);
@@ -1583,4 +1597,4 @@ declare function compileScheduleArtifact(config: PipelineConfig, artifact: Sched
 declare function generateScheduleArtifact(options: GenerateScheduleOptions): Promise<GenerateScheduleResult>;
 declare function scheduleArtifactPath(worktreePath: string, scheduleId: string): string;
 //#endregion
-export { CompiledScheduleArtifact, GenerateScheduleOptions, GenerateScheduleResult, ScheduleArtifact, ScheduleArtifactError, compileScheduleArtifact, generateScheduleArtifact, parseScheduleArtifact, scheduleArtifactPath };
+export { BacklogWorkUnit, CompiledScheduleArtifact, GenerateScheduleOptions, GenerateScheduleResult, ScheduleArtifact, ScheduleArtifactError, SchedulePlanningContext, compileScheduleArtifact, generateScheduleArtifact, parseScheduleArtifact, scheduleArtifactPath };

package/dist/{schedule/planner.js → planning/generate.js}

@@ -3,20 +3,22 @@ import { validatePipelineConfig } from "../config/validate.js";
 import "../config.js";
 import { createRunnerLaunchPlan, runLaunchPlan } from "../runner.js";
 import { normalizeRunnerOutput } from "../runner-output.js";
-import { compileWorkflowPlan } from "../workflow-planner.js";
-import { loadBacklogPlanningContext } from "./backlog-context.js";
-import { baselineScheduleArtifact } from "./baseline.js";
-import { addGeneratedImplementationCoverage } from "./passes/coverage.js";
-import { canonicalizeGeneratedScheduleIds } from "./passes/ids.js";
-import { SCHEDULE_PASS_ORDER } from "./passes/index.js";
-import { applyNodeCatalogModelFallbacks } from "./passes/models.js";
-import { namespaceScheduleWorkflows } from "./passes/references.js";
-import { plannerPrompt, plannerRepairPrompt } from "./prompts.js";
+import { loadBacklogPlanningContext } from "../schedule/backlog-context.js";
+import { baselineScheduleArtifact } from "../schedule/baseline.js";
+import { dependentsByNeed, flattenNodes, hasReachableDependent } from "./graph.js";
+import { isCoverageNode, isImplementationNode } from "../schedule/scheduling-roles.js";
+import { addGeneratedImplementationCoverage } from "../schedule/passes/coverage.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 { namespaceScheduleWorkflows } from "../schedule/passes/references.js";
+import { plannerPrompt, plannerRepairPrompt } from "../schedule/prompts.js";
+import { compileWorkflowPlan } from "./compile.js";
 import { parseDocument, stringify } from "yaml";
 import { z } from "zod";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-//#region src/schedule/planner.ts
+//#region src/planning/generate.ts
 const SCHEDULE_KIND = "pipeline-schedule";
 const ID_RE = /^[a-z][a-z0-9-]*$/;
 const SCHEDULE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9_.-]*$/;
@@ -253,9 +255,9 @@ function unsafeParallelWorktreeIssues(config, artifact) {
 }
 function workflowNodeIssues(artifact, collectIssues) {
 	return Object.entries(artifact.workflows).flatMap(([workflowId, workflow]) => {
-		const nodes = workflow.nodes.flatMap(flattenWorkflowNode);
+		const nodes = flattenWorkflowNodes(workflow.nodes);
 		return collectIssues({
-			dependentsByNeed: workflowDependentsByNeed(nodes),
+			dependentsByNeed: dependentsByNeed(nodes),
 			nodes,
 			workflowId
 		});
@@ -267,20 +269,8 @@ function isWriteCapableParallelChild(config, node) {
 	if (node.kind === "parallel") return node.nodes.some((child) => isWriteCapableParallelChild(config, child));
 	return false;
 }
-function hasDownstreamDrainMerge(nodeId, dependentsByNeed) {
-	return hasReachableDependent(nodeId, dependentsByNeed, (node) => node.kind === "builtin" && node.builtin === "drain-merge");
-}
-function hasReachableDependent(nodeId, dependentsByNeed, matches) {
-	const queue = [...dependentsByNeed.get(nodeId) ?? []];
-	const seen = /* @__PURE__ */ new Set();
-	while (queue.length > 0) {
-		const node = queue.shift();
-		if (!node || seen.has(node.id)) continue;
-		seen.add(node.id);
-		if (matches(node)) return true;
-		queue.push(...dependentsByNeed.get(node.id) ?? []);
-	}
-	return false;
+function hasDownstreamDrainMerge(nodeId, index) {
+	return hasReachableDependent(nodeId, index, (node) => node.kind === "builtin" && node.builtin === "drain-merge");
 }
 function generatedRootWorkflowIssues(artifact) {
 	const workflowIds = Object.keys(artifact.workflows);
@@ -331,15 +321,15 @@ function workUnitDependencyIssues(config, artifact, workUnits) {
 	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 nodes = flattenWorkflowNodes(workflow.nodes);
+		const index = dependentsByNeed(nodes);
 		const nodesByWorkUnit = nodesByAssignedWorkUnit(nodes);
 		return nodes.filter((node) => isImplementationNode(config, node)).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(", ")}`];
+				return prerequisiteNodes.some((source) => hasReachableDependent(source.id, index, (candidate) => candidate.id === node.id)) ? [] : [`work unit dependency edge missing in '${workflowId}': '${dependentId}' node '${node.id}' must depend on prerequisite '${prerequisiteId}' nodes ${prerequisiteNodes.map((prerequisite) => `'${prerequisite.id}'`).join(", ")}`];
 			});
 		});
 	});
@@ -355,9 +345,6 @@ function nodesByAssignedWorkUnit(nodes) {
 	}
 	return grouped;
 }
-function hasPathToNode(sourceId, targetId, dependentsByNeed) {
-	return hasReachableDependent(sourceId, dependentsByNeed, (node) => node.id === targetId);
-}
 function unsupportedGeneratedBuiltinIssues(artifact) {
 	const allowed = new Set(SCHEDULE_BUILTINS);
 	return allWorkflowNodes(artifact.workflows).flatMap((node) => {
@@ -369,33 +356,14 @@ function unsupportedGeneratedBuiltinIssues(artifact) {
 function implementationCoverageIssues(config, artifact) {
 	return workflowNodeIssues(artifact, ({ dependentsByNeed, nodes, workflowId }) => nodes.filter((node) => isImplementationNode(config, node)).filter((node) => !hasDownstreamCoverage(config, node.id, dependentsByNeed)).map((node) => `implementation node '${workflowId}.${node.id}' is without downstream verification or review`));
 }
-function isImplementationNode(config, node) {
-	return hasSchedulingRole(config, node, "implementation");
-}
-function workflowDependentsByNeed(nodes) {
-	const dependentsByNeed = /* @__PURE__ */ new Map();
-	for (const node of nodes) for (const need of node.needs ?? []) {
-		const dependents = dependentsByNeed.get(need) ?? [];
-		dependents.push(node);
-		dependentsByNeed.set(need, dependents);
-	}
-	return dependentsByNeed;
-}
-function hasDownstreamCoverage(config, nodeId, dependentsByNeed) {
-	return hasReachableDependent(nodeId, dependentsByNeed, (node) => isCoverageNode(config, node));
-}
-function isCoverageNode(config, node) {
-	return hasSchedulingRole(config, node, "coverage");
-}
-function hasSchedulingRole(config, node, role) {
-	if (node.kind !== "agent") return false;
-	return config.profiles[node.profile]?.scheduling_roles?.includes(role) ?? false;
+function hasDownstreamCoverage(config, nodeId, index) {
+	return hasReachableDependent(nodeId, index, (node) => isCoverageNode(config, node));
 }
 function allWorkflowNodes(workflows) {
-	return Object.values(workflows).flatMap((workflow) => workflow.nodes.flatMap(flattenWorkflowNode));
+	return Object.values(workflows).flatMap((workflow) => flattenWorkflowNodes(workflow.nodes));
 }
-function flattenWorkflowNode(node) {
-	return node.kind === "parallel" ? [node, ...node.nodes.flatMap(flattenWorkflowNode)] : [node];
+function flattenWorkflowNodes(nodes) {
+	return flattenNodes(nodes, (node) => node.kind === "parallel" ? node.nodes : void 0);
 }
 //#endregion
 export { ScheduleArtifactError, compileScheduleArtifact, generateScheduleArtifact, parseScheduleArtifact, scheduleArtifactPath };