ralphctl 0.27.0 → 0.28.0

package/dist/cli-W3M7L4TP.mjs

@@ -0,0 +1,2772 @@
+#!/usr/bin/env node
+import {
+  AI_PROVIDERS,
+  AI_PROVIDERS_HINT,
+  ASSERT_SPRINT_STATUS,
+  AbortError,
+  AbsolutePath,
+  BUNDLED_SKILLS,
+  CLI_METADATA,
+  DEFAULT_SETTINGS,
+  DISPLAY_TEXT_MAX_CHARS,
+  FLOW_IDS,
+  IsoTimestamp,
+  PRESET_NAMES,
+  PROVIDER_BINARY,
+  ProjectId,
+  RALPHCTL_DEBUG_TRACE_ENV,
+  RALPHCTL_HOME_ENV,
+  Result,
+  SKILL_MOUNTING_FLOW_IDS,
+  SprintId,
+  StorageError,
+  TaskId,
+  TicketId,
+  ValidationError,
+  activateSprintUseCase,
+  addTicket,
+  applyPreset,
+  applySettingsKey,
+  approveTicketRequirements,
+  assertNoActivePeer,
+  assertSprintStatus,
+  bootstrapApp,
+  buildComposedSkillSource,
+  checkCli,
+  commandExists,
+  createAiProvider,
+  createAtomicWriteFile,
+  createBundledAgentDefinitionSource,
+  createCloseSprintFlow,
+  createCreatePrFlow,
+  createDoctorFlow,
+  createExportContextFlow,
+  createExportRequirementsFlow,
+  createFsProjectRepository,
+  createFsSprintExecutionRepository,
+  createFsSprintRepository,
+  createFsTaskRepository,
+  createJsonSettingsRepository,
+  createLastSelectionStore,
+  createOperatorAgentDefinitionSource,
+  createProject,
+  createRepository,
+  createRunner,
+  createSettingsApplyPresetFlow,
+  createSettingsSetFlow,
+  createSettingsSetProviderFlow,
+  createSettingsShowFlow,
+  createSkillsAdapter,
+  createSprintWithExecution,
+  createTask,
+  createTicket,
+  createTicketAddFlow,
+  createTicketPublishFlow,
+  createTicketRemoveFlow,
+  defaultAiSettingsForProvider,
+  detectInstalledProviders,
+  ensureCanonicalSprintDir,
+  ensureStorageRoots,
+  evaluationArtifactSprintPath,
+  evaluatorOutputContract,
+  flowRegistry,
+  foldOutcomeStats,
+  formatBytes,
+  formatDiffStat,
+  formatRelativeAge,
+  generatorOutputContract,
+  groupByFlow,
+  isAiProvider,
+  isPresetName,
+  latestRecordedEvaluation,
+  listRuns,
+  messageOf,
+  nameBlockedTasks,
+  parseDuration,
+  planSprint,
+  plural,
+  presetAdaptationLines,
+  probeTaskQuarantine,
+  quarantineStashMessage,
+  recommendedPriorWork,
+  reopenDoneSprint,
+  resolveEffort,
+  resolveSprintDir,
+  runCommand,
+  sanitizeDisplayText,
+  storagePathsFromRoot,
+  unblockTaskLocked,
+  warnIfVague
+} from "./chunk-WAHQPVTG.mjs";
+
+// src/application/ui/cli/cli.ts
+import { Command } from "commander";
+
+// src/application/ui/cli/parse-implement-role-overrides.ts
+var parseRole = (role, provider, model) => {
+  if (provider === void 0 !== (model === void 0)) {
+    const [have, need] = provider === void 0 ? ["model", "provider"] : ["provider", "model"];
+    return {
+      ok: false,
+      error: `--implement-${role}-${have} requires --implement-${role}-${need} (both must be supplied together).`
+    };
+  }
+  if (provider === void 0 || model === void 0) {
+    return { ok: true };
+  }
+  if (!isAiProvider(provider)) {
+    return {
+      ok: false,
+      error: `--implement-${role}-provider: '${provider}' is not a supported provider (${AI_PROVIDERS_HINT}).`
+    };
+  }
+  const trimmedModel = model.trim();
+  if (trimmedModel.length === 0) {
+    return { ok: false, error: `--implement-${role}-model must be a non-empty string.` };
+  }
+  return { ok: true, row: { provider, model: trimmedModel } };
+};
+var parseImplementRoleOverrides = (input) => {
+  const generator = parseRole("generator", input.generatorProvider, input.generatorModel);
+  if (!generator.ok) return { ok: false, error: generator.error };
+  const evaluator = parseRole("evaluator", input.evaluatorProvider, input.evaluatorModel);
+  if (!evaluator.ok) return { ok: false, error: evaluator.error };
+  if (generator.row === void 0 && evaluator.row === void 0) {
+    return { ok: true, overrides: void 0 };
+  }
+  return {
+    ok: true,
+    overrides: {
+      ...generator.row !== void 0 ? { generator: generator.row } : {},
+      ...evaluator.row !== void 0 ? { evaluator: evaluator.row } : {}
+    }
+  };
+};
+
+// src/application/ui/cli/report-cli-error.ts
+var fail = (message) => {
+  process.stderr.write(`error: ${message}
+`);
+  process.exitCode = 1;
+};
+var okOrFail = (r, prefix = "") => {
+  if (!r.ok) fail(prefix + r.error.message);
+  return r.ok;
+};
+var EXIT_INTERRUPTED = 130;
+var reportFatal = (err) => {
+  if (err instanceof AbortError) {
+    process.stderr.write("ralphctl: cancelled\n");
+    process.exitCode = EXIT_INTERRUPTED;
+    return;
+  }
+  const message = messageOf(err);
+  process.stderr.write(`ralphctl: ${message.trim()}
+`);
+  const debug = process.env[RALPHCTL_DEBUG_TRACE_ENV];
+  if (typeof debug === "string" && debug.length > 0 && err instanceof Error && err.stack !== void 0) {
+    process.stderr.write(`${err.stack}
+`);
+  } else {
+    process.stderr.write(`ralphctl: re-run with ${RALPHCTL_DEBUG_TRACE_ENV}=1 for the full stack
+`);
+  }
+  process.exitCode = 1;
+};
+
+// src/application/ui/cli/resolve-sprint-selection.ts
+var DEFAULT_MISSING_MESSAGE = "no sprint specified \u2014 pass --sprint <id> or pin one with `ralphctl sprint set-current <id>`";
+var invalidId = (value, detail) => (
+  // Keep the long-established `invalid sprint id: …` stderr phrasing every command printed
+  // before this helper existed — scripts (and the e2e suite) match on it.
+  new ValidationError({ field: "sprint-id", value, message: `invalid sprint id: ${detail}` })
+);
+var resolveSprintId = async (raw, stateRoot, opts = {}) => {
+  if (raw !== void 0) {
+    const parsed2 = SprintId.parse(raw);
+    if (!parsed2.ok) return Result.error(invalidId(raw, parsed2.error.message));
+    return Result.ok({ sprintId: parsed2.value, fromPin: false });
+  }
+  const pinned = (await createLastSelectionStore(stateRoot).read())?.sprintId;
+  if (pinned === void 0) {
+    return Result.error(
+      new ValidationError({
+        field: "sprint",
+        value: void 0,
+        message: opts.missingMessage ?? DEFAULT_MISSING_MESSAGE
+      })
+    );
+  }
+  const parsed = SprintId.parse(String(pinned));
+  if (!parsed.ok) return Result.error(invalidId(pinned, `${parsed.error.message} (from the pinned selection)`));
+  return Result.ok({ sprintId: parsed.value, fromPin: true });
+};
+var pinFallbackNotice = (id) => `using current sprint ${String(id)} (from sprint set-current; pass --sprint to override)
+`;
+var SPRINT_OPTION_FLAGS = "-s, --sprint <id>";
+var SPRINT_OPTION_DESC = "sprint id (defaults to the current sprint)";
+var resolveSprintForCli = async (raw, stateRoot) => {
+  const resolved = await resolveSprintId(raw, stateRoot);
+  if (!okOrFail(resolved)) return void 0;
+  if (resolved.value.fromPin) process.stderr.write(pinFallbackNotice(resolved.value.sprintId));
+  return resolved.value.sprintId;
+};
+var resolveSprintAndIdForCli = async (rawSprint, stateRoot, rawId, parse, label) => {
+  const resolved = await resolveSprintId(rawSprint, stateRoot);
+  if (!okOrFail(resolved)) return void 0;
+  const id = parse(rawId);
+  if (!id.ok) {
+    fail(`invalid ${label} id: ${id.error.message}`);
+    return void 0;
+  }
+  if (resolved.value.fromPin) process.stderr.write(pinFallbackNotice(resolved.value.sprintId));
+  return { sprintId: resolved.value.sprintId, id: id.value };
+};
+
+// src/application/ui/cli/commands/export-requirements.ts
+var exportRequirementsAction = async (opts) => {
+  const outputPath = AbsolutePath.parse(opts.output);
+  if (!okOrFail(outputPath, "--output: ")) return;
+  const { deps, storage } = await bootstrapApp();
+  const sprintId = await resolveSprintForCli(opts.sprint, storage.stateRoot);
+  if (sprintId === void 0) return;
+  const flow = createExportRequirementsFlow({
+    sprintRepo: deps.sprintRepo,
+    writeFile: deps.writeFile
+  });
+  const result = await flow.execute({
+    input: { sprintId, outputPath: outputPath.value }
+  });
+  if (!result.ok) {
+    fail(result.error.error.message);
+    return;
+  }
+  const out = result.value.ctx.output;
+  process.stdout.write(`wrote ${String(out.outputPath)} (${String(out.byteCount)} bytes)
+`);
+};
+var registerExportRequirementsCommand = (program) => {
+  program.command("export-requirements").description("write the sprint's approved-ticket requirements to a markdown file").option("-s, --sprint <id>", "sprint id (defaults to the current sprint)").requiredOption("-o, --output <path>", "output markdown path").action(exportRequirementsAction);
+};
+
+// src/application/ui/cli/commands/export-context.ts
+var exportContextAction = async (opts) => {
+  const outputPath = AbsolutePath.parse(opts.output);
+  if (!okOrFail(outputPath, "--output: ")) return;
+  let projectId;
+  if (opts.project !== void 0) {
+    const parsed = ProjectId.parse(opts.project);
+    if (!okOrFail(parsed, "invalid project id: ")) return;
+    projectId = parsed.value;
+  }
+  const { deps, storage } = await bootstrapApp();
+  const sprintId = await resolveSprintForCli(opts.sprint, storage.stateRoot);
+  if (sprintId === void 0) return;
+  const flow = createExportContextFlow({
+    sprintRepo: deps.sprintRepo,
+    projectRepo: deps.projectRepo,
+    taskRepo: deps.taskRepo,
+    writeFile: deps.writeFile
+  });
+  const result = await flow.execute({
+    input: {
+      sprintId,
+      ...projectId !== void 0 ? { projectId } : {},
+      outputPath: outputPath.value
+    }
+  });
+  if (!result.ok) {
+    fail(result.error.error.message);
+    return;
+  }
+  const out = result.value.ctx.output;
+  process.stdout.write(`wrote ${String(out.outputPath)} (${String(out.byteCount)} bytes)
+`);
+};
+var registerExportContextCommand = (program) => {
+  program.command("export-context").description("render the harness-context markdown for a sprint").option("-s, --sprint <id>", "sprint id (defaults to the current sprint)").option("-p, --project <id>", "project id (defaults to the sprint's project)").requiredOption("-o, --output <path>", "output markdown path").action(exportContextAction);
+};
+
+// src/application/ui/cli/commands/create-pr.ts
+var buildCreatePrFlow = (deps, storage, useAi) => {
+  const resolvedProvider = deps.settings.ai.createPr.provider;
+  const effort = resolveEffort("createPr", deps.settings);
+  const provider = createAiProvider({
+    flow: "createPr",
+    ai: deps.settings.ai,
+    harnessConfig: deps.settings.harness,
+    eventBus: deps.eventBus,
+    childRegistry: deps.childRegistry
+  });
+  const skillSource = buildComposedSkillSource(
+    { app: deps, storage },
+    {},
+    resolvedProvider,
+    "create-pr",
+    deps.settings,
+    {}
+  );
+  const skillsAdapter = createSkillsAdapter({ provider: resolvedProvider, logger: deps.logger });
+  return createCreatePrFlow(
+    {
+      sprintRepo: deps.sprintRepo,
+      sprintExecutionRepo: deps.sprintExecutionRepo,
+      taskRepo: deps.taskRepo,
+      pullRequestCreator: deps.pullRequestCreator,
+      gitRunner: deps.gitRunner,
+      eventBus: deps.eventBus,
+      clock: deps.clock,
+      provider,
+      templateLoader: deps.templateLoader,
+      writeFile: deps.writeFile,
+      logger: deps.logger,
+      model: deps.settings.ai.createPr.model,
+      ...effort !== void 0 ? { effort } : {},
+      skillSource,
+      skillsAdapter
+    },
+    { useAi, providerId: resolvedProvider }
+  );
+};
+var createPrAction = async (opts) => {
+  const cwdInput = opts.cwd ?? process.cwd();
+  const cwd = AbsolutePath.parse(cwdInput);
+  if (!okOrFail(cwd, "--cwd: ")) return;
+  const { deps, storage } = await bootstrapApp();
+  const sprintId = await resolveSprintForCli(opts.sprint, storage.stateRoot);
+  if (sprintId === void 0) return;
+  if (opts.ai) {
+    const gate = await checkCli("create-pr", deps.settings);
+    if (gate !== void 0 && !gate.ok) {
+      fail(gate.reason);
+      return;
+    }
+  }
+  const resolvedDir = await resolveSprintDir(storage.dataRoot, sprintId);
+  if (resolvedDir === void 0) {
+    fail("sprint dir: not found on disk");
+    return;
+  }
+  const sprintDir = AbsolutePath.parse(resolvedDir);
+  if (!okOrFail(sprintDir, "sprint dir: ")) return;
+  const flow = buildCreatePrFlow(deps, storage, opts.ai);
+  const result = await flow.execute({
+    input: {
+      sprintId,
+      cwd: cwd.value,
+      sprintDir: sprintDir.value,
+      base: opts.base,
+      draft: opts.draft,
+      ...opts.title !== void 0 ? { title: opts.title } : {},
+      ...opts.body !== void 0 ? { body: opts.body } : {}
+    }
+  });
+  if (!result.ok) {
+    fail(result.error.error.message);
+    return;
+  }
+  process.stdout.write(`opened PR ${result.value.ctx.output.url}
+`);
+};
+var registerCreatePrCommand = (program) => {
+  program.command("create-pr").description("open a PR for the sprint's branch and persist the URL").option("-s, --sprint <id>", "sprint id (defaults to the current sprint)").option("--cwd <path>", "repository root (defaults to process.cwd())").option("-b, --base <branch>", "target branch", "main").option("--draft", "open as draft", false).option("-t, --title <title>", "override the derived PR title").option("--body <body>", "override the derived PR body").option("--no-ai", "skip AI content generation, use the template only").action(createPrAction);
+};
+
+// src/application/ui/cli/commands/doctor.ts
+var PROBE_TAG = { pass: "OK  ", warn: "WARN", unknown: "UNK ", fail: "FAIL" };
+var printProbe = (probe) => {
+  const detail = probe.detail !== void 0 ? ` \u2014 ${probe.detail}` : "";
+  process.stdout.write(`${PROBE_TAG[probe.status]}  ${probe.label}${detail}
+`);
+  if (probe.hint !== void 0 && probe.status !== "pass") {
+    process.stdout.write(`      hint: ${probe.hint}
+`);
+  }
+};
+var doctorAction = async () => {
+  const { deps, storage } = await bootstrapApp();
+  const flow = createDoctorFlow({
+    projectRepo: deps.projectRepo,
+    sprintRepo: deps.sprintRepo,
+    sprintExecutionRepo: deps.sprintExecutionRepo,
+    settingsRepo: deps.settingsRepo,
+    commandExists,
+    runCommand,
+    nodeVersion: process.version
+  });
+  const result = await flow.execute({
+    input: { dataRoot: storage.dataRoot, configRoot: storage.configRoot }
+  });
+  if (!result.ok) {
+    fail(result.error.error.message);
+    return;
+  }
+  const report = result.value.ctx.output;
+  for (const probe of report.probes) printProbe(probe);
+  process.exitCode = report.hasFailures ? 1 : 0;
+};
+var registerDoctorCommand = (program) => {
+  program.command("doctor").description("run sanity probes against storage roots and core repositories").action(doctorAction);
+};
+
+// src/application/ui/cli/commands/demo.ts
+import { randomUUID } from "crypto";
+import { promises as fs2 } from "fs";
+import { tmpdir } from "os";
+import { join as join3 } from "path";
+
+// src/application/demo/seed.ts
+import { promises as fs } from "fs";
+import { join } from "path";
+var DEMO_MARKER_FILENAME = ".ralphctl-demo";
+var unwrap = (r) => {
+  if (!r.ok) throw r.error;
+  return r.value;
+};
+var runGit = async (runCommand2, repoDir, args) => {
+  const r = await runCommand2("git", ["-C", repoDir, ...args]);
+  if (!r.ok) {
+    throw new StorageError({
+      subCode: "io",
+      message: `git ${args.join(" ")} failed in ${repoDir}: ${r.stderr || `exit ${String(r.code)}`}`,
+      path: repoDir
+    });
+  }
+};
+var seedMockRepo = async (runCommand2, repoDir) => {
+  await fs.mkdir(repoDir, { recursive: true });
+  await fs.writeFile(
+    join(repoDir, "hello.py"),
+    '# Placeholder greeting \u2014 the implement sprint changes this to print "Hello, world!".\nprint("hi from the mock project")\n'
+  );
+  await fs.writeFile(
+    join(repoDir, "README.md"),
+    "# hello-python (ralphctl demo)\n\nThrowaway project for exercising the refine / plan / implement flows.\n\nRun: `python3 hello.py`\n"
+  );
+  await runGit(runCommand2, repoDir, ["init", "--initial-branch=main"]);
+  await runGit(runCommand2, repoDir, ["config", "user.name", "ralphctl demo"]);
+  await runGit(runCommand2, repoDir, ["config", "user.email", "demo@ralphctl.local"]);
+  await runGit(runCommand2, repoDir, ["add", "-A"]);
+  await runGit(runCommand2, repoDir, ["commit", "-m", "chore: scaffold hello-python demo"]);
+};
+var seedRefineSprint = async (repos, project, token) => {
+  const s1 = unwrap(createSprintWithExecution({ name: `ready to refine \xB7 ${token}`, projectId: project.id }));
+  const s1Draft = unwrap(
+    addTicket(
+      s1.sprint,
+      unwrap(
+        createTicket({
+          title: "Greet the user by name",
+          description: "The greeting should address the person running the script. Details TBD \u2014 needs refinement."
+        })
+      )
+    )
+  );
+  unwrap(await repos.sprintRepo.save(s1Draft));
+  unwrap(await repos.executionRepo.save(s1.execution));
+  return { name: s1Draft.name, state: "draft \u2014 run Refine" };
+};
+var seedPlanSprint = async (repos, project, token) => {
+  const s2 = unwrap(createSprintWithExecution({ name: `ready to plan \xB7 ${token}`, projectId: project.id }));
+  const s2Ticket = unwrap(
+    approveTicketRequirements(
+      unwrap(createTicket({ title: "Add a --name CLI argument to the greeting" })),
+      [
+        "## Requirements",
+        "",
+        "- Accept an optional `--name <value>` argument.",
+        "- When provided, print `Hello, <value>!`.",
+        "- When omitted, fall back to `Hello, world!`.",
+        "- `python3 hello.py` must still exit 0 in both cases."
+      ].join("\n")
+    )
+  );
+  const s2Draft = unwrap(addTicket(s2.sprint, s2Ticket));
+  unwrap(await repos.sprintRepo.save(s2Draft));
+  unwrap(await repos.executionRepo.save(s2.execution));
+  return { name: s2Draft.name, state: "draft (ticket approved) \u2014 run Plan" };
+};
+var seedImplementSprint = async (repos, project, repo, token, now) => {
+  const s3 = unwrap(createSprintWithExecution({ name: `ready to implement \xB7 ${token}`, projectId: project.id }));
+  const s3Ticket = unwrap(
+    approveTicketRequirements(
+      unwrap(createTicket({ title: 'Print "Hello, world!" from hello.py' })),
+      [
+        "## Requirements",
+        "",
+        "- `hello.py` prints exactly `Hello, world!` (followed by a newline).",
+        "- `python3 hello.py` exits 0."
+      ].join("\n")
+    )
+  );
+  const s3Draft = unwrap(addTicket(s3.sprint, s3Ticket));
+  const s3Planned = unwrap(planSprint(s3Draft, now));
+  const task = unwrap(
+    createTask({
+      name: 'Make hello.py print "Hello, world!"',
+      description: "Replace the placeholder greeting with the canonical hello-world output.",
+      order: 1,
+      ticketId: s3Ticket.id,
+      repositoryId: repo.id,
+      steps: [
+        "Open hello.py.",
+        "Replace the print statement so it outputs exactly: Hello, world!",
+        "Confirm `python3 hello.py` exits 0."
+      ],
+      verificationCriteria: [
+        {
+          id: "C1",
+          assertion: 'Running hello.py prints "Hello, world!" and exits 0',
+          check: "auto",
+          command: "python3 hello.py"
+        }
+      ]
+    })
+  );
+  unwrap(await repos.sprintRepo.save(s3Planned));
+  unwrap(await repos.executionRepo.save(s3.execution));
+  unwrap(await repos.taskRepo.saveAll(s3Planned.id, [task]));
+  return { name: s3Planned.name, state: "planned (1 task queued) \u2014 run Implement" };
+};
+var seedDemoWorkspace = async (deps, input) => {
+  const { runCommand: runCommand2, writeFile } = deps;
+  const { homeDir, token } = input;
+  try {
+    const repoDirStr = join(String(homeDir), "demo-repos", `hello-python-${token}`);
+    const repoDir = unwrap(AbsolutePath.parse(repoDirStr));
+    const paths = unwrap(storagePathsFromRoot(homeDir));
+    unwrap(await ensureStorageRoots(paths));
+    await seedMockRepo(runCommand2, repoDirStr);
+    const repos = {
+      sprintRepo: createFsSprintRepository({ root: paths.dataRoot }),
+      executionRepo: createFsSprintExecutionRepository({ root: paths.dataRoot }),
+      taskRepo: createFsTaskRepository({ root: paths.dataRoot })
+    };
+    const projectRepo = createFsProjectRepository({ root: paths.dataRoot });
+    const now = IsoTimestamp.now();
+    const repo = unwrap(createRepository({ path: repoDir, name: "hello-python", verifyScript: "python3 hello.py" }));
+    const project = unwrap(
+      createProject({
+        displayName: `Hello Python (demo ${token})`,
+        description: "Throwaway sandbox project for exercising refine / plan / implement.",
+        repositories: [repo]
+      })
+    );
+    unwrap(await projectRepo.save(project));
+    const sprints = [
+      await seedRefineSprint(repos, project, token),
+      await seedPlanSprint(repos, project, token),
+      await seedImplementSprint(repos, project, repo, token, now)
+    ];
+    const markerPath = unwrap(AbsolutePath.parse(join(String(homeDir), DEMO_MARKER_FILENAME)));
+    unwrap(await writeFile(markerPath, `${String(now)}
+`));
+    return Result.ok({ homeDir, repoDir, projectName: project.displayName, sprints });
+  } catch (cause) {
+    if (cause instanceof StorageError) return Result.error(cause);
+    return Result.error(cause);
+  }
+};
+
+// src/application/demo/seed-settings.ts
+var PRESET_FOR_PROVIDER = {
+  "claude-code": "claude-only",
+  "github-copilot": "copilot-only",
+  "openai-codex": "codex-only",
+  opencode: "opencode-only",
+  "xai-grok": "grok-only"
+};
+var DEMO_PROVIDER_PREFERENCE = [
+  "claude-code",
+  "openai-codex",
+  "github-copilot",
+  "opencode",
+  "xai-grok"
+];
+var pickDemoPreset = (installed) => {
+  const chosen = DEMO_PROVIDER_PREFERENCE.find((provider) => installed.has(provider)) ?? "claude-code";
+  return PRESET_FOR_PROVIDER[chosen];
+};
+var seedDemoSettings = async (input) => {
+  const paths = storagePathsFromRoot(input.homeDir);
+  if (!paths.ok) return Result.error(paths.error);
+  const installed = await (input.detect ?? detectInstalledProviders)();
+  const preset = pickDemoPreset(installed);
+  const settings = applyPreset(preset, DEFAULT_SETTINGS);
+  const saved = await createJsonSettingsRepository({ configRoot: paths.value.configRoot }).save(settings);
+  if (!saved.ok) return Result.error(saved.error);
+  return Result.ok({ preset, noCliDetected: installed.size === 0 });
+};
+
+// src/application/demo/scripted-spawn.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { dirname, isAbsolute, join as join2 } from "path";
+
+// src/integration/ai/providers/_engine/scripted-spawn.ts
+import { EventEmitter } from "events";
+var createScriptedStdin = (onStdin) => {
+  const stdin = new EventEmitter();
+  const record = (data) => {
+    if (typeof data === "string") onStdin?.(data);
+    else if (data instanceof Buffer) onStdin?.(data.toString("utf8"));
+  };
+  return Object.assign(stdin, {
+    write: (data) => {
+      record(data);
+      return true;
+    },
+    end: (data) => {
+      record(data);
+    },
+    destroy: () => {
+    }
+  });
+};
+var createScriptedStream = () => {
+  const stream = new EventEmitter();
+  return Object.assign(stream, {
+    setEncoding: () => {
+    },
+    destroy: () => {
+    }
+  });
+};
+var createScriptedChild = (source, hooks = {}) => {
+  const child = new EventEmitter();
+  const stdout = createScriptedStream();
+  const stderr = createScriptedStream();
+  const stdin = createScriptedStdin(hooks.onStdin);
+  let resolved;
+  let exited = false;
+  const finish = (code, signal, lateStdout = []) => {
+    if (exited) return;
+    exited = true;
+    child.emit("exit", code, signal);
+    setTimeout(() => {
+      for (const chunk of lateStdout) stdout.emit("data", chunk);
+      child.emit("close", code, signal);
+    }, 0);
+  };
+  Object.assign(child, {
+    stdout,
+    stderr,
+    stdin,
+    pid: 0,
+    killed: false,
+    kill: (signal) => {
+      const named = typeof signal === "number" || signal === void 0 ? "SIGTERM" : signal;
+      hooks.onKill?.(named);
+      if (named === "SIGTERM" && resolved?.trapsSigterm === true) return true;
+      setTimeout(() => finish(null, named), 0);
+      return true;
+    }
+  });
+  setTimeout(() => {
+    resolved = typeof source === "function" ? source() : source;
+    for (const chunk of resolved.stdoutChunks ?? []) stdout.emit("data", chunk);
+    for (const chunk of resolved.stderrChunks ?? []) stderr.emit("data", chunk);
+    if (resolved.hang === true) return;
+    const { exitCode = 0, exitSignal = null, exitDelayMs = 0, stdoutAfterExit } = resolved;
+    setTimeout(() => finish(exitCode, exitSignal, stdoutAfterExit), exitDelayMs);
+  }, 0);
+  return child;
+};
+
+// src/application/demo/transcript.ts
+var DEMO_TARGET_FILE = "hello.py";
+var DEMO_CRITERION_COMMAND = `node -e "const s=require('node:fs').readFileSync('hello.py','utf8'); if (!s.includes('Hello, world!')) process.exit(1)"`;
+var DEMO_VERIFY_SCRIPT = `node -e "const s=require('node:fs').readFileSync('hello.py','utf8'); if (!s.includes('print(')) process.exit(1)"`;
+var ROUND_1_SOURCE = ["# Greeting for the ralphctl demo sprint.", 'print("Hello world")', ""].join("\n");
+var ROUND_2_SOURCE = ["# Greeting for the ralphctl demo sprint.", 'print("Hello, world!")', ""].join("\n");
+var generatorSignals = (signals) => signals;
+var evaluatorSignals = (signals) => signals;
+var generatorRoundOne = (at) => ({
+  role: "generator",
+  round: 1,
+  files: [{ path: DEMO_TARGET_FILE, content: ROUND_1_SOURCE }],
+  schemaVersion: generatorOutputContract.schemaVersion,
+  signals: generatorSignals([
+    { type: "change", text: `rewrote the greeting in ${DEMO_TARGET_FILE}`, timestamp: at },
+    {
+      type: "decision",
+      text: "Kept the single print statement rather than introducing a helper \u2014 the task asks for one literal line of output.",
+      timestamp: at
+    },
+    {
+      type: "task-verified",
+      output: `$ ${DEMO_CRITERION_COMMAND}
+Hello world`,
+      timestamp: at
+    },
+    {
+      type: "commit-message",
+      subject: "feat(demo): print a greeting from hello.py",
+      body: "Why: the placeholder greeting predates the demo task and says nothing about the sprint.",
+      timestamp: at
+    },
+    { type: "task-complete", timestamp: at }
+  ]),
+  body: `Updated ${DEMO_TARGET_FILE} to print a greeting and ran the acceptance command.`
+});
+var evaluatorRoundOne = (at) => ({
+  role: "evaluator",
+  round: 1,
+  files: [],
+  schemaVersion: evaluatorOutputContract.schemaVersion,
+  signals: evaluatorSignals([
+    {
+      type: "evaluation",
+      status: "failed",
+      dimensions: [
+        {
+          dimension: "correctness",
+          passed: false,
+          finding: `${DEMO_TARGET_FILE}:2 prints "Hello world" \u2014 the criterion requires the exact string "Hello, world!" (comma + exclamation mark).`,
+          executionEvidence: `$ ${DEMO_CRITERION_COMMAND}
+exit 1`
+        },
+        { dimension: "completeness", passed: true, finding: "the only file the task names was edited" },
+        { dimension: "safety", passed: true, finding: "no shell, network, or dependency changes" },
+        {
+          dimension: "consistency",
+          passed: true,
+          finding: `the comment above the statement still describes ${DEMO_TARGET_FILE} accurately`
+        },
+        {
+          dimension: "robustness",
+          passed: true,
+          applicable: false,
+          finding: "a single literal print statement has no error path to harden"
+        }
+      ],
+      criteria: [
+        {
+          id: "C1",
+          passed: false,
+          evidence: `the acceptance command exited 1 \u2014 "Hello, world!" is absent from ${DEMO_TARGET_FILE}`
+        }
+      ],
+      critique: `Correctness: ${DEMO_TARGET_FILE}:2 must print exactly "Hello, world!" \u2014 add the comma and the exclamation mark, then re-run the acceptance command.`,
+      timestamp: at
+    },
+    {
+      type: "note",
+      text: "The generator reported the command output but not its exit status \u2014 the string mismatch is only visible in the exit code.",
+      timestamp: at
+    }
+  ]),
+  body: "FAILED \u2014 correctness: the printed string does not match the acceptance criterion."
+});
+var generatorRoundTwo = (at) => ({
+  role: "generator",
+  round: 2,
+  files: [{ path: DEMO_TARGET_FILE, content: ROUND_2_SOURCE }],
+  schemaVersion: generatorOutputContract.schemaVersion,
+  signals: generatorSignals([
+    {
+      type: "change",
+      text: `${DEMO_TARGET_FILE}:2 now prints the exact string "Hello, world!"`,
+      timestamp: at
+    },
+    {
+      type: "learning",
+      text: "Quote the acceptance string verbatim from the criterion instead of retyping it \u2014 punctuation is part of the contract.",
+      context: "the first round dropped the comma and the exclamation mark",
+      appliesTo: "tasks whose criteria assert exact output",
+      timestamp: at
+    },
+    {
+      type: "task-verified",
+      output: `$ ${DEMO_CRITERION_COMMAND}
+exit 0`,
+      timestamp: at
+    },
+    {
+      type: "commit-message",
+      subject: "fix(demo): print the exact greeting the criterion asks for",
+      body: "Why: the first attempt dropped the comma and the exclamation mark, so the acceptance command exited 1.",
+      timestamp: at
+    },
+    { type: "task-complete", timestamp: at }
+  ]),
+  body: `Applied the critique \u2014 ${DEMO_TARGET_FILE} now prints "Hello, world!" and the acceptance command exits 0.`
+});
+var evaluatorRoundTwo = (at) => ({
+  role: "evaluator",
+  round: 2,
+  files: [],
+  schemaVersion: evaluatorOutputContract.schemaVersion,
+  signals: evaluatorSignals([
+    {
+      type: "evaluation",
+      status: "passed",
+      dimensions: [
+        {
+          dimension: "correctness",
+          passed: true,
+          finding: `${DEMO_TARGET_FILE}:2 prints "Hello, world!" exactly`,
+          executionEvidence: `$ ${DEMO_CRITERION_COMMAND}
+exit 0`
+        },
+        {
+          dimension: "completeness",
+          passed: true,
+          finding: "every step the task lists is reflected in the diff"
+        },
+        { dimension: "safety", passed: true, finding: "no shell, network, or dependency changes" },
+        {
+          dimension: "consistency",
+          passed: true,
+          finding: "the surrounding comment still matches the statement below it"
+        },
+        {
+          dimension: "robustness",
+          passed: true,
+          applicable: false,
+          finding: "a single literal print statement has no error path to harden"
+        }
+      ],
+      criteria: [{ id: "C1", passed: true, evidence: "the acceptance command exited 0 on the committed tree" }],
+      critique: "No remaining findings \u2014 the prior round's correctness gap is closed.",
+      timestamp: at
+    }
+  ]),
+  body: "PASSED \u2014 the acceptance criterion holds on the committed tree."
+});
+var demoTranscript = (now = IsoTimestamp.now) => {
+  const at = now();
+  return {
+    beats: [generatorRoundOne(at), evaluatorRoundOne(at), generatorRoundTwo(at), evaluatorRoundTwo(at)]
+  };
+};
+var beatFor = (transcript, role, round) => {
+  const forRole = transcript.beats.filter((b) => b.role === role);
+  if (forRole.length === 0) return void 0;
+  const exact = forRole.find((b) => b.round === round);
+  if (exact !== void 0) return exact;
+  return round < 1 ? forRole[0] : forRole[forRole.length - 1];
+};
+
+// src/application/demo/scripted-spawn.ts
+var ROUND_SIGNALS_PATH_RE = /(?:[A-Za-z]:)?[\\/][^\s`'"]*[\\/]rounds[\\/](\d+)[\\/](generator|evaluator)[\\/]signals\.json/g;
+var resolveSpawnTarget = (prompt) => {
+  const matches = [...prompt.matchAll(ROUND_SIGNALS_PATH_RE)];
+  const match = matches[matches.length - 1];
+  if (match === void 0) return void 0;
+  const round = Number.parseInt(match[1] ?? "", 10);
+  const role = match[2];
+  return { signalsPath: match[0], role, round: Number.isInteger(round) ? round : 1 };
+};
+var writeFileAt = (path, content) => {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, content, "utf8");
+};
+var applyBeat = (beat, target, cwd) => {
+  for (const file of beat.files) {
+    if (cwd === void 0) continue;
+    writeFileAt(isAbsolute(file.path) ? file.path : join2(cwd, file.path), file.content);
+  }
+  writeFileAt(
+    target.signalsPath,
+    `${JSON.stringify({ schemaVersion: beat.schemaVersion, signals: beat.signals }, null, 2)}
+`
+  );
+};
+var flagValue = (args, flag) => {
+  const index = args.indexOf(flag);
+  return index === -1 ? void 0 : args[index + 1];
+};
+var streamLines = (beat, sessionId, model) => {
+  const lines = [
+    { type: "system", subtype: "init", session_id: sessionId, ...model !== void 0 ? { model } : {} },
+    {
+      type: "assistant",
+      session_id: sessionId,
+      message: { content: [{ type: "text", text: beat.body }] }
+    },
+    { type: "result", subtype: "success", session_id: sessionId, result: beat.body }
+  ];
+  return `${lines.map((line) => JSON.stringify(line)).join("\n")}
+`;
+};
+var sessionIdFor = (role) => `demo-scripted-${role}`;
+var unscriptedScript = (reason) => ({
+  stderrChunks: [`ralphctl demo: ${reason}
+`],
+  exitCode: 1
+});
+var createDemoProviderSpawn = (transcript, { sessionDelayMs: exitDelayMs = 0 } = {}) => {
+  return (_command, args, options) => {
+    let prompt = "";
+    return createScriptedChild(
+      () => {
+        const target = resolveSpawnTarget(prompt);
+        if (target === void 0) {
+          return unscriptedScript("this session asked for an output path the demo transcript does not script");
+        }
+        const beat = beatFor(transcript, target.role, target.round);
+        if (beat === void 0) {
+          return unscriptedScript(`no scripted beat for ${target.role} round ${String(target.round)}`);
+        }
+        applyBeat(beat, target, options.cwd);
+        return {
+          stdoutChunks: [streamLines(beat, sessionIdFor(target.role), flagValue(args, "--model"))],
+          exitDelayMs
+        };
+      },
+      {
+        onStdin: (chunk) => {
+          prompt += chunk;
+        }
+      }
+    );
+  };
+};
+
+// src/application/demo/scripted-run.ts
+var scriptedDemoSettings = () => ({
+  ...DEFAULT_SETTINGS,
+  ai: defaultAiSettingsForProvider("claude-code"),
+  harness: {
+    ...DEFAULT_SETTINGS.harness,
+    // The transcript converges on round 2; a rung that fires past it would spawn a session the
+    // transcript has no beat for.
+    bestOfNCandidates: 0,
+    escalateOnPlateau: false
+  }
+});
+var withDemoVerifyScript = (project) => ({
+  ...project,
+  repositories: project.repositories.map((repo) => ({ ...repo, verifyScript: DEMO_VERIFY_SCRIPT }))
+});
+var withDemoCriterionCommand = (task) => ({
+  ...task,
+  verificationCriteria: task.verificationCriteria.map(
+    (criterion) => criterion.check === "auto" ? { ...criterion, command: DEMO_CRITERION_COMMAND } : criterion
+  )
+});
+var prepareScriptedDemo = async (input) => {
+  const paths = storagePathsFromRoot(input.homeDir);
+  if (!paths.ok) return Result.error(paths.error);
+  const settings = scriptedDemoSettings();
+  const saved = await createJsonSettingsRepository({ configRoot: paths.value.configRoot }).save(settings);
+  if (!saved.ok) return Result.error(saved.error);
+  const projectRepo = createFsProjectRepository({ root: paths.value.dataRoot });
+  const projects = await projectRepo.list();
+  if (!projects.ok) return Result.error(projects.error);
+  for (const project of projects.value) {
+    const written = await projectRepo.save(withDemoVerifyScript(project));
+    if (!written.ok) return Result.error(written.error);
+  }
+  const sprintRepo = createFsSprintRepository({ root: paths.value.dataRoot });
+  const taskRepo = createFsTaskRepository({ root: paths.value.dataRoot });
+  const sprints = await sprintRepo.list();
+  if (!sprints.ok) return Result.error(sprints.error);
+  for (const sprint of sprints.value) {
+    const tasks = await taskRepo.findBySprintId(sprint.id);
+    if (!tasks.ok) return Result.error(tasks.error);
+    if (tasks.value.length === 0) continue;
+    const written = await taskRepo.saveAll(sprint.id, tasks.value.map(withDemoCriterionCommand));
+    if (!written.ok) return Result.error(written.error);
+  }
+  const transcript = input.now === void 0 ? demoTranscript() : demoTranscript(input.now);
+  const providerSpawn = createDemoProviderSpawn(transcript, { sessionDelayMs: input.sessionDelayMs });
+  return Result.ok({ providerSpawn, settings });
+};
+
+// src/application/ui/cli/commands/demo.ts
+var DEFAULT_DEMO_HOME = join3(tmpdir(), "ralphctl-demo");
+var pathExists = async (p) => fs2.access(p).then(() => true).catch(() => false);
+var prepareSandbox = async (homeDirStr) => {
+  if (!await pathExists(homeDirStr)) return void 0;
+  const hasMarker = await pathExists(join3(homeDirStr, DEMO_MARKER_FILENAME));
+  if (!hasMarker) {
+    return `${homeDirStr} already exists and was not created by 'ralphctl demo' (no ${DEMO_MARKER_FILENAME} marker) \u2014 refusing to wipe it. Pass --home <dir> to pick an empty or demo-owned directory instead.`;
+  }
+  await fs2.rm(homeDirStr, { recursive: true, force: true });
+  return void 0;
+};
+var printSummary = (summary, homeDirStr, settingsLine) => {
+  const line = "\u2500".repeat(60);
+  process.stdout.write(
+    [
+      "",
+      line,
+      "  Demo workspace seeded \u2713",
+      line,
+      `  home    : ${homeDirStr}`,
+      `  repo    : ${String(summary.repoDir)}  (git-initialised, python3 hello.py)`,
+      `  project : ${summary.projectName}`,
+      ...settingsLine === void 0 ? [] : [`  ai      : ${settingsLine}`],
+      "",
+      "  Sprints:",
+      ...summary.sprints.map((s) => `    \u2022 "${s.name}"  ${s.state}`),
+      line,
+      ""
+    ].join("\n")
+  );
+};
+var describeSeededSettings = (seeded) => seeded.noCliDetected ? `${seeded.preset} preset (no AI CLI on PATH \u2014 placeholder; install one and run doctor)` : `${seeded.preset} preset (from the AI CLIs detected on PATH)`;
+var demoAction = async (opts) => {
+  const homeDirStr = opts.home ?? DEFAULT_DEMO_HOME;
+  const homeDir = AbsolutePath.parse(homeDirStr);
+  if (!homeDir.ok) {
+    fail(`--home must be an absolute path: ${homeDirStr}`);
+    return;
+  }
+  const refusal = await prepareSandbox(homeDirStr);
+  if (refusal !== void 0) {
+    fail(refusal);
+    return;
+  }
+  const seeded = await seedDemoWorkspace(
+    { runCommand, writeFile: createAtomicWriteFile() },
+    { homeDir: homeDir.value, token: randomUUID().slice(0, 8) }
+  );
+  if (!okOrFail(seeded, "seeding failed: ")) return;
+  const seededSettings = await seedDemoSettings({ homeDir: homeDir.value });
+  if (!okOrFail(seededSettings, "settings seeding failed: ")) return;
+  let providerSpawn;
+  if (opts.script === true) {
+    const scripted = await prepareScriptedDemo({ homeDir: homeDir.value });
+    if (!okOrFail(scripted, "scripted demo setup failed: ")) return;
+    providerSpawn = scripted.value.providerSpawn;
+  }
+  printSummary(
+    seeded.value,
+    homeDirStr,
+    opts.script === true ? void 0 : describeSeededSettings(seededSettings.value)
+  );
+  if (opts.script === true) {
+    process.stdout.write(
+      '  Scripted mode: every AI row is pinned to claude-code and replays a canned two-round\n  generator \u2192 evaluator transcript. No provider CLI is spawned; the verify script and\n  acceptance criterion are rewritten to portable node one-liners.\n  The transcript covers the Implement flow \u2014 the "ready to implement" sprint is the one\n  to launch. Interactive flows (refine / plan / ideate) still need a real, authenticated\n  provider CLI, in demo mode too.\n\n'
+    );
+  }
+  if (!opts.launch) {
+    process.stdout.write(
+      `Launch it with:
+
+  RALPHCTL_HOME=${homeDirStr} ralphctl
+
+` + (opts.script === true ? `Or reproduce the whole scripted run:
+
+  ralphctl demo --script --home ${homeDirStr}
+
+` : "")
+    );
+    return;
+  }
+  process.stdout.write(
+    opts.script === true ? "Launching the TUI against the sandbox with the scripted transcript\u2026\n\n" : "Launching the TUI against the sandbox\u2026\n\n"
+  );
+  process.env[RALPHCTL_HOME_ENV] = homeDirStr;
+  const { launchTui } = await import("./launch-VBRTQP4L.mjs");
+  await launchTui({ ...providerSpawn !== void 0 ? { providerSpawn } : {} });
+};
+var registerDemoCommand = (program) => {
+  program.command("demo").description("seed a throwaway sandbox project and launch the TUI against it \u2014 zero setup required").option("--home <dir>", "sandbox directory (default: a fixed path under the OS tmp dir)").option("--no-launch", "seed only \u2014 print the launch command instead of opening the TUI").option("--script", "replay a canned generator/evaluator transcript instead of spawning a real AI CLI").action(demoAction);
+};
+
+// src/application/ui/cli/commands/settings.ts
+var parseProviderKey = (key2) => {
+  const implementMatch = /^ai\.implement\.(generator|evaluator)\.provider$/.exec(key2);
+  if (implementMatch !== null) return { flow: "implement", role: implementMatch[1] };
+  const flatMatch = /^ai\.(refine|plan|readiness|ideate|createPr)\.provider$/.exec(key2);
+  if (flatMatch !== null) return { flow: flatMatch[1] };
+  return void 0;
+};
+var showSettingsAction = async () => {
+  const { deps } = await bootstrapApp();
+  const flow = createSettingsShowFlow({ settingsRepo: deps.settingsRepo });
+  const result = await flow.execute({ input: void 0 });
+  if (!result.ok) {
+    fail(result.error.error.message);
+    return;
+  }
+  process.stdout.write(`${JSON.stringify(result.value.ctx.output, null, 2)}
+`);
+};
+var setProviderKeyAction = async (key2, value, role, flowId, settingsRepo) => {
+  if (!isAiProvider(value)) {
+    fail(`'${value}' is not a recognised provider (expected one of: ${AI_PROVIDERS.join(", ")})`);
+    return;
+  }
+  const providerFlow = createSettingsSetProviderFlow({ settingsRepo });
+  const saved = await providerFlow.execute({
+    input: {
+      flow: flowId,
+      provider: value,
+      ...role !== void 0 ? { role } : {}
+    }
+  });
+  if (!saved.ok) {
+    const err = saved.error.error;
+    const hint = "hint" in err && typeof err.hint === "string" ? ` (${err.hint})` : "";
+    fail(`${err.message}${hint}`);
+    return;
+  }
+  process.stdout.write(`${key2} = ${value}
+`);
+};
+var setSettingsAction = async (key2, value) => {
+  const { deps } = await bootstrapApp();
+  const providerKey = parseProviderKey(key2);
+  if (providerKey !== void 0) {
+    await setProviderKeyAction(key2, value, providerKey.role, providerKey.flow, deps.settingsRepo);
+    return;
+  }
+  const showFlow = createSettingsShowFlow({ settingsRepo: deps.settingsRepo });
+  const current = await showFlow.execute({ input: void 0 });
+  if (!current.ok) {
+    fail(current.error.error.message);
+    return;
+  }
+  const next = applySettingsKey(current.value.ctx.output, key2, value);
+  if (!okOrFail(next)) return;
+  const setFlow = createSettingsSetFlow({ settingsRepo: deps.settingsRepo });
+  const saved = await setFlow.execute({ input: { next: next.value } });
+  if (!saved.ok) {
+    fail(saved.error.error.message);
+    return;
+  }
+  process.stdout.write(`${key2} = ${value}
+`);
+};
+var applyPresetAction = async (name) => {
+  if (!isPresetName(name)) {
+    fail(`unknown preset '${name}' \u2014 expected one of: ${PRESET_NAMES.join(", ")}`);
+    return;
+  }
+  const { deps } = await bootstrapApp();
+  const flow = createSettingsApplyPresetFlow({
+    settingsRepo: deps.settingsRepo,
+    availableModelsFor: deps.availableModelsFor
+  });
+  const result = await flow.execute({ input: { preset: name } });
+  if (!result.ok) {
+    fail(result.error.error.message);
+    return;
+  }
+  const output = result.value.ctx.output;
+  for (const w of output.warnings) {
+    process.stderr.write(
+      `warning: ${PROVIDER_BINARY[w.provider]} CLI not found on PATH; affects flows: ${w.flows.join(", ")}
+`
+    );
+  }
+  for (const line of presetAdaptationLines(output)) process.stderr.write(`note: ${line}
+`);
+  process.stdout.write(`applied preset ${name}
+`);
+};
+var registerSettingsCommand = (program) => {
+  const settings = program.command("settings").description("inspect and mutate ralphctl settings");
+  settings.command("show").description("print the current settings as JSON").action(showSettingsAction);
+  settings.command("set <key> <value>").description("mutate one setting and persist (read-modify-write, schema-validated)").action(setSettingsAction);
+  settings.command("apply-preset <name>").description(`stamp a preset onto ai.* (one of: ${PRESET_NAMES.join(", ")})`).action(applyPresetAction);
+};
+
+// src/application/ui/cli/completion.ts
+var bashScript = (commands) => `# ralphctl bash completion \u2014 source from ~/.bashrc
+_ralphctl_complete() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+  local commands="${commands.join(" ")}"
+  COMPREPLY=( $(compgen -W "$commands" -- "$cur") )
+}
+complete -F _ralphctl_complete ralphctl
+`;
+var zshScript = (commands) => `#compdef ralphctl
+# ralphctl zsh completion \u2014 source from ~/.zshrc (or place under $fpath)
+_ralphctl() {
+  local -a commands
+  commands=(${commands.map((c) => `'${c}'`).join(" ")})
+  _describe 'command' commands
+}
+_ralphctl "$@"
+`;
+var generateCompletion = (shell, commands) => {
+  const sorted = [...new Set(commands)].sort();
+  switch (shell) {
+    case "bash":
+      return bashScript(sorted);
+    case "zsh":
+      return zshScript(sorted);
+  }
+};
+
+// src/application/ui/cli/commands/completion.ts
+var SUPPORTED = ["bash", "zsh"];
+var registerCompletionCommand = (program) => {
+  program.command("completion <shell>").description(`print a shell-completion script (supported: ${SUPPORTED.join(", ")})`).action((shell) => {
+    if (!SUPPORTED.includes(shell)) {
+      process.stderr.write(`error: unsupported shell '${shell}' \u2014 supported: ${SUPPORTED.join(", ")}
+`);
+      process.exitCode = 1;
+      return;
+    }
+    const commands = program.commands.map((c) => c.name());
+    process.stdout.write(generateCompletion(shell, commands));
+  });
+};
+
+// src/application/ui/cli/confirm-destructive.ts
+import { createInterface } from "readline";
+var confirmDestructive = async (opts) => {
+  if (opts.yes) return true;
+  if (process.stdin.isTTY !== true) {
+    process.stderr.write(
+      `error: refusing to ${opts.action} without confirmation on a non-TTY stdin \u2014 re-run with --yes to bypass${opts.nonTtyHint ?? ""}
+`
+    );
+    process.exitCode = 1;
+    return false;
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await askLine(rl, opts.confirmPrompt);
+    if (answer === void 0) {
+      process.stdout.write("aborted\n");
+      process.exitCode = 130;
+      return false;
+    }
+    const confirmed = isYes(answer.trim());
+    if (!confirmed) process.stdout.write("aborted\n");
+    return confirmed;
+  } finally {
+    rl.close();
+  }
+};
+var askLine = (rl, prompt) => new Promise((resolve) => {
+  rl.once("close", () => resolve(void 0));
+  rl.question(prompt, resolve);
+});
+var isYes = (answer) => {
+  const lower = answer.toLowerCase();
+  return lower === "y" || lower === "yes";
+};
+
+// src/application/ui/cli/commands/project.ts
+var listProjectsAction = async () => {
+  const { deps } = await bootstrapApp();
+  const result = await deps.projectRepo.list();
+  if (!okOrFail(result)) return;
+  if (result.value.length === 0) {
+    process.stdout.write("(no projects yet \u2014 create one in the TUI)\n");
+    return;
+  }
+  for (const p of result.value) {
+    process.stdout.write(`${formatProjectLine(p)}
+`);
+  }
+};
+var showProjectAction = async (raw) => {
+  const { deps, storage } = await bootstrapApp();
+  let effectiveRaw = raw;
+  if (effectiveRaw === void 0) {
+    const pinned = await createLastSelectionStore(storage.stateRoot).read();
+    if (pinned?.projectId === void 0) {
+      fail("no current project \u2014 pick one in the TUI or pass an id");
+      return;
+    }
+    effectiveRaw = String(pinned.projectId);
+  }
+  const id = ProjectId.parse(effectiveRaw);
+  if (!okOrFail(id, "invalid project id: ")) return;
+  const result = await deps.projectRepo.findById(id.value);
+  if (!okOrFail(result)) return;
+  process.stdout.write(`${JSON.stringify(result.value, null, 2)}
+`);
+};
+var removeProjectAction = async (raw, opts) => {
+  const id = ProjectId.parse(raw);
+  if (!okOrFail(id, "invalid project id: ")) return;
+  const confirmed = await confirmDestructive({
+    yes: opts.yes === true,
+    action: `remove project ${String(id.value)}`,
+    confirmPrompt: `remove project ${String(id.value)}? [y/N] `
+  });
+  if (!confirmed) return;
+  const { deps, storage } = await bootstrapApp();
+  const result = await deps.projectRepo.remove(id.value);
+  if (!okOrFail(result)) return;
+  const store = createLastSelectionStore(storage.stateRoot);
+  const cur = await store.read();
+  if (cur?.projectId === id.value) await store.write(void 0);
+  process.stdout.write(`removed project ${String(id.value)}
+`);
+};
+var registerProjectCommand = (program) => {
+  const project = program.command("project").description("inspect and manage projects");
+  project.command("list").description("list all registered projects").action(listProjectsAction);
+  project.command("show [id]").description("print a single project as JSON (defaults to the current project)").action(showProjectAction);
+  project.command("remove <id>").description("delete a project (does not touch sprints or repository contents)").option("-y, --yes", "skip the interactive y/N confirmation").action(removeProjectAction);
+};
+var formatProjectLine = (p) => {
+  const repos = p.repositories.length;
+  return `${String(p.id)}  ${String(p.slug).padEnd(24)}  ${p.displayName}  (${plural(repos, "repo")})`;
+};
+
+// src/application/ui/cli/commands/sprint.ts
+import { join as join4 } from "path";
+
+// src/business/sprint/reopen-sprint.ts
+var reopenDoneSprintUseCase = async (props) => {
+  const log = props.logger.named("sprint.reopen-done");
+  if (props.sprint.status === "review") {
+    log.debug("already review, skipping", { sprintId: props.sprint.id });
+    return Result.ok(props.sprint);
+  }
+  const conflictCheck = await assertNoActivePeer(props.sprint, props.sprintRepo, log, "reopen");
+  if (!conflictCheck.ok) return Result.error(conflictCheck.error);
+  log.debug("reopening sprint", { sprintId: props.sprint.id, from: props.sprint.status });
+  const transitioned = reopenDoneSprint(props.sprint, props.clock());
+  if (!transitioned.ok) {
+    log.warn("invalid state transition", {
+      sprintId: props.sprint.id,
+      from: props.sprint.status,
+      error: transitioned.error.message
+    });
+    return Result.error(transitioned.error);
+  }
+  const persisted = await props.sprintRepo.save(transitioned.value);
+  if (!persisted.ok) {
+    log.error("save failed", { sprintId: transitioned.value.id, error: persisted.error.message });
+    return Result.error(persisted.error);
+  }
+  log.info(`reopened sprint '${transitioned.value.slug}' done \u2192 review`, {
+    sprintId: transitioned.value.id,
+    reviewAt: transitioned.value.reviewAt
+  });
+  return Result.ok(transitioned.value);
+};
+
+// src/application/ui/cli/commands/sprint.ts
+var INVALID_SPRINT_ID = "invalid sprint id: ";
+var showName = (name) => sanitizeDisplayText(name, DISPLAY_TEXT_MAX_CHARS);
+var listSprintsAction = async () => {
+  const { deps } = await bootstrapApp();
+  const result = await deps.sprintRepo.list();
+  if (!okOrFail(result)) return;
+  if (result.value.length === 0) {
+    process.stdout.write("(no sprints yet \u2014 create one in the TUI)\n");
+    return;
+  }
+  for (const s of result.value) {
+    process.stdout.write(`${formatSprintLine(s)}
+`);
+  }
+};
+var showSprintAction = async (raw) => {
+  const { deps, storage } = await bootstrapApp();
+  const id = await resolveSprintId(raw, storage.stateRoot, {
+    missingMessage: "no current sprint pinned \u2014 run `ralphctl sprint set-current <id>` or pass an id"
+  });
+  if (!okOrFail(id)) return;
+  const result = await deps.sprintRepo.findById(id.value.sprintId);
+  if (!okOrFail(result)) return;
+  process.stdout.write(`${JSON.stringify(result.value, null, 2)}
+`);
+};
+var removeSprintAction = async (raw, opts) => {
+  const id = SprintId.parse(raw);
+  if (!okOrFail(id, INVALID_SPRINT_ID)) return;
+  const confirmed = await confirmDestructive({
+    yes: opts.yes === true,
+    action: `remove sprint ${String(id.value)}`,
+    confirmPrompt: `remove sprint ${String(id.value)} (cascades to its execution + tasks)? [y/N] `
+  });
+  if (!confirmed) return;
+  const { deps, storage } = await bootstrapApp();
+  const result = await deps.sprintRemoval.remove(id.value);
+  if (!okOrFail(result)) return;
+  const store = createLastSelectionStore(storage.stateRoot);
+  const cur = await store.read();
+  if (cur?.sprintId === id.value) {
+    const { sprintId: _drop, ...rest } = cur;
+    void _drop;
+    await store.write(rest);
+  }
+  process.stdout.write(`removed sprint ${String(id.value)}
+`);
+};
+var activateSprintAction = async (raw) => {
+  const id = SprintId.parse(raw);
+  if (!okOrFail(id, INVALID_SPRINT_ID)) return;
+  const { deps } = await bootstrapApp();
+  const loaded = await deps.sprintRepo.findById(id.value);
+  if (!okOrFail(loaded)) return;
+  const result = await activateSprintUseCase({
+    sprint: loaded.value,
+    sprintRepo: deps.sprintRepo,
+    clock: deps.clock,
+    logger: deps.logger
+  });
+  if (!okOrFail(result)) return;
+  process.stdout.write(`activated sprint '${result.value.slug}' (${String(result.value.id)})
+`);
+};
+var reopenSprintAction = async (raw) => {
+  const id = SprintId.parse(raw);
+  if (!okOrFail(id, INVALID_SPRINT_ID)) return;
+  const { deps } = await bootstrapApp();
+  const loaded = await deps.sprintRepo.findById(id.value);
+  if (!okOrFail(loaded)) return;
+  const wasAlreadyReview = loaded.value.status === "review";
+  const result = await reopenDoneSprintUseCase({
+    sprint: loaded.value,
+    sprintRepo: deps.sprintRepo,
+    clock: deps.clock,
+    logger: deps.logger
+  });
+  if (!okOrFail(result)) return;
+  const transitionLine = wasAlreadyReview ? `sprint '${result.value.slug}' (${String(result.value.id)}) is already in review \u2014 nothing to reopen
+` : `reopened sprint '${result.value.slug}' (${String(result.value.id)}) done \u2192 review
+`;
+  process.stdout.write(
+    `${transitionLine}  unblock its blocked tasks (ralphctl task unblock <id>) to make them runnable again
+`
+  );
+};
+var confirmBlockedTasksOrStop = async (sprint, taskRepo, yes) => {
+  const tasksLoaded = await taskRepo.findBySprintId(sprint.id);
+  if (!tasksLoaded.ok) {
+    fail(tasksLoaded.error.message);
+    return void 0;
+  }
+  const blockedTasks = tasksLoaded.value.filter((t) => t.status === "blocked");
+  if (blockedTasks.length === 0) return blockedTasks;
+  const confirmed = await confirmDestructive({
+    yes,
+    action: `close sprint ${String(sprint.id)} with ${String(blockedTasks.length)} task(s) still blocked: ${nameBlockedTasks(blockedTasks)}`,
+    confirmPrompt: `${String(blockedTasks.length)} task(s) are blocked: ${nameBlockedTasks(blockedTasks)}. Closing won't refuse, but a done sprint needs reopening (unblock one to do that) before they can run again. Close anyway? [y/N] `
+  });
+  return confirmed ? blockedTasks : void 0;
+};
+var closeSprintAction = async (raw, opts) => {
+  const id = SprintId.parse(raw);
+  if (!okOrFail(id, INVALID_SPRINT_ID)) return;
+  const { deps, storage } = await bootstrapApp();
+  const loaded = await deps.sprintRepo.findById(id.value);
+  if (!okOrFail(loaded)) return;
+  const sprint = loaded.value;
+  const closable = assertSprintStatus(sprint, ["review"], ASSERT_SPRINT_STATUS);
+  if (!okOrFail(closable)) return;
+  const blockedTasks = await confirmBlockedTasksOrStop(sprint, deps.taskRepo, opts.yes === true);
+  if (blockedTasks === void 0) return;
+  const sprintDir = AbsolutePath.parse(await ensureCanonicalSprintDir(storage.dataRoot, sprint.id, sprint.slug));
+  if (!okOrFail(sprintDir)) return;
+  const progressPath = AbsolutePath.parse(join4(String(sprintDir.value), "progress.md"));
+  if (!okOrFail(progressPath)) return;
+  const project = await deps.projectRepo.findById(sprint.projectId);
+  const memoryMirror = project.ok ? { writeFile: deps.writeFile, memoryRoot: storage.memoryRoot, projectId: String(project.value.id) } : void 0;
+  const element = createCloseSprintFlow({
+    sprintRepo: deps.sprintRepo,
+    fileLocker: deps.fileLocker,
+    locksRoot: storage.locksRoot,
+    sprintDir: sprintDir.value,
+    eventBus: deps.eventBus,
+    clock: deps.clock,
+    logger: deps.logger,
+    appendFile: deps.appendFile,
+    writeFile: deps.writeFile,
+    progressFile: progressPath.value,
+    ...memoryMirror !== void 0 ? { memoryMirror } : {}
+  });
+  const runner = createRunner({
+    id: `cli-sprint-close-${String(id.value)}`,
+    element,
+    initialCtx: { sprintId: id.value, distillRequested: false }
+  });
+  let failure;
+  const unsubscribe = runner.subscribe((event) => {
+    if (event.type === "failed") failure = event.error;
+  });
+  await runner.start();
+  unsubscribe();
+  if (runner.status === "aborted") {
+    fail("close was aborted internally \u2014 please retry");
+    return;
+  }
+  if (runner.status === "failed") {
+    fail(failure?.message ?? "sprint close failed");
+    return;
+  }
+  const closed = runner.ctx.sprint;
+  if (closed === void 0) {
+    fail("close completed but returned no sprint \u2014 please retry");
+    return;
+  }
+  process.stdout.write(`closed sprint '${closed.slug}' (${String(closed.id)})
+`);
+  if (blockedTasks.length > 0) {
+    process.stdout.write(
+      `  note: ${String(blockedTasks.length)} task(s) stayed blocked: ${nameBlockedTasks(blockedTasks)}
+  recover with: ralphctl task unblock <id> (reopens this sprint automatically)
+`
+    );
+  }
+};
+var setCurrentSprintAction = async (raw) => {
+  const id = SprintId.parse(raw);
+  if (!okOrFail(id, INVALID_SPRINT_ID)) return;
+  const { deps, storage } = await bootstrapApp();
+  const sprint = await deps.sprintRepo.findById(id.value);
+  if (!okOrFail(sprint)) return;
+  const project = await deps.projectRepo.findById(sprint.value.projectId);
+  if (!okOrFail(project, "project lookup failed: ")) return;
+  const store = createLastSelectionStore(storage.stateRoot);
+  await store.write({
+    projectId: project.value.id,
+    projectLabel: project.value.displayName,
+    sprintId: sprint.value.id
+  });
+  process.stdout.write(`pinned current sprint to '${sprint.value.slug}' (${String(sprint.value.id)})
+`);
+};
+var progressSprintAction = async (raw) => {
+  const { deps, storage } = await bootstrapApp();
+  const resolved = await resolveSprintId(raw, storage.stateRoot, {
+    missingMessage: "no current sprint pinned \u2014 run `ralphctl sprint set-current <id>` or pass an id"
+  });
+  if (!okOrFail(resolved)) return;
+  const sprintId = resolved.value.sprintId;
+  const sprint = await deps.sprintRepo.findById(sprintId);
+  if (!okOrFail(sprint)) return;
+  const tasks = await deps.taskRepo.findBySprintId(sprintId);
+  if (!okOrFail(tasks)) return;
+  const execution = await deps.sprintExecutionRepo.findById(sprintId);
+  const branchLine = execution.ok ? execution.value.branch !== null ? execution.value.branch : "(no branch assigned yet \u2014 first implement run will assign one)" : "(no execution record \u2014 sprint never started)";
+  process.stdout.write(formatProgress(sprint.value, tasks.value, branchLine));
+};
+var registerSprintCommand = (program) => {
+  const sprintCmd = program.command("sprint").description("inspect and manage sprints");
+  sprintCmd.command("list").description("list all sprints").action(listSprintsAction);
+  sprintCmd.command("show [id]").description("print a single sprint as JSON (defaults to the current sprint)").action(showSprintAction);
+  sprintCmd.command("remove <id>").description("delete a sprint (cascades to its execution + tasks)").option("-y, --yes", "skip the interactive y/N confirmation").action(removeSprintAction);
+  sprintCmd.command("activate <id>").description("transition a planned sprint to active (idempotent \u2014 already-active passes through)").action(activateSprintAction);
+  sprintCmd.command("close <id>").description(
+    "transition a review sprint to done (rejects any other status); confirms first if any task is still blocked"
+  ).option("-y, --yes", "skip the blocked-task confirmation when any task is still blocked").action(closeSprintAction);
+  sprintCmd.command("reopen <id>").description(
+    "reopen a closed sprint back to review so its blocked work is reachable again (idempotent \u2014 already-review passes through)"
+  ).action(reopenSprintAction);
+  sprintCmd.command("set-current <id>").description(
+    "pin a sprint as the user's current selection (read by the TUI on launch and used as the default sprint for CLI commands)"
+  ).action(setCurrentSprintAction);
+  sprintCmd.command("progress [id]").description("print task counts, blockers, and the sprint branch (defaults to the current sprint)").action(progressSprintAction);
+};
+var groupBlockedTasks = (allTasks) => {
+  const byId = new Map(allTasks.map((t) => [t.id, t]));
+  const rootIdOf = (task) => {
+    const seen = /* @__PURE__ */ new Set([task.id]);
+    let current = task;
+    for (; ; ) {
+      if (current.status !== "blocked") return task.id;
+      if (current.blockKind !== "upstream") return current.id;
+      const deps = current.dependsOn.map((depId) => byId.get(depId));
+      const nextDep = deps.find((d) => d !== void 0 && d.status !== "done");
+      if (nextDep === void 0 || seen.has(nextDep.id)) return current.id;
+      seen.add(nextDep.id);
+      current = nextDep;
+    }
+  };
+  const groups = /* @__PURE__ */ new Map();
+  for (const t of allTasks) {
+    if (t.status !== "blocked") continue;
+    const rootId = rootIdOf(t);
+    const rootCandidate = byId.get(rootId);
+    const root = rootCandidate !== void 0 && rootCandidate.status === "blocked" ? rootCandidate : t;
+    const existing = groups.get(rootId);
+    if (existing === void 0) groups.set(rootId, { root, waiting: t.id === rootId ? [] : [t] });
+    else if (t.id !== rootId) groups.set(rootId, { ...existing, waiting: [...existing.waiting, t] });
+  }
+  return [...groups.values()];
+};
+var formatProgress = (sprint, tasks, branchLine) => {
+  const total = tasks.length;
+  const done = tasks.filter((t) => t.status === "done").length;
+  const inProgress = tasks.filter((t) => t.status === "in_progress").length;
+  const todo = tasks.filter((t) => t.status === "todo").length;
+  const blocked = tasks.filter((t) => t.status === "blocked");
+  const lines = [];
+  lines.push(`Progress \u2014 ${sprint.name}`);
+  lines.push(`  id      ${String(sprint.id)}`);
+  lines.push(`  status  ${sprint.status}`);
+  lines.push(`  branch  ${branchLine}`);
+  lines.push(
+    `  tasks   ${String(done)}/${String(total)} done \xB7 ${String(inProgress)} in progress \xB7 ${String(todo)} todo \xB7 ${String(blocked.length)} blocked`
+  );
+  if (blocked.length > 0) {
+    lines.push("");
+    lines.push(`Blockers (${String(blocked.length)})`);
+    for (const group of groupBlockedTasks(tasks)) {
+      const reasonFirstLine = group.root.blockedReason.split("\n")[0] ?? group.root.blockedReason;
+      lines.push(`  \u2717 ${showName(group.root.name)}`);
+      lines.push(`      ${sanitizeDisplayText(reasonFirstLine, DISPLAY_TEXT_MAX_CHARS)}`);
+      lines.push(`      recover with: ralphctl task unblock ${String(group.root.id)}`);
+      if (group.waiting.length > 0) {
+        const names = group.waiting.map((t) => showName(t.name)).join(", ");
+        lines.push(`      \u21B3 ${String(group.waiting.length)} upstream-blocked task(s) waiting on this: ${names}`);
+      }
+    }
+  }
+  return `${lines.join("\n")}
+`;
+};
+var formatSprintLine = (s) => {
+  const tickets = s.tickets.length;
+  return `${String(s.id)}  ${String(s.slug).padEnd(24)}  [${s.status.padEnd(8)}]  ${s.name}  (${plural(tickets, "ticket")})`;
+};
+
+// src/application/ui/cli/commands/ticket.ts
+var listTicketsAction = async (opts) => {
+  const { deps, storage } = await bootstrapApp();
+  const sprintId = await resolveSprintForCli(opts.sprint, storage.stateRoot);
+  if (sprintId === void 0) return;
+  const sprint = await deps.sprintRepo.findById(sprintId);
+  if (!okOrFail(sprint)) return;
+  if (sprint.value.tickets.length === 0) {
+    process.stdout.write("(no tickets on this sprint yet \u2014 add one with `ralphctl ticket add`)\n");
+    return;
+  }
+  for (const t of sprint.value.tickets) {
+    process.stdout.write(`${formatTicketLine(t)}
+`);
+  }
+};
+var showTicketAction = async (rawTicketId, opts) => {
+  const { deps, storage } = await bootstrapApp();
+  const ids = await resolveSprintAndIdForCli(opts.sprint, storage.stateRoot, rawTicketId, TicketId.parse, "ticket");
+  if (ids === void 0) return;
+  const { sprintId, id: ticketId } = ids;
+  const sprint = await deps.sprintRepo.findById(sprintId);
+  if (!okOrFail(sprint)) return;
+  const found = sprint.value.tickets.find((t) => t.id === ticketId);
+  if (!found) {
+    fail(`ticket ${rawTicketId} not found on sprint ${String(sprintId)}`);
+    return;
+  }
+  process.stdout.write(`${JSON.stringify(found, null, 2)}
+`);
+};
+var addTicketAction = async (opts) => {
+  const { deps, storage } = await bootstrapApp();
+  const sprintId = await resolveSprintForCli(opts.sprint, storage.stateRoot);
+  if (sprintId === void 0) return;
+  const flow = createTicketAddFlow({ sprintRepo: deps.sprintRepo });
+  const result = await flow.execute({
+    input: {
+      sprintId,
+      title: opts.title,
+      ...opts.description !== void 0 ? { description: opts.description } : {},
+      ...opts.link !== void 0 ? { link: opts.link } : {}
+    }
+  });
+  if (!result.ok) {
+    fail(result.error.error.message);
+    return;
+  }
+  const ticket = result.value.ctx.output;
+  process.stdout.write(`added ticket ${String(ticket.id)} to sprint ${String(sprintId)} \u2014 ${ticket.title}
+`);
+};
+var removeTicketAction = async (rawTicketId, opts) => {
+  const { deps, storage } = await bootstrapApp();
+  const ids = await resolveSprintAndIdForCli(opts.sprint, storage.stateRoot, rawTicketId, TicketId.parse, "ticket");
+  if (ids === void 0) return;
+  const { sprintId, id: ticketId } = ids;
+  const confirmed = await confirmDestructive({
+    yes: opts.yes === true,
+    action: `remove ticket ${rawTicketId}`,
+    confirmPrompt: `remove ticket ${rawTicketId} from sprint ${String(sprintId)}? [y/N] `
+  });
+  if (!confirmed) return;
+  const flow = createTicketRemoveFlow({ sprintRepo: deps.sprintRepo });
+  const result = await flow.execute({
+    input: { sprintId, ticketId }
+  });
+  if (!result.ok) {
+    fail(result.error.error.message);
+    return;
+  }
+  const out = result.value.ctx.output;
+  if (!out.removed) {
+    fail(`ticket ${rawTicketId} not found on sprint ${String(sprintId)}`);
+    return;
+  }
+  process.stdout.write(
+    `removed ticket ${rawTicketId} from sprint ${String(sprintId)} (${plural(out.remainingTickets, "ticket")} remain)
+`
+  );
+};
+var publishTicketAction = async (rawTicketId, opts) => {
+  const { deps, storage } = await bootstrapApp();
+  const ids = await resolveSprintAndIdForCli(opts.sprint, storage.stateRoot, rawTicketId, TicketId.parse, "ticket");
+  if (ids === void 0) return;
+  const { sprintId, id: ticketId } = ids;
+  if (deps.issuePusher === void 0) {
+    fail("issue tracker is unavailable");
+    return;
+  }
+  const flow = createTicketPublishFlow({
+    sprintRepo: deps.sprintRepo,
+    projectRepo: deps.projectRepo,
+    issuePusher: deps.issuePusher
+  });
+  const result = await flow.execute({
+    input: { sprintId, ticketId }
+  });
+  if (!result.ok) {
+    fail(result.error.error.message);
+    return;
+  }
+  const out = result.value.ctx.output;
+  process.stdout.write(`published ticket ${rawTicketId} on sprint ${String(sprintId)} \u2014 ${out.outcome}
+`);
+};
+var registerTicketCommand = (program) => {
+  const ticketCmd = program.command("ticket").description("inspect and manage tickets within a sprint");
+  ticketCmd.command("list").description("list every ticket on the sprint").option(SPRINT_OPTION_FLAGS, SPRINT_OPTION_DESC).action(listTicketsAction);
+  ticketCmd.command("show <ticketId>").description("print a single ticket as JSON").option(SPRINT_OPTION_FLAGS, SPRINT_OPTION_DESC).action(showTicketAction);
+  ticketCmd.command("add").description("append a pending ticket to a draft sprint").option(SPRINT_OPTION_FLAGS, SPRINT_OPTION_DESC).requiredOption("-t, --title <title>", "ticket title").option("-d, --description <text>", "optional description").option("-l, --link <url>", "optional issue link (http/https)").action(addTicketAction);
+  ticketCmd.command("publish <ticketId>").description("create a tracker issue or post an approved-requirements comment").option(SPRINT_OPTION_FLAGS, SPRINT_OPTION_DESC).action(publishTicketAction);
+  ticketCmd.command("remove <ticketId>").description("drop a ticket from a draft sprint").option(SPRINT_OPTION_FLAGS, SPRINT_OPTION_DESC).option("-y, --yes", "skip the interactive y/N confirmation").action(removeTicketAction);
+};
+var formatTicketLine = (t) => {
+  const linkSuffix = t.link !== void 0 ? ` \u2014 ${String(t.link)}` : "";
+  return `${String(t.id)}  [${t.status.padEnd(8)}]  ${t.title}${linkSuffix}`;
+};
+
+// src/application/ui/cli/commands/task.ts
+import { promises as fs3 } from "fs";
+import { join as join5 } from "path";
+import { Option } from "commander";
+var listTasksAction = async (opts) => {
+  const { deps, storage } = await bootstrapApp();
+  const sprintId = await resolveSprintForCli(opts.sprint, storage.stateRoot);
+  if (sprintId === void 0) return;
+  const result = await deps.taskRepo.findBySprintId(sprintId);
+  if (!okOrFail(result)) return;
+  if (result.value.length === 0) {
+    process.stdout.write("(no tasks yet \u2014 run plan to generate them)\n");
+    return;
+  }
+  for (const t of result.value) {
+    process.stdout.write(`${formatTaskLine(t)}
+`);
+  }
+};
+var showTaskAction = async (rawTaskId, opts) => {
+  const { deps, storage } = await bootstrapApp();
+  const ids = await resolveSprintAndIdForCli(opts.sprint, storage.stateRoot, rawTaskId, TaskId.parse, "task");
+  if (ids === void 0) return;
+  const { sprintId, id: taskId } = ids;
+  const result = await deps.taskRepo.findById(sprintId, taskId);
+  if (!okOrFail(result)) return;
+  process.stdout.write(`${JSON.stringify(result.value, null, 2)}
+`);
+};
+var evaluationTaskAction = async (rawTaskId, opts) => {
+  const { deps, storage } = await bootstrapApp();
+  const ids = await resolveSprintAndIdForCli(opts.sprint, storage.stateRoot, rawTaskId, TaskId.parse, "task");
+  if (ids === void 0) return;
+  const { sprintId, id: taskId } = ids;
+  const loaded = await deps.taskRepo.findById(sprintId, taskId);
+  if (!okOrFail(loaded)) return;
+  const latest = latestRecordedEvaluation(loaded.value);
+  if (latest === void 0) {
+    process.stdout.write(`no evaluation recorded for task ${String(taskId)}
+`);
+    return;
+  }
+  const relativePath = evaluationArtifactSprintPath(String(taskId), latest.file);
+  if (relativePath === void 0) {
+    process.stdout.write(`no evaluation artifact recorded for attempt ${String(latest.attemptN)} (legacy record)
+`);
+    return;
+  }
+  const sprintDirPath = await resolveSprintDir(storage.dataRoot, sprintId);
+  if (sprintDirPath === void 0) {
+    process.stdout.write(`evaluation artifact not found on disk: ${relativePath}
+`);
+    return;
+  }
+  try {
+    const body = await fs3.readFile(join5(sprintDirPath, relativePath), "utf8");
+    process.stderr.write(`# attempt ${String(latest.attemptN)} \xB7 eval ${latest.status} \xB7 ${relativePath}
+`);
+    process.stdout.write(body.endsWith("\n") ? body : `${body}
+`);
+  } catch (cause) {
+    const code = cause?.code;
+    if (code === "ENOENT") {
+      process.stdout.write(`evaluation artifact not found on disk: ${relativePath}
+`);
+      return;
+    }
+    fail(`could not read evaluation artifact: ${messageOf(cause)}`);
+  }
+};
+var CAUSE_PHRASE = {
+  "budget-exhausted": "an attempt-budget block",
+  "generator-self-block": "a self-block",
+  "operator-cancelled": "an operator cancel",
+  "post-verify-regression": "a post-verify regression"
+};
+var defaultReason = (task) => task.status === "in_progress" ? "an interrupted run" : task.status === "blocked" ? CAUSE_PHRASE[task.blockCause ?? "unknown"] ?? "an unclassified block" : "the last block";
+var planPriorWork = async (deps, sprintId, task, flag) => {
+  if (task.status === "todo" && flag === void 0) return { probe: { kind: "none" }, defaulted: true };
+  const sprint = await deps.sprintRepo.findById(sprintId);
+  const project = sprint.ok ? await deps.projectRepo.findById(sprint.value.projectId) : void 0;
+  const probe = await probeTaskQuarantine(deps, project?.ok === true ? project.value : void 0, sprintId, task);
+  const choice = flag ?? recommendedPriorWork(task);
+  if (probe.kind === "present") {
+    return {
+      probe,
+      defaulted: flag === void 0,
+      decision: { choice, stashMessage: probe.stashMessage, stat: probe.stat, entries: probe.entries }
+    };
+  }
+  if (probe.kind === "unknown" && flag !== void 0) {
+    return { probe, defaulted: false, decision: { choice, stashMessage: quarantineStashMessage(sprintId, task.id) } };
+  }
+  return { probe, defaulted: flag === void 0 };
+};
+var STARTS_FRESH = "starts fresh";
+var CONTINUES = "continues from the rejected diff";
+var describeChoice = (fact) => fact?.nextAttempt === "fresh" ? STARTS_FRESH : fact?.nextAttempt === "continue" ? CONTINUES : "restores the rejected diff (no choice recorded)";
+var unblockTaskAction = async (rawTaskId, opts) => {
+  const { deps, storage } = await bootstrapApp();
+  const ids = await resolveSprintAndIdForCli(opts.sprint, storage.stateRoot, rawTaskId, TaskId.parse, "task");
+  if (ids === void 0) return;
+  const { sprintId, id: taskId } = ids;
+  const loaded = await deps.taskRepo.findById(sprintId, taskId);
+  if (!okOrFail(loaded)) return;
+  const sprint = await deps.sprintRepo.findById(sprintId);
+  if (!okOrFail(sprint)) return;
+  const plan = await planPriorWork(deps, sprintId, loaded.value, opts.priorWork);
+  const result = await unblockTaskLocked(deps, {
+    sprint: sprint.value,
+    taskId,
+    ...plan.decision !== void 0 ? { priorWork: plan.decision } : {}
+  });
+  if (!okOrFail(result)) return;
+  const taskRef = String(result.value.task.id);
+  process.stdout.write(
+    `unblocked task '${sanitizeDisplayText(result.value.task.name, DISPLAY_TEXT_MAX_CHARS)}' (${taskRef})
+`
+  );
+  const sprintRef = String(sprintId);
+  writePriorWorkReport(plan, loaded.value, opts.priorWork, sprintRef, taskRef);
+  const retry = `ralphctl task unblock --sprint ${sprintRef} ${taskRef}`;
+  const reopened = result.value.sprintReopened;
+  if (reopened !== void 0) {
+    const moved = reopened.from !== reopened.sprint.status;
+    process.stdout.write(
+      moved ? `reopened sprint '${reopened.sprint.slug}' (${sprintRef}) ${reopened.from} \u2192 ${reopened.sprint.status}
+` : `sprint '${reopened.sprint.slug}' (${sprintRef}) is still ${reopened.sprint.status}
+`
+    );
+    if (reopened.sprint.status !== "active") {
+      process.stderr.write(`note: the review \u2192 active step did not persist \u2014 run '${retry}' again to finish it
+`);
+    }
+  }
+  const conflict = result.value.sprintReopenConflict;
+  if (conflict !== void 0) {
+    process.stderr.write(`note: ${conflict.message}
+`);
+    if (conflict.hint !== void 0) process.stderr.write(`      ${conflict.hint}
+`);
+    process.stderr.write(
+      `      then 'ralphctl sprint reopen ${sprintRef}' and '${retry}' to make this task runnable
+`
+    );
+  }
+};
+var writePriorWorkReport = (plan, before, flag, sprintRef, taskRef) => {
+  const { probe } = plan;
+  if (probe.kind === "unknown") {
+    process.stderr.write(
+      flag !== void 0 ? `note: couldn't read git stash (${probe.error}) \u2014 recorded --prior-work ${flag} anyway
+` : `note: couldn't read git stash (${probe.error}); a rejected diff there would be restored on the next attempt
+`
+    );
+    return;
+  }
+  if (probe.kind === "none") {
+    if (flag !== void 0) {
+      process.stderr.write(
+        "note: no rejected diff in git stash for this task \u2014 --prior-work has nothing to apply to\n"
+      );
+    }
+    return;
+  }
+  const choice = plan.decision?.choice ?? "fresh";
+  process.stdout.write(`rejected diff in git stash: ${probe.stashMessage} \u2014 ${formatDiffStat(probe.stat)}
+`);
+  if (before.status === "todo") {
+    const now = choice === "fresh" ? STARTS_FRESH : CONTINUES;
+    process.stdout.write(`next attempt: ${now} (was: ${describeChoice(before.quarantinedDiff)})
+`);
+    return;
+  }
+  const how = plan.defaulted ? `default after ${defaultReason(before)}` : `--prior-work ${choice}`;
+  const other = choice === "fresh" ? "continue" : "fresh";
+  const effect = choice === "fresh" ? `${STARTS_FRESH} (${how}); the diff stays in the stash` : `${CONTINUES} (${how}); it is restored before the first AI turn`;
+  process.stdout.write(`next attempt: ${effect}
+`);
+  if (plan.defaulted) {
+    const verb = other === "continue" ? "to continue from it instead" : "to start fresh instead";
+    process.stdout.write(
+      `      ${verb}: ralphctl task unblock --sprint ${sprintRef} ${taskRef} --prior-work ${other}
+`
+    );
+  }
+};
+var registerTaskCommand = (program) => {
+  const task = program.command("task").description("inspect tasks for a sprint (planning generates them)");
+  task.command("list").description("list every task on the sprint, in order").option(SPRINT_OPTION_FLAGS, SPRINT_OPTION_DESC).action(listTasksAction);
+  task.command("show <taskId>").description("print a single task as JSON").option(SPRINT_OPTION_FLAGS, SPRINT_OPTION_DESC).action(showTaskAction);
+  task.command("evaluation <taskId>").description("print the latest evaluator verdict (evaluation.md) for the task's most recent evaluated attempt").option(SPRINT_OPTION_FLAGS, SPRINT_OPTION_DESC).action(evaluationTaskAction);
+  task.command("unblock <taskId>").description("flip a blocked task back to todo so the implement loop picks it up again").option(SPRINT_OPTION_FLAGS, SPRINT_OPTION_DESC).addOption(
+    new Option(
+      "--prior-work <choice>",
+      "what the next attempt does with its quarantined rejected diff (default depends on why it stopped)"
+    ).choices(["continue", "fresh"])
+  ).action(unblockTaskAction);
+};
+var formatTaskLine = (t) => {
+  const orderStr = String(t.order).padStart(3, " ");
+  const show = (text) => sanitizeDisplayText(text, DISPLAY_TEXT_MAX_CHARS);
+  const head = `${orderStr}.  ${String(t.id)}  [${t.status.padEnd(8)}]  ${show(t.name)}`;
+  const fact = t.quarantinedDiff;
+  if (t.status === "todo" && fact !== void 0) {
+    const next = fact.nextAttempt === "fresh" ? "starts fresh \u2014 rejected diff stays in git stash" : fact.nextAttempt === "continue" ? "continues from the rejected diff" : "restores the rejected diff in git stash (no choice recorded)";
+    return `${head}
+       next attempt: ${next}`;
+  }
+  if (t.status !== "blocked") return head;
+  const reasonFirstLine = t.blockedReason.split("\n")[0] ?? t.blockedReason;
+  const lines = [head, `       ${show(reasonFirstLine)}`];
+  if (t.blockerClass !== void 0) lines.push(`       blocker: ${t.blockerClass}`);
+  if (t.question !== void 0) lines.push(`       question: ${show(t.question)}`);
+  if (t.whatUnblocksMe !== void 0) lines.push(`       unblocks with: ${show(t.whatUnblocksMe)}`);
+  if (fact !== void 0) {
+    const stat = fact.stat !== void 0 ? ` (${formatDiffStat(fact.stat)})` : "";
+    lines.push(`       stash: ${fact.stashMessage}${stat}`);
+  }
+  const flagHint = fact !== void 0 ? " [--prior-work continue|fresh]" : "";
+  lines.push(`       recover with: ralphctl task unblock ${String(t.id)}${flagHint}`);
+  return lines.join("\n");
+};
+
+// src/application/ui/cli/commands/runs.ts
+import { promises as fs4 } from "fs";
+import { createInterface as createInterface2 } from "readline";
+
+// src/application/ui/cli/commands/runs-stats-report.ts
+var STATUS_ORDER = ["done", "blocked", "in_progress", "todo"];
+var STATUS_LABELS = {
+  done: "done",
+  blocked: "blocked",
+  in_progress: "in progress",
+  todo: "todo"
+};
+var RUNG_ORDER = ["model", "effort", "evaluator-effort", "nudge", "best-of-n"];
+var PLATEAU_SOURCE_ORDER = ["threshold", "diversity", "entropy", "unspecified"];
+var ATTRIBUTION_LABEL = {
+  regressed: "regressed",
+  "baseline-broken": "baseline-broken",
+  "fixed-baseline": "fixed-baseline",
+  clean: "clean",
+  unspecified: "unattributed"
+};
+var ATTRIBUTION_ORDER = Object.keys(ATTRIBUTION_LABEL);
+var WARNING_ORDER = [
+  "verify-failed",
+  "crashed",
+  "malformed",
+  "budget-exhausted",
+  "plateau",
+  "unknown"
+];
+var ABORT_ORDER = [
+  "rate-limit-exhausted",
+  "watchdog-killed",
+  "process-crash",
+  "harness-interrupted",
+  "sigterm",
+  "user-cancel",
+  "self-blocked",
+  "unknown"
+];
+var TOP_DIMENSIONS = 8;
+var LABEL_WIDTH = 15;
+var TAXONOMY_LABEL_WIDTH = 22;
+var pct = (rate) => `${(rate * 100).toFixed(1)}%`;
+var keyAt = (text, width) => `  ${text.padEnd(width)}`;
+var key = (text) => keyAt(text, LABEL_WIDTH);
+var taxonomyKey = (text) => keyAt(text, TAXONOMY_LABEL_WIDTH);
+var taxonomyRows = (counts, order) => {
+  const tail = Object.keys(counts).filter((candidate) => !order.includes(candidate));
+  return [...order, ...tail].filter((taxon) => (counts[taxon] ?? 0) > 0).map((taxon) => `${taxonomyKey(taxon)}${String(counts[taxon] ?? 0)}`);
+};
+var num = (n, width) => String(n).padStart(width);
+var denominator = (n, unit) => `(of ${plural(n, unit)})`;
+var headline = (stats) => `Harness outcomes \u2014 ${plural(stats.sprintCount, "sprint")} \xB7 ${plural(stats.totals.taskCount, "task")} \xB7 ${plural(stats.totals.attemptCount, "attempt")}`;
+var renderOutcomes = (rollup) => {
+  const { byStatus, doneClean, doneWithWarning } = rollup.outcomes;
+  const lines = [`Outcome mix ${denominator(rollup.taskCount, "task")}`];
+  for (const status of STATUS_ORDER) {
+    const suffix = status === "done" ? `  (clean ${String(doneClean)} \xB7 with warning ${String(doneWithWarning)})` : "";
+    lines.push(`${key(STATUS_LABELS[status])}${String(byStatus[status])}${suffix}`);
+  }
+  return lines;
+};
+var regressionLine = (attribution) => {
+  if (attribution.attributed === 0) return `${key("regressions")}\u2014 (no attempt carries an attribution verdict)`;
+  const broke = `${plural(attribution.byVerdict.regressed, "attempt")} broke a green baseline`;
+  return `${key("regressions")}${broke} (${pct(attribution.regressionRate)} of ${plural(attribution.attributed, "attributed attempt")})`;
+};
+var renderSummary = (rollup) => {
+  const { doneOnFirstAttempt, doneTotal, rate } = rollup.firstPass;
+  const criteria = rollup.criteria;
+  return [
+    "Summary",
+    `${key("first pass")}${String(doneOnFirstAttempt)}/${String(doneTotal)} done on attempt 1 (${pct(rate)}) \u2014 of ${plural(doneTotal, "done task")}`,
+    regressionLine(rollup.attribution),
+    `${key("criteria")}${String(criteria.passed)}/${String(criteria.declared)} passed (${pct(criteria.passRate)}) \xB7 ${String(criteria.failed)} failed \xB7 ${String(criteria.unknown)} unknown \xB7 ${plural(criteria.tasksWithVerdicts, "task")} graded`
+  ];
+};
+var renderAttempts = (rollup) => {
+  const buckets = rollup.attemptsToDone;
+  const lines = [`Attempts to done ${denominator(rollup.firstPass.doneTotal, "done task")}`];
+  if (buckets.length === 0) {
+    lines.push("  (no done task carries an attempt count yet)");
+    return lines;
+  }
+  for (const bucket of buckets) {
+    lines.push(`${key(plural(bucket.attempts, "attempt"))}${plural(bucket.tasks, "task")}`);
+  }
+  return lines;
+};
+var renderPlateau = (plateau, taskCount, attemptCount) => {
+  const lines = [
+    "Plateau",
+    `${key("tasks")}${plural(plateau.tasksWithPlateau, "task")} (${pct(plateau.taskRate)}) \u2014 of ${plural(taskCount, "task")}`,
+    `${key("attempts")}${String(plateau.attemptsWithPlateau)} \u2014 of ${plural(attemptCount, "attempt")}`
+  ];
+  for (const source of PLATEAU_SOURCE_ORDER) {
+    const hits = plateau.bySource[source];
+    if (hits > 0) lines.push(`${key(source)}${String(hits)}`);
+  }
+  return lines;
+};
+var renderAttribution = (attribution, attemptCount) => {
+  const lines = [`Attribution ${denominator(attemptCount, "attempt")}`];
+  if (attribution.attributed === 0) {
+    lines.push("  (no attempt carries an attribution verdict)");
+    return lines;
+  }
+  for (const verdict of ATTRIBUTION_ORDER) {
+    const hits = attribution.byVerdict[verdict];
+    if (hits > 0 || verdict === "regressed") lines.push(`${taxonomyKey(ATTRIBUTION_LABEL[verdict])}${String(hits)}`);
+  }
+  return lines;
+};
+var renderWarnings = (warnings, attemptCount) => {
+  const lines = [`Warnings ${denominator(attemptCount, "attempt")}`];
+  if (warnings.attemptsWithWarning === 0) {
+    lines.push("  (no attempt carried a warning)");
+    return lines;
+  }
+  return [...lines, ...taxonomyRows(warnings.byKind, WARNING_ORDER)];
+};
+var renderAborts = (aborts, attemptCount) => {
+  const lines = [`Aborts ${denominator(attemptCount, "attempt")}`];
+  if (aborts.attemptsAborted === 0) {
+    lines.push("  (no attempt was aborted)");
+    return lines;
+  }
+  return [...lines, ...taxonomyRows(aborts.byCause, ABORT_ORDER)];
+};
+var RUNG_HEADER = `  ${"rung".padEnd(18)}granted  resolved  fell-through  unsettled`;
+var renderEscalation = (rollup) => {
+  const rows = RUNG_ORDER.filter((rung) => rollup.escalation[rung].granted > 0);
+  const lines = [`Escalation rungs ${denominator(rollup.taskCount, "task")}`];
+  if (rows.length === 0) {
+    lines.push("  (no escalation rung fired)");
+    return lines;
+  }
+  lines.push(RUNG_HEADER);
+  for (const rung of rows) {
+    const efficacy = rollup.escalation[rung];
+    lines.push(
+      `  ${rung.padEnd(18)}${num(efficacy.granted, 7)}${num(efficacy.resolved, 10)}${num(efficacy.fellThrough, 14)}${num(efficacy.unsettled, 11)}`
+    );
+  }
+  return lines;
+};
+var renderDimensions = (dimensions) => {
+  const lines = ["Failed dimensions"];
+  if (dimensions.length === 0) {
+    lines.push("  (no plateau recorded a failed dimension)");
+    return lines;
+  }
+  for (const entry of dimensions.slice(0, TOP_DIMENSIONS)) {
+    lines.push(`${key(entry.dimension)}${String(entry.count)}`);
+  }
+  const hidden = dimensions.length - TOP_DIMENSIONS;
+  if (hidden > 0) lines.push(`  \u2026 ${plural(hidden, "more dimension")} (use --json for the full histogram)`);
+  return lines;
+};
+var sprintLine = (entry) => {
+  const { rollup } = entry;
+  const regressed = rollup.attribution.tasksWithRegression;
+  const parts = [
+    plural(rollup.taskCount, "task"),
+    `${String(rollup.outcomes.byStatus.done)} done`,
+    `${String(rollup.outcomes.byStatus.blocked)} blocked`,
+    `first-pass ${pct(rollup.firstPass.rate)}`,
+    `plateau ${pct(rollup.plateau.taskRate)}`,
+    // Appended only when it happened — the line is already five fields wide.
+    ...regressed > 0 ? [`${String(regressed)} regressed`] : []
+  ];
+  return `  ${entry.sprintName} (${entry.sprintId})
+    ${parts.join(" \xB7 ")}`;
+};
+var renderBySprint = (bySprint) => [
+  "By sprint",
+  ...bySprint.map(sprintLine)
+];
+var renderOutcomeStats = (stats) => {
+  const sections = [
+    [headline(stats)],
+    renderSummary(stats.totals),
+    renderOutcomes(stats.totals),
+    renderAttempts(stats.totals),
+    renderPlateau(stats.totals.plateau, stats.totals.taskCount, stats.totals.attemptCount),
+    renderAttribution(stats.totals.attribution, stats.totals.attemptCount),
+    renderWarnings(stats.totals.warnings, stats.totals.attemptCount),
+    renderAborts(stats.totals.aborts, stats.totals.attemptCount),
+    renderEscalation(stats.totals),
+    renderDimensions(stats.totals.failedDimensions),
+    ...stats.bySprint.length > 1 ? [renderBySprint(stats.bySprint)] : []
+  ];
+  return `${sections.map((section) => section.join("\n")).join("\n\n")}
+`;
+};
+
+// src/application/ui/cli/commands/runs-stats.ts
+var SINCE_DESC = "ISO date \u2014 keep sprints whose latest lifecycle stamp (done, else review, else activated, else planned) is on or after it; never-planned drafts have no stamp and drop out";
+var registerRunsStatsCommand = (runs) => {
+  runs.command("stats").description("summarise harness outcomes across sprints (outcome mix, first-pass rate, escalation efficacy)").option("--json", "print the raw rollup as JSON (stable ordering \u2014 diff two runs to compare settings)").option("--since <date>", SINCE_DESC).option("-s, --sprint <id>", "restrict the rollup to a single sprint").option("-p, --project <id>", "restrict the rollup to one project's sprints").action(runStatsCommand);
+};
+var runStatsCommand = async (opts) => {
+  if (opts.sprint !== void 0 && opts.project !== void 0) {
+    fail("--sprint and --project are mutually exclusive \u2014 pass one, or neither to cover every sprint");
+    return;
+  }
+  const since = parseSince(opts.since);
+  if (!since.ok) return;
+  const { deps } = await bootstrapApp();
+  const scoped = await resolveScopedSprints(deps, opts);
+  if (!scoped.ok) return;
+  const inWindow = since.sinceMs === void 0 ? scoped.sprints : scoped.sprints.filter(activeSince(since.sinceMs));
+  if (inWindow.length === 0 && opts.json !== true) {
+    process.stdout.write(emptyNotice(opts));
+    return;
+  }
+  const slices = await loadSlices(deps, inWindow);
+  if (slices === void 0) return;
+  const stats = foldOutcomeStats(slices);
+  process.stdout.write(opts.json === true ? `${JSON.stringify(stats, null, 2)}
+` : renderOutcomeStats(stats));
+};
+var parseSince = (raw) => {
+  if (raw === void 0) return { ok: true, sinceMs: void 0 };
+  const parsed = Date.parse(raw);
+  if (Number.isNaN(parsed)) {
+    fail(`--since must be an ISO date (e.g. 2026-01-31 or 2026-01-31T09:00:00Z) \u2014 got '${raw}'`);
+    return { ok: false };
+  }
+  return { ok: true, sinceMs: parsed };
+};
+var lastActivityMs = (sprint) => {
+  const stamp = sprint.doneAt ?? sprint.reviewAt ?? sprint.activatedAt ?? sprint.plannedAt;
+  if (stamp === null) return void 0;
+  const parsed = Date.parse(String(stamp));
+  return Number.isNaN(parsed) ? void 0 : parsed;
+};
+var activeSince = (sinceMs) => (sprint) => {
+  const activity = lastActivityMs(sprint);
+  return activity !== void 0 && activity >= sinceMs;
+};
+var resolveScopedSprints = async (deps, opts) => {
+  if (opts.sprint !== void 0) {
+    const id = SprintId.parse(opts.sprint);
+    if (!okOrFail(id, "invalid sprint id: ")) return { ok: false };
+    const found = await deps.sprintRepo.findById(id.value);
+    if (!okOrFail(found)) return { ok: false };
+    return { ok: true, sprints: [found.value] };
+  }
+  const all = await deps.sprintRepo.list();
+  if (!okOrFail(all)) return { ok: false };
+  if (opts.project === void 0) return { ok: true, sprints: all.value };
+  const projectId = ProjectId.parse(opts.project);
+  if (!okOrFail(projectId, "invalid project id: ")) return { ok: false };
+  const project = await deps.projectRepo.findById(projectId.value);
+  if (!okOrFail(project)) return { ok: false };
+  return { ok: true, sprints: all.value.filter((sprint) => sprint.projectId === projectId.value) };
+};
+var loadSlices = async (deps, sprints) => {
+  const reads = await Promise.all(
+    sprints.map(async (sprint) => ({ sprint, tasks: await deps.taskRepo.findBySprintId(sprint.id) }))
+  );
+  const slices = [];
+  for (const { sprint, tasks } of reads) {
+    if (!tasks.ok) {
+      fail(`sprint ${String(sprint.id)}: ${tasks.error.message}`);
+      return void 0;
+    }
+    slices.push({ sprint, tasks: tasks.value });
+  }
+  return slices;
+};
+var emptyNotice = (opts) => {
+  const filtered = opts.since !== void 0 || opts.sprint !== void 0 || opts.project !== void 0;
+  return filtered ? "(no sprints match this scope \u2014 widen or drop --since / --sprint / --project)\n" : "(no sprints yet \u2014 nothing to summarise)\n";
+};
+
+// src/application/ui/cli/commands/runs.ts
+var registerRunsCommand = (program) => {
+  const runs = program.command("runs").description("inspect and prune per-run forensic artifacts");
+  runs.command("list").description("list per-run forensic artifacts grouped by flow").option("-f, --flow <name>", "restrict the listing to a single flow").action(runListCommand);
+  runs.command("prune").description("delete per-run forensic artifacts (filters required unless invoked interactively)").option("--older-than <duration>", "delete runs older than this (h / d / w suffix, e.g. 7d)").option("--keep-last <n>", "retain the N most-recent runs per flow").option("-f, --flow <name>", "restrict pruning to a single flow").option("--dry-run", "list candidates without deleting (wins over --yes)").option("-y, --yes", "skip the interactive y/N confirmation").action(runPruneCommand);
+  registerRunsStatsCommand(runs);
+};
+var runListCommand = async (opts) => {
+  const { storage } = await bootstrapApp();
+  const result = await listRuns(storage.runsRoot);
+  if (!okOrFail(result)) return;
+  const entries = opts.flow !== void 0 ? result.value.filter((r) => r.flow === opts.flow) : result.value;
+  if (entries.length === 0) {
+    if (opts.flow !== void 0) {
+      process.stdout.write(
+        `(no runs for flow '${opts.flow}' yet under ${String(storage.runsRoot)} \u2014 drop --flow to see all)
+`
+      );
+    } else {
+      process.stdout.write(`(no runs yet under ${String(storage.runsRoot)} \u2014 run a flow to generate one)
+`);
+    }
+    return;
+  }
+  const groups = groupByFlow(entries);
+  const now = /* @__PURE__ */ new Date();
+  let grandTotalBytes = 0;
+  let grandTotalRuns = 0;
+  for (const [flow, runs] of groups) {
+    const flowBytes = runs.reduce((acc, r) => acc + r.sizeBytes, 0);
+    grandTotalBytes += flowBytes;
+    grandTotalRuns += runs.length;
+    process.stdout.write(`${flow}  (${plural(runs.length, "run")}, ${formatBytes(flowBytes)})
+`);
+    for (const run of runs) {
+      process.stdout.write(`  ${run.runId}  ${formatRelativeAge(run.timestamp, now)}  ${formatBytes(run.sizeBytes)}
+`);
+    }
+  }
+  process.stdout.write(`total: ${plural(grandTotalRuns, "run")}, ${formatBytes(grandTotalBytes)}
+`);
+};
+var runPruneCommand = async (opts) => {
+  const noFlags = opts.olderThan === void 0 && opts.keepLast === void 0 && opts.flow === void 0 && opts.dryRun !== true && opts.yes !== true;
+  if (noFlags) {
+    await runInteractivePrune();
+    return;
+  }
+  const filters = parsePruneFilters(opts);
+  if (!filters.ok) return;
+  const scopedResult = await resolveScopedRuns(opts.flow);
+  if (!scopedResult.ok) return;
+  if (filters.olderThanMs === void 0 && filters.keepLast === void 0) {
+    fail(
+      "--older-than or --keep-last is required (or invoke `ralphctl runs prune` with no flags for the interactive picker)"
+    );
+    return;
+  }
+  const candidates = computeAndAnnouncePruneCandidates(scopedResult.grouped, {
+    olderThanMs: filters.olderThanMs,
+    keepLast: filters.keepLast
+  });
+  if (candidates === void 0) return;
+  if (opts.dryRun === true) {
+    return;
+  }
+  if (opts.yes !== true) {
+    const confirmed = await confirmNonInteractivePrune(candidates.length);
+    if (!confirmed) return;
+  }
+  await performPrune(candidates);
+};
+var parseKeepLast = (raw) => /^\d+$/u.test(raw.trim()) ? Number(raw.trim()) : void 0;
+var parsePruneFilters = (opts) => {
+  let olderThanMs;
+  if (opts.olderThan !== void 0) {
+    const parsed = parseDuration(opts.olderThan);
+    if (!okOrFail(parsed)) return { ok: false };
+    olderThanMs = parsed.value;
+  }
+  let keepLast;
+  if (opts.keepLast !== void 0) {
+    keepLast = parseKeepLast(opts.keepLast);
+    if (keepLast === void 0) {
+      fail("--keep-last must be a non-negative integer");
+      return { ok: false };
+    }
+  }
+  return { ok: true, olderThanMs, keepLast };
+};
+var resolveScopedRuns = async (flow) => {
+  const { storage } = await bootstrapApp();
+  const result = await listRuns(storage.runsRoot);
+  if (!okOrFail(result)) return { ok: false };
+  const allEntries = result.value;
+  if (flow !== void 0) {
+    const flowExists = allEntries.some((r) => r.flow === flow);
+    if (!flowExists) {
+      fail(`no such flow '${flow}' under ${String(storage.runsRoot)}`);
+      return { ok: false };
+    }
+  }
+  const scoped = flow !== void 0 ? allEntries.filter((r) => r.flow === flow) : allEntries;
+  return { ok: true, grouped: groupByFlow(scoped) };
+};
+var computeAndAnnouncePruneCandidates = (grouped, filters) => {
+  const { candidates, unknownStampWarnings } = selectCandidates(grouped, filters);
+  for (const warning of unknownStampWarnings) {
+    process.stderr.write(`warning: skipping run with non-conforming dir name (no timestamp): ${warning}
+`);
+  }
+  if (candidates.length === 0) {
+    process.stdout.write("nothing to prune\n");
+    return void 0;
+  }
+  printCandidateSummary(candidates);
+  return candidates;
+};
+var confirmNonInteractivePrune = async (count) => confirmDestructive({
+  yes: false,
+  action: "delete",
+  confirmPrompt: `delete ${plural(count, "run")}? [y/N] `,
+  nonTtyHint: ", or --dry-run to list candidates only"
+});
+var runInteractivePrune = async () => {
+  if (process.stdin.isTTY !== true) {
+    fail(
+      "interactive prune requires a TTY \u2014 supply --older-than or --keep-last (plus --yes / --dry-run) on non-interactive stdin"
+    );
+    return;
+  }
+  const { storage } = await bootstrapApp();
+  const listed = await listRuns(storage.runsRoot);
+  if (!okOrFail(listed)) return;
+  if (listed.value.length === 0) {
+    process.stdout.write(`no runs to prune under ${String(storage.runsRoot)}
+`);
+    return;
+  }
+  const groups = groupByFlow(listed.value);
+  const flows = Array.from(groups.keys());
+  printRunsOverview(groups);
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  try {
+    const filterChoice = await promptPruneFilterChoice(rl);
+    if (!filterChoice.ok) return;
+    const flowChoice = await promptFlowFilterChoice(rl, flows);
+    if (!flowChoice.ok) return;
+    const scoped = flowChoice.flowFilter !== void 0 ? listed.value.filter((r) => r.flow === flowChoice.flowFilter) : listed.value;
+    const grouped = groupByFlow(scoped);
+    const candidates = computeAndAnnouncePruneCandidates(grouped, {
+      olderThanMs: filterChoice.olderThanMs,
+      keepLast: filterChoice.keepLast
+    });
+    if (candidates === void 0) return;
+    const ok = await askLine(rl, `delete ${plural(candidates.length, "run")}? [y/N] `);
+    if (ok === void 0) {
+      reportPromptAborted();
+      return;
+    }
+    if (!isYes(ok.trim())) {
+      process.stdout.write("aborted\n");
+      return;
+    }
+    await performPrune(candidates);
+  } finally {
+    rl.close();
+  }
+};
+var printRunsOverview = (groups) => {
+  process.stdout.write("current runs:\n");
+  for (const [flow, runs] of groups) {
+    const flowBytes = runs.reduce((acc, r) => acc + r.sizeBytes, 0);
+    process.stdout.write(`  ${flow}  (${plural(runs.length, "run")}, ${formatBytes(flowBytes)})
+`);
+  }
+  process.stdout.write("\n");
+};
+var reportPromptAborted = () => {
+  process.stdout.write("aborted\n");
+  process.exitCode = 130;
+  return { ok: false };
+};
+var promptPruneFilterChoice = async (rl) => {
+  const criterion = (await askLine(rl, "prune by [1] age threshold or [2] keep-last N? "))?.trim();
+  if (criterion === void 0) return reportPromptAborted();
+  if (criterion === "1") {
+    const duration = (await askLine(rl, "duration (e.g. 7d, 24h, 2w): "))?.trim();
+    if (duration === void 0) return reportPromptAborted();
+    const parsed = parseDuration(duration);
+    if (!okOrFail(parsed)) return { ok: false };
+    return { ok: true, olderThanMs: parsed.value, keepLast: void 0 };
+  }
+  if (criterion === "2") {
+    const n = (await askLine(rl, "keep last N runs per flow: "))?.trim();
+    if (n === void 0) return reportPromptAborted();
+    const keepLast = parseKeepLast(n);
+    if (keepLast === void 0) {
+      fail("keep-last must be a non-negative integer");
+      return { ok: false };
+    }
+    return { ok: true, olderThanMs: void 0, keepLast };
+  }
+  fail(`unrecognised choice '${criterion}' \u2014 expected 1 or 2`);
+  return { ok: false };
+};
+var promptFlowFilterChoice = async (rl, flows) => {
+  const flowAnswer = (await askLine(rl, `restrict to a flow? [enter for all, or one of: ${flows.join(", ")}] `))?.trim();
+  if (flowAnswer === void 0) return reportPromptAborted();
+  const flowFilter = flowAnswer.length === 0 ? void 0 : flowAnswer;
+  if (flowFilter !== void 0 && !flows.includes(flowFilter)) {
+    fail(`no such flow '${flowFilter}'`);
+    return { ok: false };
+  }
+  return { ok: true, flowFilter };
+};
+var selectCandidates = (grouped, filters) => {
+  const { olderThanMs, keepLast } = filters;
+  const candidates = [];
+  const unknownStampWarnings = [];
+  const nowMs = Date.now();
+  for (const [, runsForFlow] of grouped) {
+    const keep = buildKeepSet(runsForFlow, keepLast);
+    for (const run of runsForFlow) {
+      const { qualifies, unknownStamp } = evaluatePruneQualification(run, keep, olderThanMs, nowMs);
+      if (unknownStamp) unknownStampWarnings.push(run.path);
+      if (qualifies) candidates.push(run);
+    }
+  }
+  return { candidates, unknownStampWarnings };
+};
+var buildKeepSet = (runsForFlow, keepLast) => {
+  if (keepLast === void 0) return void 0;
+  const keep = /* @__PURE__ */ new Set();
+  for (const r of runsForFlow.slice(0, keepLast)) keep.add(r.path);
+  return keep;
+};
+var evaluatePruneQualification = (run, keepSet, olderThanMs, nowMs) => {
+  let ageQualifies = true;
+  let unknownStamp = false;
+  if (olderThanMs !== void 0) {
+    if (run.timestamp === null) {
+      unknownStamp = true;
+      ageQualifies = false;
+    } else {
+      ageQualifies = nowMs - run.timestamp.getTime() >= olderThanMs;
+    }
+  }
+  const keepQualifies = keepSet === void 0 ? true : !keepSet.has(run.path);
+  return { qualifies: ageQualifies && keepQualifies, unknownStamp };
+};
+var printCandidateSummary = (candidates) => {
+  const grouped = groupByFlow(candidates);
+  process.stdout.write("candidates:\n");
+  let totalBytes = 0;
+  for (const [flow, runs] of grouped) {
+    const flowBytes = runs.reduce((acc, r) => acc + r.sizeBytes, 0);
+    totalBytes += flowBytes;
+    process.stdout.write(`  ${flow}: ${plural(runs.length, "run")}, ${formatBytes(flowBytes)}
+`);
+  }
+  process.stdout.write(`  total: ${plural(candidates.length, "run")}, ${formatBytes(totalBytes)}
+`);
+};
+var performPrune = async (candidates) => {
+  const failures = [];
+  let freedBytes = 0;
+  let freedCount = 0;
+  for (const candidate of candidates) {
+    try {
+      await fs4.rm(String(candidate.path), { recursive: true, force: false });
+      freedBytes += candidate.sizeBytes;
+      freedCount += 1;
+    } catch (cause) {
+      const reason = messageOf(cause);
+      failures.push({ path: String(candidate.path), reason });
+    }
+  }
+  process.stdout.write(`pruned ${plural(freedCount, "run")}, freed ${formatBytes(freedBytes)}
+`);
+  if (failures.length > 0) {
+    for (const failure of failures) {
+      process.stderr.write(`  failed: ${failure.path} \u2014 ${failure.reason}
+`);
+    }
+    fail(`${plural(failures.length, "run")} could not be deleted`);
+  }
+};
+
+// src/application/ui/cli/commands/agents.ts
+var IMPLEMENT_ROLES = ["generator", "evaluator"];
+var listAgentsAction = async () => {
+  const { deps, storage } = await bootstrapApp();
+  const bundledSource = createBundledAgentDefinitionSource();
+  const operatorSource = createOperatorAgentDefinitionSource({
+    operatorAgentDefinitionsRoot: storage.operatorAgentDefinitionsRoot,
+    logger: deps.logger,
+    warnIfVague: (definition) => warnIfVague(deps.logger, definition)
+  });
+  const [bundled, operator] = await Promise.all([bundledSource.list(), operatorSource.list()]);
+  if (!okOrFail(bundled)) return;
+  if (!okOrFail(operator)) return;
+  const showFlow = createSettingsShowFlow({ settingsRepo: deps.settingsRepo });
+  const current = await showFlow.execute({ input: void 0 });
+  if (!current.ok) {
+    fail(current.error.error.message);
+    return;
+  }
+  const agentBindings = current.value.ctx.output.ai.implement.agents;
+  const byName = /* @__PURE__ */ new Map();
+  for (const definition of bundled.value) byName.set(definition.name, { tier: "bundled", definition });
+  for (const definition of operator.value) byName.set(definition.name, { tier: "operator", definition });
+  if (byName.size === 0) {
+    process.stdout.write("(no agent definitions available)\n");
+    return;
+  }
+  const listed = [...byName.values()].sort((a, b) => a.definition.name.localeCompare(b.definition.name));
+  for (const { tier, definition } of listed) {
+    const boundRoles = IMPLEMENT_ROLES.filter((role) => agentBindings?.[role] === definition.name);
+    const boundLabel = boundRoles.length > 0 ? boundRoles.join(", ") : "-";
+    process.stdout.write(
+      `${definition.name.padEnd(28)}  ${tier.padEnd(8)}  bound: ${boundLabel.padEnd(20)}  ${definition.description}
+`
+    );
+  }
+};
+var registerAgentsCommand = (program) => {
+  const agents = program.command("agents").description("inspect portable agent definitions");
+  agents.command("list").description("list bundled + operator agent definitions and which implement role each is bound to").action(listAgentsAction);
+};
+
+// src/application/ui/cli/commands/skills.ts
+var savedDisabledFrom = (skills) => {
+  const byFlow = /* @__PURE__ */ new Map();
+  for (const flowId of FLOW_IDS) byFlow.set(flowId, new Set(skills?.[flowId]?.disabled ?? []));
+  return (flowId) => byFlow.get(flowId) ?? /* @__PURE__ */ new Set();
+};
+var enabledFlowsFor = (entry, savedDisabled) => SKILL_MOUNTING_FLOW_IDS.filter((flowId) => {
+  if (entry.defaultFor.includes(flowId)) return !savedDisabled(flowId).has(entry.name);
+  const install = entry.installs.find((i) => i.flow === flowId);
+  return install !== void 0 && install.status !== "broken";
+});
+var PROVENANCE_RANK = {
+  "locally-modified": 5,
+  broken: 4,
+  "update-available": 3,
+  "in-sync": 2,
+  manual: 1
+};
+var provenanceLabel = (status) => {
+  switch (status) {
+    case "locally-modified":
+      return "locally modified";
+    case "broken":
+      return "broken copy";
+    case "update-available":
+      return "update available";
+    case "in-sync":
+      return "in sync";
+    case "manual":
+      return "manual";
+  }
+};
+var provenanceFor = (entry) => {
+  if (entry.installs.length === 0) return "-";
+  const worst = entry.installs.reduce((acc, i) => PROVENANCE_RANK[i.status] > PROVENANCE_RANK[acc.status] ? i : acc);
+  return provenanceLabel(worst.status);
+};
+var formatSkillLine = (entry, bundledNames, savedDisabled) => {
+  const tier = bundledNames.has(entry.name) ? "bundled" : "manual";
+  const flowsLabel = enabledFlowsFor(entry, savedDisabled).join(", ") || "-";
+  const provenance = provenanceFor(entry);
+  return `${entry.name.padEnd(38)}  ${tier.padEnd(8)}  flows: ${flowsLabel.padEnd(44)}  ${provenance.padEnd(18)}  ${entry.description}`;
+};
+var listSkillsAction = async () => {
+  const { deps } = await bootstrapApp();
+  const catalogR = await deps.skillCatalog.list();
+  if (!okOrFail(catalogR)) return;
+  if (catalogR.value.length === 0) {
+    process.stdout.write("(no skills bundled)\n");
+    return;
+  }
+  const settingsR = await deps.settingsRepo.load();
+  const savedDisabled = savedDisabledFrom(settingsR.ok ? settingsR.value.ai.skills : void 0);
+  const bundledNames = new Set(BUNDLED_SKILLS.map((e) => e.name));
+  const sorted = [...catalogR.value].sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of sorted) {
+    process.stdout.write(`${formatSkillLine(entry, bundledNames, savedDisabled)}
+`);
+  }
+};
+var registerSkillsCommand = (program) => {
+  const skills = program.command("skills").description("inspect the bundled skill catalog");
+  skills.command("list").description("list bundled + manually-dropped skills, their tier, enabled flows, and provenance").action(listSkillsAction);
+};
+
+// src/integration/ai/prompts/_engine/bundled-templates.ts
+var BUNDLED_PROMPT_TEMPLATES = [
+  "apply-feedback",
+  "create-pr",
+  "detect-scripts",
+  "detect-skills",
+  "distill-learnings",
+  "evaluate",
+  "evaluate-continuation",
+  "ideate",
+  "implement",
+  "implement-continuation",
+  "implement-crash-resume",
+  "plan",
+  "readiness",
+  "refine",
+  "reproduce",
+  "select-candidate"
+];
+var BUNDLED_PROMPT_PARTIALS = [
+  "approval-gate",
+  "autonomous-operation",
+  "conventions-agents-md",
+  "conventions-claude-md",
+  "conventions-copilot-instructions",
+  "decisions",
+  "evaluator-failure-modes",
+  "evaluator-grading-rules",
+  "evidence-bound",
+  "git-boundary",
+  "harness-context",
+  "one-shot-operation",
+  "parallel-tool-calls",
+  "question-format",
+  "skill-body",
+  "task-blocked",
+  "task-fields",
+  "task-sizing",
+  "validation-checklist"
+];
+
+// src/application/ui/cli/commands/prompts.ts
+var formatPromptLine = (loaded) => `${loaded.name.padEnd(26)}  ${loaded.kind.padEnd(8)}  ${String(loaded.bytes).padStart(6)} bytes`;
+var listPromptsAction = async () => {
+  const { deps } = await bootstrapApp();
+  const requested = [
+    ...BUNDLED_PROMPT_TEMPLATES.map((name) => ({ name, kind: "template", bytes: 0 })),
+    ...BUNDLED_PROMPT_PARTIALS.map((name) => ({ name, kind: "partial", bytes: 0 }))
+  ];
+  const loaded = [];
+  for (const entry of requested) {
+    const body = await deps.templateLoader.load(entry.name);
+    if (!okOrFail(body)) return;
+    if (body.value.trim().length === 0) {
+      fail(`prompt template '${entry.name}' resolved to an empty file \u2014 the install is incomplete`);
+      return;
+    }
+    loaded.push({ ...entry, bytes: Buffer.byteLength(body.value, "utf8") });
+  }
+  for (const entry of loaded.sort((a, b) => a.name.localeCompare(b.name))) {
+    process.stdout.write(`${formatPromptLine(entry)}
+`);
+  }
+};
+var registerPromptsCommand = (program) => {
+  const prompts = program.command("prompts").description("inspect the bundled prompt templates");
+  prompts.command("list").description("load every bundled prompt template + partial and list its name, kind and size").action(listPromptsAction);
+};
+
+// src/application/ui/cli/cli.ts
+var runCli = async (argv) => {
+  const program = new Command();
+  program.name("ralphctl").description("ralphctl \u2014 interactive TUI and CLI").version(CLI_METADATA.currentVersion, "-v, --version", "show version").allowExcessArguments(true).option(
+    "--implement-generator-provider <provider>",
+    "override settings.ai.implement.generator.provider for this launch (requires --implement-generator-model)"
+  ).option(
+    "--implement-generator-model <model>",
+    "override settings.ai.implement.generator.model for this launch (requires --implement-generator-provider)"
+  ).option(
+    "--implement-evaluator-provider <provider>",
+    "override settings.ai.implement.evaluator.provider for this launch (requires --implement-evaluator-model)"
+  ).option(
+    "--implement-evaluator-model <model>",
+    "override settings.ai.implement.evaluator.model for this launch (requires --implement-evaluator-provider)"
+  ).action(async (opts, command) => {
+    const verb = command.args[0];
+    if (verb !== void 0) {
+      const isFlow = flowRegistry.some((entry) => entry.manifest.id === verb);
+      const flowHint = isFlow ? ` \u2014 '${verb}' is an interactive flow \u2014 launch the TUI with bare 'ralphctl'` : "";
+      process.stderr.write(
+        `error: unknown command '${verb}' \u2014 run 'ralphctl --help' for available commands${flowHint}
+`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const parsed = parseImplementRoleOverrides({
+      generatorProvider: opts.implementGeneratorProvider,
+      generatorModel: opts.implementGeneratorModel,
+      evaluatorProvider: opts.implementEvaluatorProvider,
+      evaluatorModel: opts.implementEvaluatorModel
+    });
+    if (!parsed.ok) {
+      process.stderr.write(`ralphctl: ${parsed.error}
+`);
+      process.exitCode = 1;
+      return;
+    }
+    const { launchTui } = await import("./launch-VBRTQP4L.mjs");
+    await launchTui({ ...parsed.overrides !== void 0 ? { implementRoleOverrides: parsed.overrides } : {} });
+  });
+  registerExportRequirementsCommand(program);
+  registerExportContextCommand(program);
+  registerCreatePrCommand(program);
+  registerDoctorCommand(program);
+  registerDemoCommand(program);
+  registerSettingsCommand(program);
+  registerCompletionCommand(program);
+  registerProjectCommand(program);
+  registerSprintCommand(program);
+  registerTicketCommand(program);
+  registerTaskCommand(program);
+  registerRunsCommand(program);
+  registerAgentsCommand(program);
+  registerSkillsCommand(program);
+  registerPromptsCommand(program);
+  try {
+    await program.parseAsync([...argv]);
+  } catch (err) {
+    reportFatal(err);
+  }
+};
+export {
+  runCli
+};