@oisincoveney/pipeline 3.24.2 → 4.0.0

package/dist/planning/generate.js

@@ -1,6 +1,7 @@
 import { uniqueGeneratedId } from "../strings.js";
 import { dependentsByNeed, flattenNodes, hasReachableDependent } from "./graph.js";
-import { workflowSchema } from "../config/schemas.js";
+import { parseResultWithSchema, regexString, requiredString, struct } from "../schema-boundary.js";
+import { configIssuesFromSchemaIssues, workflowSchema } from "../config/schemas.js";
 import { validatePipelineConfig } from "../config/validate.js";
 import "../config.js";
 import { ensurePipelineWorkspaceIgnore } from "../run-control/workspace.js";
@@ -10,8 +11,8 @@ import { createRunnerLaunchPlan } from "../runner.js";
 import { normalizeRunnerOutput } from "../runner-output.js";
 import { loadBacklogPlanningContext } from "../schedule/backlog-context.js";
 import { baselineScheduleArtifact } from "../schedule/baseline.js";
-import { isCoverageNode, isImplementationNode, isWriteCapableParallelChild } from "../schedule/scheduling-roles.js";
-import { addGeneratedImplementationCoverage } from "../schedule/passes/coverage.js";
+import { isImplementationNode, isWriteCapableParallelChild } from "../schedule/scheduling-roles.js";
+import { addGeneratedImplementationCoverage, hasDownstreamCoverage } from "../schedule/passes/coverage.js";
 import { integrateParallelWriteFanout } from "../schedule/passes/drain-merge.js";
 import { canonicalizeGeneratedScheduleIds } from "../schedule/passes/ids.js";
 import { SCHEDULE_PASS_ORDER } from "../schedule/passes/index.js";
@@ -19,16 +20,18 @@ import { applyNodeCatalogModelFallbacks } from "../schedule/passes/models.js";
 import { appendPullRequestDelivery, shouldAppendPullRequestDelivery } from "../schedule/passes/open-pull-request.js";
 import { namespaceScheduleWorkflows } from "../schedule/passes/references.js";
 import { plannerPrompt, plannerRepairPrompt } from "../schedule/prompts.js";
+import * as Option$1 from "effect/Option";
+import * as Schema from "effect/Schema";
 import { parseDocument, stringify } from "yaml";
-import { Data } from "effect";
-import { z } from "zod";
+import { isSuccess } from "effect/Result";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import * as Data from "effect/Data";
 //#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_.-]*$/;
