@oisincoveney/pipeline 2.9.0 → 2.11.0

package/dist/hooks.d.ts

@@ -13,8 +13,8 @@ declare const hookResultSchema: z.ZodObject<{
     taskContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
   }, z.core.$strict>>;
   status: z.ZodEnum<{
-    fail: "fail";
     pass: "pass";
+    fail: "fail";
     skip: "skip";
   }>;
   summary: z.ZodOptional<z.ZodString>;

package/dist/install-commands/opencode.js

@@ -355,8 +355,9 @@ function projectAgentsMdDefinition(cwd, host) {
 			"",
 			`Use Qdrant collection \`${repoName}\` for this repository.`,
 			"",
-			`- Call \`qdrant-find\` before research with \`collection_name: ${repoName}\` unless the user explicitly disables memory.`,
-			`- Call \`qdrant-store\` during LEARN with \`collection_name: ${repoName}\` for durable lessons worth reusing.`,
+			"- Use the Qdrant interface exposed by the active host; do not assume `qdrant-find` or `qdrant-store` are shell commands.",
+			`- Before research, call MCP tool \`qdrant_qdrant_find\` with \`collection_name: ${repoName}\` when MCP tools are available; otherwise use the host's \`qdrant-find\` command/alias if one exists.`,
+			`- During LEARN, call MCP tool \`qdrant_qdrant_store\` with \`collection_name: ${repoName}\` for durable lessons worth reusing; otherwise use the host's \`qdrant-store\` command/alias if one exists.`,
 			"- Include metadata with at least `repo`, `phase`, `workflow` or `entrypoint`, `task`, and `outcome` when storing lessons.",
 			"",
 			AGENTS_MD_END,

package/dist/moka-submit.d.ts

@@ -5,13 +5,13 @@ 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<{
@@ -206,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<{

package/dist/pipeline-init.js

@@ -1,5 +1,7 @@
 import { installCommands } from "./install-commands.js";
+import { existsSync } from "node:fs";
 import { execa } from "execa";
+import { join } from "node:path";
 //#region src/pipeline-init.ts
 const DEFAULT_SKILL_INSTALL_SOURCE = "oisin-ee/skills";
 const SKILL_INSTALL_AGENT_ARGS = [
@@ -16,6 +18,18 @@ const SKILL_INSTALL_AGENT_ARGS = [
 function skillInstallArgs(scope) {
 	return scope === "personal" ? [...SKILL_INSTALL_AGENT_ARGS, "--global"] : [...SKILL_INSTALL_AGENT_ARGS, "--copy"];
 }
+const DEFAULT_HARNESS_COMMIT_MESSAGE = "chore: update agent harnesses";
+const OWNED_HARNESS_PATHS = [
+	".agents/skills",
+	".claude/agents",
+	".claude/commands",
+	".claude/settings.json",
+	".claude/skills",
+	".codex/skills",
+	".opencode",
+	"AGENTS.md",
+	"skills-lock.json"
+];
 async function installDefaultSkills(cwd, scope) {
 	try {
 		await execa("npx", [
@@ -46,6 +60,31 @@ async function initPipelineProject(options = {}) {
 		scope
 	};
 }
+async function refreshAgentHarnesses(options = {}) {
+	const context = refreshAgentHarnessesContext(options);
+	const init = await initPipelineProject({
+		cwd: context.cwd,
+		scope: options.scope,
+		skillInstaller: options.skillInstaller
+	});
+	const committed = await refreshAgentHarnessesCommitResult(context);
+	return {
+		...init,
+		commitMessage: context.commitMessage,
+		committed
+	};
+}
+function refreshAgentHarnessesContext(options) {
+	return {
+		commandRunner: options.commandRunner ?? runCommand,
+		commitMessage: options.commitMessage ?? DEFAULT_HARNESS_COMMIT_MESSAGE,
+		cwd: options.cwd ?? process.cwd()
+	};
+}
+async function refreshAgentHarnessesCommitResult(context) {
+	await assertGitWorktree(context.cwd, context.commandRunner);
+	return stageableOwnedPathsExist(context.cwd) ? await commitOwnedHarnessRefresh(context.cwd, context.commandRunner, context.commitMessage) : false;
+}
 function formatPipelineInitResult(result) {
 	return [
 		"Initialized package-owned pipeline support:",
@@ -54,5 +93,74 @@ function formatPipelineInitResult(result) {
 		"no repo-local pipeline config files were created"
 	].join("\n");
 }
+function formatRefreshAgentHarnessesResult(result) {
+	return [formatPipelineInitResult(result), result.committed ? `committed refreshed harnesses: ${result.commitMessage}` : "refreshed harnesses already current; no commit created"].join("\n");
+}
+async function runCommand(command, args, options) {
+	const result = await execa(command, args, {
+		cwd: options.cwd,
+		reject: options.reject ?? true
+	});
+	return {
+		exitCode: result.exitCode ?? 0,
+		stderr: result.stderr,
+		stdout: result.stdout
+	};
+}
+async function assertGitWorktree(cwd, commandRunner) {
+	await commandRunner("git", ["rev-parse", "--is-inside-work-tree"], { cwd });
+}
+async function commitOwnedHarnessRefresh(cwd, commandRunner, commitMessage) {
+	await stageOwnedHarnessPaths(cwd, commandRunner);
+	await assertOnlyOwnedHarnessFilesStaged(cwd, commandRunner);
+	if (!await hasStagedChanges(cwd, commandRunner)) return false;
+	await commandRunner("git", [
+		"commit",
+		"--no-verify",
+		"-m",
+		commitMessage
+	], { cwd });
+	return true;
+}
+async function hasStagedChanges(cwd, commandRunner) {
+	return (await commandRunner("git", [
+		"diff",
+		"--cached",
+		"--quiet"
+	], {
+		cwd,
+		reject: false
+	})).exitCode !== 0;
+}
+async function assertOnlyOwnedHarnessFilesStaged(cwd, commandRunner) {
+	const unrelatedFiles = (await commandRunner("git", [
+		"diff",
+		"--cached",
+		"--name-only"
+	], { cwd })).stdout.split("\n").map((path) => path.trim()).filter(Boolean).filter((path) => !isOwnedHarnessPath(path));
+	if (unrelatedFiles.length === 0) return;
+	throw new Error([
+		"Refusing to commit because unrelated files are already staged.",
+		...unrelatedFiles.map((path) => `- ${path}`),
+		"Unstage unrelated files before running `moka refresh-harnesses`."
+	].join("\n"));
+}
+function isOwnedHarnessPath(path) {
+	return OWNED_HARNESS_PATHS.some((ownedPath) => path === ownedPath || path.startsWith(`${ownedPath}/`));
+}
+function existingOwnedPaths(cwd) {
+	return OWNED_HARNESS_PATHS.filter((path) => existsSync(join(cwd, path)));
+}
+function stageableOwnedPathsExist(cwd) {
+	return existingOwnedPaths(cwd).length > 0;
+}
+async function stageOwnedHarnessPaths(cwd, commandRunner) {
+	await commandRunner("git", [
+		"add",
+		"-A",
+		"--",
+		...existingOwnedPaths(cwd)
+	], { cwd });
+}
 //#endregion
-export { formatPipelineInitResult, initPipelineProject };
+export { formatPipelineInitResult, formatRefreshAgentHarnessesResult, initPipelineProject, refreshAgentHarnesses };

package/dist/runner-event-schema.d.ts

@@ -10,8 +10,8 @@ declare const runnerEventRecordSchema: z.ZodUnion<readonly [z.ZodObject<{
   at: z.ZodOptional<z.ZodString>;
   sequence: z.ZodNumber;
   type: z.ZodEnum<{
-    "workflow.planned": "workflow.planned";
     "workflow.start": "workflow.start";
+    "workflow.planned": "workflow.planned";
   }>;
   workflowPlan: z.ZodObject<{
     edges: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -55,10 +55,10 @@ declare const runnerEventRecordSchema: z.ZodUnion<readonly [z.ZodObject<{
     }>;
   }, z.core.$strip>;
   type: z.ZodEnum<{
+    "node.start": "node.start";
+    "node.finish": "node.finish";
     "agent.finish": "agent.finish";
     "agent.start": "agent.start";
-    "node.finish": "node.finish";
-    "node.start": "node.start";
   }>;
 }, z.core.$strip>, z.ZodObject<{
   at: z.ZodOptional<z.ZodString>;
@@ -103,8 +103,8 @@ declare const runnerEventRecordSchema: z.ZodUnion<readonly [z.ZodObject<{
     nodeId: z.ZodOptional<z.ZodString>;
     outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     status: z.ZodEnum<{
-      fail: "fail";
       pass: "pass";
+      fail: "fail";
       skip: "skip";
     }>;
     summary: z.ZodOptional<z.ZodString>;
@@ -180,8 +180,8 @@ declare const runnerEventBatchSchema: z.ZodObject<{
     at: z.ZodOptional<z.ZodString>;
     sequence: z.ZodNumber;
     type: z.ZodEnum<{
-      "workflow.planned": "workflow.planned";
       "workflow.start": "workflow.start";
+      "workflow.planned": "workflow.planned";
     }>;
     workflowPlan: z.ZodObject<{
       edges: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -225,10 +225,10 @@ declare const runnerEventBatchSchema: z.ZodObject<{
       }>;
     }, z.core.$strip>;
     type: z.ZodEnum<{
+      "node.start": "node.start";
+      "node.finish": "node.finish";
       "agent.finish": "agent.finish";
       "agent.start": "agent.start";
-      "node.finish": "node.finish";
-      "node.start": "node.start";
     }>;
   }, z.core.$strip>, z.ZodObject<{
     at: z.ZodOptional<z.ZodString>;
@@ -273,8 +273,8 @@ declare const runnerEventBatchSchema: z.ZodObject<{
       nodeId: z.ZodOptional<z.ZodString>;
       outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
       status: z.ZodEnum<{
-        fail: "fail";
         pass: "pass";
+        fail: "fail";
         skip: "skip";
       }>;
       summary: z.ZodOptional<z.ZodString>;

package/dist/runtime/services/backlog-service.d.ts

@@ -0,0 +1,16 @@
+import { Context, Effect, Layer } from "effect";
+
+//#region src/runtime/services/backlog-service.d.ts
+declare const BacklogCommandError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "BacklogCommandError";
+} & Readonly<A>;
+declare class BacklogCommandError extends BacklogCommandError_base<{
+  readonly message: string;
+  readonly stdout: string;
+}> {}
+declare const BacklogService_base: Context.TagClass<BacklogService, "BacklogService", {
+  readonly run: (args: readonly string[], cwd: string) => Effect.Effect<string, BacklogCommandError>;
+}>;
+declare class BacklogService extends BacklogService_base {}
+//#endregion
+export { BacklogService };

package/dist/runtime/services/backlog-service.js

@@ -0,0 +1,25 @@
+import { Context, Data, Effect, Layer } from "effect";
+import { execa } from "execa";
+//#region src/runtime/services/backlog-service.ts
+var BacklogCommandError = class extends Data.TaggedError("BacklogCommandError") {};
+Data.TaggedError("BacklogParseError");
+function commandErrorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function commandErrorStdout(error) {
+	const stdout = error.stdout;
+	return typeof stdout === "string" ? stdout : "";
+}
+function toBacklogCommandError(error) {
+	return new BacklogCommandError({
+		message: commandErrorMessage(error),
+		stdout: commandErrorStdout(error)
+	});
+}
+var BacklogService = class extends Context.Tag("BacklogService")() {};
+const BacklogServiceLive = Layer.succeed(BacklogService, { run: (args, cwd) => Effect.tryPromise({
+	catch: toBacklogCommandError,
+	try: () => execa("backlog", [...args], { cwd })
+}).pipe(Effect.map((result) => result.stdout)) });
+//#endregion
+export { BacklogService, BacklogServiceLive };

package/dist/standard-output-schemas.js

@@ -1,3 +1,4 @@
+import { ticketPlanSchema } from "./tickets/ticket-plan.js";
 import { z } from "zod";
 //#region src/standard-output-schemas.ts
 const VERDICT_SCHEMA = z.enum(["PASS", "FAIL"]);
@@ -57,6 +58,7 @@ const STANDARD_OUTPUT_SCHEMAS = {
 		summary: z.string().optional(),
 		verdict: VERDICT_SCHEMA
 	}).strict(),
+	"ticket-plan": ticketPlanSchema,
 	verify: z.object({
 		evidence: STRING_ARRAY_SCHEMA,
 		verdict: VERDICT_SCHEMA,

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

@@ -0,0 +1,75 @@
+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";
+//#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({
+		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),
+			createdIds,
+			message: `could not parse created task id from Backlog output; created ids: ${formatCreatedIds(createdIds)}; failed command: ${formatBacklogCommand(args)}`,
+			stdout
+		}));
+		createdIds.push(taskId);
+		return taskId;
+	});
+}
+function commandFailure(args, createdIds, error) {
+	return new ApplyTicketPlanError({
+		command: formatBacklogCommand(args),
+		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";
+}
+//#endregion
+export { applyTicketPlanEffect };

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

@@ -0,0 +1,130 @@
+import { errorMessage, formatZodIssues } from "./validation-error-format.js";
+import { RepoIoService } from "../runtime/services/repo-io-service.js";
+import { indexChildrenByParentId } from "./ticket-task-index.js";
+import { z } from "zod";
+import { Data, Effect } from "effect";
+import { join } from "node:path";
+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 DESCRIPTION_MARKERS = {
+	end: "<!-- SECTION:DESCRIPTION:END -->",
+	start: "<!-- SECTION:DESCRIPTION:BEGIN -->"
+};
+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([]),
+	id: nonEmptyStringSchema,
+	modified_files: z.array(nonEmptyStringSchema).default([]),
+	ordinal: z.number().finite().optional(),
+	parent_task_id: nonEmptyStringSchema.optional(),
+	priority: z.enum([
+		"high",
+		"medium",
+		"low"
+	]).optional(),
+	references: z.array(nonEmptyStringSchema).default([]),
+	status: z.enum([
+		"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
+		};
+	});
+}
+function indexTasksByIdEffect(tasks) {
+	const tasksById = /* @__PURE__ */ new Map();
+	for (const task of tasks) {
+		const existing = tasksById.get(task.id);
+		if (existing) return Effect.fail(storeError(task.filePath, `Duplicate Backlog task id ${task.id}: ${existing.filePath} and ${task.filePath}`));
+		tasksById.set(task.id, task);
+	}
+	return Effect.succeed(tasksById);
+}
+function taskRecordFromDocument(frontmatter, content, filePath) {
+	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
+	};
+}
+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
+	});
+}
+//#endregion
+export { loadBacklogTaskStoreEffect };

package/dist/tickets/ticket-graph.js

@@ -0,0 +1,92 @@
+import { compareBacklogTasks, compareTicketIds, indexChildrenByParentId } from "./ticket-task-index.js";
+import { Data, Effect } from "effect";
+import { Graph, alg } from "@dagrejs/graphlib";
+//#region src/tickets/ticket-graph.ts
+var TicketGraphError = class extends Data.TaggedError("TicketGraphError") {};
+function buildTicketGraphEffect(tasks) {
+	return Effect.gen(function* () {
+		const graph = buildUncheckedTicketGraph(tasks);
+		const missingDependencies = missingDependencyMessages(graph);
+		if (missingDependencies.length > 0) return yield* Effect.fail(new TicketGraphError({ message: `Backlog dependency graph has missing references: ${missingDependencies.join("; ")}` }));
+		const cycles = alg.findCycles(graph.dependencyGraph);
+		if (cycles.length > 0) return yield* Effect.fail(new TicketGraphError({ message: `Backlog dependency graph contains cycle: ${cycles.map((cycle) => cycle.sort(compareTaskIds).join(" -> ")).join("; ")}` }));
+		return graph;
+	});
+}
+function sequenceTicketBatchesEffect(graph, ticketIds = graph.dependencyGraph.nodes()) {
+	return Effect.gen(function* () {
+		const batches = sequenceUncheckedTicketBatches(graph, ticketIds);
+		if (batches.length === 0 && ticketIds.length > 0) return yield* Effect.fail(new TicketGraphError({ message: `Backlog dependency graph cannot be sequenced: ${[...ticketIds].sort(compareTaskIds).join(", ")}` }));
+		return batches;
+	});
+}
+function scopedTicketIds(graph, rootId) {
+	if (!rootId) return graph.dependencyGraph.nodes().sort(compareTaskIds);
+	if (!graph.tasksById.has(rootId)) return [];
+	const ids = new Set([rootId]);
+	const visit = (id) => {
+		for (const child of graph.childrenByParentId.get(id) ?? []) {
+			ids.add(child.id);
+			visit(child.id);
+		}
+	};
+	visit(rootId);
+	return [...ids].sort(compareTaskIds);
+}
+function predecessorIds(graph, id) {
+	return [...graph.dependencyGraph.predecessors(id) ?? []].sort(compareTaskIds);
+}
+function compareTaskIds(a, b) {
+	return compareTicketIds(a, b);
+}
+function buildUncheckedTicketGraph(tasks) {
+	const sortedTasks = [...tasks].sort(compareTasks);
+	const tasksById = indexTasksById(sortedTasks);
+	const dependencyGraph = buildDependencyGraph(sortedTasks, tasksById);
+	return {
+		childrenByParentId: indexChildrenByParentId(sortedTasks),
+		dependencyGraph,
+		tasksById
+	};
+}
+function indexTasksById(tasks) {
+	const tasksById = /* @__PURE__ */ new Map();
+	for (const task of tasks) tasksById.set(task.id, task);
+	return tasksById;
+}
+function buildDependencyGraph(tasks, tasksById) {
+	const dependencyGraph = new Graph({ directed: true });
+	addDependencyNodes(dependencyGraph, tasks);
+	addDependencyEdges(dependencyGraph, tasks, tasksById);
+	return dependencyGraph;
+}
+function addDependencyNodes(dependencyGraph, tasks) {
+	for (const task of tasks) dependencyGraph.setNode(task.id, task);
+}
+function addDependencyEdges(dependencyGraph, tasks, tasksById) {
+	for (const task of tasks) addTaskDependencyEdges(dependencyGraph, task, tasksById);
+}
+function addTaskDependencyEdges(dependencyGraph, task, tasksById) {
+	for (const dependency of task.dependencies) if (tasksById.has(dependency)) dependencyGraph.setEdge(dependency, task.id);
+}
+function missingDependencyMessages(graph) {
+	const messages = [];
+	for (const task of graph.tasksById.values()) for (const dependency of task.dependencies) if (!graph.tasksById.has(dependency)) messages.push(`${task.id} depends on missing ${dependency}`);
+	return messages;
+}
+function sequenceUncheckedTicketBatches(graph, ticketIds) {
+	const remaining = new Set(ticketIds);
+	const batches = [];
+	while (remaining.size > 0) {
+		const ready = [...remaining].filter((id) => predecessorIds(graph, id).every((dependency) => !remaining.has(dependency))).sort(compareTaskIds);
+		if (ready.length === 0) return [];
+		batches.push(ready);
+		for (const id of ready) remaining.delete(id);
+	}
+	return batches;
+}
+function compareTasks(a, b) {
+	return compareBacklogTasks(a, b);
+}
+//#endregion
+export { buildTicketGraphEffect, compareTaskIds, predecessorIds, scopedTicketIds, sequenceTicketBatchesEffect };

package/dist/tickets/ticket-plan-command-args.js

@@ -0,0 +1,28 @@
+//#region src/tickets/ticket-plan-command-args.ts
+function ticketCreateArgs(task, options = {}) {
+	const dependencyIds = options.dependencyIds ?? localDependencyKeys(task);
+	return [
+		"task",
+		"create",
+		task.title,
+		...options.parentId ? ["--parent", options.parentId] : [],
+		"--description",
+		task.description,
+		...task.priority ? ["--priority", task.priority] : [],
+		...dependencyIds.flatMap((dependencyId) => ["--dep", dependencyId]),
+		...task.acceptance_criteria.flatMap((criterion) => ["--ac", `${criterion.text}; evidence: ${criterion.evidence}`]),
+		"--plan",
+		task.plan,
+		...task.references.flatMap((reference) => ["--ref", reference]),
+		...task.likely_files.flatMap((path) => ["--modified-file", path]),
+		"--plain"
+	];
+}
+function formatBacklogCommand(args) {
+	return ["backlog", ...args].join(" ");
+}
+function localDependencyKeys(task) {
+	return "depends_on" in task ? task.depends_on : [];
+}
+//#endregion
+export { formatBacklogCommand, ticketCreateArgs };

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

@@ -0,0 +1,22 @@
+import { ticketCreateArgs } from "./ticket-plan-command-args.js";
+//#region src/tickets/ticket-plan-render.ts
+const SAFE_SHELL_ARG_RE = /^[A-Za-z0-9_./:=@+-]+$/;
+function renderTicketPlanDryRun(plan) {
+	return [
+		"# Dry run: no Backlog files were written.",
+		...plan.epic ? [renderCreateCommand(plan.epic)] : [],
+		...plan.tickets.map((ticket) => renderCreateCommand(ticket, plan.epic?.key))
+	].join("\n");
+}
+function renderCreateCommand(task, parentKey) {
+	return renderCommand(["backlog", ...ticketCreateArgs(task, { parentId: parentKey })]);
+}
+function renderCommand(args) {
+	return args.map(shellArg).join(" ");
+}
+function shellArg(value) {
+	if (SAFE_SHELL_ARG_RE.test(value)) return value;
+	return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+//#endregion
+export { renderTicketPlanDryRun };