@oisincoveney/pipeline 3.24.2 → 4.0.0

package/dist/standard-output-schemas.js

@@ -1,83 +1,85 @@
+import { effectSchemaDocumentDraft07, mutableArray, nonEmptyMutableArray, positiveInteger, requiredString, stringArray, struct } from "./schema-boundary.js";
 import { ticketPlanSchema } from "./tickets/ticket-plan.js";
-import { z } from "zod";
+import * as Option$1 from "effect/Option";
+import * as R from "effect/Record";
+import * as Schema from "effect/Schema";
+import * as Arr from "effect/Array";
 //#region src/standard-output-schemas.ts
-const VERDICT_SCHEMA = z.enum(["PASS", "FAIL"]);
-const STRING_ARRAY_SCHEMA = z.array(z.string());
-const CHANGE_SCHEMA = z.object({
-	files: z.array(z.string().min(1)).min(1),
-	summary: z.string().min(1),
-	why: z.string().min(1)
-}).strict();
+const VERDICT_SCHEMA = Schema.Literals(["PASS", "FAIL"]);
+const STRING_ARRAY_SCHEMA = stringArray;
+const CHANGE_SCHEMA = struct({
+	files: nonEmptyMutableArray(requiredString),
+	summary: requiredString,
+	why: requiredString
+});
 const STANDARD_OUTPUT_SCHEMAS = {
-	acceptance: z.object({
-		acceptance: z.array(z.object({
+	acceptance: struct({
+		acceptance: mutableArray(struct({
 			evidence: STRING_ARRAY_SCHEMA,
-			id: z.string(),
-			violations: STRING_ARRAY_SCHEMA.optional(),
-			verdict: VERDICT_SCHEMA
-		}).strict()),
+			id: Schema.String,
+			verdict: VERDICT_SCHEMA,
+			violations: Schema.optional(STRING_ARRAY_SCHEMA)
+		})),
 		evidence: STRING_ARRAY_SCHEMA,
 		verdict: VERDICT_SCHEMA,
-		violations: STRING_ARRAY_SCHEMA.optional()
-	}).strict(),
-	implementation: z.object({
-		changes: z.array(CHANGE_SCHEMA).min(1),
-		followups: STRING_ARRAY_SCHEMA.optional(),
-		lessons: STRING_ARRAY_SCHEMA.optional(),
-		risks: STRING_ARRAY_SCHEMA.optional(),
-		summary: z.string().optional(),
+		violations: Schema.optional(STRING_ARRAY_SCHEMA)
+	}),
+	implementation: struct({
+		changes: nonEmptyMutableArray(CHANGE_SCHEMA),
+		followups: Schema.optional(STRING_ARRAY_SCHEMA),
+		lessons: Schema.optional(STRING_ARRAY_SCHEMA),
+		risks: Schema.optional(STRING_ARRAY_SCHEMA),
+		summary: Schema.optional(Schema.String),
 		verification: STRING_ARRAY_SCHEMA
-	}).strict(),
-	learn: z.object({
+	}),
+	learn: struct({
 		evidence: STRING_ARRAY_SCHEMA,
-		qdrant: z.object({
-			attempted: z.boolean(),
-			succeeded: z.boolean()
-		}).strict()
-	}).strict(),
-	research: z.object({
+		qdrant: struct({
+			attempted: Schema.Boolean,
+			succeeded: Schema.Boolean
+		})
+	}),
+	research: struct({
 		ac: STRING_ARRAY_SCHEMA,
-		files: STRING_ARRAY_SCHEMA.optional(),
+		files: Schema.optional(STRING_ARRAY_SCHEMA),
 		findings: STRING_ARRAY_SCHEMA,
-		risks: STRING_ARRAY_SCHEMA.optional(),
-		target: z.string().optional()
-	}).strict(),
-	review: z.object({
-		findings: z.array(z.object({
-			file: z.string().optional(),
-			line: z.number().int().min(1).optional(),
-			message: z.string(),
-			rule: z.string().optional(),
-			severity: z.enum([
+		risks: Schema.optional(STRING_ARRAY_SCHEMA),
+		target: Schema.optional(Schema.String)
+	}),
+	review: struct({
+		findings: mutableArray(struct({
+			file: Schema.optional(Schema.String),
+			line: Schema.optional(positiveInteger),
+			message: Schema.String,
+			rule: Schema.optional(Schema.String),
+			severity: Schema.Literals([
 				"info",
 				"warn",
 				"error",
 				"critical"
 			])
-		}).strict()),
-		summary: z.string().optional(),
+		})),
+		summary: Schema.optional(Schema.String),
 		verdict: VERDICT_SCHEMA
-	}).strict(),
+	}),
 	"ticket-plan": ticketPlanSchema,
-	verify: z.object({
+	verify: struct({
 		evidence: STRING_ARRAY_SCHEMA,
 		verdict: VERDICT_SCHEMA,
-		violations: STRING_ARRAY_SCHEMA.optional()
-	}).strict()
+		violations: Schema.optional(STRING_ARRAY_SCHEMA)
+	})
 };
-const standardOutputSchemaNames = Object.freeze(Object.keys(STANDARD_OUTPUT_SCHEMAS).sort());
-function standardOutputSchemaJson(name) {
+const standardOutputSchemaNames = R.keys(STANDARD_OUTPUT_SCHEMAS).toSorted();
+const NO_STANDARD_OUTPUT_SCHEMA = null;
+const encodeUnknownJson = Schema.encodeUnknownSync(Schema.fromJsonString(Schema.Unknown));
+const standardOutputSchemaJson = (name) => {
 	const schema = STANDARD_OUTPUT_SCHEMAS[name];
-	if (!schema) throw new Error(`Missing standard output schema registry entry '${name}'`);
-	return JSON.stringify(z.toJSONSchema(schema, { target: "draft-07" }), null, 2);
-}
-function standardOutputSchemaPath(name) {
-	return `.pipeline/schemas/${name}.schema.json`;
-}
-function standardOutputSchemaNameFromPath(schemaPath) {
+	return encodeUnknownJson(effectSchemaDocumentDraft07(schema));
+};
+const standardOutputSchemaPath = (name) => `.pipeline/schemas/${name}.schema.json`;
+const standardOutputSchemaNameFromPath = (schemaPath) => {
 	const normalized = schemaPath.replaceAll("\\", "/");
-	for (const name of standardOutputSchemaNames) if (normalized === standardOutputSchemaPath(name)) return name;
-	return null;
-}
+	return Option$1.getOrElse(Arr.findFirst(standardOutputSchemaNames, (name) => normalized === standardOutputSchemaPath(name)), () => NO_STANDARD_OUTPUT_SCHEMA);
+};
 //#endregion
 export { standardOutputSchemaJson, standardOutputSchemaNameFromPath };

package/dist/strings.js

@@ -1,28 +1,28 @@
 //#region src/strings.ts
-function uniqueStrings(values, options = {}) {
-	const input = options.filterEmpty ? values.filter(Boolean) : values;
+const uniqueStrings = (values, options = {}) => {
+	const input = options.filterEmpty === true ? values.filter((value) => value.length > 0) : values;
 	const unique = [...new Set(input)];
-	return options.sort ? unique.sort() : unique;
-}
-const GENERATED_ID_INVALID_CHARS_RE = /[^a-z0-9]+/g;
-const GENERATED_ID_TRIM_HYPHENS_RE = /^-+|-+$/g;
-const STARTS_WITH_ALPHA_RE = /^[a-z]/;
+	return options.sort === true ? unique.toSorted() : unique;
+};
+const GENERATED_ID_INVALID_CHARS_RE = /[^a-z0-9]+/gu;
+const GENERATED_ID_TRIM_HYPHENS_RE = /^-+|-+$/gu;
+const STARTS_WITH_ALPHA_RE = /^[a-z]/u;
 /**
 * Slugify an arbitrary string into a workflow-safe id (lowercase, hyphenated).
 * When the slug does not begin with a letter it is prefixed with
 * `fallbackPrefix` so the result is always a valid node/workflow id.
 */
-function generatedId(value, fallbackPrefix) {
+const generatedId = (value, fallbackPrefix) => {
 	const slug = value.trim().toLowerCase().replaceAll(GENERATED_ID_INVALID_CHARS_RE, "-").replaceAll(GENERATED_ID_TRIM_HYPHENS_RE, "");
 	if (STARTS_WITH_ALPHA_RE.test(slug)) return slug;
-	return slug ? `${fallbackPrefix}-${slug}` : fallbackPrefix;
-}
+	return slug.length > 0 ? `${fallbackPrefix}-${slug}` : fallbackPrefix;
+};
 /**
 * Slugify `value` to a generated id (see {@link generatedId}) and disambiguate
 * against `usedIds` by appending an incrementing numeric suffix. Mutates
 * `usedIds` to reserve the chosen id.
 */
-function uniqueGeneratedId(value, usedIds, fallbackPrefix) {
+const uniqueGeneratedId = (value, usedIds, fallbackPrefix) => {
 	const base = generatedId(value, fallbackPrefix);
 	let candidate = base;
 	let suffix = 2;
@@ -32,6 +32,6 @@ function uniqueGeneratedId(value, usedIds, fallbackPrefix) {
 	}
 	usedIds.add(candidate);
 	return candidate;
-}
+};
 //#endregion
 export { uniqueGeneratedId, uniqueStrings };

package/dist/task-ref.js

@@ -1,17 +1,17 @@
 //#region src/task-ref.ts
 const TICKET_ID_SOURCE = String.raw`(?=[A-Za-z0-9.-]*\d)[A-Za-z][A-Za-z0-9]*(?:-[A-Za-z0-9]+)+(?:\.[A-Za-z0-9]+)*`;
-new RegExp(`^(${TICKET_ID_SOURCE})\\b\\s*(.*)$`, "s");
-const TICKET_ID_RE = new RegExp(`\\b(${TICKET_ID_SOURCE})\\b`, "g");
-function extractTicketIds(input) {
+new RegExp(`^(${TICKET_ID_SOURCE})\\b\\s*(.*)$`, "su");
+const TICKET_ID_RE = new RegExp(`\\b(${TICKET_ID_SOURCE})\\b`, "gu");
+const extractTicketIds = (input) => {
 	const ids = [];
 	const seen = /* @__PURE__ */ new Set();
 	for (const match of input.matchAll(TICKET_ID_RE)) {
 		const id = match[1];
-		if (!id || seen.has(id)) continue;
+		if (id.length === 0 || seen.has(id)) continue;
 		seen.add(id);
 		ids.push(id);
 	}
 	return ids;
-}
+};
 //#endregion
 export { extractTicketIds };

package/dist/tickets/apply-ticket-plan.js

@@ -1,75 +1,66 @@
 import { BacklogService } from "../runtime/services/backlog-service.js";
 import { parseBacklogTaskId } from "../backlog.js";
 import { formatBacklogCommand, ticketCreateArgs } from "./ticket-plan-command-args.js";
-import { Data, Effect } from "effect";
+import { Data, Effect, Option } from "effect";
 //#region src/tickets/apply-ticket-plan.ts
 var ApplyTicketPlanError = class extends Data.TaggedError("ApplyTicketPlanError") {};
-function applyTicketPlanEffect(plan, worktreePath, options) {
-	return Effect.gen(function* () {
-		const backlog = yield* BacklogService;
-		const createdIds = [];
-		const parentId = yield* resolveParentId(plan, options, worktreePath, backlog, createdIds);
-		return {
-			createdIds,
-			parentId,
-			taskIdsByKey: yield* createChildTickets(plan, parentId, worktreePath, backlog, createdIds)
-		};
-	});
-}
-function resolveParentId(plan, options, worktreePath, backlog, createdIds) {
-	if (options.parentId) return Effect.succeed(options.parentId);
-	if (!plan.epic) return Effect.fail(new ApplyTicketPlanError({
+const formatCreatedIds = (createdIds) => createdIds.length > 0 ? createdIds.join(", ") : "none";
+const commandFailure = (args, createdIds, error) => new ApplyTicketPlanError({
+	command: formatBacklogCommand(args),
+	createdIds,
+	message: `backlog command failed after created ids: ${formatCreatedIds(createdIds)}; failed command: ${formatBacklogCommand(args)}; ${error.message}`,
+	stdout: error.stdout
+});
+const runCreateAndParseId = (args, worktreePath, backlog, createdIds) => Effect.gen(function* effectBody() {
+	const stdout = yield* backlog.run(args, worktreePath).pipe(Effect.mapError((error) => commandFailure(args, createdIds, error)));
+	const taskId = parseBacklogTaskId(stdout);
+	if (Option.isNone(taskId)) return yield* Effect.fail(new ApplyTicketPlanError({
+		command: formatBacklogCommand(args),
+		createdIds,
+		message: `could not parse created task id from Backlog output; created ids: ${formatCreatedIds(createdIds)}; failed command: ${formatBacklogCommand(args)}`,
+		stdout
+	}));
+	createdIds.push(taskId.value);
+	return taskId.value;
+});
+const resolveParentId = (plan, options, worktreePath, backlog, createdIds) => {
+	if (options.parentId !== void 0 && options.parentId.length > 0) return Effect.succeed(options.parentId);
+	if (plan.epic === void 0) return Effect.fail(new ApplyTicketPlanError({
 		createdIds,
 		message: "Cannot apply ticket plan without --parent because the plan does not include an epic."
 	}));
 	return runCreateAndParseId(ticketCreateArgs(plan.epic), worktreePath, backlog, createdIds);
-}
-function createChildTickets(plan, parentId, worktreePath, backlog, createdIds) {
-	return Effect.gen(function* () {
-		const remaining = new Map(plan.tickets.map((ticket) => [ticket.key, ticket]));
-		const taskIdsByKey = {};
-		while (remaining.size > 0) {
-			const ready = [...remaining.values()].filter((ticket) => ticket.depends_on.every((key) => taskIdsByKey[key]));
-			if (ready.length === 0) return yield* Effect.fail(new ApplyTicketPlanError({
-				createdIds,
-				message: "Cannot apply ticket plan because local dependency keys contain a cycle or unresolved prerequisite."
-			}));
-			for (const ticket of ready) {
-				const taskId = yield* runCreateAndParseId(ticketCreateArgs(ticket, {
-					dependencyIds: ticket.depends_on.map((key) => taskIdsByKey[key]),
-					parentId
-				}), worktreePath, backlog, createdIds);
-				taskIdsByKey[ticket.key] = taskId;
-				remaining.delete(ticket.key);
-			}
-		}
-		return taskIdsByKey;
-	});
-}
-function runCreateAndParseId(args, worktreePath, backlog, createdIds) {
-	return Effect.gen(function* () {
-		const stdout = yield* backlog.run(args, worktreePath).pipe(Effect.mapError((error) => commandFailure(args, createdIds, error)));
-		const taskId = parseBacklogTaskId(stdout);
-		if (!taskId) return yield* Effect.fail(new ApplyTicketPlanError({
-			command: formatBacklogCommand(args),
+};
+const createChildTickets = (plan, parentId, worktreePath, backlog, createdIds) => Effect.gen(function* effectBody() {
+	const remaining = new Map(plan.tickets.map((ticket) => [ticket.key, ticket]));
+	const taskIdsByKey = {};
+	while (remaining.size > 0) {
+		const ready = [...remaining.values()].filter((ticket) => ticket.depends_on.every((key) => taskIdsByKey[key]));
+		if (ready.length === 0) return yield* Effect.fail(new ApplyTicketPlanError({
 			createdIds,
-			message: `could not parse created task id from Backlog output; created ids: ${formatCreatedIds(createdIds)}; failed command: ${formatBacklogCommand(args)}`,
-			stdout
+			message: "Cannot apply ticket plan because local dependency keys contain a cycle or unresolved prerequisite."
 		}));
-		createdIds.push(taskId);
-		return taskId;
-	});
-}
-function commandFailure(args, createdIds, error) {
-	return new ApplyTicketPlanError({
-		command: formatBacklogCommand(args),
+		for (const ticket of ready) {
+			const dependencyIds = ticket.depends_on.map((key) => taskIdsByKey[key]);
+			const taskId = yield* runCreateAndParseId(ticketCreateArgs(ticket, {
+				dependencyIds,
+				parentId
+			}), worktreePath, backlog, createdIds);
+			taskIdsByKey[ticket.key] = taskId;
+			remaining.delete(ticket.key);
+		}
+	}
+	return taskIdsByKey;
+});
+const applyTicketPlanEffect = (plan, worktreePath, options) => Effect.gen(function* effectBody() {
+	const backlog = yield* BacklogService;
+	const createdIds = [];
+	const parentId = yield* resolveParentId(plan, options, worktreePath, backlog, createdIds);
+	return {
 		createdIds,
-		message: `backlog command failed after created ids: ${formatCreatedIds(createdIds)}; failed command: ${formatBacklogCommand(args)}; ${error.message}`,
-		stdout: error.stdout
-	});
-}
-function formatCreatedIds(createdIds) {
-	return createdIds.length > 0 ? createdIds.join(", ") : "none";
-}
+		parentId,
+		taskIdsByKey: yield* createChildTickets(plan, parentId, worktreePath, backlog, createdIds)
+	};
+});
 //#endregion
 export { applyTicketPlanEffect };

package/dist/tickets/backlog-task-store.d.ts

@@ -1,27 +1,19 @@
-import { Effect } from "effect";
-import { z } from "zod";
-
+import "../runtime/services/repo-io-service.js";
+import "effect/Effect";
+import * as Schema from "effect/Schema";
 //#region src/tickets/backlog-task-store.d.ts
-declare const taskFrontmatterSchema: z.ZodObject<{
-  dependencies: z.ZodDefault<z.ZodArray<z.ZodString>>;
-  id: z.ZodString;
-  modified_files: z.ZodDefault<z.ZodArray<z.ZodString>>;
-  ordinal: z.ZodOptional<z.ZodNumber>;
-  parent_task_id: z.ZodOptional<z.ZodString>;
-  priority: z.ZodOptional<z.ZodEnum<{
-    high: "high";
-    low: "low";
-    medium: "medium";
-  }>>;
-  references: z.ZodDefault<z.ZodArray<z.ZodString>>;
-  status: z.ZodEnum<{
-    Done: "Done";
-    "In Progress": "In Progress";
-    "To Do": "To Do";
-  }>;
-  title: z.ZodString;
-}, z.core.$loose>;
-type TaskFrontmatter = z.infer<typeof taskFrontmatterSchema>;
+declare const taskFrontmatterSchema: Schema.Struct<{
+  readonly dependencies: Schema.withDecodingDefault<Schema.mutable<Schema.$Array<Schema.Trim>>, never>;
+  readonly id: Schema.Trim;
+  readonly modified_files: Schema.withDecodingDefault<Schema.mutable<Schema.$Array<Schema.Trim>>, never>;
+  readonly ordinal: Schema.optional<Schema.Number>;
+  readonly parent_task_id: Schema.optional<Schema.Trim>;
+  readonly priority: Schema.optional<Schema.Literals<readonly ["high", "medium", "low"]>>;
+  readonly references: Schema.withDecodingDefault<Schema.mutable<Schema.$Array<Schema.Trim>>, never>;
+  readonly status: Schema.Literals<readonly ["To Do", "In Progress", "Done"]>;
+  readonly title: Schema.Trim;
+}>;
+type TaskFrontmatter = typeof taskFrontmatterSchema.Type;
 type BacklogTaskPriority = NonNullable<TaskFrontmatter["priority"]>;
 type BacklogTaskStatus = TaskFrontmatter["status"];
 interface BacklogTaskRecord {

package/dist/tickets/backlog-task-store.js

@@ -1,13 +1,15 @@
-import { errorMessage, formatZodIssues } from "./validation-error-format.js";
+import { formatSchemaIssueList, mutableArray, parseResultWithSchema, struct, trimmedRequiredString, withDefault } from "../schema-boundary.js";
+import { errorMessage } from "./validation-error-format.js";
 import { RepoIoService } from "../runtime/services/repo-io-service.js";
 import { indexChildrenByParentId } from "./ticket-task-index.js";
-import { Data, Effect } from "effect";
-import { z } from "zod";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
 import { join } from "node:path";
+import * as Data from "effect/Data";
 import matter from "gray-matter";
 //#region src/tickets/backlog-task-store.ts
-const LINE_RE = /\r?\n/;
-const ACCEPTANCE_ITEM_RE = /^\s*-\s*\[[ xX]\]\s*(?:#?[\w.-]+\s+)?(.+)$/;
+const LINE_RE = /\r?\n/u;
+const ACCEPTANCE_ITEM_RE = /^\s*-\s*\[[ xX]\]\s*(?:#?[\w.-]+\s+)?(.+)$/u;
 const DESCRIPTION_MARKERS = {
 	end: "<!-- SECTION:DESCRIPTION:END -->",
 	start: "<!-- SECTION:DESCRIPTION:BEGIN -->"
@@ -16,69 +18,69 @@ const ACCEPTANCE_MARKERS = {
 	end: "<!-- AC:END -->",
 	start: "<!-- AC:BEGIN -->"
 };
-const nonEmptyStringSchema = z.string().trim().min(1);
-const taskFrontmatterSchema = z.object({
-	dependencies: z.array(nonEmptyStringSchema).default([]),
+const nonEmptyStringSchema = trimmedRequiredString;
+const taskFrontmatterSchema = struct({
+	dependencies: withDefault(mutableArray(nonEmptyStringSchema), []),
 	id: nonEmptyStringSchema,
-	modified_files: z.array(nonEmptyStringSchema).default([]),
-	ordinal: z.number().finite().optional(),
-	parent_task_id: nonEmptyStringSchema.optional(),
-	priority: z.enum([
+	modified_files: withDefault(mutableArray(nonEmptyStringSchema), []),
+	ordinal: Schema.optional(Schema.Number),
+	parent_task_id: Schema.optional(nonEmptyStringSchema),
+	priority: Schema.optional(Schema.Literals([
 		"high",
 		"medium",
 		"low"
-	]).optional(),
-	references: z.array(nonEmptyStringSchema).default([]),
-	status: z.enum([
+	])),
+	references: withDefault(mutableArray(nonEmptyStringSchema), []),
+	status: Schema.Literals([
 		"To Do",
 		"In Progress",
 		"Done"
 	]),
 	title: nonEmptyStringSchema
-}).passthrough();
+});
 var BacklogTaskStoreError = class extends Data.TaggedError("BacklogTaskStoreError") {};
-function loadBacklogTaskStoreEffect(worktreePath) {
-	return Effect.gen(function* () {
-		return yield* buildBacklogTaskStoreEffect(yield* readBacklogTasksEffect(worktreePath));
-	});
-}
-function parseBacklogTaskMarkdownEffect(source, filePath) {
-	return Effect.gen(function* () {
-		const parsed = yield* Effect.try({
-			catch: (error) => storeError(filePath, `Could not parse Backlog task frontmatter: ${errorMessage(error)}`),
-			try: () => matter(source)
-		});
-		return taskRecordFromDocument(yield* decodeFrontmatterEffect(parsed.data, filePath), parsed.content, filePath);
-	});
-}
-function readBacklogTasksEffect(worktreePath) {
-	const tasksDir = join(worktreePath, "backlog", "tasks");
-	return Effect.gen(function* () {
-		const repoIo = yield* RepoIoService;
-		if (!(yield* repoIo.exists(tasksDir).pipe(Effect.mapError((error) => ioStoreError(tasksDir, error))))) return [];
-		const entries = yield* repoIo.readDir(tasksDir).pipe(Effect.mapError((error) => ioStoreError(tasksDir, error)));
-		return yield* Effect.all(entries.filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => {
-			const filePath = join(tasksDir, entry.name);
-			return repoIo.readText(filePath).pipe(Effect.mapError((error) => ioStoreError(filePath, error)), Effect.flatMap((source) => parseBacklogTaskMarkdownEffect(source, filePath)));
-		}));
-	});
-}
-function decodeFrontmatterEffect(frontmatter, filePath) {
-	const decoded = taskFrontmatterSchema.safeParse(frontmatter);
-	if (decoded.success) return Effect.succeed(decoded.data);
-	return Effect.fail(storeError(filePath, `Invalid Backlog task frontmatter in ${filePath}: ${formatZodIssues(decoded.error.issues)}`));
-}
-function buildBacklogTaskStoreEffect(tasks) {
-	return Effect.gen(function* () {
-		const tasksById = yield* indexTasksByIdEffect(tasks);
-		return {
-			childrenByParentId: indexChildrenByParentId(tasks),
-			tasks,
-			tasksById
-		};
+const extractMarkedBlock = (content, markers) => {
+	const start = content.indexOf(markers.start);
+	if (start === -1) return "";
+	const bodyStart = start + markers.start.length;
+	const end = content.indexOf(markers.end, bodyStart);
+	if (end === -1) return "";
+	return content.slice(bodyStart, end).trim();
+};
+const extractDescription = (content) => extractMarkedBlock(content, DESCRIPTION_MARKERS);
+const extractAcceptanceCriteria = (content) => extractMarkedBlock(content, ACCEPTANCE_MARKERS).split(LINE_RE).map((line) => ACCEPTANCE_ITEM_RE.exec(line)?.[1]?.trim()).filter((criterion) => criterion !== void 0 && criterion.length > 0);
+const taskRecordFromDocument = (frontmatter, content, filePath) => ({
+	acceptanceCriteria: extractAcceptanceCriteria(content),
+	dependencies: frontmatter.dependencies,
+	description: extractDescription(content),
+	filePath,
+	id: frontmatter.id,
+	modifiedFiles: frontmatter.modified_files,
+	ordinal: frontmatter.ordinal,
+	parentTaskId: frontmatter.parent_task_id,
+	priority: frontmatter.priority,
+	references: frontmatter.references,
+	status: frontmatter.status,
+	title: frontmatter.title
+});
+const storeError = (path, message) => new BacklogTaskStoreError({
+	message,
+	path
+});
+const decodeFrontmatterEffect = (frontmatter, filePath) => {
+	const decoded = parseResultWithSchema(taskFrontmatterSchema, frontmatter, { onExcessProperty: "preserve" });
+	if (decoded.ok) return Effect.succeed(decoded.value);
+	return Effect.fail(storeError(filePath, `Invalid Backlog task frontmatter in ${filePath}: ${formatSchemaIssueList(decoded.issues)}`));
+};
+const parseBacklogTaskMarkdownEffect = (source, filePath) => Effect.gen(function* effectBody() {
+	const parsed = yield* Effect.try({
+		catch: (error) => storeError(filePath, `Could not parse Backlog task frontmatter: ${errorMessage(error)}`),
+		try: () => matter(source)
 	});
-}
-function indexTasksByIdEffect(tasks) {
+	const frontmatter = yield* decodeFrontmatterEffect(parsed.data, filePath);
+	return taskRecordFromDocument(frontmatter, parsed.content, filePath);
+});
+const indexTasksByIdEffect = (tasks) => {
 	const tasksById = /* @__PURE__ */ new Map();
 	for (const task of tasks) {
 		const existing = tasksById.get(task.id);
@@ -86,45 +88,31 @@ function indexTasksByIdEffect(tasks) {
 		tasksById.set(task.id, task);
 	}
 	return Effect.succeed(tasksById);
-}
-function taskRecordFromDocument(frontmatter, content, filePath) {
+};
+const buildBacklogTaskStoreEffect = (tasks) => Effect.gen(function* effectBody() {
+	const tasksById = yield* indexTasksByIdEffect(tasks);
 	return {
-		acceptanceCriteria: extractAcceptanceCriteria(content),
-		dependencies: frontmatter.dependencies,
-		description: extractDescription(content),
-		filePath,
-		id: frontmatter.id,
-		modifiedFiles: frontmatter.modified_files,
-		ordinal: frontmatter.ordinal,
-		parentTaskId: frontmatter.parent_task_id,
-		priority: frontmatter.priority,
-		references: frontmatter.references,
-		status: frontmatter.status,
-		title: frontmatter.title
+		childrenByParentId: indexChildrenByParentId(tasks),
+		tasks,
+		tasksById
 	};
-}
-function extractDescription(content) {
-	return extractMarkedBlock(content, DESCRIPTION_MARKERS);
-}
-function extractAcceptanceCriteria(content) {
-	return extractMarkedBlock(content, ACCEPTANCE_MARKERS).split(LINE_RE).map((line) => ACCEPTANCE_ITEM_RE.exec(line)?.[1]?.trim()).filter((criterion) => Boolean(criterion));
-}
-function extractMarkedBlock(content, markers) {
-	const start = content.indexOf(markers.start);
-	if (start < 0) return "";
-	const bodyStart = start + markers.start.length;
-	const end = content.indexOf(markers.end, bodyStart);
-	if (end < 0) return "";
-	return content.slice(bodyStart, end).trim();
-}
-function ioStoreError(path, error) {
-	return storeError(path, `Could not read Backlog task data: ${errorMessage(error)}`);
-}
-function storeError(path, message) {
-	return new BacklogTaskStoreError({
-		message,
-		path
+});
+const ioStoreError = (path, error) => storeError(path, `Could not read Backlog task data: ${errorMessage(error)}`);
+const readBacklogTasksEffect = (worktreePath) => {
+	const tasksDir = join(worktreePath, "backlog", "tasks");
+	return Effect.gen(function* effectBody() {
+		const repoIo = yield* RepoIoService;
+		if (!(yield* repoIo.exists(tasksDir).pipe(Effect.mapError((error) => ioStoreError(tasksDir, error))))) return [];
+		const entries = yield* repoIo.readDir(tasksDir).pipe(Effect.mapError((error) => ioStoreError(tasksDir, error)));
+		return yield* Effect.all(entries.filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => {
+			const filePath = join(tasksDir, entry.name);
+			return repoIo.readText(filePath).pipe(Effect.mapError((error) => ioStoreError(filePath, error)), Effect.flatMap((source) => parseBacklogTaskMarkdownEffect(source, filePath)));
+		}));
 	});
-}
+};
+const loadBacklogTaskStoreEffect = (worktreePath) => Effect.gen(function* effectBody() {
+	const tasks = yield* readBacklogTasksEffect(worktreePath);
+	return yield* buildBacklogTaskStoreEffect(tasks);
+});
 //#endregion
 export { BacklogTaskStoreError, loadBacklogTaskStoreEffect };