-const MARKDOWN_YAML_FENCE_RE = /```(?:ya?ml)?\s*\r?\n([\s\S]*?)\r?\n```/i;
+const ID_RE = /^[a-z][a-z0-9-]*$/u;
+const SCHEDULE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9_.-]*$/u;
+const MARKDOWN_YAML_FENCE_RE = /```(?:ya?ml)?\s*\r?\n([\s\S]*?)\r?\n```/iu;
 const SCHEDULE_PLANNER_REPAIR_ATTEMPTS = 1;
 const PREFERRED_IMPLEMENTATION_PROFILE_IDS = ["moka-code-writer"];
 const SCHEDULE_BUILTINS = [
@@ -42,16 +45,20 @@ const SCHEDULE_BUILTINS = [
 	"typecheck"
 ];
 const PARALLEL_MERGE_BUILTINS = /* @__PURE__ */ new Set(["drain-merge"]);
-const scheduleArtifactSchema = z.object({
-	generated_at: z.string().datetime(),
-	kind: z.literal(SCHEDULE_KIND),
-	root_workflow: z.string().regex(ID_RE),
-	schedule_id: z.string().regex(SCHEDULE_ID_RE),
-	source_entrypoint: z.string().regex(ID_RE),
-	task: z.string().min(1),
-	version: z.literal(1),
-	workflows: z.record(z.string().regex(ID_RE), workflowSchema)
-}).strict();
+const scheduleArtifactSchema = struct({
+	generated_at: requiredString.check(Schema.makeFilter((value) => isSuccess(Schema.decodeUnknownResult(Schema.DateTimeUtcFromString)(value)) || "must be an ISO datetime string", {
+		description: "ISO datetime string accepted by Effect DateTime parsing.",
+		identifier: "ScheduleArtifactDateTimeString",
+		title: "Schedule artifact datetime string"
+	})),
+	kind: Schema.Literal(SCHEDULE_KIND),
+	root_workflow: regexString(ID_RE),
+	schedule_id: regexString(SCHEDULE_ID_RE),
+	source_entrypoint: regexString(ID_RE),
+	task: requiredString,
+	version: Schema.Literal(1),
+	workflows: Schema.Record(regexString(ID_RE), workflowSchema)
+});
 /**
 * A backlog ticket's frontmatter may declare dependencies on sibling tickets
 * that are not part of this run (e.g. submitting TOVA-766.03 alone when its
@@ -62,7 +69,7 @@ const scheduleArtifactSchema = z.object({
 * the same predicate workUnitDependencyIssues applies after generation — so the
 * planner prompt context and downstream validation stay consistent.
 */
-function pruneOutOfScopeDependencies(context) {
+const pruneOutOfScopeDependencies = (context) => {
 	const inScope = new Set([...context.parentWorkUnits, ...context.workUnits].map((unit) => unit.id));
 	const prune = (unit) => unit.dependencies ? {
 		...unit,
@@ -72,24 +79,27 @@ function pruneOutOfScopeDependencies(context) {
 		parentWorkUnits: context.parentWorkUnits.map(prune),
 		workUnits: context.workUnits.map(prune)
 	};
-}
-function parseScheduleArtifact(source, sourcePath = "schedule.yaml") {
+};
+var ScheduleArtifactError = class extends Data.TaggedError("ScheduleArtifactError") {
+	constructor(message) {
+		super({ message });
+	}
+};
+const parseScheduleArtifact = (source, sourcePath = "schedule.yaml") => {
 	const document = parseDocument(source, {
 		prettyErrors: false,
 		uniqueKeys: true
 	});
 	if (document.errors.length > 0) throw new ScheduleArtifactError(`Failed to parse ${sourcePath}: ${document.errors.map((err) => err.message).join("; ")}`);
-	const parsed = scheduleArtifactSchema.safeParse(document.toJS());
-	if (!parsed.success) throw new ScheduleArtifactError([`Invalid schedule artifact ${sourcePath}:`, ...parsed.error.issues.map((issue) => issue.path.length > 0 ? `- ${issue.path.join(".")}: ${issue.message}` : `- ${issue.message}`)].join("\n"));
-	return parsed.data;
-}
-var ScheduleArtifactError = class extends Data.TaggedError("ScheduleArtifactError") {
-	constructor(message) {
-		super({ message });
+	const parsed = parseResultWithSchema(scheduleArtifactSchema, document.toJS(), { onExcessProperty: "error" });
+	if (!parsed.ok) {
+		const issues = configIssuesFromSchemaIssues(parsed.issues);
+		throw new ScheduleArtifactError([`Invalid schedule artifact ${sourcePath}:`, ...issues.map((issue) => issue.path !== void 0 && issue.path !== "" ? `- ${issue.path}: ${issue.message}` : `- ${issue.message}`)].join("\n"));
 	}
+	return parsed.value;
 };
-function compileScheduleArtifact(config, artifact, projectRoot) {
-	if (!artifact.workflows[artifact.root_workflow]) throw new ScheduleArtifactError(`schedule root workflow '${artifact.root_workflow}' is not declared`);
+const compileScheduleArtifact = (config, artifact, projectRoot) => {
+	if (!Object.hasOwn(artifact.workflows, artifact.root_workflow)) throw new ScheduleArtifactError(`schedule root workflow '${artifact.root_workflow}' is not declared`);
 	const { scheduledWorkflows, workflowId } = namespaceScheduleWorkflows(artifact, ScheduleArtifactError);
 	const mergedConfig = validatePipelineConfig({
 		...structuredClone(config),
@@ -103,82 +113,40 @@ function compileScheduleArtifact(config, artifact, projectRoot) {
 		plan: compileWorkflowPlan(mergedConfig, workflowId),
 		workflowId
 	};
-}
-async function generateScheduleArtifact(options) {
-	const result = await generateScheduleArtifactInMemory(options);
-	return {
-		artifact: result.artifact,
-		path: persistScheduleArtifact(options.worktreePath, result.artifact)
-	};
-}
-async function generateScheduleArtifactInMemory(options) {
-	const entrypoint = options.config.entrypoints[options.entrypointId];
-	if (!(entrypoint && "schedule" in entrypoint)) throw new ScheduleArtifactError(`entrypoint '${options.entrypointId}' is not a scheduled entrypoint`);
-	const policy = options.config.schedules[entrypoint.schedule];
-	if (!policy) throw new ScheduleArtifactError(`schedule policy '${entrypoint.schedule}' is not declared`);
-	const baseline = baselineScheduleArtifact({
-		baseline: policy.baseline,
-		config: options.config,
-		entrypointId: options.entrypointId,
-		generatedAt: options.generatedAt ?? /* @__PURE__ */ new Date(),
-		runId: options.runId,
-		task: options.task
-	});
-	const planningContext = schedulePlanningContext({
-		task: options.task,
-		phaseContext: options.phaseContext,
-		worktreePath: options.worktreePath
-	});
-	const generatedArtifact = await planScheduleArtifact(baseline, policy.planner_profile, options, planningContext);
-	assertSchedulePassOrder();
-	const artifact = hydrateScheduleTaskContexts(canonicalizeGeneratedScheduleIds(applyNodeCatalogModelFallbacks(options.config, policy.node_catalog, appendPullRequestDelivery(shouldAppendPullRequestDelivery({
-		config: options.config,
-		requested: options.pullRequestDeliveryRequested
-	}), integrateParallelWriteFanout(options.config, addGeneratedImplementationCoverage(options.config, generatedArtifact))))), planningContext);
-	validateScheduleArtifact(options.config, artifact, planningContext);
-	compileScheduleArtifact(options.config, artifact, options.worktreePath);
+};
+const ticketPlanTaskWorkUnit = (task, localIds = /* @__PURE__ */ new Map()) => ({
+	acceptance_criteria: task.acceptance_criteria.map((criterion, index) => ({
+		id: `${task.key}-ac-${index + 1}`,
+		text: criterion.text
+	})),
+	dependencies: "depends_on" in task ? task.depends_on.flatMap((key) => {
+		const id = localIds.get(key);
+		return id === void 0 ? [] : [id];
+	}) : [],
+	description: task.description,
+	id: task.key,
+	title: task.title
+});
+const ticketPlanPlanningContext = (plan) => {
+	const localIds = new Map(plan.tickets.map((ticket) => [ticket.key, ticket.key]));
 	return {
-		artifact,
-		yaml: stringify(artifact)
+		parentWorkUnits: plan.epic ? [ticketPlanTaskWorkUnit(plan.epic)] : [],
+		workUnits: plan.tickets.map((ticket) => ticketPlanTaskWorkUnit(ticket, localIds))
 	};
-}
-function schedulePlanningContext(input) {
-	return pruneOutOfScopeDependencies(mergePhasePlanningContext(loadBacklogPlanningContext(input.task, input.worktreePath), input.phaseContext));
-}
-function mergePhasePlanningContext(base, phaseContext) {
-	const planned = phaseContext?.ticketPlan ? ticketPlanPlanningContext(phaseContext.ticketPlan) : {
+};
+const mergePhasePlanningContext = (base, phaseContext) => {
+	const planned = phaseContext?.ticketPlan === void 0 ? {
 		parentWorkUnits: [],
 		workUnits: []
-	};
+	} : ticketPlanPlanningContext(phaseContext.ticketPlan);
 	return {
 		parentWorkUnits: [...base.parentWorkUnits, ...planned.parentWorkUnits],
-		...phaseContext?.research ? { research: phaseContext.research } : {},
+		...phaseContext?.research === void 0 ? {} : { research: phaseContext.research },
 		workUnits: [...base.workUnits, ...planned.workUnits]
 	};
-}
-function ticketPlanPlanningContext(plan) {
-	const localIds = new Map(plan.tickets.map((ticket) => [ticket.key, ticket.key]));
-	return {
-		parentWorkUnits: plan.epic ? [ticketPlanTaskWorkUnit(plan.epic)] : [],
-		workUnits: plan.tickets.map((ticket) => ticketPlanTaskWorkUnit(ticket, localIds))
-	};
-}
-function ticketPlanTaskWorkUnit(task, localIds = /* @__PURE__ */ new Map()) {
-	return {
-		acceptance_criteria: task.acceptance_criteria.map((criterion, index) => ({
-			id: `${task.key}-ac-${index + 1}`,
-			text: criterion.text
-		})),
-		dependencies: "depends_on" in task ? task.depends_on.flatMap((key) => {
-			const id = localIds.get(key);
-			return id ? [id] : [];
-		}) : [],
-		description: task.description,
-		id: task.key,
-		title: task.title
-	};
-}
-function assertSchedulePassOrder() {
+};
+const schedulePlanningContext = (input) => pruneOutOfScopeDependencies(mergePhasePlanningContext(loadBacklogPlanningContext(input.task, input.worktreePath), input.phaseContext));
+const assertSchedulePassOrder = () => {
 	if (SCHEDULE_PASS_ORDER.join("\0") !== [
 		"coverage",
 		"drain-merge",
@@ -187,61 +155,30 @@ function assertSchedulePassOrder() {
 		"ids",
 		"references"
 	].join("\0")) throw new ScheduleArtifactError("Schedule pass order is misconfigured");
-}
-function persistScheduleArtifact(worktreePath, artifact) {
+};
+const persistScheduleArtifact = (worktreePath, artifact) => {
 	ensurePipelineWorkspaceIgnore(worktreePath);
 	const relativePath = join(".pipeline", "runs", artifact.schedule_id, "schedule.yaml");
 	const fullPath = join(worktreePath, relativePath);
 	mkdirSync(join(worktreePath, ".pipeline", "runs", artifact.schedule_id), { recursive: true });
 	writeFileSync(fullPath, stringify(artifact));
 	return relativePath;
-}
-function scheduleArtifactPath(worktreePath, scheduleId) {
-	return join(worktreePath, ".pipeline", "runs", scheduleId, "schedule.yaml");
-}
-async function planScheduleArtifact(baseline, plannerProfile, options, planningContext) {
-	const requiredPlannerProfile = requireSchedulePlannerProfile(plannerProfile, options.entrypointId);
-	const ticketPlanFallback = ticketPlanScheduleArtifact(baseline, options.config, planningContext, options.phaseContext);
-	const sourceResult = await runSchedulePlannerSource(requiredPlannerProfile, plannerPrompt(options.entrypointId, options.task, baseline, options.config, planningContext), options);
-	if (!sourceResult.ok) {
-		if (ticketPlanFallback) return ticketPlanFallback;
-		throw sourceResult.error;
-	}
-	const source = requireSchedulePlannerSource(sourceResult.source);
-	const initial = acceptedGeneratedSchedule(parseGeneratedSchedule(source, "planner output"));
-	if (initial.ok) return initial.artifact;
-	return scheduleArtifactAfterRepair(await repairInvalidScheduleArtifact({
-		baseline,
-		initialFailure: initial.error,
-		initialSource: source,
-		options,
-		plannerProfile: requiredPlannerProfile
-	}), ticketPlanFallback ?? baseline, initial.error, source);
-}
-async function runSchedulePlannerSource(plannerProfile, prompt, options) {
-	try {
-		return {
-			ok: true,
-			source: await runSchedulePlanner(plannerProfile, prompt, options)
-		};
-	} catch (err) {
-		if (err instanceof ScheduleArtifactError) return {
-			error: err,
-			ok: false
-		};
-		throw err;
-	}
-}
-function ticketPlanScheduleArtifact(baseline, config, planningContext, phaseContext) {
-	if (!phaseContext?.ticketPlan || planningContext.workUnits.length === 0) return;
+};
+const scheduleArtifactPath = (worktreePath, scheduleId) => join(worktreePath, ".pipeline", "runs", scheduleId, "schedule.yaml");
+const profileIdForSchedulingRole = (config, role, preferredIds) => {
+	const matchingIds = Object.entries(config.profiles).filter(([, profile]) => profile.scheduling_roles?.includes(role) === true).map(([id]) => id);
+	return preferredIds.find((id) => matchingIds.includes(id)) ?? matchingIds.toSorted()[0];
+};
+const ticketPlanScheduleArtifact = (baseline, config, planningContext, phaseContext) => {
+	if (phaseContext?.ticketPlan === void 0 || planningContext.workUnits.length === 0) return;
 	const implementationProfile = profileIdForSchedulingRole(config, "implementation", PREFERRED_IMPLEMENTATION_PROFILE_IDS);
-	if (!implementationProfile) throw new ScheduleArtifactError("Cannot generate TicketPlan schedule: no profile declares scheduling role 'implementation'");
+	if (implementationProfile === void 0) throw new ScheduleArtifactError("Cannot generate TicketPlan schedule: no profile declares scheduling role 'implementation'");
 	const usedIds = /* @__PURE__ */ new Set();
 	const nodeIdsByUnit = new Map(planningContext.workUnits.map((unit) => [unit.id, uniqueGeneratedId(`${unit.id}-implement`, usedIds, "work-implement")]));
 	const nodes = planningContext.workUnits.map((unit) => {
 		const needs = (unit.dependencies ?? []).flatMap((id) => {
 			const nodeId = nodeIdsByUnit.get(id);
-			return nodeId ? [nodeId] : [];
+			return nodeId === void 0 ? [] : [nodeId];
 		});
 		return {
 			id: nodeIdsByUnit.get(unit.id) ?? "work-implement",
@@ -259,20 +196,16 @@ function ticketPlanScheduleArtifact(baseline, config, planningContext, phaseCont
 			nodes
 		} }
 	};
-}
-function profileIdForSchedulingRole(config, role, preferredIds) {
-	const matchingIds = Object.entries(config.profiles).filter(([, profile]) => profile.scheduling_roles?.includes(role)).map(([id]) => id);
-	return preferredIds.find((id) => matchingIds.includes(id)) ?? matchingIds.sort()[0];
-}
-function requireSchedulePlannerProfile(plannerProfile, entrypointId) {
-	if (plannerProfile) return plannerProfile;
+};
+const requireSchedulePlannerProfile = (plannerProfile, entrypointId) => {
+	if (plannerProfile !== void 0 && plannerProfile.length > 0) return plannerProfile;
 	throw new ScheduleArtifactError(`schedule '${entrypointId}' requires planner_profile`);
-}
-function requireSchedulePlannerSource(source) {
-	if (source) return source;
+};
+const requireSchedulePlannerSource = (source) => {
+	if (source.length > 0) return source;
 	throw new ScheduleArtifactError("schedule planner returned empty output");
-}
-function scheduleArtifactAfterRepair(repair, baseline, initialFailure, initialSource) {
+};
+const scheduleArtifactAfterRepair = (repair, baseline, initialFailure, initialSource) => {
 	if (repair.kind === "accepted") return repair.artifact;
 	if (repair.kind === "fallback") return baseline;
 	throw new ScheduleArtifactError([
@@ -284,71 +217,37 @@ function scheduleArtifactAfterRepair(repair, baseline, initialFailure, initialSo
 		"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 runScheduleRepair(input, latestFailure, latestSource, attempt);
-		if (!repairedSource) return { kind: "fallback" };
-		const repaired = acceptedGeneratedSchedule(parseGeneratedSchedule(repairedSource, "planner repair output"));
-		if (repaired.ok) return {
-			artifact: repaired.artifact,
-			kind: "accepted"
-		};
-		latestFailure = repaired.error;
-		latestSource = repairedSource;
-	}
-	return {
-		kind: "invalid",
-		latestFailure,
-		latestSource
-	};
-}
-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 normalizeGeneratedScheduleSource = (source) => {
+	return MARKDOWN_YAML_FENCE_RE.exec(source)?.[1] ?? source;
+};
+const parseGeneratedSchedule = (source, sourcePath) => {
 	const parseableSource = normalizeGeneratedScheduleSource(source);
 	try {
 		return {
 			artifact: parseScheduleArtifact(parseableSource, sourcePath),
 			ok: true
 		};
-	} catch (err) {
-		if (!(err instanceof ScheduleArtifactError)) throw err;
+	} catch (error) {
+		if (!(error instanceof ScheduleArtifactError)) throw error;
 		return {
-			error: new ScheduleArtifactError(`${err.message}\nPlanner output:\n${source}`),
+			error: new ScheduleArtifactError(`${error.message}\nPlanner output:\n${source}`),
 			ok: false
 		};
 	}
-}
-function normalizeGeneratedScheduleSource(source) {
-	return MARKDOWN_YAML_FENCE_RE.exec(source)?.[1] ?? source;
-}
-function acceptedGeneratedSchedule(parsed) {
-	if (!parsed.ok) return parsed;
-	const builtinCheck = generatedBuiltinsSupported(parsed.artifact);
-	return builtinCheck.ok ? parsed : builtinCheck;
-}
-function generatedBuiltinsSupported(artifact) {
-	const issues = unsupportedGeneratedBuiltinIssues(artifact);
-	return issues.length === 0 ? { ok: true } : {
-		error: new ScheduleArtifactError(["Invalid generated schedule:", ...issues.map((issue) => `- ${issue}`)].join("\n")),
-		ok: false
-	};
-}
-async function runSchedulePlanner(plannerProfile, prompt, options, nodeId = "schedule-plan") {
+};
+const plannerFailureMessage = (plannerProfile, result) => {
+	const stderr = result.stderr?.trim() ?? "";
+	const stdout = result.stdout.trim();
+	const details = [
+		result.timedOut === true ? "timed out waiting for scheduler subprocess" : void 0,
+		stderr.length > 0 ? `stderr:\n${stderr}` : void 0,
+		stdout.length > 0 ? `stdout:\n${stdout}` : void 0
+	].filter((value) => value !== void 0);
+	const message = `schedule planner '${plannerProfile}' failed with exit ${result.exitCode}`;
+	return details.length === 0 ? message : `${message}\n${details.join("\n")}`;
+};
+const runSchedulePlanner = async (plannerProfile, prompt, options, nodeId = "schedule-plan") => {
 	const executor = options.executor ?? runLaunchPlan;
 	const plan = createRunnerLaunchPlan(options.config, {
 		nodeId,
@@ -359,72 +258,79 @@ async function runSchedulePlanner(plannerProfile, prompt, options, nodeId = "sch
 	const result = await executor(plan, {});
 	if (result.exitCode !== 0) throw new ScheduleArtifactError(plannerFailureMessage(plannerProfile, result));
 	return normalizeRunnerOutput(plan, result.stdout).output.trim();
-}
-function plannerFailureMessage(plannerProfile, result) {
-	const details = [
-		result.timedOut ? "timed out waiting for scheduler subprocess" : void 0,
-		result.stderr?.trim() ? `stderr:\n${result.stderr.trim()}` : void 0,
-		result.stdout.trim() ? `stdout:\n${result.stdout.trim()}` : void 0
-	].filter((value) => Boolean(value));
-	const message = `schedule planner '${plannerProfile}' failed with exit ${result.exitCode}`;
-	return details.length === 0 ? message : `${message}\n${details.join("\n")}`;
-}
-function validateScheduleArtifact(config, artifact, planningContext) {
-	const issues = [
-		...generatedRootWorkflowIssues(artifact),
-		...missingAssignedWorkUnitIssues(artifact, planningContext.workUnits),
-		...workUnitDependencyIssues(config, artifact, planningContext.workUnits),
-		...unsupportedGeneratedBuiltinIssues(artifact),
-		...implementationCoverageIssues(config, artifact),
-		...unsafeParallelWorktreeIssues(config, artifact)
-	];
-	if (issues.length > 0) throw new ScheduleArtifactError(["Invalid generated schedule:", ...issues.map((issue) => `- ${issue}`)].join("\n"));
-}
-function unsafeParallelWorktreeIssues(config, artifact) {
-	return workflowNodeIssues(artifact, ({ dependentsByNeed, nodes, workflowId }) => nodes.filter((node) => node.kind === "parallel").flatMap((node) => {
-		if (node.nodes.filter((child) => isWriteCapableParallelChild(config, child)).length <= 1) return [];
-		if (hasDownstreamDrainMerge(node.id, dependentsByNeed)) return [];
-		return [`parallel node '${workflowId}.${node.id}' has write-capable children sharing a worktree without isolated worktree roots or drain-merge integration`];
-	}));
-}
-function registerContainmentEdge(parent, child, index) {
+};
+const runSchedulePlannerSource = async (plannerProfile, prompt, options) => {
+	try {
+		return {
+			ok: true,
+			source: await runSchedulePlanner(plannerProfile, prompt, options)
+		};
+	} catch (error) {
+		if (error instanceof ScheduleArtifactError) return {
+			error,
+			ok: false
+		};
+		throw error;
+	}
+};
+const runScheduleRepair = async (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 (error) {
+		if (error instanceof ScheduleArtifactError) return;
+		throw error;
+	}
+};
+const registerContainmentEdge = (parent, child, index) => {
 	const dependents = index.get(child.id) ?? [];
 	dependents.push(parent);
 	index.set(child.id, dependents);
-}
-function addParallelContainmentEdges(nodes, index) {
+};
+const addParallelContainmentEdges = (nodes, index) => {
 	for (const node of nodes) {
 		if (node.kind !== "parallel") continue;
 		for (const child of node.nodes) registerContainmentEdge(node, child, index);
 		addParallelContainmentEdges(node.nodes, index);
 	}
-}
-function dependentsByNeedWithContainment(nested, flat) {
+};
+const dependentsByNeedWithContainment = (nested, flat) => {
 	const index = dependentsByNeed(flat);
 	addParallelContainmentEdges(nested, index);
 	return index;
-}
-function workflowNodeIssues(artifact, collectIssues) {
-	return Object.entries(artifact.workflows).flatMap(([workflowId, workflow]) => {
-		const nodes = flattenWorkflowNodes(workflow.nodes);
-		return collectIssues({
-			dependentsByNeed: dependentsByNeedWithContainment(workflow.nodes, nodes),
-			nodes,
-			workflowId
-		});
-	});
-}
-function hasDownstreamDrainMerge(nodeId, index) {
-	return hasReachableDependent(nodeId, index, (node) => node.kind === "builtin" && PARALLEL_MERGE_BUILTINS.has(node.builtin));
-}
-function generatedRootWorkflowIssues(artifact) {
+};
+const hasDownstreamDrainMerge = (nodeId, index) => hasReachableDependent(nodeId, index, (node) => node.kind === "builtin" && PARALLEL_MERGE_BUILTINS.has(node.builtin));
+const generatedRootWorkflowIssues = (artifact) => {
 	const workflowIds = Object.keys(artifact.workflows);
 	const issues = [];
 	if (artifact.root_workflow !== "root") issues.push("generated schedules must use root_workflow 'root'");
-	if (workflowIds.length !== 1 || !artifact.workflows.root) issues.push("generated schedules must embed exactly one task-specific workflow named 'root'");
+	if (workflowIds.length !== 1 || !Object.hasOwn(artifact.workflows, "root")) issues.push("generated schedules must embed exactly one task-specific workflow named 'root'");
 	return issues;
-}
-function hydrateScheduleTaskContexts(artifact, planningContext) {
+};
+const backlogWorkUnitTaskContext = (unit) => ({
+	...unit.acceptance_criteria.length > 0 ? { acceptance_criteria: unit.acceptance_criteria } : {},
+	...unit.description !== void 0 && unit.description.length > 0 ? { description: unit.description } : {},
+	id: unit.id,
+	...unit.title !== void 0 && unit.title.length > 0 ? { title: unit.title } : {}
+});
+const hydrateWorkflowNodeTaskContext = (node, contexts) => {
+	const contextId = node.task_context?.id;
+	const context = contextId !== void 0 && contextId.length > 0 ? contexts.get(contextId) : void 0;
+	const hydrated = context === void 0 ? node : {
+		...node,
+		task_context: context
+	};
+	if (hydrated.kind !== "parallel") return hydrated;
+	return {
+		...hydrated,
+		nodes: hydrated.nodes.map((child) => hydrateWorkflowNodeTaskContext(child, contexts))
+	};
+};
+const hydrateScheduleTaskContexts = (artifact, planningContext) => {
 	const contexts = new Map([...planningContext.parentWorkUnits, ...planningContext.workUnits].map((unit) => [unit.id, backlogWorkUnitTaskContext(unit)]));
 	if (contexts.size === 0) return artifact;
 	return {
@@ -434,34 +340,34 @@ function hydrateScheduleTaskContexts(artifact, planningContext) {
 			nodes: workflow.nodes.map((node) => hydrateWorkflowNodeTaskContext(node, contexts))
 		}]))
 	};
-}
-function backlogWorkUnitTaskContext(unit) {
-	return {
-		...unit.acceptance_criteria.length > 0 ? { acceptance_criteria: unit.acceptance_criteria } : {},
-		...unit.description ? { description: unit.description } : {},
-		id: unit.id,
-		...unit.title ? { title: unit.title } : {}
-	};
-}
-function hydrateWorkflowNodeTaskContext(node, contexts) {
-	const context = node.task_context?.id ? contexts.get(node.task_context.id) : void 0;
-	const hydrated = context ? {
-		...node,
-		task_context: context
-	} : node;
-	if (hydrated.kind !== "parallel") return hydrated;
-	return {
-		...hydrated,
-		nodes: hydrated.nodes.map((child) => hydrateWorkflowNodeTaskContext(child, contexts))
-	};
-}
-function missingAssignedWorkUnitIssues(artifact, workUnits) {
-	if (workUnits.length === 0) return [];
-	const assigned = new Set(allWorkflowNodes(artifact.workflows).map((node) => node.task_context?.id).filter((id) => Boolean(id)));
-	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(config, artifact, workUnits) {
+};
+const nodesByAssignedWorkUnit = (nodes) => {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const node of nodes) {
+		const id = node.task_context?.id;
+		if (id === void 0 || id.length === 0) continue;
+		const current = grouped.get(id) ?? [];
+		current.push(node);
+		grouped.set(id, current);
+	}
+	return grouped;
+};
+const flattenWorkflowNodes = (nodes) => flattenNodes(nodes, (node) => node.kind === "parallel" ? node.nodes : void 0);
+const workflowNodeIssues = (artifact, collectIssues) => Object.entries(artifact.workflows).flatMap(([workflowId, workflow]) => {
+	const nodes = flattenWorkflowNodes(workflow.nodes);
+	return collectIssues({
+		dependentsByNeed: dependentsByNeedWithContainment(workflow.nodes, nodes),
+		nodes,
+		workflowId
+	});
+});
+const implementationCoverageIssues = (config, artifact) => 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`));
+const unsafeParallelWorktreeIssues = (config, artifact) => workflowNodeIssues(artifact, ({ dependentsByNeed, nodes, workflowId }) => nodes.filter((node) => node.kind === "parallel").flatMap((node) => {
+	if (node.nodes.filter((child) => isWriteCapableParallelChild(config, child)).length <= 1) return [];
+	if (hasDownstreamDrainMerge(node.id, dependentsByNeed)) return [];
+	return [`parallel node '${workflowId}.${node.id}' has write-capable children sharing a worktree without isolated worktree roots or drain-merge integration`];
+}));
+const workUnitDependencyIssues = (config, 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))]));
@@ -471,44 +377,131 @@ function workUnitDependencyIssues(config, artifact, workUnits) {
 		const nodesByWorkUnit = nodesByAssignedWorkUnit(nodes);
 		return nodes.filter((node) => isImplementationNode(config, node)).flatMap((node) => {
 			const dependentId = node.task_context?.id;
-			if (!dependentId) return [];
+			if (dependentId === void 0 || dependentId.length === 0) return [];
 			return (dependenciesByUnit.get(dependentId) ?? []).flatMap((prerequisiteId) => {
 				const prerequisiteNodes = nodesByWorkUnit.get(prerequisiteId) ?? [];
 				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(", ")}`];
 			});
 		});
 	});
-}
-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 unsupportedGeneratedBuiltinIssues(artifact) {
+};
+const allWorkflowNodes = (workflows) => Object.values(workflows).flatMap((workflow) => flattenWorkflowNodes(workflow.nodes));
+const missingAssignedWorkUnitIssues = (artifact, workUnits) => {
+	if (workUnits.length === 0) return [];
+	const assigned = new Set(allWorkflowNodes(artifact.workflows).map((node) => node.task_context?.id).filter((id) => id !== void 0 && id.length > 0));
+	const missing = workUnits.map((unit) => unit.id).filter((id) => !assigned.has(id));
+	return missing.length > 0 ? [`missing assigned backlog work units: ${missing.join(", ")}`] : [];
+};
+const unsupportedGeneratedBuiltinIssues = (artifact) => {
 	const allowed = new Set(SCHEDULE_BUILTINS);
 	return allWorkflowNodes(artifact.workflows).flatMap((node) => {
 		const nodeBuiltinIssues = node.kind === "builtin" && !allowed.has(node.builtin) ? [`unsupported generated builtin '${node.builtin}' on node '${node.id}'. Allowed builtins: ${SCHEDULE_BUILTINS.join(", ")}`] : [];
 		const gateBuiltinIssues = (node.gates ?? []).flatMap((gate) => gate.kind === "builtin" && !allowed.has(gate.builtin) ? [`unsupported generated builtin gate '${gate.builtin}' on node '${node.id}' gate '${gate.id}'. Allowed builtins: ${SCHEDULE_BUILTINS.join(", ")}`] : []);
 		return [...nodeBuiltinIssues, ...gateBuiltinIssues];
 	});
-}
-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 hasDownstreamCoverage(config, nodeId, index) {
-	return hasReachableDependent(nodeId, index, (node) => isCoverageNode(config, node));
-}
-function allWorkflowNodes(workflows) {
-	return Object.values(workflows).flatMap((workflow) => flattenWorkflowNodes(workflow.nodes));
-}
-function flattenWorkflowNodes(nodes) {
-	return flattenNodes(nodes, (node) => node.kind === "parallel" ? node.nodes : void 0);
-}
+};
+const generatedBuiltinsSupported = (artifact) => {
+	const issues = unsupportedGeneratedBuiltinIssues(artifact);
+	return issues.length === 0 ? { ok: true } : {
+		error: new ScheduleArtifactError(["Invalid generated schedule:", ...issues.map((issue) => `- ${issue}`)].join("\n")),
+		ok: false
+	};
+};
+const acceptedGeneratedSchedule = (parsed) => {
+	if (!parsed.ok) return parsed;
+	const builtinCheck = generatedBuiltinsSupported(parsed.artifact);
+	return builtinCheck.ok ? parsed : builtinCheck;
+};
+const repairInvalidScheduleArtifact = async (input) => {
+	let latestFailure = input.initialFailure;
+	let latestSource = input.initialSource;
+	for (let attempt = 1; attempt <= SCHEDULE_PLANNER_REPAIR_ATTEMPTS; attempt += 1) {
+		const repairedSource = await runScheduleRepair(input, latestFailure, latestSource, attempt);
+		if (repairedSource === void 0 || repairedSource.length === 0) return { kind: "fallback" };
+		const repaired = acceptedGeneratedSchedule(parseGeneratedSchedule(repairedSource, "planner repair output"));
+		if (repaired.ok) return {
+			artifact: repaired.artifact,
+			kind: "accepted"
+		};
+		latestFailure = repaired.error;
+		latestSource = repairedSource;
+	}
+	return {
+		kind: "invalid",
+		latestFailure,
+		latestSource
+	};
+};
+const planScheduleArtifact = async (baseline, plannerProfile, options, planningContext) => {
+	const requiredPlannerProfile = requireSchedulePlannerProfile(plannerProfile, options.entrypointId);
+	const ticketPlanFallback = ticketPlanScheduleArtifact(baseline, options.config, planningContext, options.phaseContext);
+	const prompt = plannerPrompt(options.entrypointId, options.task, baseline, options.config, planningContext);
+	const sourceResult = await runSchedulePlannerSource(requiredPlannerProfile, prompt, options);
+	if (!sourceResult.ok) {
+		if (ticketPlanFallback !== void 0) return ticketPlanFallback;
+		throw sourceResult.error;
+	}
+	const source = requireSchedulePlannerSource(sourceResult.source);
+	const initial = acceptedGeneratedSchedule(parseGeneratedSchedule(source, "planner output"));
+	if (initial.ok) return initial.artifact;
+	const repair = await repairInvalidScheduleArtifact({
+		baseline,
+		initialFailure: initial.error,
+		initialSource: source,
+		options,
+		plannerProfile: requiredPlannerProfile
+	});
+	return scheduleArtifactAfterRepair(repair, ticketPlanFallback ?? baseline, initial.error, source);
+};
+const validateScheduleArtifact = (config, artifact, planningContext) => {
+	const issues = [
+		...generatedRootWorkflowIssues(artifact),
+		...missingAssignedWorkUnitIssues(artifact, planningContext.workUnits),
+		...workUnitDependencyIssues(config, artifact, planningContext.workUnits),
+		...unsupportedGeneratedBuiltinIssues(artifact),
+		...implementationCoverageIssues(config, artifact),
+		...unsafeParallelWorktreeIssues(config, artifact)
+	];
+	if (issues.length > 0) throw new ScheduleArtifactError(["Invalid generated schedule:", ...issues.map((issue) => `- ${issue}`)].join("\n"));
+};
+const generateScheduleArtifactInMemory = async (options) => {
+	if (!Object.hasOwn(options.config.entrypoints, options.entrypointId)) throw new ScheduleArtifactError(`entrypoint '${options.entrypointId}' is not a scheduled entrypoint`);
+	const entrypoint = options.config.entrypoints[options.entrypointId];
+	if (!("schedule" in entrypoint)) throw new ScheduleArtifactError(`entrypoint '${options.entrypointId}' is not a scheduled entrypoint`);
+	if (!Object.hasOwn(options.config.schedules, entrypoint.schedule)) throw new ScheduleArtifactError(`schedule policy '${entrypoint.schedule}' is not declared`);
+	const policy = options.config.schedules[entrypoint.schedule];
+	const baseline = baselineScheduleArtifact({
+		baseline: policy.baseline,
+		config: options.config,
+		entrypointId: options.entrypointId,
+		generatedAt: options.generatedAt ?? /* @__PURE__ */ new Date(),
+		runId: options.runId,
+		task: options.task
+	});
+	const planningContext = schedulePlanningContext({
+		phaseContext: options.phaseContext,
+		task: options.task,
+		worktreePath: options.worktreePath
+	});
+	const generatedArtifact = await planScheduleArtifact(baseline, policy.planner_profile, options, planningContext);
+	assertSchedulePassOrder();
+	const artifact = hydrateScheduleTaskContexts(canonicalizeGeneratedScheduleIds(applyNodeCatalogModelFallbacks(options.config, Option$1.fromUndefinedOr(policy.node_catalog), appendPullRequestDelivery(shouldAppendPullRequestDelivery({
+		config: options.config,
+		requested: options.pullRequestDeliveryRequested
+	}), integrateParallelWriteFanout(options.config, addGeneratedImplementationCoverage(options.config, generatedArtifact))))), planningContext);
+	validateScheduleArtifact(options.config, artifact, planningContext);
+	compileScheduleArtifact(options.config, artifact, options.worktreePath);
+	return {
+		artifact,
+		yaml: stringify(artifact)
+	};
+};
+const generateScheduleArtifact = async (options) => {
+	const result = await generateScheduleArtifactInMemory(options);
+	return {
+		artifact: result.artifact,
+		path: persistScheduleArtifact(options.worktreePath, result.artifact)
+	};
+};
 //#endregion
 export { ScheduleArtifactError, compileScheduleArtifact, generateScheduleArtifact, generateScheduleArtifactInMemory, parseScheduleArtifact, pruneOutOfScopeDependencies, scheduleArtifactPath, schedulePlanningContext, ticketPlanPlanningContext };