@oisincoveney/pipeline 2.9.0 → 2.11.0

package/README.md

@@ -98,6 +98,8 @@ Canonical commands:
 - `moka export <run-id> --sanitize`: print a portable evidence bundle.
 - `moka doctor`: check local prerequisites and config health.
 - `moka init`: install package-owned host resources for a repository.
+- `moka refresh-harnesses`: force-refresh generated agent harnesses and commit
+  owned resource changes.
 
 ```shell
 moka run "Implement PIPE-123 user-facing behavior"
@@ -109,6 +111,7 @@ moka run --effort normal "Implement a standard fix"
 moka run --target remote --effort thorough "Submit a full hosted graph run"
 moka run --read-only "Inspect the repository without edits"
 moka run --target remote --command -- opencode run "fix this bug"
+moka refresh-harnesses
 ```
 
 Flag defaults and choices:
@@ -119,6 +122,27 @@ Flag defaults and choices:
 - `--effort` selects `quick`, `normal`, or `thorough`; `normal` is the default.
 - `--read-only` switches mode to `read`; mode defaults to `write`.
 
+Moka ticket selects and scopes Backlog work; moka run executes selected work.
+Use Backlog CLI for task creation and editing instead of direct markdown edits.
+
+```shell
+moka ticket graph check --root PIPE-84
+moka ticket sequence --root PIPE-84 --plain
+moka ticket next --root PIPE-84 --json
+moka ticket next --claim --root PIPE-84
+moka ticket create --dry-run "Plan a small Backlog task"
+moka ticket create --apply --parent PIPE-84 "Plan and create child tasks"
+moka ticket start --root PIPE-84
+moka ticket start --dry-run --root PIPE-84 --effort quick --target local
+```
+
+Read-only ticket commands are `moka ticket graph check`, `moka ticket sequence`,
+`moka ticket next`, `moka ticket create --dry-run`, and
+`moka ticket start --dry-run`. Commands that mutate or run work are
+`moka ticket next --claim`, `moka ticket create --apply`, and
+`moka ticket start` without `--dry-run`: they use Backlog CLI task creation and
+editing or invoke `moka run` for the selected ticket.
+
 Local run artifacts live under `.pipeline/runs/<runId>/`:
 
 ```text

package/defaults/opencode-ecosystem.yaml

@@ -180,9 +180,9 @@ mcp_backends:
     required: true
     credentials: [GITHUB_TOKEN]
     role: repository, PR, issue, and release workflow access
-  - id: playwright-browser
-    name: Playwright/browser
-    locality: repo-local
+  - id: playwright
+    name: Playwright
+    locality: shared-remote
     required: true
     credentials: []
     role: browser automation and frontend verification

package/defaults/profiles.yaml

@@ -13,6 +13,9 @@ mcp_gateway:
     uidotsh:
       locality: shared-remote
       tool_prefixes: [uidotsh]
+    playwright:
+      locality: shared-remote
+      tool_prefixes: [playwright]
     qdrant:
       locality: repo-scoped-remote
       tool_prefixes: [qdrant]
@@ -108,6 +111,20 @@ profiles:
       format: json_schema
       schema_path: .pipeline/schemas/research.schema.json
       repair: { enabled: true, max_attempts: 1 }
+  moka-ticket-scoper:
+    runner: opencode
+    description: Scope a request into a validated Backlog ticket plan.
+    instructions: { inline: "Use the scope skill contract to produce implementation-complete Backlog tickets. Return only valid JSON matching `.pipeline/schemas/ticket-plan.schema.json`. Every acceptance criterion must include concrete evidence text. Do not emit partial tickets; include dependencies, likely files, references, priorities, and plan text for each proposed ticket." }
+    timeout_ms: 300000
+    skills: [scope]
+    mcp_servers: [pipeline-gateway]
+    tools: [read, list, grep, glob, bash]
+    filesystem: { mode: read-only, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
+    network: { mode: inherit }
+    output:
+      format: json_schema
+      schema_path: .pipeline/schemas/ticket-plan.schema.json
+      repair: { enabled: true, max_attempts: 1 }
   moka-inspector:
     runner: opencode
     model: openai/gpt-5.5-low

package/dist/backlog.js

@@ -0,0 +1,13 @@
+//#region src/backlog.ts
+/**
+* `backlog task create` (with `--plain`) prints `Task <PREFIX>-<id> - <title>`
+* on the second non-blank line. We accept custom all-caps Backlog prefixes and
+* subtask ids like `PIPE-3.1`.
+*/
+const TASK_ID_RE = /^Task\s+([A-Z]+-[\w.]+)\b/m;
+function parseBacklogTaskId(stdout) {
+	const m = TASK_ID_RE.exec(stdout);
+	return m ? m[1] : null;
+}
+//#endregion
+export { parseBacklogTaskId };

package/dist/cli/program.d.ts

@@ -1,5 +1,7 @@
-import { runPipelineFromConfig } from "../pipeline-runtime.js";
 import { RunEffort, RunMode, RunTarget } from "../run-control/contracts.js";
+import { RunCommand } from "./run-command.js";
+import { TicketCommandOptions } from "../commands/ticket-command.js";
+import { runPipelineFromConfig } from "../pipeline-runtime.js";
 import { Effect } from "effect";
 import { Command } from "commander";
 
@@ -27,7 +29,11 @@ interface RunControlOptions {
  */
 declare function execute(description: string, options?: ExecuteOptions): Promise<void>;
 declare function quick(description: string, options?: Omit<ExecuteOptions, "entrypoint">): Promise<void>;
-declare function createCliProgram(): Command;
+interface CliProgramOptions {
+  readonly runCommand?: RunCommand;
+  readonly ticketCommand?: TicketCommandOptions;
+}
+declare function createCliProgram(options?: CliProgramOptions): Command;
 declare function runCli(argv: string[]): Promise<void>;
 //#endregion
 export { createCliProgram, execute, quick, runCli };

package/dist/cli/program.js

@@ -11,9 +11,11 @@ import { formatCodexAuthSyncResult, syncLocalCodexAuth } from "../codex-auth-syn
 import { registerBenchCommand } from "../commands/bench-command.js";
 import { registerConfiguredEntrypointCommands } from "../commands/pipeline-command.js";
 import { registerRunnerCommandCommand } from "../commands/runner-command-command.js";
+import { MOKA_RUN_EFFORTS, MOKA_RUN_TARGETS, resolveMokaRun } from "./run-resolver.js";
+import { registerTicketCommand } from "../commands/ticket-command.js";
 import { formatConfigLintWarning, lintPipelineConfig } from "../config/lint.js";
 import { formatInstallCommandsResult, installCommands, parseCommandHost } from "../install-commands.js";
-import { formatPipelineInitResult, initPipelineProject } from "../pipeline-init.js";
+import { formatPipelineInitResult, formatRefreshAgentHarnessesResult, initPipelineProject, refreshAgentHarnesses } from "../pipeline-init.js";
 import { createRun, runControlStatusPaths, updateRunController } from "../run-control/store.js";
 import { registerRunControlCommands } from "../run-control/commands.js";
 import { startDetachedRunController } from "../run-control/detach.js";
@@ -21,7 +23,7 @@ import { createRunStoreRuntimeReporter } from "../run-control/runtime-reporter.j
 import { createRunControlSupervisor } from "../run-control/supervisor.js";
 import { runDoctor } from "./doctor.js";
 import { createTerminalRuntimeReporter, formatDoctorResult, formatRuntimeFailure, formatRuntimeResult } from "./format.js";
-import { MOKA_RUN_EFFORTS, MOKA_RUN_TARGETS, resolveMokaRun } from "./run-resolver.js";
+import { dispatchMokaRunCommand } from "./run-command.js";
 import { addMokaSubmitOptions, runMokaSubmitFromCli } from "./submit-options.js";
 import { Effect } from "effect";
 import { readFileSync } from "node:fs";
@@ -231,30 +233,31 @@ function scheduledEntrypointId(config, workflowId, entrypointId) {
 	const entrypoint = config.entrypoints[id];
 	return entrypoint && "schedule" in entrypoint ? id : null;
 }
-function createCliProgram() {
+function createCliProgram(options = {}) {
 	const configuredPipeline = loadConfiguredEntrypoints(process.env.PIPELINE_TARGET_PATH ?? process.cwd());
 	const program = new Command();
 	program.name("moka").description("Submit work to Momokaya").version(readPackageVersion()).exitOverride();
+	const dispatchResolvedRunCommand = async (call) => {
+		await dispatchMokaRunCommand(call, {
+			runCommand: options.runCommand,
+			runDetached: ({ execution, runControl, task: resolvedTask }) => runDetachedResolvedTask(resolvedTask, execution, runControl),
+			runLocal: ({ execution, runControl, task: resolvedTask }) => runLocalResolvedTask(resolvedTask, execution, runControl),
+			runRemoteSubmit: async ({ descriptionParts: parts, execution }) => {
+				printMokaSubmitResult(await runMokaSubmitFromCli(parts, remoteSubmitFlags(execution)));
+			}
+		});
+	};
 	const runAction = async (descriptionParts, flags) => {
 		const task = descriptionParts.join(" ");
-		const resolution = resolveMokaRun({
+		await dispatchResolvedRunCommand({
+			descriptionParts,
 			flags,
+			resolution: resolveMokaRun({
+				flags,
+				task
+			}),
 			task
 		});
-		if (resolution.execution.kind === "remote-submit") {
-			printMokaSubmitResult(await runMokaSubmitFromCli(descriptionParts, remoteSubmitFlags(resolution.execution)));
-			return;
-		}
-		const runControl = {
-			effort: resolution.effort,
-			mode: resolution.mode === "read" ? "read-only" : "write",
-			target: resolution.target
-		};
-		if (flags.detach) {
-			await runDetachedResolvedTask(task, resolution.execution, runControl);
-			return;
-		}
-		await runLocalResolvedTask(task, resolution.execution, runControl);
 	};
 	program.command("run").description("Primary command: run a workflow from package-owned @oisincoveney/pipeline config").argument("<description...>", "task description").option("--command", "treat input after -- as explicit argv for remote submission").option("--entrypoint <entrypoint>", "entrypoint alias from package config").option("--detach", "start a supervised controller process in the background").addOption(new Option$1("--effort <effort>", "run effort").choices([...MOKA_RUN_EFFORTS]).default("normal")).option("--read-only", "run the read-only inspect workflow").option("--schedule <schedule>", "approved schedule YAML to execute").addOption(new Option$1("--target <target>", "execution target").choices([...MOKA_RUN_TARGETS]).default("local")).option("--workflow <workflow>", "workflow id from package config").action(runAction);
 	program.command("run-controller", { hidden: true }).description("Internal detached run controller").argument("<description...>", "task description").requiredOption("--run-id <run-id>", "existing run id to supervise").option("--entrypoint <entrypoint>", "entrypoint alias from package config").option("--schedule <schedule>", "approved schedule YAML to execute").option("--workflow <workflow>", "workflow id from package config").action(async (descriptionParts, flags) => {
@@ -334,6 +337,14 @@ function createCliProgram() {
 		});
 		console.log(formatPipelineInitResult(result));
 	});
+	program.command("refresh-harnesses").description("Force-refresh generated agent harnesses and commit owned resource changes").addOption(new Option$1("--skill-scope <scope>", "where to install default skills: project (repo-local copy) or personal (one inherited user/global install)").choices(["project", "personal"]).default("project")).option("--message <message>", "git commit message for refreshed harness changes", "chore: update agent harnesses").action(async (flags) => {
+		const result = await refreshAgentHarnesses({
+			commitMessage: flags.message,
+			cwd: process.env.PIPELINE_TARGET_PATH ?? process.cwd(),
+			scope: flags.skillScope
+		});
+		console.log(formatRefreshAgentHarnessesResult(result));
+	});
 	program.command("install-commands").description("Install generated slash-command adapters into this repository").addOption(new Option$1("--host <host>", "host command set to install").choices([
 		"all",
 		"opencode",
@@ -364,6 +375,10 @@ function createCliProgram() {
 	});
 	registerRunnerCommandCommand(program);
 	registerBenchCommand(program);
+	registerTicketCommand(program, {
+		...options.ticketCommand,
+		runCommand: options.ticketCommand?.runCommand ?? dispatchResolvedRunCommand
+	});
 	const configuredEntrypointCommands = registerConfiguredEntrypointCommands(program, compatibilityPresetDescriptions(configuredPipeline), async (entrypoint, task, _opts) => {
 		await execute(task, { entrypoint });
 	});

package/dist/cli/run-command.d.ts

@@ -0,0 +1,12 @@
+import { RunResolution, RunResolverFlags } from "./run-resolver.js";
+
+//#region src/cli/run-command.d.ts
+interface RunCommandCall {
+  readonly descriptionParts: string[];
+  readonly flags: RunResolverFlags;
+  readonly resolution: RunResolution;
+  readonly task: string;
+}
+type RunCommand = (call: RunCommandCall) => Promise<void> | void;
+//#endregion
+export { RunCommand };

package/dist/cli/run-command.js

@@ -0,0 +1,42 @@
+//#region src/cli/run-command.ts
+async function dispatchMokaRunCommand(call, dependencies) {
+	if (dependencies.runCommand) {
+		await dependencies.runCommand(call);
+		return;
+	}
+	await dispatchResolvedMokaRunCommand(call, dependencies);
+}
+async function dispatchResolvedMokaRunCommand(call, dependencies) {
+	const { resolution } = call;
+	const { execution } = resolution;
+	if (execution.kind === "remote-submit") {
+		await dependencies.runRemoteSubmit({
+			descriptionParts: call.descriptionParts,
+			execution
+		});
+		return;
+	}
+	await dispatchLocalMokaRunCommand(call, execution, dependencies);
+}
+async function dispatchLocalMokaRunCommand(call, execution, dependencies) {
+	const localDispatchInput = localRunDispatchInput(call, execution);
+	if (call.flags.detach) {
+		await dependencies.runDetached(localDispatchInput);
+		return;
+	}
+	await dependencies.runLocal(localDispatchInput);
+}
+function localRunDispatchInput(call, execution) {
+	const { resolution, task } = call;
+	return {
+		execution,
+		runControl: {
+			effort: resolution.effort,
+			mode: resolution.mode === "read" ? "read-only" : "write",
+			target: resolution.target
+		},
+		task
+	};
+}
+//#endregion
+export { dispatchMokaRunCommand };

package/dist/cli/run-resolver.d.ts

@@ -0,0 +1,36 @@
+//#region src/cli/run-resolver.d.ts
+declare const MOKA_RUN_EFFORTS: readonly ["normal", "quick", "thorough"];
+declare const MOKA_RUN_TARGETS: readonly ["local", "remote"];
+type MokaRunEffort = (typeof MOKA_RUN_EFFORTS)[number];
+type MokaRunTarget = (typeof MOKA_RUN_TARGETS)[number];
+type MokaRunMode = "read" | "write";
+interface RunResolverFlags {
+  command?: boolean;
+  detach?: boolean;
+  effort?: MokaRunEffort;
+  entrypoint?: string;
+  readOnly?: boolean;
+  schedule?: string;
+  target?: MokaRunTarget;
+  workflow?: string;
+}
+interface LocalRuntimeExecution {
+  entrypoint?: string;
+  kind: "local-runtime";
+  schedule?: string;
+  workflow?: string;
+}
+interface RemoteSubmitExecution {
+  command?: boolean;
+  kind: "remote-submit";
+  mode: "full" | "quick";
+  schedule?: string;
+}
+interface RunResolution {
+  effort: MokaRunEffort;
+  execution: LocalRuntimeExecution | RemoteSubmitExecution;
+  mode: MokaRunMode;
+  target: MokaRunTarget;
+}
+//#endregion
+export { RunResolution, RunResolverFlags };

package/dist/commands/pipeline-command.js

@@ -6,11 +6,13 @@ const BUILTIN_PIPE_COMMANDS = new Set([
 	"explain-plan",
 	"doctor",
 	"init",
+	"refresh-harnesses",
 	"install-commands",
 	"mcp",
 	"submit",
 	"argo",
-	"runner-command"
+	"runner-command",
+	"ticket"
 ]);
 var EntrypointCommandService = class extends Context.Tag("EntrypointCommandService")() {};
 const createEntrypointCommandServiceLive = (runEntrypoint) => Layer.succeed(EntrypointCommandService, { runEntrypoint: (entrypoint, task, opts) => Effect.tryPromise({

package/dist/commands/ticket-command.d.ts

@@ -0,0 +1,15 @@
+import { RunCommand } from "../cli/run-command.js";
+import { AgentResult, RunnerExecutionOptions, RunnerLaunchPlan } from "../runner.js";
+import { BacklogService } from "../runtime/services/backlog-service.js";
+import { Layer } from "effect";
+import { Command } from "commander";
+
+//#region src/commands/ticket-command.d.ts
+type TicketPlanExecutor = (plan: RunnerLaunchPlan, options: RunnerExecutionOptions) => Promise<AgentResult>;
+interface TicketCommandOptions {
+  readonly backlogLayer?: Layer.Layer<BacklogService>;
+  readonly runCommand?: RunCommand;
+  readonly ticketPlanExecutor?: TicketPlanExecutor;
+}
+//#endregion
+export { TicketCommandOptions };

package/dist/commands/ticket-command.js

@@ -0,0 +1,308 @@
+import { parseTicketPlanEffect } from "../tickets/ticket-plan.js";
+import { loadPipelineConfig } from "../config/load.js";
+import "../config.js";
+import { RepoIoServiceLive } from "../runtime/services/repo-io-service.js";
+import { createRunnerLaunchPlan, runLaunchPlan } from "../runner.js";
+import { normalizeRunnerOutput } from "../runner-output.js";
+import { MOKA_RUN_EFFORTS, MOKA_RUN_TARGETS, resolveMokaRun } from "../cli/run-resolver.js";
+import { BacklogService, BacklogServiceLive } from "../runtime/services/backlog-service.js";
+import { applyTicketPlanEffect } from "../tickets/apply-ticket-plan.js";
+import { loadBacklogTaskStoreEffect } from "../tickets/backlog-task-store.js";
+import { buildTicketGraphEffect, scopedTicketIds, sequenceTicketBatchesEffect } from "../tickets/ticket-graph.js";
+import { renderTicketPlanDryRun } from "../tickets/ticket-plan-render.js";
+import { selectNextTicket, selectReadyTickets } from "../tickets/ticket-selection.js";
+import { Data, Effect } from "effect";
+import { Option as Option$1 } from "commander";
+//#region src/commands/ticket-command.ts
+var TicketCommandError = class extends Data.TaggedError("TicketCommandError") {};
+const TICKET_SCOPER_PROFILE = "moka-ticket-scoper";
+const TICKET_SELECTION_STRATEGIES = new Set([
+	"priority",
+	"bfs",
+	"dfs"
+]);
+const TICKET_CREATE_FLAG_RULES = [
+	{
+		invalid: (flags) => Boolean(flags.dryRun && flags.apply),
+		message: "moka ticket create accepts only one of --dry-run or --apply"
+	},
+	{
+		invalid: (flags) => !(flags.dryRun || flags.apply),
+		message: "moka ticket create requires --dry-run or --apply"
+	},
+	{
+		invalid: (flags) => Boolean(flags.parent && !flags.apply),
+		message: "moka ticket create --parent is only valid with --apply"
+	}
+];
+function registerTicketCommand(program, options = {}) {
+	const ticketCommand = program.command("ticket").description("Scope, inspect, and select Backlog tickets for moka runs");
+	ticketCommand.command("graph").description("Inspect the Backlog ticket dependency graph").command("check").description("Validate Backlog ticket dependency references and cycles").option("--root <ticket-id>", "limit validation summary to one ticket tree").action((flags) => runTicketProgram(checkTicketGraphEffect(currentWorktreePath(), flags)));
+	ticketCommand.command("sequence").description("Print dependency execution batches for Backlog tickets").option("--root <ticket-id>", "sequence one ticket tree").option("--plain", "print plain text output").action((flags) => runTicketProgram(printTicketSequenceEffect(currentWorktreePath(), flags)));
+	ticketCommand.command("next").description("Select the next ready Backlog ticket deterministically").option("--root <ticket-id>", "select from one ticket tree").option("--claim", "mark the selected ticket In Progress through Backlog").option("--include-parents", "allow parent tickets in selection results").option("--json", "print machine-readable selection output").option("--strategy <strategy>", "selection strategy: priority, bfs, or dfs").action((flags) => runTicketProgramWithBacklog(printNextTicketEffect(currentWorktreePath(), flags), options.backlogLayer ?? BacklogServiceLive));
+	ticketCommand.command("start").description("Claim the next ready Backlog ticket and run moka").option("--root <ticket-id>", "select from one ticket tree").option("--include-parents", "allow parent tickets in selection results").option("--strategy <strategy>", "selection strategy: priority, bfs, or dfs").option("--dry-run", "print the selected moka run command without claiming").addOption(new Option$1("--effort <effort>", "run effort").choices([...MOKA_RUN_EFFORTS]).default("normal")).addOption(new Option$1("--target <target>", "execution target").choices([...MOKA_RUN_TARGETS]).default("local")).option("--read-only", "run the read-only inspect workflow").action((flags) => runTicketProgramWithBacklog(startTicketEffect(currentWorktreePath(), flags, options.runCommand), options.backlogLayer ?? BacklogServiceLive));
+	ticketCommand.command("create").description("Create a validated Backlog ticket plan").argument("<request...>", "ticket planning request").option("--dry-run", "render Backlog commands without writing tasks").option("--apply", "apply the validated ticket plan through Backlog").option("--parent <task-id>", "existing parent task for applied children").action((requestParts, flags) => Effect.runPromise(Effect.provide(printTicketCreateEffect(currentWorktreePath(), requestParts.join(" "), flags, options.ticketPlanExecutor ?? runLaunchPlan), options.backlogLayer ?? BacklogServiceLive)));
+}
+function startTicketEffect(worktreePath, flags, runCommand) {
+	return Effect.gen(function* () {
+		const { loaded, selectionOptions } = yield* loadTicketSelectionEffect(worktreePath, flags);
+		const selected = yield* readyTicketEffect(selectNextTicket(loaded.graph, selectionOptions));
+		const task = ticketRunTask(selected);
+		const descriptionParts = [task];
+		const runFlags = yield* ticketStartRunFlagsEffect(flags);
+		const resolution = yield* Effect.try({
+			catch: (error) => new TicketCommandError({ message: `Could not resolve moka run for ticket '${selected.id}': ${errorMessage(error)}` }),
+			try: () => resolveMokaRun({
+				flags: runFlags,
+				task
+			})
+		});
+		yield* writeLineEffect(`Selected ticket: ${formatNextTicket(selected)}`);
+		if (flags.dryRun) {
+			yield* writeLineEffect(formatTicketStartDryRun(runFlags, task));
+			return;
+		}
+		if (!runCommand) return yield* Effect.fail(new TicketCommandError({ message: "Could not start moka run: no run dispatcher configured." }));
+		yield* claimTicketEffect(worktreePath, selected);
+		yield* Effect.tryPromise({
+			catch: (error) => new TicketCommandError({ message: `Could not start moka run for ticket '${selected.id}': ${errorMessage(error)}` }),
+			try: async () => {
+				await runCommand({
+					descriptionParts,
+					flags: runFlags,
+					resolution,
+					task
+				});
+			}
+		});
+	});
+}
+function ticketRunTask(ticket) {
+	const title = formatNextTicket(ticket);
+	const description = ticket.description?.trim();
+	return description ? `${title}\n\n${description}` : title;
+}
+function ticketStartRunFlagsEffect(flags) {
+	return Effect.gen(function* () {
+		yield* validateTicketStartFlagsEffect(flags);
+		return ticketStartRunFlags(flags);
+	});
+}
+function validateTicketStartFlagsEffect(flags) {
+	return flags.readOnly && flags.target === "remote" ? Effect.fail(new TicketCommandError({ message: "moka ticket start --read-only cannot be combined with --target remote." })) : Effect.void;
+}
+function ticketStartRunFlags(flags) {
+	return {
+		effort: flags.effort ?? "normal",
+		readOnly: flags.readOnly,
+		target: flags.target ?? "local"
+	};
+}
+function formatTicketStartDryRun(flags, task) {
+	return [
+		"moka run",
+		`--effort ${flags.effort ?? "normal"}`,
+		`--target ${flags.target ?? "local"}`,
+		flags.readOnly ? "--read-only" : "",
+		shellQuote(task)
+	].filter(Boolean).join(" ");
+}
+function shellQuote(value) {
+	return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function printTicketCreateEffect(worktreePath, request, flags, executor) {
+	return Effect.gen(function* () {
+		yield* validateTicketCreateFlagsEffect(flags);
+		const ticketPlan = yield* parseTicketPlanEffect(yield* runTicketScoperEffect(yield* ticketScoperLaunchPlanEffect(worktreePath, request), executor));
+		if (flags.dryRun) {
+			yield* writeLineEffect(renderTicketPlanDryRun(ticketPlan));
+			return;
+		}
+		yield* writeLineEffect(formatAppliedTicketPlan(yield* applyTicketPlanEffect(ticketPlan, worktreePath, { parentId: flags.parent })));
+	});
+}
+function validateTicketCreateFlagsEffect(flags) {
+	const message = ticketCreateFlagErrorMessage(flags);
+	return message ? Effect.fail(new TicketCommandError({ message })) : Effect.void;
+}
+function ticketCreateFlagErrorMessage(flags) {
+	return TICKET_CREATE_FLAG_RULES.find((rule) => rule.invalid(flags))?.message;
+}
+function ticketScoperLaunchPlanEffect(worktreePath, request) {
+	return Effect.gen(function* () {
+		const config = yield* Effect.try({
+			catch: (error) => new TicketCommandError({ message: `Could not load pipeline config: ${errorMessage(error)}` }),
+			try: () => loadPipelineConfig(worktreePath, { allowMissingLintFileReferences: true })
+		});
+		return yield* Effect.try({
+			catch: (error) => new TicketCommandError({ message: `Could not create ticket scoper launch plan: ${errorMessage(error)}` }),
+			try: () => createRunnerLaunchPlan(config, {
+				nodeId: "ticket-plan",
+				profileId: TICKET_SCOPER_PROFILE,
+				prompt: ticketPlanPrompt(request),
+				worktreePath
+			})
+		});
+	});
+}
+function runTicketScoperEffect(launchPlan, executor) {
+	return Effect.gen(function* () {
+		const result = yield* Effect.tryPromise({
+			catch: (error) => new TicketCommandError({ message: `Ticket scoper failed: ${errorMessage(error)}` }),
+			try: () => executor(launchPlan, {})
+		});
+		if (result.exitCode !== 0) return yield* Effect.fail(new TicketCommandError({ message: ticketScoperFailureMessage(result) }));
+		return normalizeRunnerOutput(launchPlan, result.stdout).output.trim();
+	});
+}
+function checkTicketGraphEffect(worktreePath, flags) {
+	return Effect.gen(function* () {
+		yield* writeLineEffect(`OK: ticket graph valid (${(yield* loadTicketGraphEffect(worktreePath, flags.root)).scopedIds.length} tickets)`);
+	});
+}
+function printTicketSequenceEffect(worktreePath, flags) {
+	return Effect.gen(function* () {
+		const loaded = yield* loadTicketGraphEffect(worktreePath, flags.root);
+		yield* writeLineEffect(formatSequence(yield* sequenceTicketBatchesEffect(loaded.graph, loaded.scopedIds)));
+	});
+}
+function printNextTicketEffect(worktreePath, flags) {
+	return Effect.gen(function* () {
+		const { loaded, selectionOptions } = yield* loadTicketSelectionEffect(worktreePath, flags);
+		const selected = selectNextTicket(loaded.graph, selectionOptions);
+		if (flags.claim) {
+			const ticket = yield* readyTicketEffect(selected);
+			yield* claimTicketEffect(worktreePath, ticket);
+			yield* writeLineEffect(`Claimed ${formatNextTicket(ticket)}`);
+			return;
+		}
+		const ready = selectReadyTickets(loaded.graph, selectionOptions);
+		yield* writeLineEffect(flags.json ? JSON.stringify({
+			ready: ready.map(ticketJson),
+			selected: ticketJson(selected)
+		}) : formatNextTicket(selected));
+	});
+}
+function claimTicketEffect(worktreePath, ticket) {
+	return Effect.gen(function* () {
+		yield* (yield* BacklogService).run([
+			"task",
+			"edit",
+			ticket.id,
+			"--status",
+			"In Progress",
+			"--plain"
+		], worktreePath).pipe(Effect.mapError((error) => new TicketCommandError({ message: `Could not claim ticket '${ticket.id}': ${errorMessage(error)}` })));
+	});
+}
+function loadTicketGraphEffect(worktreePath, rootId) {
+	return Effect.gen(function* () {
+		const graph = yield* buildTicketGraphEffect((yield* loadBacklogTaskStoreEffect(worktreePath)).tasks);
+		const scopedIds = scopedTicketIds(graph, rootId);
+		if (rootId && scopedIds.length === 0) return yield* Effect.fail(new TicketCommandError({ message: `Unknown Backlog ticket '${rootId}'` }));
+		return {
+			graph,
+			scopedIds
+		};
+	});
+}
+function loadTicketSelectionEffect(worktreePath, flags) {
+	return Effect.gen(function* () {
+		const strategy = yield* parseSelectionStrategyEffect(flags.strategy);
+		return {
+			loaded: yield* loadTicketGraphEffect(worktreePath, flags.root),
+			selectionOptions: {
+				includeParents: flags.includeParents,
+				rootId: flags.root,
+				strategy
+			}
+		};
+	});
+}
+function parseSelectionStrategyEffect(strategy) {
+	return strategy === void 0 || isTicketSelectionStrategy(strategy) ? Effect.succeed(strategy) : Effect.fail(new TicketCommandError({ message: `Unknown ticket selection strategy '${strategy}'; expected priority, bfs, or dfs` }));
+}
+function isTicketSelectionStrategy(strategy) {
+	return TICKET_SELECTION_STRATEGIES.has(strategy);
+}
+function formatSequence(batches) {
+	return batches.map((batch, index) => [`Sequence ${index + 1}:`, ...batch.map((id) => `  ${id}`)].join("\n")).join("\n\n");
+}
+function formatNextTicket(ticket) {
+	return ticket ? `${ticket.id} - ${ticket.title}` : "No ready tickets.";
+}
+function formatAppliedTicketPlan(applied) {
+	return ["Created tickets:", ...Object.entries(applied.taskIdsByKey).map(([key, taskId]) => `  ${key}: ${taskId}`)].join("\n");
+}
+function ticketJson(ticket) {
+	if (!ticket) return null;
+	return {
+		acceptanceCriteria: ticket.acceptanceCriteria,
+		dependencies: ticket.dependencies,
+		description: ticket.description,
+		id: ticket.id,
+		modifiedFiles: ticket.modifiedFiles,
+		ordinal: ticket.ordinal,
+		parentTaskId: ticket.parentTaskId,
+		priority: ticket.priority,
+		references: ticket.references,
+		status: ticket.status,
+		title: ticket.title
+	};
+}
+function writeLineEffect(line) {
+	return Effect.sync(() => console.log(line));
+}
+function readyTicketEffect(ticket) {
+	return ticket ? Effect.succeed(ticket) : Effect.fail(new TicketCommandError({ message: "No ready tickets." }));
+}
+function currentWorktreePath() {
+	return process.env.PIPELINE_TARGET_PATH ?? process.cwd();
+}
+function runTicketProgram(program) {
+	return Effect.runPromise(Effect.provide(program, RepoIoServiceLive));
+}
+function runTicketProgramWithBacklog(program, backlogLayer) {
+	return Effect.runPromise(Effect.provide(Effect.provide(program, RepoIoServiceLive), backlogLayer));
+}
+function ticketPlanPrompt(request) {
+	return [
+		"Use the scope skill contract to produce a complete Backlog ticket plan.",
+		"Return only JSON matching this exact snake_case shape. Do not emit Markdown.",
+		"{\"epic\":{\"key\":\"epic\",\"title\":\"...\",\"description\":\"...\",\"priority\":\"high|medium|low\",\"acceptance_criteria\":[{\"text\":\"...\",\"evidence\":\"...\"}],\"likely_files\":[\"path\"],\"references\":[\"path-or-url\"],\"plan\":\"...\"},\"tickets\":[{\"key\":\"local-key\",\"title\":\"...\",\"description\":\"...\",\"priority\":\"high|medium|low\",\"depends_on\":[\"other-local-key\"],\"acceptance_criteria\":[{\"text\":\"...\",\"evidence\":\"...\"}],\"likely_files\":[\"path\"],\"references\":[\"path-or-url\"],\"plan\":\"...\"}]}",
+		"Omit epic entirely when no epic should be created.",
+		"Use depends_on only for local ticket keys from the same tickets array.",
+		"Every acceptance_criteria entry must include concrete evidence text.",
+		"Do not use epics, type, dependencies, labels, acceptanceCriteria, qualityGate, or camelCase keys.",
+		"Do not return partial tickets; if the request is unclear, encode the missing decision in the plan text instead of omitting required fields.",
+		"Task request:",
+		request
+	].join("\n");
+}
+function ticketScoperFailureMessage(result) {
+	return runnerFailureMessage(`ticket scoper '${TICKET_SCOPER_PROFILE}'`, "timed out waiting for ticket scoper", result);
+}
+function runnerFailureMessage(label, timeoutMessage, result) {
+	const details = runnerFailureDetails(timeoutMessage, result);
+	const message = `${label} failed with exit ${result.exitCode}`;
+	return details.length === 0 ? message : `${message}\n${details.join("\n")}`;
+}
+function runnerFailureDetails(timeoutMessage, result) {
+	const details = [];
+	appendDetail(details, result.timedOut ? timeoutMessage : void 0);
+	appendDetail(details, labelledOutput("stderr", result.stderr));
+	appendDetail(details, labelledOutput("stdout", result.stdout));
+	return details;
+}
+function labelledOutput(label, value) {
+	const trimmed = value?.trim();
+	return trimmed ? `${label}:\n${trimmed}` : void 0;
+}
+function appendDetail(details, detail) {
+	if (detail) details.push(detail);
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+export { registerTicketCommand };