ralphctl 0.1.0 → 0.1.2

package/dist/cli.mjs

@@ -0,0 +1,4245 @@
+#!/usr/bin/env node
+import {
+  addCheckScriptToRepository,
+  projectAddCommand
+} from "./chunk-MRKOFVTM.mjs";
+import {
+  TaskNotFoundError,
+  addTask,
+  areAllTasksDone,
+  branchExists,
+  buildIdeateAutoPrompt,
+  buildIdeatePrompt,
+  buildTicketRefinePrompt,
+  exportRequirementsToMarkdown,
+  extractJsonObject,
+  formatTicketForPrompt,
+  getActiveProvider,
+  getCurrentBranch,
+  getDefaultBranch,
+  getNextTask,
+  getTask,
+  getTaskImportSchema,
+  getTasks,
+  importTasks,
+  inputPositiveInt,
+  isGhAvailable,
+  isGlabAvailable,
+  listTasks,
+  parsePlanningBlocked,
+  parseRequirementsFile,
+  parseTasksJson,
+  providerDisplayName,
+  removeTask,
+  renderParsedTasksTable,
+  reorderTask,
+  resolveProvider,
+  runAiSession,
+  saveTasks,
+  selectProject,
+  selectProjectPaths,
+  selectProjectRepository,
+  selectSprint,
+  selectTask,
+  selectTaskStatus,
+  selectTicket,
+  spawnHeadless,
+  spawnInteractive,
+  sprintPlanCommand,
+  sprintRefineCommand,
+  sprintStartCommand,
+  updateTaskStatus,
+  validateImportTasks
+} from "./chunk-LOR7QBXX.mjs";
+import {
+  escapableSelect
+} from "./chunk-NTWO2LXB.mjs";
+import {
+  sprintCreateCommand
+} from "./chunk-JON4GCLR.mjs";
+import {
+  IssueFetchError,
+  TicketNotFoundError,
+  addTicket,
+  allRequirementsApproved,
+  editorInput,
+  fetchIssueFromUrl,
+  formatIssueContext,
+  formatTicketDisplay,
+  getPendingRequirements,
+  getTicket,
+  groupTicketsByProject,
+  listTickets,
+  removeTicket,
+  ticketAddCommand,
+  updateTicket
+} from "./chunk-MNMQC36F.mjs";
+import {
+  EXIT_ERROR,
+  exitWithCode
+} from "./chunk-7TG3EAQ2.mjs";
+import {
+  ProjectNotFoundError,
+  addProjectRepo,
+  getProject,
+  listProjects,
+  removeProject,
+  removeProjectRepo
+} from "./chunk-WGHJI3OI.mjs";
+import {
+  NoCurrentSprintError,
+  SprintNotFoundError,
+  SprintStatusError,
+  assertSprintStatus,
+  closeSprint,
+  deleteSprint,
+  getAiProvider,
+  getConfig,
+  getCurrentSprint,
+  getCurrentSprintOrThrow,
+  getEditor,
+  getProgress,
+  getSprint,
+  listSprints,
+  logProgress,
+  resolveSprintId,
+  saveSprint,
+  setAiProvider,
+  setCurrentSprint,
+  setEditor,
+  withFileLock
+} from "./chunk-EKMZZRWI.mjs";
+import {
+  AiProviderSchema,
+  IdeateOutputSchema,
+  ImportTasksSchema,
+  RequirementStatusSchema,
+  SprintSchema,
+  SprintStatusSchema,
+  TaskStatusSchema,
+  TasksSchema,
+  assertSafeCwd,
+  expandTilde,
+  fileExists,
+  getDataDir,
+  getIdeateDir,
+  getRefinementDir,
+  getSchemaPath,
+  getSprintDir,
+  getSprintFilePath,
+  getTasksFilePath,
+  readValidatedJson,
+  validateProjectPath
+} from "./chunk-6PYTKGB5.mjs";
+import {
+  DETAIL_LABEL_WIDTH,
+  badge,
+  boxChars,
+  clearScreen,
+  colors,
+  createSpinner,
+  emoji,
+  error,
+  field,
+  fieldMultiline,
+  formatSprintStatus,
+  formatTaskStatus,
+  getQuoteForContext,
+  horizontalLine,
+  icons,
+  labelValue,
+  log,
+  muted,
+  printCountSummary,
+  printHeader,
+  printSeparator,
+  progressBar,
+  renderCard,
+  renderTable,
+  showBanner,
+  showEmpty,
+  showError,
+  showInfo,
+  showNextStep,
+  showNextSteps,
+  showRandomQuote,
+  showSuccess,
+  showTip,
+  showWarning,
+  success,
+  terminalBell
+} from "./chunk-QBXHAXHI.mjs";
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/interactive/menu.ts
+import { Separator } from "@inquirer/prompts";
+var SEPARATOR_WIDTH = 48;
+function titled(label) {
+  const lineLen = Math.max(2, SEPARATOR_WIDTH - label.length - 4);
+  return new Separator(colors.muted(`
+\u2500\u2500 ${label} ${"\u2500".repeat(lineLen)}`));
+}
+function line() {
+  return new Separator(colors.muted("\u2500".repeat(SEPARATOR_WIDTH)));
+}
+var WORKFLOW_ACTIONS = {
+  sprint: /* @__PURE__ */ new Set(["create", "refine", "ideate", "plan", "start", "close"]),
+  ticket: /* @__PURE__ */ new Set(["add", "refine"]),
+  task: /* @__PURE__ */ new Set(["add", "import"]),
+  progress: /* @__PURE__ */ new Set(["log"])
+};
+function isWorkflowAction(group, subCommand) {
+  return WORKFLOW_ACTIONS[group]?.has(subCommand) ?? false;
+}
+function buildPlanActions(ctx) {
+  const items = [];
+  const isDraft = ctx.currentSprintStatus === "draft";
+  const hasSprint = ctx.currentSprintId !== null;
+  items.push({ name: "Create Sprint", value: "action:sprint:create", description: "Start a new sprint" });
+  const addTicketDisabled = !hasSprint ? "create a sprint first" : !isDraft ? "need draft sprint" : !ctx.hasProjects ? "add a project first" : false;
+  items.push({
+    name: "Add Ticket",
+    value: "action:ticket:add",
+    description: "Add work to current sprint",
+    disabled: addTicketDisabled
+  });
+  let refineDisabled = false;
+  let refineDesc = "Clarify ticket requirements";
+  if (!hasSprint) {
+    refineDisabled = "create a sprint first";
+  } else if (!isDraft) {
+    refineDisabled = "need draft sprint";
+  } else if (ctx.ticketCount === 0) {
+    refineDisabled = "add tickets first";
+  } else if (ctx.pendingRequirements === 0) {
+    refineDisabled = "all tickets refined";
+  } else {
+    refineDesc = `${String(ctx.pendingRequirements)} ticket${ctx.pendingRequirements !== 1 ? "s" : ""} pending`;
+  }
+  items.push({
+    name: "Refine Requirements",
+    value: "action:sprint:refine",
+    description: refineDesc,
+    disabled: refineDisabled
+  });
+  let planDisabled = false;
+  const planDesc = "Generate tasks from requirements";
+  if (!hasSprint) {
+    planDisabled = "create a sprint first";
+  } else if (!isDraft) {
+    planDisabled = "need draft sprint";
+  } else if (ctx.ticketCount === 0) {
+    planDisabled = "add tickets first";
+  } else if (!ctx.allRequirementsApproved) {
+    planDisabled = "refine all tickets first";
+  }
+  items.push({
+    name: ctx.taskCount > 0 ? "Re-Plan Tasks" : "Plan Tasks",
+    value: "action:sprint:plan",
+    description: planDesc,
+    disabled: planDisabled
+  });
+  const ideateDisabled = !hasSprint ? "create a sprint first" : !isDraft ? "need draft sprint" : !ctx.hasProjects ? "add a project first" : false;
+  items.push({
+    name: "Ideate",
+    value: "action:sprint:ideate",
+    description: "Quick idea to tasks",
+    disabled: ideateDisabled
+  });
+  return items;
+}
+function buildExecuteActions(ctx) {
+  const items = [];
+  const isDraft = ctx.currentSprintStatus === "draft";
+  const isActive = ctx.currentSprintStatus === "active";
+  const hasSprint = ctx.currentSprintId !== null;
+  let startDisabled = false;
+  if (!hasSprint) {
+    startDisabled = "create a sprint first";
+  } else if (!isDraft && !isActive) {
+    startDisabled = "need draft or active sprint";
+  } else if (ctx.taskCount === 0) {
+    startDisabled = "plan tasks first";
+  }
+  items.push({
+    name: "Start Sprint",
+    value: "action:sprint:start",
+    description: "Begin implementation",
+    disabled: startDisabled
+  });
+  items.push({
+    name: "Health Check",
+    value: "action:sprint:health",
+    description: "Diagnose blockers and stale tasks",
+    disabled: !hasSprint ? "no sprint" : false
+  });
+  items.push({
+    name: "Close Sprint",
+    value: "action:sprint:close",
+    description: "Close the current sprint",
+    disabled: !isActive ? "need active sprint" : false
+  });
+  return items;
+}
+function buildMainMenu(ctx) {
+  const items = [];
+  let defaultValue;
+  if (ctx.nextAction) {
+    const actionValue = `action:${ctx.nextAction.group}:${ctx.nextAction.subCommand}`;
+    items.push({
+      name: `\u2192 ${ctx.nextAction.label}`,
+      value: actionValue,
+      description: ctx.nextAction.description
+    });
+    defaultValue = actionValue;
+  }
+  items.push(titled("PLAN"));
+  for (const action of buildPlanActions(ctx)) {
+    items.push(action);
+  }
+  items.push(titled("EXECUTE"));
+  for (const action of buildExecuteActions(ctx)) {
+    items.push(action);
+  }
+  items.push(titled("BROWSE"));
+  items.push({ name: "Sprints", value: "sprint", description: "List, show, switch" });
+  items.push({ name: "Tickets", value: "ticket", description: "List, show, edit" });
+  items.push({ name: "Tasks", value: "task", description: "List, show, manage" });
+  items.push(titled("SETUP"));
+  items.push({ name: "Projects", value: "project", description: "Manage projects & repositories" });
+  items.push({ name: "Configuration", value: "config", description: "AI provider, settings" });
+  items.push({ name: "Doctor", value: "action:doctor:run", description: "Check environment health" });
+  items.push(titled("SESSION"));
+  if (!ctx.currentSprintId) {
+    items.push({ name: "Quick Start Wizard", value: "wizard", description: "Guided sprint setup" });
+  }
+  items.push({ name: "Exit", value: "exit" });
+  return { items, defaultValue };
+}
+function buildSprintSubMenu(ctx) {
+  const items = [];
+  items.push(titled("BROWSE"));
+  items.push({ name: "List", value: "list", description: "List all sprints" });
+  items.push({ name: "Show", value: "show", description: "Show sprint details" });
+  items.push({ name: "Set Current", value: "current", description: "Set current sprint" });
+  items.push(titled("EXPORT"));
+  items.push({
+    name: "Requirements",
+    value: "requirements",
+    description: "Export refined requirements"
+  });
+  items.push({ name: "Context", value: "context", description: "Output full sprint context" });
+  items.push({ name: "Progress", value: "progress show", description: "View progress log" });
+  items.push(titled("MANAGE"));
+  items.push({ name: "Log Progress", value: "progress log", description: "Add progress entry" });
+  items.push({ name: "Delete", value: "delete", description: "Delete a sprint permanently" });
+  items.push(line());
+  items.push({ name: "Back", value: "back", description: "Return to main menu" });
+  const titleSuffix = ctx.currentSprintName ? ` \u2014 ${ctx.currentSprintName} (${ctx.currentSprintStatus ?? "unknown"})` : "";
+  return { title: `Sprint${titleSuffix}`, items };
+}
+function buildTicketSubMenu(ctx) {
+  const items = [];
+  items.push({
+    name: "Add",
+    value: "add",
+    description: ctx.hasProjects ? "Add a ticket" : "Add a ticket (add a project first)",
+    disabled: !ctx.hasProjects ? "add a project first" : false
+  });
+  items.push({ name: "Edit", value: "edit", description: "Edit a ticket" });
+  items.push({ name: "List", value: "list", description: "List all tickets" });
+  items.push({ name: "Show", value: "show", description: "Show ticket details" });
+  const approvedCount = ctx.ticketCount - ctx.pendingRequirements;
+  let refineDisabled = false;
+  if (ctx.currentSprintStatus !== "draft") {
+    refineDisabled = "need draft sprint";
+  } else if (approvedCount === 0) {
+    refineDisabled = "no approved tickets";
+  }
+  items.push({
+    name: "Refine",
+    value: "refine",
+    description: "Re-refine approved requirements",
+    disabled: refineDisabled
+  });
+  items.push(line());
+  items.push({ name: "Remove", value: "remove", description: "Remove a ticket" });
+  items.push({ name: "Back", value: "back", description: "Return to main menu" });
+  const titleSuffix = ctx.currentSprintName ? ` \u2014 ${ctx.currentSprintName}` : "";
+  return { title: `Ticket${titleSuffix}`, items };
+}
+function buildTaskSubMenu(ctx) {
+  const items = [];
+  items.push(titled("VIEW"));
+  items.push({ name: "List", value: "list", description: "List all tasks" });
+  items.push({ name: "Show", value: "show", description: "Show task details" });
+  items.push({ name: "Next", value: "next", description: "Get next task" });
+  items.push(titled("MANAGE"));
+  items.push({ name: "Add", value: "add", description: "Add a new task" });
+  items.push({ name: "Import", value: "import", description: "Import from JSON" });
+  items.push({ name: "Status", value: "status", description: "Update status" });
+  items.push({ name: "Reorder", value: "reorder", description: "Change priority" });
+  items.push(line());
+  items.push({ name: "Remove", value: "remove", description: "Remove a task" });
+  items.push({ name: "Back", value: "back", description: "Return to main menu" });
+  const titleSuffix = ctx.currentSprintName ? ` \u2014 ${ctx.currentSprintName}` : "";
+  return { title: `Task${titleSuffix}`, items };
+}
+function buildProjectSubMenu() {
+  const items = [];
+  items.push({ name: "Add", value: "add", description: "Add a new project" });
+  items.push({ name: "List", value: "list", description: "List all projects" });
+  items.push({ name: "Show", value: "show", description: "Show project details" });
+  items.push(titled("REPOSITORIES"));
+  items.push({
+    name: "Add Repository",
+    value: "repo add",
+    description: "Add repository to project"
+  });
+  items.push({ name: "Remove Repository", value: "repo remove", description: "Remove repository" });
+  items.push(line());
+  items.push({ name: "Remove", value: "remove", description: "Remove a project" });
+  items.push({ name: "Back", value: "back", description: "Return to main menu" });
+  return { title: "Project", items };
+}
+function buildConfigSubMenu() {
+  const items = [];
+  items.push({ name: "Show Settings", value: "show", description: "View current configuration" });
+  items.push({ name: "Set AI Provider", value: "set provider", description: "Choose Claude Code or GitHub Copilot" });
+  items.push(line());
+  items.push({ name: "Back", value: "back", description: "Return to main menu" });
+  return { title: "Configuration", items };
+}
+function buildSubMenu(group, ctx) {
+  switch (group) {
+    case "sprint":
+      return buildSprintSubMenu(ctx);
+    case "ticket":
+      return buildTicketSubMenu(ctx);
+    case "task":
+      return buildTaskSubMenu(ctx);
+    case "project":
+      return buildProjectSubMenu();
+    case "config":
+      return buildConfigSubMenu();
+    default:
+      return null;
+  }
+}
+
+// src/interactive/dashboard.ts
+async function loadDashboardData() {
+  const sprintId = await getCurrentSprint();
+  if (!sprintId) return null;
+  try {
+    const sprint = await getSprint(sprintId);
+    const tasks = await getTasks(sprintId);
+    const pendingTickets = getPendingRequirements(sprint.tickets);
+    const pendingCount = pendingTickets.length;
+    const approvedCount = sprint.tickets.length - pendingCount;
+    const doneIds = new Set(tasks.filter((t) => t.status === "done").map((t) => t.id));
+    const blockedCount = tasks.filter(
+      (t) => t.status !== "done" && t.blockedBy.length > 0 && !t.blockedBy.every((id) => doneIds.has(id))
+    ).length;
+    const ticketIdsWithTasks = new Set(tasks.map((t) => t.ticketId).filter(Boolean));
+    const plannedTicketCount = sprint.tickets.filter((t) => ticketIdsWithTasks.has(t.id)).length;
+    const aiProvider = await getAiProvider();
+    return { sprint, tasks, approvedCount, pendingCount, blockedCount, plannedTicketCount, aiProvider };
+  } catch {
+    return null;
+  }
+}
+function getNextAction(data) {
+  const { sprint, tasks, pendingCount, approvedCount } = data;
+  const ticketCount = sprint.tickets.length;
+  const totalTasks = tasks.length;
+  const allDone = totalTasks > 0 && tasks.every((t) => t.status === "done");
+  if (sprint.status === "draft") {
+    if (ticketCount === 0) {
+      return { label: "Add Ticket", description: "No tickets yet", group: "ticket", subCommand: "add" };
+    }
+    if (pendingCount > 0) {
+      return {
+        label: "Refine Requirements",
+        description: `${String(pendingCount)} ticket${pendingCount !== 1 ? "s" : ""} pending`,
+        group: "sprint",
+        subCommand: "refine"
+      };
+    }
+    if (approvedCount > 0 && totalTasks === 0) {
+      return { label: "Plan Tasks", description: "Requirements approved", group: "sprint", subCommand: "plan" };
+    }
+    if (totalTasks > 0 && data.plannedTicketCount < ticketCount) {
+      const unplanned = ticketCount - data.plannedTicketCount;
+      return {
+        label: "Re-Plan Tasks",
+        description: `${String(unplanned)} unplanned ticket${unplanned !== 1 ? "s" : ""}`,
+        group: "sprint",
+        subCommand: "plan"
+      };
+    }
+    if (totalTasks > 0) {
+      return {
+        label: "Start Sprint",
+        description: `${String(totalTasks)} task${totalTasks !== 1 ? "s" : ""} ready`,
+        group: "sprint",
+        subCommand: "start"
+      };
+    }
+  }
+  if (sprint.status === "active") {
+    if (allDone) {
+      return { label: "Close Sprint", description: "All tasks done", group: "sprint", subCommand: "close" };
+    }
+    return {
+      label: "Continue Work",
+      description: `${String(totalTasks - tasks.filter((t) => t.status === "done").length)} task${totalTasks - tasks.filter((t) => t.status === "done").length !== 1 ? "s" : ""} remaining`,
+      group: "sprint",
+      subCommand: "start"
+    };
+  }
+  return null;
+}
+function renderStatusHeader(data) {
+  if (!data) return [];
+  const { sprint, tasks, approvedCount, aiProvider } = data;
+  const totalTasks = tasks.length;
+  const ticketCount = sprint.tickets.length;
+  const lines = [];
+  const sprintLabel = colors.highlight(sprint.name);
+  const statusBadge = formatSprintStatus(sprint.status);
+  const ticketPart = `${String(ticketCount)} ticket${ticketCount !== 1 ? "s" : ""}`;
+  const taskPart = `${String(totalTasks)} task${totalTasks !== 1 ? "s" : ""}`;
+  const providerPart = aiProvider === "claude" ? "Claude" : aiProvider === "copilot" ? "Copilot" : null;
+  const providerSuffix = providerPart ? `  |  ${providerPart}` : "";
+  lines.push(
+    `  ${icons.sprint} ${sprintLabel}  ${statusBadge}  ${colors.muted(`|  ${ticketPart}  |  ${taskPart}${providerSuffix}`)}`
+  );
+  if ((sprint.status === "active" || sprint.status === "closed") && totalTasks > 0) {
+    const doneCount = tasks.filter((t) => t.status === "done").length;
+    const bar = progressBar(doneCount, totalTasks, { width: 15 });
+    const inProgressCount = tasks.filter((t) => t.status === "in_progress").length;
+    const todoCount = tasks.filter((t) => t.status === "todo").length;
+    lines.push(
+      `  ${bar}  ${colors.muted(`${String(doneCount)} done, ${String(inProgressCount)} active, ${String(todoCount)} todo`)}`
+    );
+  } else if (sprint.status === "draft" && ticketCount > 0) {
+    const refinedColor = approvedCount === ticketCount ? colors.success : colors.warning;
+    const refinedPart = refinedColor(`Refined: ${String(approvedCount)}/${String(ticketCount)}`);
+    const plannedColor = data.plannedTicketCount === ticketCount ? colors.success : colors.muted;
+    const plannedPart = plannedColor(`Planned: ${String(data.plannedTicketCount)}/${String(ticketCount)}`);
+    lines.push(`  ${refinedPart}  ${colors.muted("|")}  ${plannedPart}`);
+  }
+  return lines;
+}
+function renderDashboard(data) {
+  const { sprint, tasks, approvedCount, blockedCount } = data;
+  const chars = boxChars.rounded;
+  const todoCount = tasks.filter((t) => t.status === "todo").length;
+  const inProgressCount = tasks.filter((t) => t.status === "in_progress").length;
+  const doneCount = tasks.filter((t) => t.status === "done").length;
+  const totalTasks = tasks.length;
+  const ticketCount = sprint.tickets.length;
+  const lines = [];
+  const sprintLabel = colors.highlight(sprint.name);
+  const statusBadge = formatSprintStatus(sprint.status);
+  lines.push(`  ${icons.sprint} ${sprintLabel}  ${statusBadge}`);
+  const ticketSummary = `${String(ticketCount)} ticket${ticketCount !== 1 ? "s" : ""}`;
+  const taskSummary = `${String(totalTasks)} task${totalTasks !== 1 ? "s" : ""}`;
+  lines.push(`  ${colors.muted(`${ticketSummary} ${chars.vertical} ${taskSummary}`)}`);
+  if (totalTasks > 0) {
+    const bar = progressBar(doneCount, totalTasks);
+    const detail = colors.muted(
+      `${String(doneCount)} done, ${String(inProgressCount)} active, ${String(todoCount)} todo`
+    );
+    lines.push(`  ${bar}  ${detail}`);
+  }
+  if (sprint.status === "draft" && ticketCount > 0) {
+    const refinedColor = approvedCount === ticketCount ? colors.success : colors.warning;
+    const refinedPart = refinedColor(`Refined: ${String(approvedCount)}/${String(ticketCount)}`);
+    const plannedColor = data.plannedTicketCount === ticketCount ? colors.success : colors.muted;
+    const plannedPart = plannedColor(`Planned: ${String(data.plannedTicketCount)}/${String(ticketCount)}`);
+    lines.push(`  ${refinedPart}  ${colors.muted("|")}  ${plannedPart}`);
+  }
+  if (blockedCount > 0) {
+    lines.push(
+      `  ${colors.warning(icons.warning)} ${colors.warning(`${String(blockedCount)} blocked task${blockedCount !== 1 ? "s" : ""}`)}`
+    );
+  }
+  const nextAction = getNextAction(data);
+  if (nextAction) {
+    lines.push(
+      `  ${colors.muted(icons.tip)} ${colors.muted(nextAction.label + ":")} ${colors.highlight(nextAction.description)}`
+    );
+  }
+  return lines;
+}
+function renderEmptyDashboard() {
+  const quote = getQuoteForContext("idle");
+  return [
+    `  ${emoji.donut}  ${colors.muted("No current sprint")}`,
+    `  ${colors.muted(`"${quote}"`)}`,
+    "",
+    `  ${colors.muted(icons.tip)} ${colors.muted("Get started:")}`,
+    `    ${colors.muted("1.")} ${colors.muted("Add a project:")}  ${colors.highlight("ralphctl project add")}`,
+    `    ${colors.muted("2.")} ${colors.muted("Create a sprint:")} ${colors.highlight("ralphctl sprint create")}`
+  ];
+}
+async function showDashboard() {
+  const data = await loadDashboardData();
+  console.log("");
+  if (data) {
+    const lines = renderDashboard(data);
+    for (const line2 of lines) {
+      console.log(line2);
+    }
+  } else {
+    const lines = renderEmptyDashboard();
+    for (const line2 of lines) {
+      console.log(line2);
+    }
+  }
+  console.log("");
+}
+
+// src/interactive/index.ts
+import { select as select3 } from "@inquirer/prompts";
+
+// src/commands/project/list.ts
+async function projectListCommand() {
+  const projects = await listProjects();
+  if (projects.length === 0) {
+    showEmpty("projects", "Add one with: ralphctl project add");
+    return;
+  }
+  printHeader("Projects", icons.project);
+  for (const project of projects) {
+    const repoCount = muted(
+      `(${String(project.repositories.length)} repo${project.repositories.length !== 1 ? "s" : ""})`
+    );
+    log.raw(`${colors.highlight(project.name)}  ${project.displayName}  ${repoCount}`);
+    for (const repo of project.repositories) {
+      log.item(`${repo.name} ${muted("\u2192")} ${muted(repo.path)}`);
+    }
+    if (project.description) {
+      log.dim(`    ${project.description}`);
+    }
+    log.newline();
+  }
+  log.dim(`Showing ${String(projects.length)} project(s)`);
+  log.newline();
+}
+
+// src/commands/project/show.ts
+async function projectShowCommand(args) {
+  let projectName = args[0];
+  if (!projectName) {
+    const selected = await selectProject("Select project to show:");
+    if (!selected) return;
+    projectName = selected;
+  }
+  try {
+    const project = await getProject(projectName);
+    const infoLines = [labelValue("Name", project.name), labelValue("Display Name", project.displayName)];
+    if (project.description) {
+      infoLines.push(labelValue("Description", project.description));
+    }
+    infoLines.push(labelValue("Repositories", String(project.repositories.length)));
+    log.newline();
+    console.log(renderCard(`${icons.project} ${project.displayName}`, infoLines));
+    for (const repo of project.repositories) {
+      log.newline();
+      const repoLines = [labelValue("Path", repo.path)];
+      if (repo.checkScript) {
+        repoLines.push(labelValue("Check", colors.info(repo.checkScript)));
+      } else {
+        repoLines.push(muted("No check script configured"));
+      }
+      console.log(renderCard(`  ${repo.name}`, repoLines));
+    }
+    log.newline();
+  } catch (err) {
+    if (err instanceof ProjectNotFoundError) {
+      showError(`Project not found: ${projectName}`);
+      log.newline();
+    } else {
+      throw err;
+    }
+  }
+}
+
+// src/commands/project/remove.ts
+import { confirm } from "@inquirer/prompts";
+async function projectRemoveCommand(args) {
+  const skipConfirm = args.includes("-y") || args.includes("--yes");
+  let projectName = args.find((a) => !a.startsWith("-"));
+  if (!projectName) {
+    const selected = await selectProject("Select project to remove:");
+    if (!selected) return;
+    projectName = selected;
+  }
+  try {
+    const project = await getProject(projectName);
+    if (!skipConfirm) {
+      const confirmed = await confirm({
+        message: `Remove project "${project.displayName}" (${project.name})?`,
+        default: false
+      });
+      if (!confirmed) {
+        console.log(muted("\nProject removal cancelled.\n"));
+        return;
+      }
+    }
+    await removeProject(projectName);
+    showSuccess("Project removed", [["Name", projectName]]);
+    console.log("");
+  } catch (err) {
+    if (err instanceof ProjectNotFoundError) {
+      showError(`Project not found: ${projectName}`);
+      console.log("");
+    } else {
+      throw err;
+    }
+  }
+}
+
+// src/commands/project/repo.ts
+import { basename, resolve } from "path";
+import { confirm as confirm2, input, select } from "@inquirer/prompts";
+async function projectRepoAddCommand(args) {
+  let projectName = args[0];
+  let path = args[1];
+  if (!projectName) {
+    const selected = await selectProject("Select project to add repository to:");
+    if (!selected) return;
+    projectName = selected;
+  }
+  path ??= await input({
+    message: `${emoji.donut} Repository path to add:`,
+    validate: (v) => v.trim().length > 0 ? true : "Path is required"
+  });
+  try {
+    const resolvedPath = resolve(expandTilde(path));
+    const bareRepo = { name: basename(resolvedPath), path: resolvedPath };
+    log.info(`
+Configuring: ${bareRepo.name}`);
+    const repoWithScripts = await addCheckScriptToRepository(bareRepo);
+    const project = await addProjectRepo(projectName, repoWithScripts);
+    showSuccess("Repository added", [["Project", projectName]]);
+    log.newline();
+    log.info("Current repositories:");
+    for (const repo of project.repositories) {
+      log.item(`${repo.name} \u2192 ${repo.path}`);
+    }
+    log.newline();
+  } catch (err) {
+    if (err instanceof ProjectNotFoundError) {
+      showError(`Project not found: ${projectName}`);
+      log.newline();
+    } else if (err instanceof Error) {
+      showError(err.message);
+      log.newline();
+    } else {
+      throw err;
+    }
+  }
+}
+async function projectRepoRemoveCommand(args) {
+  const skipConfirm = args.includes("-y") || args.includes("--yes");
+  const filteredArgs = args.filter((a) => !a.startsWith("-"));
+  let projectName = filteredArgs[0];
+  let path = filteredArgs[1];
+  if (!projectName) {
+    const selected = await selectProject("Select project to remove repository from:");
+    if (!selected) return;
+    projectName = selected;
+  }
+  try {
+    const project = await getProject(projectName);
+    if (!path) {
+      if (project.repositories.length === 0) {
+        console.log(muted("\nNo repositories to remove.\n"));
+        return;
+      }
+      path = await select({
+        message: `${emoji.donut} Select repository to remove:`,
+        choices: project.repositories.map((r) => ({
+          name: `${r.name} (${r.path})`,
+          value: r.path
+        }))
+      });
+    }
+    if (!skipConfirm) {
+      const confirmed = await confirm2({
+        message: `Remove repository "${path}" from project "${project.displayName}"?`,
+        default: false
+      });
+      if (!confirmed) {
+        console.log(muted("\nRepository removal cancelled.\n"));
+        return;
+      }
+    }
+    const updatedProject = await removeProjectRepo(projectName, path);
+    showSuccess("Repository removed", [["Project", projectName]]);
+    log.newline();
+    log.info("Remaining repositories:");
+    for (const repo of updatedProject.repositories) {
+      log.item(`${repo.name} \u2192 ${repo.path}`);
+    }
+    log.newline();
+  } catch (err) {
+    if (err instanceof ProjectNotFoundError) {
+      showError(`Project not found: ${projectName}`);
+      log.newline();
+    } else if (err instanceof Error) {
+      showError(err.message);
+      log.newline();
+    } else {
+      throw err;
+    }
+  }
+}
+
+// src/commands/sprint/list.ts
+async function sprintListCommand(args = []) {
+  let statusFilter;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--status" && args[i + 1]) {
+      statusFilter = args[i + 1];
+      i++;
+    }
+  }
+  if (statusFilter) {
+    const result = SprintStatusSchema.safeParse(statusFilter);
+    if (!result.success) {
+      showError(`Invalid status: "${statusFilter}". Valid values: draft, active, closed`);
+      return;
+    }
+  }
+  const sprints = await listSprints();
+  if (sprints.length === 0) {
+    showEmpty("sprints", "Create one with: ralphctl sprint create");
+    return;
+  }
+  const filtered = statusFilter ? sprints.filter((s) => s.status === statusFilter) : sprints;
+  const isFiltered = filtered.length !== sprints.length;
+  const filterStr = statusFilter ? ` (filtered: status=${statusFilter})` : "";
+  if (filtered.length === 0) {
+    showEmpty("matching sprints", "Try adjusting your filters");
+    return;
+  }
+  printHeader("Sprints", icons.sprint);
+  const currentSprintId = await getCurrentSprint();
+  const rows = filtered.map((sprint) => {
+    const isCurrent = sprint.id === currentSprintId;
+    const marker = isCurrent ? badge("current", "success") : "";
+    return [marker, sprint.id, formatSprintStatus(sprint.status), sprint.name, String(sprint.tickets.length)];
+  });
+  console.log(
+    renderTable(
+      [
+        { header: "", minWidth: 0 },
+        { header: "ID" },
+        { header: "Status" },
+        { header: "Name" },
+        { header: "Tickets", align: "right" }
+      ],
+      rows
+    )
+  );
+  log.newline();
+  const showingLabel = isFiltered ? `Showing ${String(filtered.length)} of ${String(sprints.length)} sprint(s)${filterStr}` : `Showing ${String(sprints.length)} sprint(s)`;
+  log.dim(showingLabel);
+  const hasActive = sprints.some((s) => s.status === "active");
+  if (!hasActive) {
+    log.newline();
+    showNextStep("ralphctl sprint start", "start a sprint");
+  }
+  log.newline();
+}
+
+// src/commands/sprint/show.ts
+async function sprintShowCommand(args) {
+  const sprintId = args[0];
+  let id;
+  try {
+    id = await resolveSprintId(sprintId);
+  } catch {
+    const selected = await selectSprint("Select sprint to show:");
+    if (!selected) return;
+    id = selected;
+  }
+  const sprint = await getSprint(id);
+  const tasks = await listTasks(id);
+  const currentSprintId = await getCurrentSprint();
+  const isCurrent = sprint.id === currentSprintId;
+  const infoLines = [
+    labelValue("ID", sprint.id + (isCurrent ? " " + badge("current", "success") : "")),
+    labelValue("Status", formatSprintStatus(sprint.status)),
+    labelValue("Created", new Date(sprint.createdAt).toLocaleString())
+  ];
+  if (sprint.activatedAt) {
+    infoLines.push(labelValue("Activated", new Date(sprint.activatedAt).toLocaleString()));
+  }
+  if (sprint.closedAt) {
+    infoLines.push(labelValue("Closed", new Date(sprint.closedAt).toLocaleString()));
+  }
+  if (sprint.branch) {
+    infoLines.push(labelValue("Branch", sprint.branch));
+  }
+  log.newline();
+  console.log(renderCard(`${icons.sprint} ${sprint.name}`, infoLines));
+  log.newline();
+  const ticketLines = [];
+  if (sprint.tickets.length === 0) {
+    ticketLines.push(muted("No tickets yet"));
+    ticketLines.push(muted(`${icons.tip} Add with: ralphctl ticket add`));
+  } else {
+    const ticketsByProject = groupTicketsByProject(sprint.tickets);
+    let first = true;
+    for (const [projectName, tickets] of ticketsByProject) {
+      if (!first) ticketLines.push("");
+      first = false;
+      ticketLines.push(`${colors.info(icons.project)} ${colors.info(projectName)}`);
+      for (const ticket of tickets) {
+        const reqBadge = ticket.requirementStatus === "approved" ? badge("approved", "success") : badge("pending", "warning");
+        ticketLines.push(`  ${icons.bullet} ${formatTicketDisplay(ticket)} ${reqBadge}`);
+      }
+    }
+  }
+  console.log(renderCard(`${icons.ticket} Tickets (${String(sprint.tickets.length)})`, ticketLines));
+  log.newline();
+  const taskLines = [];
+  const tasksByStatus = {
+    todo: tasks.filter((t) => t.status === "todo").length,
+    in_progress: tasks.filter((t) => t.status === "in_progress").length,
+    done: tasks.filter((t) => t.status === "done").length
+  };
+  if (tasks.length === 0) {
+    taskLines.push(muted("No tasks yet"));
+    taskLines.push(muted(`${icons.tip} Plan with: ralphctl sprint plan`));
+  } else {
+    taskLines.push(
+      `${formatTaskStatus("todo")} ${String(tasksByStatus.todo)}   ${formatTaskStatus("in_progress")} ${String(tasksByStatus.in_progress)}   ${formatTaskStatus("done")} ${String(tasksByStatus.done)}`
+    );
+    taskLines.push(colors.muted(horizontalLine(40, "rounded")));
+    for (const task of tasks) {
+      const statusIcon = task.status === "done" ? icons.success : task.status === "in_progress" ? icons.active : icons.inactive;
+      const statusColor = task.status === "done" ? "success" : task.status === "in_progress" ? "warning" : "muted";
+      taskLines.push(`${muted(String(task.order) + ".")} ${badge(statusIcon, statusColor)} ${task.name}`);
+    }
+  }
+  console.log(renderCard(`${icons.task} Tasks (${String(tasks.length)})`, taskLines));
+  if (tasks.length > 0) {
+    printCountSummary("Progress", tasksByStatus.done, tasks.length);
+  }
+  log.newline();
+  if (sprint.status === "draft") {
+    const pendingCount = getPendingRequirements(sprint.tickets).length;
+    if (sprint.tickets.length === 0) {
+      showNextStep("ralphctl ticket add --project <name>", "add tickets to this sprint");
+    } else if (pendingCount > 0) {
+      showNextStep("ralphctl sprint refine", "refine ticket requirements");
+    } else if (tasks.length === 0) {
+      showNextStep("ralphctl sprint plan", "generate tasks from tickets");
+    } else {
+      showNextStep("ralphctl sprint start", "begin implementation");
+    }
+  } else if (sprint.status === "active") {
+    if (tasksByStatus.done === tasks.length && tasks.length > 0) {
+      showNextStep("ralphctl sprint close", "all tasks done \u2014 close the sprint");
+    } else {
+      showNextStep("ralphctl sprint start", "continue implementation");
+    }
+  }
+  log.newline();
+}
+
+// src/commands/sprint/context.ts
+async function sprintContextCommand(args) {
+  const sprintId = args[0];
+  let id;
+  try {
+    id = await resolveSprintId(sprintId);
+  } catch {
+    const selected = await selectSprint("Select sprint to show context for:");
+    if (!selected) {
+      showWarning("No sprints available.");
+      showNextStep("ralphctl sprint create", "create a sprint first");
+      log.newline();
+      return;
+    }
+    id = selected;
+  }
+  const sprint = await getSprint(id);
+  const tasks = await listTasks(id);
+  console.log(`# Sprint: ${sprint.name}`);
+  console.log(`ID: ${sprint.id}`);
+  console.log(`Status: ${sprint.status}`);
+  console.log("");
+  console.log("## Tickets");
+  console.log("");
+  if (sprint.tickets.length === 0) {
+    console.log("_No tickets defined_");
+  } else {
+    const ticketsByProject = groupTicketsByProject(sprint.tickets);
+    for (const [projectName, tickets] of ticketsByProject) {
+      console.log(`### Project: ${projectName}`);
+      try {
+        const project = await getProject(projectName);
+        const repoPaths = project.repositories.map((r) => `${r.name} (${r.path})`);
+        console.log(`Repositories: ${repoPaths.join(", ")}`);
+      } catch {
+        console.log("Repositories: (project not found)");
+      }
+      console.log("");
+      for (const ticket of tickets) {
+        const reqBadge = ticket.requirementStatus === "approved" ? " [approved]" : " [pending]";
+        console.log(`#### ${formatTicketDisplay(ticket)}${reqBadge}`);
+        if (ticket.description) {
+          console.log("");
+          console.log(ticket.description);
+        }
+        if (ticket.link) {
+          console.log("");
+          console.log(`Link: ${ticket.link}`);
+        }
+        if (ticket.requirements) {
+          console.log("");
+          console.log("**Refined Requirements:**");
+          console.log("");
+          console.log(ticket.requirements);
+        }
+        console.log("");
+      }
+    }
+  }
+  console.log("## Tasks");
+  console.log("");
+  if (tasks.length === 0) {
+    console.log("_No tasks defined yet_");
+  } else {
+    for (const task of tasks) {
+      const ticketRef = task.ticketId ? ` [${task.ticketId}]` : "";
+      console.log(`### ${task.id}: ${task.name}${ticketRef}`);
+      console.log(`Status: ${task.status} | Order: ${String(task.order)} | Project: ${task.projectPath}`);
+      if (task.blockedBy.length > 0) {
+        console.log(`Blocked By: ${task.blockedBy.join(", ")}`);
+      }
+      if (task.description) {
+        console.log("");
+        console.log(task.description);
+      }
+      if (task.steps.length > 0) {
+        console.log("");
+        console.log("Steps:");
+        task.steps.forEach((step, i) => {
+          console.log(`${String(i + 1)}. ${step}`);
+        });
+      }
+      console.log("");
+    }
+  }
+}
+
+// src/commands/sprint/current.ts
+async function sprintCurrentCommand(args) {
+  const sprintId = args[0];
+  if (!sprintId) {
+    const currentSprintId = await getCurrentSprint();
+    if (!currentSprintId) {
+      showWarning("No current sprint set.");
+      showNextStep("ralphctl sprint create", "create a new sprint");
+      log.newline();
+      return;
+    }
+    try {
+      const sprint = await getSprint(currentSprintId);
+      printHeader("Current Sprint");
+      console.log(field("ID", sprint.id));
+      console.log(field("Name", sprint.name));
+      console.log(field("Status", formatSprintStatus(sprint.status)));
+      log.newline();
+    } catch {
+      showWarning(`Current sprint "${currentSprintId}" no longer exists.`);
+      showNextStep("ralphctl sprint current -", "select a different sprint");
+      log.newline();
+    }
+    return;
+  }
+  if (sprintId === "-" || sprintId === "--select") {
+    const selectedId = await selectSprint("Select current sprint:", ["draft", "active"]);
+    if (!selectedId) return;
+    await setCurrentSprint(selectedId);
+    const sprint = await getSprint(selectedId);
+    showSuccess("Current sprint set!", [
+      ["ID", sprint.id],
+      ["Name", sprint.name]
+    ]);
+    log.newline();
+  } else {
+    try {
+      const sprint = await getSprint(sprintId);
+      await setCurrentSprint(sprintId);
+      showSuccess("Current sprint set!", [
+        ["ID", sprint.id],
+        ["Name", sprint.name]
+      ]);
+      log.newline();
+    } catch (err) {
+      if (err instanceof SprintNotFoundError) {
+        showError(`Sprint not found: ${sprintId}`);
+        showNextStep("ralphctl sprint list", "see available sprints");
+        log.newline();
+      } else {
+        throw err;
+      }
+    }
+  }
+}
+
+// src/commands/sprint/ideate.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+import { input as input2, select as select2 } from "@inquirer/prompts";
+function parseArgs(args) {
+  const options = {
+    auto: false,
+    allPaths: false
+  };
+  let sprintId;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const nextArg = args[i + 1];
+    if (arg === "--auto") {
+      options.auto = true;
+    } else if (arg === "--all-paths") {
+      options.allPaths = true;
+    } else if (arg === "--project") {
+      options.project = nextArg;
+      i++;
+    } else if (!arg?.startsWith("-")) {
+      sprintId = arg;
+    }
+  }
+  return { sprintId, options };
+}
+async function invokeAiInteractive(prompt, repoPaths, ideateDir) {
+  const contextFile = join(ideateDir, "ideate-context.md");
+  await writeFile(contextFile, prompt, "utf-8");
+  const provider = await getActiveProvider();
+  const startPrompt = `I have a quick idea I want to implement. The full context is in ideate-context.md. Please read that file and help me refine the idea into requirements and then plan implementation tasks.`;
+  const args = ["--add-dir", ...repoPaths];
+  const result = spawnInteractive(
+    startPrompt,
+    {
+      cwd: ideateDir,
+      args,
+      env: provider.getSpawnEnv()
+    },
+    provider
+  );
+  if (result.error) {
+    throw new Error(result.error);
+  }
+}
+async function invokeAiAuto(prompt, repoPaths, ideateDir) {
+  const provider = await getActiveProvider();
+  const args = ["--permission-mode", "plan", "--print"];
+  for (const path of repoPaths) {
+    args.push("--add-dir", path);
+  }
+  args.push("-p", prompt);
+  return spawnHeadless(
+    {
+      cwd: ideateDir,
+      args,
+      env: provider.getSpawnEnv()
+    },
+    provider
+  );
+}
+function parseIdeateOutput(output) {
+  const jsonStr = extractJsonObject(output);
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonStr);
+  } catch (err) {
+    throw new Error(`Invalid JSON: ${err instanceof Error ? err.message : "parse error"}`, { cause: err });
+  }
+  const result = IdeateOutputSchema.safeParse(parsed);
+  if (!result.success) {
+    const issues = result.error.issues.map((issue) => {
+      const path = issue.path.length > 0 ? `[${issue.path.join(".")}]` : "";
+      return `  ${path}: ${issue.message}`;
+    }).join("\n");
+    throw new Error(`Invalid ideate output format:
+${issues}`);
+  }
+  return result.data;
+}
+async function sprintIdeateCommand(args) {
+  const { sprintId, options } = parseArgs(args);
+  let id;
+  try {
+    id = await resolveSprintId(sprintId);
+  } catch {
+    showWarning("No sprint specified and no current sprint set.");
+    showNextStep("ralphctl sprint create", "create a new sprint");
+    log.newline();
+    return;
+  }
+  const sprint = await getSprint(id);
+  try {
+    assertSprintStatus(sprint, ["draft"], "ideate");
+  } catch (err) {
+    if (err instanceof Error) {
+      showError(err.message);
+      log.newline();
+    }
+    return;
+  }
+  const projects = await listProjects();
+  if (projects.length === 0) {
+    showWarning("No projects configured.");
+    showNextStep("ralphctl project add", "add a project first");
+    log.newline();
+    return;
+  }
+  printHeader("Quick Ideation", icons.ticket);
+  console.log(field("Sprint", sprint.name));
+  console.log(field("ID", sprint.id));
+  console.log(field("Mode", options.auto ? "Auto (headless)" : "Interactive"));
+  log.newline();
+  let projectName = options.project;
+  if (!projectName) {
+    if (projects.length === 1) {
+      projectName = projects[0]?.name;
+      console.log(field("Project", projectName ?? "(unknown)"));
+    } else {
+      projectName = await select2({
+        message: "Select project:",
+        choices: projects.map((p) => ({ name: p.displayName, value: p.name }))
+      });
+    }
+  }
+  if (!projectName) {
+    showError("No project selected.");
+    log.newline();
+    return;
+  }
+  let project;
+  try {
+    project = await getProject(projectName);
+  } catch {
+    showError(`Project '${projectName}' not found.`);
+    log.newline();
+    return;
+  }
+  const ideaTitle = await input2({
+    message: "Idea title (short summary):",
+    validate: (value) => value.trim().length > 0 ? true : "Title is required"
+  });
+  const ideaDescription = await editorInput({
+    message: "Idea description (what you want to build):"
+  });
+  if (!ideaDescription.trim()) {
+    showError("Description is required.");
+    log.newline();
+    return;
+  }
+  log.newline();
+  showInfo("Creating ticket...");
+  const ticket = await addTicket(
+    {
+      title: ideaTitle,
+      description: ideaDescription,
+      projectName
+    },
+    id
+  );
+  console.log(field("Ticket ID", ticket.id));
+  log.newline();
+  const providerName = providerDisplayName(await resolveProvider());
+  let selectedPaths;
+  const totalRepos = project.repositories.length;
+  if (options.allPaths) {
+    selectedPaths = project.repositories.map((r) => r.path);
+  } else if (options.auto) {
+    selectedPaths = project.repositories.slice(0, 1).map((r) => r.path);
+  } else if (totalRepos === 1) {
+    selectedPaths = [project.repositories[0]?.path ?? ""];
+  } else {
+    const reposByProject = /* @__PURE__ */ new Map();
+    reposByProject.set(projectName, project.repositories);
+    selectedPaths = await selectProjectPaths(reposByProject, "Select paths to explore:");
+  }
+  ticket.affectedRepositories = selectedPaths;
+  await saveSprint(sprint);
+  if (selectedPaths.length > 1) {
+    console.log(muted(`Paths: ${selectedPaths.join(", ")}`));
+  } else {
+    console.log(muted(`Path: ${selectedPaths[0] ?? process.cwd()}`));
+  }
+  const repositoriesText = selectedPaths.map((path) => `- ${path}`).join("\n");
+  const schema = await getTaskImportSchema();
+  const ideateDir = getIdeateDir(id, ticket.id);
+  await mkdir(ideateDir, { recursive: true });
+  if (options.auto) {
+    const prompt = buildIdeateAutoPrompt(ideaTitle, ideaDescription, projectName, repositoriesText, schema);
+    const spinner = createSpinner(`${providerName} is refining idea and planning tasks...`);
+    spinner.start();
+    let output;
+    try {
+      output = await invokeAiAuto(prompt, selectedPaths, ideateDir);
+      spinner.succeed(`${providerName} finished`);
+    } catch (err) {
+      spinner.fail(`${providerName} session failed`);
+      if (err instanceof Error) {
+        showError(`Failed to invoke ${providerName}: ${err.message}`);
+        showTip(`Make sure the ${providerName.toLowerCase()} CLI is installed and configured.`);
+        log.newline();
+      }
+      return;
+    }
+    const blockedReason = parsePlanningBlocked(output);
+    if (blockedReason) {
+      showWarning(`Planning blocked: ${blockedReason}`);
+      log.newline();
+      return;
+    }
+    log.dim("Parsing response...");
+    let ideateOutput;
+    try {
+      ideateOutput = parseIdeateOutput(output);
+    } catch (err) {
+      if (err instanceof Error) {
+        showError(`Failed to parse ${providerName} output: ${err.message}`);
+        log.dim("Raw output:");
+        console.log(output);
+        log.newline();
+      }
+      return;
+    }
+    const ticketIdx = sprint.tickets.findIndex((t) => t.id === ticket.id);
+    const ticketToUpdate = sprint.tickets[ticketIdx];
+    if (ticketIdx !== -1 && ticketToUpdate) {
+      ticketToUpdate.requirements = ideateOutput.requirements;
+      ticketToUpdate.requirementStatus = "approved";
+    }
+    await saveSprint(sprint);
+    showSuccess("Requirements approved and saved!");
+    log.newline();
+    let parsedTasks;
+    try {
+      parsedTasks = parseTasksJson(JSON.stringify(ideateOutput.tasks));
+    } catch (err) {
+      if (err instanceof Error) {
+        showError(`Failed to parse tasks: ${err.message}`);
+        log.newline();
+      }
+      return;
+    }
+    if (parsedTasks.length === 0) {
+      showWarning("No tasks generated.");
+      log.newline();
+      return;
+    }
+    showSuccess(`Generated ${String(parsedTasks.length)} task(s):`);
+    log.newline();
+    console.log(renderParsedTasksTable(parsedTasks));
+    console.log("");
+    const existingTasks = await getTasks(id);
+    const ticketIds = new Set(sprint.tickets.map((t) => t.id));
+    const validationErrors = validateImportTasks(parsedTasks, existingTasks, ticketIds);
+    if (validationErrors.length > 0) {
+      showError("Validation failed");
+      for (const err of validationErrors) {
+        log.item(error(err));
+      }
+      log.newline();
+      return;
+    }
+    showInfo("Importing tasks...");
+    const imported = await importTasks(parsedTasks, id);
+    terminalBell();
+    showSuccess(`Imported ${String(imported)}/${String(parsedTasks.length)} tasks.`);
+    log.newline();
+  } else {
+    const outputFile = join(ideateDir, "output.json");
+    const prompt = buildIdeatePrompt(ideaTitle, ideaDescription, projectName, repositoriesText, outputFile, schema);
+    showInfo(`Starting interactive ${providerName} session...`);
+    console.log(muted(`  Exploring: ${selectedPaths.join(", ")}`));
+    console.log(muted(`
+  ${providerName} will guide you through requirements refinement and task planning.`));
+    console.log(muted(`  When done, ask ${providerName} to write the output to: ${outputFile}
+`));
+    try {
+      await invokeAiInteractive(prompt, selectedPaths, ideateDir);
+    } catch (err) {
+      if (err instanceof Error) {
+        showError(`Failed to invoke ${providerName}: ${err.message}`);
+        showTip(`Make sure the ${providerName.toLowerCase()} CLI is installed and configured.`);
+        log.newline();
+      }
+      return;
+    }
+    console.log("");
+    if (await fileExists(outputFile)) {
+      showInfo("Output file found. Processing...");
+      let content;
+      try {
+        content = await readFile(outputFile, "utf-8");
+      } catch {
+        showError(`Failed to read output file: ${outputFile}`);
+        log.newline();
+        return;
+      }
+      let ideateOutput;
+      try {
+        ideateOutput = parseIdeateOutput(content);
+      } catch (err) {
+        if (err instanceof Error) {
+          showError(`Failed to parse output file: ${err.message}`);
+          log.newline();
+        }
+        return;
+      }
+      const ticketIdx = sprint.tickets.findIndex((t) => t.id === ticket.id);
+      const ticketToUpdate = sprint.tickets[ticketIdx];
+      if (ticketIdx !== -1 && ticketToUpdate) {
+        ticketToUpdate.requirements = ideateOutput.requirements;
+        ticketToUpdate.requirementStatus = "approved";
+      }
+      await saveSprint(sprint);
+      showSuccess("Requirements approved and saved!");
+      log.newline();
+      let parsedTasks;
+      try {
+        parsedTasks = parseTasksJson(JSON.stringify(ideateOutput.tasks));
+      } catch (err) {
+        if (err instanceof Error) {
+          showError(`Failed to parse tasks: ${err.message}`);
+          log.newline();
+        }
+        return;
+      }
+      if (parsedTasks.length === 0) {
+        showWarning("No tasks in file.");
+        log.newline();
+        return;
+      }
+      showSuccess(`Found ${String(parsedTasks.length)} task(s):`);
+      log.newline();
+      console.log(renderParsedTasksTable(parsedTasks));
+      console.log("");
+      const existingTasks = await getTasks(id);
+      const ticketIds = new Set(sprint.tickets.map((t) => t.id));
+      const validationErrors = validateImportTasks(parsedTasks, existingTasks, ticketIds);
+      if (validationErrors.length > 0) {
+        showError("Validation failed");
+        for (const err of validationErrors) {
+          log.item(error(err));
+        }
+        log.newline();
+        return;
+      }
+      showInfo("Importing tasks...");
+      const imported = await importTasks(parsedTasks, id);
+      terminalBell();
+      showSuccess(`Imported ${String(imported)}/${String(parsedTasks.length)} tasks.`);
+      log.newline();
+    } else {
+      showWarning("No output file found.");
+      showTip(`Expected: ${outputFile}`);
+      showNextStep("ralphctl sprint ideate", "run ideation again");
+      log.newline();
+    }
+  }
+}
+
+// src/commands/sprint/close.ts
+import { spawnSync } from "child_process";
+import { confirm as confirm3 } from "@inquirer/prompts";
+async function sprintCloseCommand(args) {
+  let sprintId;
+  let createPr = false;
+  const positionalArgs = [];
+  for (const arg of args) {
+    if (arg === "--create-pr") {
+      createPr = true;
+    } else {
+      positionalArgs.push(arg);
+    }
+  }
+  if (positionalArgs[0]) {
+    sprintId = positionalArgs[0];
+  } else {
+    const sprints = await listSprints();
+    const activeSprints = sprints.filter((s) => s.status === "active");
+    if (activeSprints.length === 0) {
+      showError("No active sprints to close.");
+      log.newline();
+      return;
+    } else if (activeSprints.length === 1 && activeSprints[0]) {
+      sprintId = activeSprints[0].id;
+    } else {
+      const selected = await selectSprint("Select sprint to close:", ["active"]);
+      if (!selected) return;
+      sprintId = selected;
+    }
+  }
+  const allDone = await areAllTasksDone(sprintId);
+  if (!allDone) {
+    const tasks = await listTasks(sprintId);
+    const remaining = tasks.filter((t) => t.status !== "done");
+    log.newline();
+    showWarning(`${String(remaining.length)} task(s) are not done:`);
+    for (const task of remaining) {
+      log.item(`${task.id}: ${task.name} (${task.status})`);
+    }
+    log.newline();
+    const proceed = await confirm3({
+      message: "Close sprint anyway?",
+      default: false
+    });
+    if (!proceed) {
+      console.log(muted("\nSprint close cancelled.\n"));
+      return;
+    }
+  }
+  try {
+    const sprintBeforeClose = await getSprint(sprintId);
+    const sprint = await closeSprint(sprintId);
+    showSuccess("Sprint closed!", [
+      ["ID", sprint.id],
+      ["Name", sprint.name],
+      ["Status", formatSprintStatus(sprint.status)]
+    ]);
+    showRandomQuote();
+    log.newline();
+    if (createPr && sprintBeforeClose.branch) {
+      await createPullRequests(sprintId, sprintBeforeClose.branch, sprint.name);
+    } else if (createPr && !sprintBeforeClose.branch) {
+      log.dim("No sprint branch set \u2014 skipping PR creation.");
+      log.newline();
+    }
+  } catch (err) {
+    if (err instanceof SprintNotFoundError) {
+      showError(`Sprint not found: ${sprintId}`);
+      log.newline();
+    } else if (err instanceof SprintStatusError) {
+      showError(err.message);
+      log.newline();
+    } else {
+      throw err;
+    }
+  }
+}
+async function createPullRequests(sprintId, branchName, sprintName) {
+  if (!isGhAvailable()) {
+    showWarning("GitHub CLI (gh) not found. Install it to create PRs automatically.");
+    log.dim(`  Manual: gh pr create --head ${branchName} --title "Sprint: ${sprintName}"`);
+    log.newline();
+    return;
+  }
+  const tasks = await listTasks(sprintId);
+  const uniquePaths = [...new Set(tasks.map((t) => t.projectPath))];
+  for (const projectPath of uniquePaths) {
+    try {
+      assertSafeCwd(projectPath);
+      if (!branchExists(projectPath, branchName)) {
+        log.dim(`Branch '${branchName}' not found in ${projectPath} \u2014 skipping`);
+        continue;
+      }
+      const baseBranch = getDefaultBranch(projectPath);
+      const title = `Sprint: ${sprintName}`;
+      log.info(`Creating PR in ${projectPath}...`);
+      const pushResult = spawnSync("git", ["push", "-u", "origin", branchName], {
+        cwd: projectPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      if (pushResult.status !== 0) {
+        showWarning(`Failed to push branch in ${projectPath}: ${pushResult.stderr.trim()}`);
+        log.dim(
+          `  Manual: cd ${projectPath} && git push -u origin ${branchName} && gh pr create --base ${baseBranch} --head ${branchName} --title "${title}"`
+        );
+        continue;
+      }
+      const result = spawnSync(
+        "gh",
+        [
+          "pr",
+          "create",
+          "--base",
+          baseBranch,
+          "--head",
+          branchName,
+          "--title",
+          title,
+          "--body",
+          `Sprint: ${sprintName}
+ID: ${sprintId}`
+        ],
+        {
+          cwd: projectPath,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        }
+      );
+      if (result.status === 0) {
+        const prUrl = result.stdout.trim();
+        showSuccess(`PR created: ${prUrl}`);
+      } else {
+        showWarning(`Failed to create PR in ${projectPath}: ${result.stderr.trim()}`);
+        log.dim(
+          `  Manual: cd ${projectPath} && gh pr create --base ${baseBranch} --head ${branchName} --title "${title}"`
+        );
+      }
+    } catch (err) {
+      showWarning(`Error creating PR for ${projectPath}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  log.newline();
+}
+
+// src/commands/sprint/delete.ts
+import { confirm as confirm4 } from "@inquirer/prompts";
+async function sprintDeleteCommand(args) {
+  const skipConfirm = args.includes("-y") || args.includes("--yes");
+  let sprintId = args.find((a) => !a.startsWith("-"));
+  if (!sprintId) {
+    const selected = await selectSprint("Select sprint to delete:");
+    if (!selected) return;
+    sprintId = selected;
+  }
+  try {
+    const sprint = await getSprint(sprintId);
+    let taskCount = 0;
+    try {
+      const tasks = await listTasks(sprintId);
+      taskCount = tasks.length;
+    } catch {
+    }
+    if (!skipConfirm) {
+      log.newline();
+      log.warn("This will permanently delete the sprint and all its data.");
+      log.item(`Name: ${sprint.name}`);
+      log.item(`Status: ${formatSprintStatus(sprint.status)}`);
+      log.item(`Tickets: ${String(sprint.tickets.length)}`);
+      log.item(`Tasks: ${String(taskCount)}`);
+      log.newline();
+      const confirmed = await confirm4({
+        message: `Delete sprint "${sprint.name}"?`,
+        default: false
+      });
+      if (!confirmed) {
+        console.log(muted("\nSprint deletion cancelled.\n"));
+        return;
+      }
+    }
+    const currentSprintId = await getCurrentSprint();
+    await deleteSprint(sprintId);
+    if (currentSprintId === sprintId) {
+      await setCurrentSprint(null);
+      showTip('Current sprint was cleared. Use "ralphctl sprint current" to set a new one.');
+    }
+    showSuccess("Sprint deleted", [
+      ["Name", sprint.name],
+      ["ID", sprint.id]
+    ]);
+    showRandomQuote();
+    log.newline();
+  } catch (err) {
+    if (err instanceof SprintNotFoundError) {
+      showError(`Sprint not found: ${sprintId}`);
+      log.newline();
+    } else {
+      throw err;
+    }
+  }
+}
+
+// src/commands/sprint/requirements.ts
+import { join as join2 } from "path";
+async function sprintRequirementsCommand(args = []) {
+  const sprintId = args.find((a) => !a.startsWith("-"));
+  let id;
+  try {
+    id = await resolveSprintId(sprintId);
+  } catch {
+    const selected = await selectSprint("Select sprint to export requirements from:");
+    if (!selected) return;
+    id = selected;
+  }
+  const sprint = await getSprint(id);
+  if (sprint.tickets.length === 0) {
+    showEmpty("tickets in this sprint", "Add tickets first: ralphctl ticket add --project <name>");
+    return;
+  }
+  const approvedTickets = sprint.tickets.filter((t) => t.requirementStatus === "approved");
+  if (approvedTickets.length === 0) {
+    showWarning("No approved requirements to export.");
+    log.dim("Refine requirements first: ralphctl sprint refine");
+    log.newline();
+    return;
+  }
+  printHeader("Export Requirements", icons.sprint);
+  console.log(field("Sprint", sprint.name));
+  console.log(field("Tickets", `${String(sprint.tickets.length)} total, ${String(approvedTickets.length)} approved`));
+  log.newline();
+  const sprintDir = getSprintDir(id);
+  const outputPath = join2(sprintDir, "requirements.md");
+  try {
+    await exportRequirementsToMarkdown(sprint, outputPath);
+    showSuccess("Requirements written to:");
+    log.item(outputPath);
+  } catch (err) {
+    if (err instanceof Error) {
+      showError(`Failed to write requirements: ${err.message}`);
+    } else {
+      showError("Failed to write requirements: Unknown error");
+    }
+    return;
+  }
+  log.newline();
+}
+
+// src/commands/sprint/health.ts
+function checkBlockers(tasks) {
+  const doneTasks = new Set(tasks.filter((t) => t.status === "done").map((t) => t.id));
+  const allTaskIds = new Set(tasks.map((t) => t.id));
+  const blocked = [];
+  for (const task of tasks) {
+    if (task.status === "done") continue;
+    const unresolvedDeps = task.blockedBy.filter((depId) => allTaskIds.has(depId) && !doneTasks.has(depId));
+    if (unresolvedDeps.length > 0) {
+      blocked.push(`${task.name} ${colors.muted(`(${task.id})`)} blocked by ${unresolvedDeps.join(", ")}`);
+    }
+  }
+  return {
+    name: "Blockers",
+    status: blocked.length > 0 ? "fail" : "pass",
+    items: blocked
+  };
+}
+function checkStaleTasks(tasks) {
+  const stale = tasks.filter((t) => t.status === "in_progress");
+  const items = stale.map((t) => `${t.name} ${colors.muted(`(${t.id})`)}`);
+  return {
+    name: "Stale Tasks",
+    status: items.length > 0 ? "warn" : "pass",
+    items
+  };
+}
+function checkOrphanedDeps(tasks) {
+  const allTaskIds = new Set(tasks.map((t) => t.id));
+  const orphaned = [];
+  for (const task of tasks) {
+    const missingDeps = task.blockedBy.filter((depId) => !allTaskIds.has(depId));
+    if (missingDeps.length > 0) {
+      orphaned.push(`${task.name} ${colors.muted(`(${task.id})`)} references missing: ${missingDeps.join(", ")}`);
+    }
+  }
+  return {
+    name: "Orphaned Dependencies",
+    status: orphaned.length > 0 ? "fail" : "pass",
+    items: orphaned
+  };
+}
+function checkTicketsWithoutTasks(sprint, tasks) {
+  const ticketIdsWithTasks = new Set(tasks.map((t) => t.ticketId).filter(Boolean));
+  const orphanedTickets = sprint.tickets.filter((t) => !ticketIdsWithTasks.has(t.id));
+  const items = orphanedTickets.map((t) => `${t.title} ${colors.muted(`(${t.id})`)}`);
+  return {
+    name: "Tickets Without Tasks",
+    status: items.length > 0 ? "warn" : "pass",
+    items
+  };
+}
+function checkDuplicateOrders(tasks) {
+  const orderCounts = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    const existing = orderCounts.get(task.order) ?? [];
+    existing.push(`${task.name} ${colors.muted(`(${task.id})`)}`);
+    orderCounts.set(task.order, existing);
+  }
+  const items = [];
+  for (const [order, taskNames] of orderCounts) {
+    if (taskNames.length > 1) {
+      items.push(`Order ${String(order)}: ${taskNames.join(", ")}`);
+    }
+  }
+  return {
+    name: "Duplicate Task Orders",
+    status: items.length > 0 ? "warn" : "pass",
+    items
+  };
+}
+function checkPendingRequirementsOnActive(sprint) {
+  if (sprint.status !== "active") {
+    return { name: "Pending Requirements", status: "pass", items: [] };
+  }
+  const pending = sprint.tickets.filter((t) => t.requirementStatus === "pending");
+  const items = pending.map((t) => `${t.title} ${colors.muted(`(${t.id})`)} \u2014 refine before planning`);
+  return {
+    name: "Pending Requirements",
+    status: items.length > 0 ? "warn" : "pass",
+    items
+  };
+}
+function checkBranchConsistency(sprint, tasks) {
+  if (!sprint.branch) {
+    return { name: "Branch Consistency", status: "pass", items: [] };
+  }
+  const remainingTasks = tasks.filter((t) => t.status !== "done");
+  const uniquePaths = [...new Set(remainingTasks.map((t) => t.projectPath))];
+  const items = [];
+  for (const projectPath of uniquePaths) {
+    try {
+      const current = getCurrentBranch(projectPath);
+      if (current !== sprint.branch) {
+        items.push(`${projectPath} \u2014 on '${current}', expected '${sprint.branch}'`);
+      }
+    } catch {
+      items.push(`${projectPath} \u2014 unable to determine branch`);
+    }
+  }
+  return {
+    name: "Branch Consistency",
+    status: items.length > 0 ? "warn" : "pass",
+    items
+  };
+}
+function checkTasksWithoutSteps(tasks) {
+  const empty = tasks.filter((t) => t.steps.length === 0);
+  const items = empty.map((t) => `${t.name} ${colors.muted(`(${t.id})`)}`);
+  return {
+    name: "Tasks Without Steps",
+    status: items.length > 0 ? "warn" : "pass",
+    items
+  };
+}
+function renderCheckCard(check) {
+  const colorFn = check.status === "pass" ? colors.success : check.status === "warn" ? colors.warning : colors.error;
+  const statusIcon = check.status === "pass" ? icons.success : check.status === "warn" ? icons.warning : icons.error;
+  const lines = [];
+  if (check.items.length === 0) {
+    lines.push(colors.success(`${icons.success} No issues found`));
+  } else {
+    for (const item of check.items) {
+      lines.push(`${colorFn(statusIcon)} ${item}`);
+    }
+  }
+  return renderCard(check.name, lines, { colorFn });
+}
+async function sprintHealthCommand() {
+  let sprint;
+  try {
+    sprint = await getCurrentSprintOrThrow();
+  } catch (err) {
+    if (err instanceof Error) {
+      showError(err.message);
+    } else {
+      showError("Unknown error");
+    }
+    return;
+  }
+  const tasks = await getTasks(sprint.id);
+  printHeader(`Sprint Health: ${sprint.name}`, icons.sprint);
+  const checks = [
+    checkBlockers(tasks),
+    checkStaleTasks(tasks),
+    checkOrphanedDeps(tasks),
+    checkTicketsWithoutTasks(sprint, tasks),
+    checkTasksWithoutSteps(tasks),
+    checkDuplicateOrders(tasks),
+    checkPendingRequirementsOnActive(sprint),
+    checkBranchConsistency(sprint, tasks)
+  ];
+  for (const check of checks) {
+    console.log(renderCheckCard(check));
+    log.newline();
+  }
+  const passing = checks.filter((c) => c.status === "pass").length;
+  const total = checks.length;
+  const bar = progressBar(passing, total);
+  log.info(`Health Score: ${bar}  ${colors.muted(`${String(passing)}/${String(total)} checks passing`)}`);
+  log.newline();
+  const category = passing === total ? "success" : "error";
+  const quote = getQuoteForContext(category);
+  console.log(colors.muted(`  "${quote}"`));
+  log.newline();
+}
+
+// src/commands/ticket/edit.ts
+import { input as input3 } from "@inquirer/prompts";
+function validateUrl(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ticketEditCommand(ticketId, options = {}) {
+  const isInteractive = options.interactive !== false;
+  let resolvedId = ticketId;
+  if (!resolvedId) {
+    if (!isInteractive) {
+      showError("Ticket ID is required in non-interactive mode");
+      exitWithCode(EXIT_ERROR);
+    }
+    const selected = await selectTicket("Select ticket to edit:");
+    if (!selected) {
+      return;
+    }
+    resolvedId = selected;
+  }
+  let ticket;
+  try {
+    ticket = await getTicket(resolvedId);
+  } catch (err) {
+    if (err instanceof TicketNotFoundError) {
+      showError(`Ticket not found: ${resolvedId}`);
+      showNextStep("ralphctl ticket list", "see available tickets");
+      if (!isInteractive) exitWithCode(EXIT_ERROR);
+      return;
+    }
+    throw err;
+  }
+  let newTitle;
+  let newDescription;
+  let newLink;
+  if (isInteractive) {
+    console.log(`
+  Editing: ${formatTicketDisplay(ticket)}`);
+    console.log(muted(`  Project: ${ticket.projectName} (read-only)
+`));
+    newTitle = await input3({
+      message: `${icons.ticket} Title:`,
+      default: ticket.title,
+      validate: (v) => v.trim().length > 0 ? true : "Title is required"
+    });
+    newDescription = await editorInput({
+      message: "Description:",
+      default: ticket.description
+    });
+    newLink = await input3({
+      message: `${icons.info} Link:`,
+      default: ticket.link ?? "",
+      validate: (v) => {
+        if (!v) return true;
+        return validateUrl(v) ? true : "Invalid URL format";
+      }
+    });
+    newTitle = newTitle.trim();
+    newDescription = newDescription.trim() || void 0;
+    newLink = newLink.trim() || void 0;
+  } else {
+    if (options.title !== void 0) {
+      const trimmed = options.title.trim();
+      if (trimmed.length === 0) {
+        showError("--title cannot be empty");
+        exitWithCode(EXIT_ERROR);
+      }
+      newTitle = trimmed;
+    }
+    if (options.description !== void 0) {
+      newDescription = options.description.trim() || void 0;
+    }
+    if (options.link !== void 0) {
+      const trimmed = options.link.trim();
+      if (trimmed && !validateUrl(trimmed)) {
+        showError("--link must be a valid URL");
+        exitWithCode(EXIT_ERROR);
+      }
+      newLink = trimmed || void 0;
+    }
+    if (newTitle === void 0 && newDescription === void 0 && newLink === void 0) {
+      showError("No updates provided. Use --title, --description, or --link.");
+      exitWithCode(EXIT_ERROR);
+    }
+  }
+  const updates = {};
+  if (newTitle !== void 0 && newTitle !== ticket.title) {
+    updates.title = newTitle;
+  }
+  if (newDescription !== void 0 && newDescription !== ticket.description) {
+    updates.description = newDescription;
+  }
+  if (newLink !== void 0 && newLink !== ticket.link) {
+    updates.link = newLink;
+  }
+  if (Object.keys(updates).length === 0) {
+    console.log(muted("\n  No changes made.\n"));
+    return;
+  }
+  try {
+    const updated = await updateTicket(ticket.id, updates);
+    showSuccess("Ticket updated!", [
+      ["ID", updated.id],
+      ["Title", updated.title],
+      ["Project", updated.projectName]
+    ]);
+    if (updated.description) {
+      console.log(fieldMultiline("Description", updated.description));
+    }
+    if (updated.link) {
+      console.log(field("Link", updated.link));
+    }
+    console.log("");
+  } catch (err) {
+    if (err instanceof SprintStatusError) {
+      showError(err.message);
+    } else {
+      throw err;
+    }
+    if (!isInteractive) exitWithCode(EXIT_ERROR);
+  }
+}
+
+// src/commands/ticket/list.ts
+function parseListArgs(args) {
+  const result = {
+    brief: false
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const next = args[i + 1];
+    if (arg === "-b" || arg === "--brief") result.brief = true;
+    else if (arg === "--project" && next) {
+      result.projectFilter = next;
+      i++;
+    } else if (arg === "--status" && next) {
+      result.statusFilter = next;
+      i++;
+    }
+  }
+  return result;
+}
+function buildFilterSummary(filters) {
+  const parts = [];
+  if (filters.projectFilter) parts.push(`project=${filters.projectFilter}`);
+  if (filters.statusFilter) parts.push(`status=${filters.statusFilter}`);
+  return parts.length > 0 ? ` (filtered: ${parts.join(", ")})` : "";
+}
+async function ticketListCommand(args) {
+  const { brief, projectFilter, statusFilter } = parseListArgs(args);
+  if (statusFilter) {
+    const result = RequirementStatusSchema.safeParse(statusFilter);
+    if (!result.success) {
+      showError(`Invalid status: "${statusFilter}". Valid values: pending, approved`);
+      return;
+    }
+  }
+  const tickets = await listTickets();
+  if (tickets.length === 0) {
+    showEmpty("tickets", "Add one with: ralphctl ticket add --project <project-name>");
+    return;
+  }
+  let filtered = tickets;
+  if (projectFilter) filtered = filtered.filter((t) => t.projectName === projectFilter);
+  if (statusFilter) filtered = filtered.filter((t) => t.requirementStatus === statusFilter);
+  const filterStr = buildFilterSummary({ brief, projectFilter, statusFilter });
+  const isFiltered = filtered.length !== tickets.length;
+  if (filtered.length === 0) {
+    showEmpty("matching tickets", "Try adjusting your filters");
+    return;
+  }
+  if (brief) {
+    const countLabel = isFiltered ? `${String(filtered.length)} of ${String(tickets.length)}` : String(tickets.length);
+    console.log(`
+# Tickets (${countLabel})${filterStr}
+`);
+    for (const ticket of filtered) {
+      const display = `[${ticket.id}] ${ticket.title}`;
+      const reqBadge = ticket.requirementStatus === "approved" ? " [approved]" : " [pending]";
+      console.log(`- ${display}${reqBadge} (${ticket.projectName})`);
+    }
+    console.log("");
+    return;
+  }
+  const ticketsByProject = groupTicketsByProject(filtered);
+  printHeader(`Tickets (${String(filtered.length)})`, icons.ticket);
+  for (const [projectName, projectTickets] of ticketsByProject) {
+    log.raw(`${colors.info(icons.project)} ${colors.info(projectName)}`);
+    try {
+      const project = await getProject(projectName);
+      for (const repo of project.repositories) {
+        log.raw(`    ${muted(repo.name)} ${muted("\u2192")} ${muted(repo.path)}`, 1);
+      }
+    } catch {
+      log.raw(`    ${muted("(project not found)")}`, 1);
+    }
+    log.newline();
+    for (const ticket of projectTickets) {
+      const reqBadge = ticket.requirementStatus === "approved" ? badge("approved", "success") : badge("pending", "muted");
+      log.raw(`  ${icons.bullet} ${formatTicketDisplay(ticket)} ${reqBadge}`);
+      if (ticket.description) {
+        const preview = ticket.description.split("\n")[0] ?? "";
+        const truncated = preview.length > 60 ? preview.slice(0, 57) + "..." : preview;
+        log.raw(`      ${muted(truncated)}`, 1);
+      }
+    }
+    log.newline();
+  }
+  const approved = filtered.filter((t) => t.requirementStatus === "approved").length;
+  log.dim(
+    `Requirements: ${success(`${String(approved)} approved`)} / ${muted(`${String(filtered.length - approved)} pending`)}`
+  );
+  const showingLabel = isFiltered ? `Showing ${String(filtered.length)} of ${String(tickets.length)} ticket(s)${filterStr}` : `Showing ${String(tickets.length)} ticket(s)`;
+  log.dim(showingLabel);
+  log.newline();
+}
+
+// src/commands/ticket/show.ts
+async function ticketShowCommand(args) {
+  let ticketId = args[0];
+  if (!ticketId) {
+    const selected = await selectTicket("Select ticket to show:");
+    if (!selected) return;
+    ticketId = selected;
+  }
+  try {
+    const ticket = await getTicket(ticketId);
+    const reqBadge = ticket.requirementStatus === "approved" ? badge("approved", "success") : badge("pending", "muted");
+    const infoLines = [labelValue("ID", ticket.id)];
+    infoLines.push(labelValue("Project", ticket.projectName));
+    infoLines.push(labelValue("Requirements", reqBadge));
+    if (ticket.link) {
+      infoLines.push(labelValue("Link", ticket.link));
+    }
+    try {
+      const project = await getProject(ticket.projectName);
+      infoLines.push("");
+      for (const repo of project.repositories) {
+        infoLines.push(`  ${icons.bullet} ${repo.name} ${muted("\u2192")} ${muted(repo.path)}`);
+      }
+    } catch {
+      infoLines.push(labelValue("Repositories", muted("(project not found)")));
+    }
+    log.newline();
+    console.log(renderCard(`${icons.ticket} ${ticket.title}`, infoLines));
+    if (ticket.description) {
+      log.newline();
+      const descLines = [];
+      for (const line2 of ticket.description.split("\n")) {
+        descLines.push(line2);
+      }
+      console.log(renderCard(`${icons.edit} Description`, descLines));
+    }
+    if (ticket.affectedRepositories && ticket.affectedRepositories.length > 0) {
+      log.newline();
+      const affectedLines = [];
+      for (const repoPath of ticket.affectedRepositories) {
+        affectedLines.push(`${icons.bullet} ${repoPath}`);
+      }
+      console.log(renderCard(`${icons.project} Affected Repositories`, affectedLines));
+    }
+    log.newline();
+  } catch (err) {
+    if (err instanceof TicketNotFoundError) {
+      showError(`Ticket not found: ${ticketId}`);
+      showNextStep("ralphctl ticket list", "see available tickets");
+      log.newline();
+    } else {
+      throw err;
+    }
+  }
+}
+
+// src/commands/ticket/remove.ts
+import { confirm as confirm5 } from "@inquirer/prompts";
+async function ticketRemoveCommand(args) {
+  const skipConfirm = args.includes("-y") || args.includes("--yes");
+  let ticketId = args.find((a) => !a.startsWith("-"));
+  if (!ticketId) {
+    const selected = await selectTicket("Select ticket to remove:");
+    if (!selected) return;
+    ticketId = selected;
+  }
+  try {
+    const ticket = await getTicket(ticketId);
+    if (!skipConfirm) {
+      const confirmed = await confirm5({
+        message: `Remove ticket ${formatTicketDisplay(ticket)}?`,
+        default: false
+      });
+      if (!confirmed) {
+        console.log(muted("\nTicket removal cancelled.\n"));
+        return;
+      }
+    }
+    await removeTicket(ticketId);
+    showSuccess("Ticket removed", [["ID", ticketId]]);
+    log.newline();
+  } catch (err) {
+    if (err instanceof TicketNotFoundError) {
+      showError(`Ticket not found: ${ticketId}`);
+      showNextStep("ralphctl ticket list", "see available tickets");
+      log.newline();
+    } else if (err instanceof SprintStatusError) {
+      showError(err.message);
+      log.newline();
+    } else {
+      throw err;
+    }
+  }
+}
+
+// src/commands/ticket/refine.ts
+import { mkdir as mkdir2, readFile as readFile2 } from "fs/promises";
+import { join as join3 } from "path";
+import { confirm as confirm6 } from "@inquirer/prompts";
+async function ticketRefineCommand(ticketId, options = {}) {
+  const isInteractive = options.interactive !== false;
+  let sprintId;
+  try {
+    sprintId = await resolveSprintId();
+  } catch {
+    showWarning("No current sprint set.");
+    showTip("Create a sprint first or set one with: ralphctl sprint current");
+    log.newline();
+    return;
+  }
+  const sprint = await getSprint(sprintId);
+  try {
+    assertSprintStatus(sprint, ["draft"], "refine ticket");
+  } catch (err) {
+    if (err instanceof Error) {
+      showError(err.message);
+      log.newline();
+    }
+    return;
+  }
+  const approvedTickets = sprint.tickets.filter((t) => t.requirementStatus === "approved");
+  if (approvedTickets.length === 0) {
+    showWarning("No approved tickets to re-refine.");
+    showTip('Run "ralphctl sprint refine" to refine pending tickets first.');
+    log.newline();
+    return;
+  }
+  let resolvedId = ticketId;
+  if (!resolvedId) {
+    if (!isInteractive) {
+      showError("Ticket ID is required in non-interactive mode");
+      exitWithCode(EXIT_ERROR);
+    }
+    const selected = await selectTicket("Select ticket to re-refine:", (t) => t.requirementStatus === "approved");
+    if (!selected) return;
+    resolvedId = selected;
+  }
+  const ticket = sprint.tickets.find((t) => t.id === resolvedId);
+  if (!ticket) {
+    showError(`Ticket not found: ${resolvedId}`);
+    if (!isInteractive) exitWithCode(EXIT_ERROR);
+    return;
+  }
+  if (ticket.requirementStatus !== "approved") {
+    showError('Only approved tickets can be re-refined. Run "ralphctl sprint refine" for pending tickets.');
+    if (!isInteractive) exitWithCode(EXIT_ERROR);
+    return;
+  }
+  printHeader("Re-Refine Ticket", icons.ticket);
+  console.log(field("Sprint", sprint.name));
+  console.log(field("Ticket", formatTicketDisplay(ticket)));
+  console.log(field("Project", ticket.projectName));
+  if (ticket.link) {
+    console.log(field("Link", ticket.link));
+  }
+  if (ticket.description) {
+    console.log(fieldMultiline("Description", ticket.description));
+  }
+  log.newline();
+  const schemaPath = getSchemaPath("requirements-output.schema.json");
+  const schema = await readFile2(schemaPath, "utf-8");
+  const providerName = providerDisplayName(await resolveProvider());
+  const proceed = await confirm6({
+    message: `${emoji.donut} Start ${providerName} re-refinement session?`,
+    default: true
+  });
+  if (!proceed) {
+    log.dim("Cancelled.");
+    log.newline();
+    return;
+  }
+  let issueContext = "";
+  if (ticket.link) {
+    const fetchSpinner = createSpinner("Fetching issue data...");
+    fetchSpinner.start();
+    try {
+      const issueData = fetchIssueFromUrl(ticket.link);
+      if (issueData) {
+        issueContext = formatIssueContext(issueData);
+        fetchSpinner.succeed(`Issue data fetched (${String(issueData.comments.length)} comment(s))`);
+      } else {
+        fetchSpinner.stop();
+      }
+    } catch (err) {
+      fetchSpinner.fail("Could not fetch issue data");
+      if (err instanceof IssueFetchError || err instanceof Error) {
+        showWarning(`${err.message} \u2014 continuing without issue context`);
+      }
+    }
+  }
+  const refineDir = getRefinementDir(sprintId, ticket.id);
+  await mkdir2(refineDir, { recursive: true });
+  const outputFile = join3(refineDir, "requirements.json");
+  let ticketContent = formatTicketForPrompt(ticket);
+  if (ticket.requirements) {
+    ticketContent += "\n### Previously Approved Requirements\n\n";
+    ticketContent += ticket.requirements;
+    ticketContent += "\n";
+  }
+  const prompt = buildTicketRefinePrompt(ticketContent, outputFile, schema, issueContext);
+  log.dim(`Working directory: ${refineDir}`);
+  log.dim(`Requirements output: ${outputFile}`);
+  log.newline();
+  const spinner = createSpinner(`Starting ${providerName} session...`);
+  spinner.start();
+  try {
+    await runAiSession(refineDir, prompt, ticket.title);
+    spinner.succeed(`${providerName} session completed`);
+  } catch (err) {
+    spinner.fail(`${providerName} session failed`);
+    if (err instanceof Error) {
+      showError(err.message);
+    }
+    log.newline();
+    return;
+  }
+  log.newline();
+  if (!await fileExists(outputFile)) {
+    showWarning("No requirements file found from AI session.");
+    log.newline();
+    return;
+  }
+  let content;
+  try {
+    content = await readFile2(outputFile, "utf-8");
+  } catch {
+    showError(`Failed to read requirements file: ${outputFile}`);
+    log.newline();
+    return;
+  }
+  let refinedRequirements;
+  try {
+    refinedRequirements = parseRequirementsFile(content);
+  } catch (err) {
+    if (err instanceof Error) {
+      showError(`Failed to parse requirements file: ${err.message}`);
+    }
+    log.newline();
+    return;
+  }
+  if (refinedRequirements.length === 0) {
+    showWarning("No requirements found in output file.");
+    log.newline();
+    return;
+  }
+  const matchingRequirements = refinedRequirements.filter((r) => r.ref === ticket.id || r.ref === ticket.title);
+  if (matchingRequirements.length === 0) {
+    showWarning("Requirement reference does not match this ticket.");
+    log.newline();
+    return;
+  }
+  const requirement = matchingRequirements.length === 1 ? {
+    ref: matchingRequirements[0]?.ref ?? "",
+    requirements: matchingRequirements[0]?.requirements ?? ""
+  } : {
+    ref: matchingRequirements[0]?.ref ?? "",
+    requirements: matchingRequirements.map((r, idx) => {
+      const text = r.requirements.trim();
+      if (/^#\s/.test(text)) return text;
+      return `# ${String(idx + 1)}. Section ${String(idx + 1)}
+
+${text}`;
+    }).join("\n\n---\n\n")
+  };
+  const reqLines = requirement.requirements.split("\n");
+  console.log(renderCard(`${icons.ticket} Re-Refined Requirements`, reqLines));
+  log.newline();
+  const approveRequirement = await confirm6({
+    message: `${emoji.donut} Approve these requirements?`,
+    default: true
+  });
+  if (approveRequirement) {
+    const ticketIdx = sprint.tickets.findIndex((t) => t.id === ticket.id);
+    const ticketToSave = sprint.tickets[ticketIdx];
+    if (ticketIdx !== -1 && ticketToSave) {
+      ticketToSave.requirements = requirement.requirements;
+    }
+    await saveSprint(sprint);
+    showSuccess("Requirements updated and saved!");
+  } else {
+    log.dim("Requirements not approved. Previous requirements unchanged.");
+  }
+  log.newline();
+}
+
+// src/commands/task/add.ts
+import { resolve as resolve2 } from "path";
+import { confirm as confirm7, input as input4 } from "@inquirer/prompts";
+async function taskAddCommand(options = {}) {
+  const isInteractive = options.interactive !== false;
+  try {
+    const sprintId = await resolveSprintId();
+    const sprint = await getSprint(sprintId);
+    assertSprintStatus(sprint, ["draft"], "add tasks");
+  } catch (err) {
+    if (err instanceof SprintStatusError) {
+      const mainError = err.message.split("\n")[0] ?? err.message;
+      showError(mainError);
+      showNextSteps([
+        ["ralphctl sprint close", "close current sprint"],
+        ["ralphctl sprint create", "start a new draft sprint"]
+      ]);
+      log.newline();
+      if (!isInteractive) exitWithCode(EXIT_ERROR);
+      return;
+    }
+    if (err instanceof NoCurrentSprintError) {
+      showError("No current sprint set.");
+      showNextSteps([["ralphctl sprint create", "create a new sprint"]]);
+      log.newline();
+      if (!isInteractive) exitWithCode(EXIT_ERROR);
+      return;
+    }
+    throw err;
+  }
+  let name;
+  let description;
+  let steps;
+  let ticketId;
+  let projectPath;
+  if (options.interactive === false) {
+    const errors = [];
+    const trimmedName = options.name?.trim();
+    const trimmedProject = options.project?.trim();
+    if (!trimmedName) {
+      errors.push("--name is required");
+    }
+    if (!trimmedProject && !options.ticket) {
+      errors.push("--project is required (or --ticket to inherit from ticket)");
+    }
+    if (errors.length > 0 || !trimmedName) {
+      showError("Validation failed");
+      for (const e of errors) {
+        log.item(error(e));
+      }
+      log.newline();
+      exitWithCode(EXIT_ERROR);
+    }
+    name = trimmedName;
+    const trimmedDesc = options.description?.trim();
+    description = trimmedDesc === "" ? void 0 : trimmedDesc;
+    steps = options.steps ?? [];
+    const trimmedTicket = options.ticket?.trim();
+    ticketId = trimmedTicket === "" ? void 0 : trimmedTicket;
+    if (ticketId) {
+      try {
+        const ticket = await getTicket(ticketId);
+        const project = await getProject(ticket.projectName);
+        projectPath = project.repositories[0]?.path;
+      } catch {
+        if (!trimmedProject) {
+          showError(`Ticket not found: ${ticketId}`);
+          console.log(muted("  Provide --project or a valid --ticket\n"));
+          exitWithCode(EXIT_ERROR);
+        }
+        const validation = await validateProjectPath(trimmedProject);
+        if (validation !== true) {
+          showError(`Invalid project path: ${validation}`);
+          exitWithCode(EXIT_ERROR);
+        }
+        projectPath = resolve2(trimmedProject);
+      }
+    } else if (trimmedProject) {
+      const validation = await validateProjectPath(trimmedProject);
+      if (validation !== true) {
+        showError(`Invalid project path: ${validation}`);
+        exitWithCode(EXIT_ERROR);
+      }
+      projectPath = resolve2(trimmedProject);
+    } else {
+      showError("--project is required");
+      exitWithCode(EXIT_ERROR);
+    }
+  } else {
+    name = await input4({
+      message: `${icons.task} Task name:`,
+      default: options.name?.trim(),
+      validate: (v) => v.trim().length > 0 ? true : "Name is required"
+    });
+    description = await editorInput({
+      message: "Description (optional):",
+      default: options.description?.trim()
+    });
+    steps = options.steps ? [...options.steps] : [];
+    const addSteps = await confirm7({
+      message: `${emoji.donut} ${steps.length > 0 ? `Add more steps? (${String(steps.length)} pre-filled)` : "Add implementation steps?"}`,
+      default: steps.length === 0
+    });
+    if (addSteps) {
+      let stepNum = steps.length + 1;
+      let adding = true;
+      while (adding) {
+        const step = await input4({
+          message: `  Step ${String(stepNum)} (empty to finish):`
+        });
+        if (step.trim()) {
+          steps.push(step.trim());
+          stepNum++;
+        } else {
+          adding = false;
+        }
+      }
+    }
+    const tickets = await listTickets();
+    if (tickets.length > 0) {
+      const { select: select4 } = await import("@inquirer/prompts");
+      const defaultTicketValue = options.ticket ? tickets.find((t) => t.id === options.ticket)?.id ?? "" : "";
+      const ticketChoice = await select4({
+        message: `${icons.ticket} Link to ticket:`,
+        default: defaultTicketValue,
+        choices: [
+          { name: `${emoji.donut} None (select project/repo manually)`, value: "" },
+          ...tickets.map((t) => ({
+            name: `${icons.ticket} ${formatTicketDisplay(t)} ${muted(`(${t.projectName})`)}`,
+            value: t.id
+          }))
+        ]
+      });
+      if (ticketChoice) {
+        ticketId = ticketChoice;
+        const ticket = tickets.find((t) => t.id === ticketChoice);
+        if (ticket) {
+          try {
+            const project = await getProject(ticket.projectName);
+            if (project.repositories.length === 1) {
+              projectPath = project.repositories[0]?.path;
+            } else {
+              const { select: selectRepo } = await import("@inquirer/prompts");
+              projectPath = await selectRepo({
+                message: `${emoji.donut} Select repository for this task:`,
+                choices: project.repositories.map((r) => ({
+                  name: `${r.name} (${r.path})`,
+                  value: r.path
+                }))
+              });
+            }
+          } catch {
+            log.warn(`Project '${ticket.projectName}' not found, will prompt for path.`);
+          }
+        }
+      }
+    } else if (options.ticket) {
+      ticketId = options.ticket;
+      try {
+        const ticket = await getTicket(ticketId);
+        const project = await getProject(ticket.projectName);
+        projectPath = project.repositories[0]?.path;
+      } catch {
+      }
+    }
+    if (projectPath === void 0) {
+      const projects = await listProjects();
+      if (projects.length > 0) {
+        const { select: select4 } = await import("@inquirer/prompts");
+        const choice = await select4({
+          message: `${icons.project} Select project:`,
+          choices: [
+            { name: `${icons.edit} Enter path manually`, value: "__manual__" },
+            { name: `${emoji.donut} Select project/repository`, value: "__select__" }
+          ]
+        });
+        if (choice === "__manual__") {
+          projectPath = await input4({
+            message: `${icons.project} Project path:`,
+            default: options.project?.trim() ?? process.cwd(),
+            validate: async (v) => {
+              const result = await validateProjectPath(v.trim());
+              return result;
+            }
+          });
+          projectPath = resolve2(expandTilde(projectPath.trim()));
+        } else {
+          const selectedPath = await selectProjectRepository("Select repository:");
+          if (!selectedPath) {
+            showError("No repository selected");
+            exitWithCode(EXIT_ERROR);
+          }
+          projectPath = selectedPath;
+        }
+      } else {
+        projectPath = await input4({
+          message: `${icons.project} Project path:`,
+          default: options.project?.trim() ?? process.cwd(),
+          validate: async (v) => {
+            const result = await validateProjectPath(v.trim());
+            return result;
+          }
+        });
+        projectPath = resolve2(expandTilde(projectPath.trim()));
+      }
+    }
+    name = name.trim();
+    const trimmedDescription = description.trim();
+    description = trimmedDescription === "" ? void 0 : trimmedDescription;
+  }
+  if (!projectPath) {
+    showError("Project path is required");
+    exitWithCode(EXIT_ERROR);
+  }
+  try {
+    const task = await addTask({
+      name,
+      description,
+      steps,
+      ticketId,
+      projectPath
+    });
+    showSuccess("Task added!", [
+      ["ID", task.id],
+      ["Name", task.name],
+      ["Project", task.projectPath],
+      ["Order", String(task.order)]
+    ]);
+    if (task.ticketId) {
+      console.log(field("Ticket", task.ticketId));
+    }
+    if (task.steps.length > 0) {
+      console.log(field("Steps", ""));
+      task.steps.forEach((step, i) => {
+        console.log(muted(`    ${String(i + 1)}. ${step}`));
+      });
+    }
+    console.log("");
+  } catch (err) {
+    if (err instanceof SprintStatusError) {
+      const mainError = err.message.split("\n")[0] ?? err.message;
+      showError(mainError);
+      showNextSteps([
+        ["ralphctl sprint close", "close current sprint"],
+        ["ralphctl sprint create", "start a new draft sprint"]
+      ]);
+      log.newline();
+      if (!isInteractive) exitWithCode(EXIT_ERROR);
+      return;
+    }
+    throw err;
+  }
+}
+
+// src/commands/task/import.ts
+import { readFile as readFile3 } from "fs/promises";
+async function taskImportCommand(args) {
+  const filePath = args[0];
+  if (!filePath) {
+    showError("File path required.");
+    showNextStep("ralphctl task import <file.json>", "provide a task file");
+    log.dim("Expected JSON format:");
+    console.log(
+      muted(`[
+  {
+    "id": "1",
+    "name": "Task name",
+    "projectPath": "/path/to/repo",
+    "description": "Optional description",
+    "steps": ["Step 1", "Step 2"],
+    "ticketId": "abc12345",
+    "blockedBy": ["task-001"]
+  }
+]`)
+    );
+    log.dim("Note: projectPath is required for each task.");
+    log.newline();
+    return;
+  }
+  let content;
+  try {
+    content = await readFile3(filePath, "utf-8");
+  } catch {
+    showError(`Failed to read file: ${filePath}`);
+    log.newline();
+    return;
+  }
+  let data;
+  try {
+    data = JSON.parse(content);
+  } catch {
+    showError("Invalid JSON format.");
+    log.newline();
+    return;
+  }
+  const result = ImportTasksSchema.safeParse(data);
+  if (!result.success) {
+    showError("Invalid task format");
+    for (const issue of result.error.issues) {
+      log.item(error(`${issue.path.join(".")}: ${issue.message}`));
+    }
+    log.newline();
+    return;
+  }
+  const tasks = result.data;
+  if (tasks.length === 0) {
+    showError("No tasks to import.");
+    log.newline();
+    return;
+  }
+  const existingTasks = await getTasks();
+  const sprintId = await resolveSprintId();
+  const sprint = await getSprint(sprintId);
+  const ticketIds = new Set(sprint.tickets.map((t) => t.id));
+  const validationErrors = validateImportTasks(tasks, existingTasks, ticketIds);
+  if (validationErrors.length > 0) {
+    showError("Dependency validation failed");
+    for (const err of validationErrors) {
+      log.item(error(err));
+    }
+    log.newline();
+    return;
+  }
+  const localToRealId = /* @__PURE__ */ new Map();
+  const createdTasks = [];
+  const spinner = createSpinner(`Importing ${String(tasks.length)} task(s)...`).start();
+  let imported = 0;
+  for (const taskInput of tasks) {
+    try {
+      const task = await addTask({
+        name: taskInput.name,
+        description: taskInput.description,
+        steps: taskInput.steps ?? [],
+        ticketId: taskInput.ticketId,
+        blockedBy: [],
+        // Set later
+        projectPath: taskInput.projectPath
+      });
+      if (taskInput.id) {
+        localToRealId.set(taskInput.id, task.id);
+      }
+      createdTasks.push({ task: taskInput, realId: task.id });
+      imported++;
+      spinner.text = `Importing tasks... (${String(imported)}/${String(tasks.length)})`;
+    } catch (err) {
+      if (err instanceof SprintStatusError) {
+        spinner.fail("Import failed");
+        showError(err.message);
+        log.newline();
+        return;
+      }
+      log.itemError(`Failed to add: ${taskInput.name}`);
+      if (err instanceof Error) {
+        console.log(muted(`    ${err.message}`));
+      }
+    }
+  }
+  spinner.text = "Resolving task dependencies...";
+  const tasksFilePath = getTasksFilePath(sprintId);
+  await withFileLock(tasksFilePath, async () => {
+    const allTasks = await getTasks();
+    for (const { task: taskInput, realId } of createdTasks) {
+      const blockedBy = (taskInput.blockedBy ?? []).map((localId) => localToRealId.get(localId) ?? "").filter((id) => id !== "");
+      if (blockedBy.length > 0) {
+        const taskToUpdate = allTasks.find((t) => t.id === realId);
+        if (taskToUpdate) {
+          taskToUpdate.blockedBy = blockedBy;
+        }
+      }
+    }
+    await saveTasks(allTasks);
+  });
+  spinner.succeed(`Imported ${String(imported)}/${String(tasks.length)} tasks`);
+  for (const { task: taskInput, realId } of createdTasks) {
+    log.itemSuccess(`${realId}: ${taskInput.name}`);
+  }
+}
+
+// src/commands/task/list.ts
+function parseListArgs2(args) {
+  const result = {
+    brief: false,
+    blockedOnly: false
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const next = args[i + 1];
+    if (arg === "-b" || arg === "--brief") result.brief = true;
+    else if (arg === "--status" && next) {
+      result.statusFilter = next;
+      i++;
+    } else if (arg === "--project" && next) {
+      result.projectFilter = next;
+      i++;
+    } else if (arg === "--ticket" && next) {
+      result.ticketFilter = next;
+      i++;
+    } else if (arg === "--blocked") result.blockedOnly = true;
+  }
+  return result;
+}
+function buildFilterSummary2(filters) {
+  const parts = [];
+  if (filters.statusFilter) parts.push(`status=${filters.statusFilter}`);
+  if (filters.projectFilter) parts.push(`project=${filters.projectFilter}`);
+  if (filters.ticketFilter) parts.push(`ticket=${filters.ticketFilter}`);
+  if (filters.blockedOnly) parts.push("blocked");
+  return parts.length > 0 ? ` (filtered: ${parts.join(", ")})` : "";
+}
+async function taskListCommand(args = []) {
+  const { brief, statusFilter, projectFilter, ticketFilter, blockedOnly } = parseListArgs2(args);
+  if (statusFilter) {
+    const result = TaskStatusSchema.safeParse(statusFilter);
+    if (!result.success) {
+      showError(`Invalid status: "${statusFilter}". Valid values: todo, in_progress, done`);
+      return;
+    }
+  }
+  const tasks = await listTasks();
+  if (tasks.length === 0) {
+    showEmpty("tasks", "Add one with: ralphctl task add");
+    return;
+  }
+  let filtered = tasks;
+  if (statusFilter) filtered = filtered.filter((t) => t.status === statusFilter);
+  if (projectFilter) filtered = filtered.filter((t) => t.projectPath.includes(projectFilter));
+  if (ticketFilter) filtered = filtered.filter((t) => t.ticketId === ticketFilter);
+  if (blockedOnly) filtered = filtered.filter((t) => t.blockedBy.length > 0);
+  const filterStr = buildFilterSummary2({ brief, statusFilter, projectFilter, ticketFilter, blockedOnly });
+  const isFiltered = filtered.length !== tasks.length;
+  if (filtered.length === 0) {
+    showEmpty("matching tasks", "Try adjusting your filters");
+    return;
+  }
+  if (brief) {
+    const countLabel = isFiltered ? `${String(filtered.length)} of ${String(tasks.length)}` : String(tasks.length);
+    console.log(`
+# Tasks (${countLabel})${filterStr}
+`);
+    for (const task of filtered) {
+      const ticketRef = task.ticketId ? ` [${task.ticketId}]` : "";
+      const blockedRef = task.blockedBy.length > 0 ? ` (blocked by: ${task.blockedBy.join(", ")})` : "";
+      console.log(
+        `- ${String(task.order)}. **[${task.status}]** ${task.id}: ${task.name} (${task.projectPath})${ticketRef}${blockedRef}`
+      );
+    }
+    console.log("");
+    return;
+  }
+  const tasksByStatus = {
+    todo: filtered.filter((t) => t.status === "todo").length,
+    in_progress: filtered.filter((t) => t.status === "in_progress").length,
+    done: filtered.filter((t) => t.status === "done").length
+  };
+  printHeader(`Tasks (${String(filtered.length)})`, icons.task);
+  log.raw(
+    `${formatTaskStatus("todo")} ${String(tasksByStatus.todo)}   ${formatTaskStatus("in_progress")} ${String(tasksByStatus.in_progress)}   ${formatTaskStatus("done")} ${String(tasksByStatus.done)}`
+  );
+  log.newline();
+  const rows = filtered.map((task) => {
+    const statusIcon = task.status === "done" ? icons.success : task.status === "in_progress" ? icons.active : icons.inactive;
+    const statusColor = task.status === "done" ? "success" : task.status === "in_progress" ? "warning" : "muted";
+    const blocked = task.blockedBy.length > 0 ? colors.warning("(blocked)") : "";
+    return [badge(statusIcon, statusColor), String(task.order), task.name, task.id, blocked];
+  });
+  console.log(
+    renderTable(
+      [
+        { header: "", minWidth: 0 },
+        { header: "#", align: "right" },
+        { header: "Name" },
+        { header: "ID" },
+        { header: "" }
+      ],
+      rows
+    )
+  );
+  const percent = filtered.length > 0 ? Math.round(tasksByStatus.done / filtered.length * 100) : 0;
+  const progressColor = percent === 100 ? colors.success : percent > 50 ? colors.warning : colors.muted;
+  const showingLabel = isFiltered ? `Showing ${String(filtered.length)} of ${String(tasks.length)} task(s)${filterStr}` : `Showing ${String(tasks.length)} task(s)`;
+  log.newline();
+  log.dim(
+    `Progress: ${progressColor(`${String(tasksByStatus.done)}/${String(filtered.length)} (${String(percent)}%)`)}  |  ${showingLabel}`
+  );
+  log.newline();
+}
+
+// src/commands/task/show.ts
+async function taskShowCommand(args) {
+  let taskId = args[0];
+  if (!taskId) {
+    const selected = await selectTask("Select task to show:");
+    if (!selected) return;
+    taskId = selected;
+  }
+  try {
+    const task = await getTask(taskId);
+    const infoLines = [
+      labelValue("ID", task.id),
+      labelValue("Status", formatTaskStatus(task.status)),
+      labelValue("Order", String(task.order)),
+      labelValue("Project", task.projectPath)
+    ];
+    if (task.ticketId) {
+      infoLines.push(labelValue("Ticket", task.ticketId));
+    }
+    if (task.description) {
+      infoLines.push("");
+      infoLines.push(labelValue("Description", ""));
+      for (const line2 of task.description.split("\n")) {
+        infoLines.push(`${" ".repeat(DETAIL_LABEL_WIDTH + 1)}${line2}`);
+      }
+    }
+    log.newline();
+    console.log(renderCard(`${icons.task} ${task.name}`, infoLines));
+    if (task.steps.length > 0) {
+      log.newline();
+      const stepLines = [];
+      for (let i = 0; i < task.steps.length; i++) {
+        const step = task.steps[i] ?? "";
+        const checkbox = task.status === "done" ? colors.success("[x]") : muted("[ ]");
+        stepLines.push(`${checkbox} ${muted(String(i + 1) + ".")} ${step}`);
+      }
+      console.log(renderCard(`${icons.bullet} Steps (${String(task.steps.length)})`, stepLines));
+    }
+    if (task.blockedBy.length > 0) {
+      log.newline();
+      const depLines = [];
+      for (const dep of task.blockedBy) {
+        depLines.push(`${icons.bullet} ${dep}`);
+      }
+      console.log(renderCard(`${icons.warning} Blocked By`, depLines));
+    }
+    if (task.ticketId) {
+      try {
+        const ticket = await getTicket(task.ticketId);
+        if (ticket.requirements) {
+          log.newline();
+          const reqLines = ticket.requirements.split("\n");
+          console.log(renderCard(`${icons.ticket} Requirements`, reqLines));
+        }
+      } catch {
+      }
+    }
+    if (task.verified) {
+      log.newline();
+      const verifyLines = [`${colors.success(icons.success)} Verified`];
+      if (task.verificationOutput) {
+        verifyLines.push(colors.muted(horizontalLine(30, "rounded")));
+        for (const line2 of task.verificationOutput.split("\n").slice(0, 10)) {
+          verifyLines.push(muted(line2));
+        }
+      }
+      console.log(renderCard(`${icons.success} Verification`, verifyLines));
+    }
+    log.newline();
+  } catch (err) {
+    if (err instanceof TaskNotFoundError) {
+      showError(`Task not found: ${taskId}`);
+      showNextStep("ralphctl task list", "see available tasks");
+      log.newline();
+    } else {
+      throw err;
+    }
+  }
+}
+
+// src/commands/task/status.ts
+var VALID_STATUSES = ["todo", "in_progress", "done"];
+async function taskStatusCommand(args, options = {}) {
+  let taskId = args[0] ?? options.taskId;
+  let newStatus = args[1] ?? options.status;
+  if (options.noInteractive) {
+    const errors = [];
+    if (!taskId?.trim()) {
+      errors.push("Task ID is required");
+    }
+    if (!newStatus?.trim()) {
+      errors.push("Status is required");
+    } else {
+      const result2 = TaskStatusSchema.safeParse(newStatus);
+      if (!result2.success) {
+        errors.push(`Invalid status: ${newStatus} (valid: ${VALID_STATUSES.join(", ")})`);
+      }
+    }
+    if (errors.length > 0) {
+      showError("Validation failed");
+      for (const e of errors) {
+        log.error(e);
+      }
+      log.newline();
+      exitWithCode(EXIT_ERROR);
+    }
+  }
+  if (!taskId) {
+    const selected = await selectTask("Select task to update:");
+    if (!selected) return;
+    taskId = selected;
+  }
+  if (!newStatus) {
+    const selected = await selectTaskStatus("Select new status:");
+    if (!selected) return;
+    newStatus = selected;
+  }
+  const result = TaskStatusSchema.safeParse(newStatus);
+  if (!result.success) {
+    showError(`Invalid status: ${newStatus}`);
+    log.dim(`Valid statuses: ${VALID_STATUSES.join(", ")}`);
+    log.newline();
+    if (options.noInteractive) {
+      exitWithCode(EXIT_ERROR);
+    }
+    return;
+  }
+  try {
+    const task = await updateTaskStatus(taskId, result.data);
+    showSuccess("Task status updated!", [
+      ["ID", task.id],
+      ["Name", task.name],
+      ["Status", formatTaskStatus(task.status)]
+    ]);
+    log.newline();
+  } catch (err) {
+    if (err instanceof TaskNotFoundError) {
+      showError(`Task not found: ${taskId}`);
+      showNextStep("ralphctl task list", "see available tasks");
+      log.newline();
+      if (options.noInteractive) {
+        exitWithCode(EXIT_ERROR);
+      }
+    } else if (err instanceof SprintStatusError) {
+      showError(err.message);
+      log.newline();
+      if (options.noInteractive) {
+        exitWithCode(EXIT_ERROR);
+      }
+    } else {
+      throw err;
+    }
+  }
+}
+
+// src/commands/task/next.ts
+async function taskNextCommand() {
+  const task = await getNextTask();
+  if (!task) {
+    showEmpty("pending tasks", "All tasks are done, or add more with: ralphctl task add");
+    return;
+  }
+  printHeader("Next Task");
+  console.log(field("ID", task.id));
+  console.log(field("Name", task.name));
+  console.log(field("Status", formatTaskStatus(task.status)));
+  console.log(field("Order", String(task.order)));
+  if (task.ticketId) {
+    console.log(field("Ticket", task.ticketId));
+  }
+  if (task.description) {
+    log.newline();
+    console.log(field("Description", ""));
+    log.raw(task.description, 2);
+  }
+  if (task.steps.length > 0) {
+    log.newline();
+    console.log(field("Steps", ""));
+    task.steps.forEach((step, i) => {
+      log.raw(`${String(i + 1)}. ${step}`, 2);
+    });
+  }
+  if (task.blockedBy.length > 0) {
+    log.newline();
+    console.log(field("Blocked By", ""));
+    task.blockedBy.forEach((dep) => {
+      log.item(dep);
+    });
+  }
+  showNextStep(`ralphctl task status ${task.id} in_progress`, "Start working on this task");
+}
+
+// src/commands/task/reorder.ts
+async function taskReorderCommand(args) {
+  let taskId = args[0];
+  let newOrder;
+  if (args[1]) {
+    newOrder = parseInt(args[1], 10);
+  }
+  if (!taskId) {
+    const selected = await selectTask("Select task to reorder:");
+    if (!selected) return;
+    taskId = selected;
+  }
+  if (newOrder === void 0 || isNaN(newOrder) || newOrder < 1) {
+    newOrder = await inputPositiveInt("New position (1 = highest priority):");
+  }
+  try {
+    const task = await reorderTask(taskId, newOrder);
+    showSuccess("Task reordered!", [
+      ["ID", task.id],
+      ["Name", task.name],
+      ["New Order", String(task.order)]
+    ]);
+    log.newline();
+  } catch (err) {
+    if (err instanceof TaskNotFoundError) {
+      showError(`Task not found: ${taskId}`);
+      log.newline();
+    } else if (err instanceof SprintStatusError) {
+      showError(err.message);
+      log.newline();
+    } else {
+      throw err;
+    }
+  }
+}
+
+// src/commands/task/remove.ts
+import { confirm as confirm8 } from "@inquirer/prompts";
+async function taskRemoveCommand(args) {
+  const skipConfirm = args.includes("-y") || args.includes("--yes");
+  let taskId = args.find((a) => !a.startsWith("-"));
+  if (!taskId) {
+    const selected = await selectTask("Select task to remove:");
+    if (!selected) return;
+    taskId = selected;
+  }
+  try {
+    const task = await getTask(taskId);
+    if (!skipConfirm) {
+      const confirmed = await confirm8({
+        message: `Remove task "${task.name}" (${task.id})?`,
+        default: false
+      });
+      if (!confirmed) {
+        console.log(muted("\nTask removal cancelled.\n"));
+        return;
+      }
+    }
+    await removeTask(taskId);
+    showSuccess("Task removed", [["ID", taskId]]);
+    log.newline();
+  } catch (err) {
+    if (err instanceof TaskNotFoundError) {
+      showError(`Task not found: ${taskId}`);
+      log.newline();
+    } else if (err instanceof SprintStatusError) {
+      showError(err.message);
+      log.newline();
+    } else {
+      throw err;
+    }
+  }
+}
+
+// src/commands/progress/log.ts
+async function progressLogCommand(args) {
+  try {
+    const sprintId = await resolveSprintId();
+    const sprint = await getSprint(sprintId);
+    assertSprintStatus(sprint, ["active"], "log progress");
+  } catch (err) {
+    if (err instanceof SprintStatusError) {
+      const mainError = err.message.split("\n")[0] ?? err.message;
+      showError(mainError);
+      showNextStep("ralphctl sprint start", "activate the sprint");
+      log.newline();
+      return;
+    }
+    if (err instanceof NoCurrentSprintError) {
+      showError("No current sprint set.");
+      showNextStep("ralphctl sprint create", "create a new sprint");
+      log.newline();
+      return;
+    }
+    throw err;
+  }
+  let message = args.join(" ").trim();
+  if (!message) {
+    message = await editorInput({
+      message: "Progress message:"
+    });
+    message = message.trim();
+  }
+  if (!message) {
+    showError("No message provided.");
+    log.newline();
+    return;
+  }
+  try {
+    await logProgress(message);
+    showSuccess("Progress logged.");
+    log.newline();
+  } catch (err) {
+    if (err instanceof SprintStatusError) {
+      showError(err.message);
+      log.newline();
+    } else {
+      throw err;
+    }
+  }
+}
+
+// src/commands/progress/show.ts
+async function progressShowCommand() {
+  const content = await getProgress();
+  if (!content.trim()) {
+    showEmpty("progress entries", "Log with: ralphctl progress log");
+    return;
+  }
+  printHeader("Progress Log");
+  console.log(content);
+}
+
+// src/commands/config/config.ts
+async function configSetCommand(args) {
+  if (args.length < 2) {
+    showError("Usage: ralphctl config set <key> <value>");
+    log.dim("Available keys: provider, editor");
+    log.newline();
+    return;
+  }
+  const [key, value] = args;
+  if (key === "provider") {
+    const parsed = AiProviderSchema.safeParse(value);
+    if (!parsed.success) {
+      showError(`Invalid provider: ${value ?? "(empty)"}`);
+      log.dim("Valid providers: claude, copilot");
+      log.newline();
+      return;
+    }
+    await setAiProvider(parsed.data);
+    showSuccess(`AI provider set to: ${parsed.data}`);
+    log.newline();
+    return;
+  }
+  if (key === "editor") {
+    const trimmed = value?.trim();
+    if (!trimmed) {
+      showError("Editor command cannot be empty");
+      log.dim('Examples: "subl -w", "code --wait", "vim", "nano"');
+      log.newline();
+      return;
+    }
+    await setEditor(trimmed);
+    showSuccess(`Editor set to: ${trimmed}`);
+    log.newline();
+    return;
+  }
+  showError(`Unknown config key: ${key ?? "(empty)"}`);
+  log.dim("Available keys: provider, editor");
+  log.newline();
+}
+async function configShowCommand() {
+  const provider = await getAiProvider();
+  const editorCmd = await getEditor();
+  printHeader("Configuration", icons.info);
+  console.log(field("AI Provider", provider ?? "(not set \u2014 will prompt on first use)"));
+  console.log(field("Editor", editorCmd ?? "(not set \u2014 will prompt on first use)"));
+  log.newline();
+}
+
+// src/commands/doctor/doctor.ts
+import { access, constants } from "fs/promises";
+import { join as join4 } from "path";
+import { spawnSync as spawnSync2 } from "child_process";
+var REQUIRED_NODE_MAJOR = 24;
+function checkNodeVersion() {
+  const version = process.version;
+  const match = /^v(\d+)/.exec(version);
+  const major = match ? Number(match[1]) : 0;
+  if (major >= REQUIRED_NODE_MAJOR) {
+    return { name: "Node.js version", status: "pass", detail: version };
+  }
+  return {
+    name: "Node.js version",
+    status: "fail",
+    detail: `${version} (requires >= ${String(REQUIRED_NODE_MAJOR)}.0.0)`
+  };
+}
+function checkGitInstalled() {
+  const result = spawnSync2("git", ["--version"], {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (result.status === 0) {
+    const version = result.stdout.trim();
+    return { name: "Git installed", status: "pass", detail: version };
+  }
+  return { name: "Git installed", status: "fail", detail: "git not found in PATH" };
+}
+function checkGitIdentity() {
+  const nameResult = spawnSync2("git", ["config", "user.name"], {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const emailResult = spawnSync2("git", ["config", "user.email"], {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const name = nameResult.status === 0 ? nameResult.stdout.trim() : "";
+  const email = emailResult.status === 0 ? emailResult.stdout.trim() : "";
+  if (name && email) {
+    return { name: "Git identity", status: "pass", detail: `${name} <${email}>` };
+  }
+  const missing = [];
+  if (!name) missing.push("user.name");
+  if (!email) missing.push("user.email");
+  return { name: "Git identity", status: "warn", detail: `missing: ${missing.join(", ")}` };
+}
+async function checkAiProvider() {
+  const config = await getConfig();
+  const provider = config.aiProvider;
+  if (!provider) {
+    return { name: "AI provider binary", status: "skip", detail: "not configured" };
+  }
+  const binary = provider === "claude" ? "claude" : "copilot";
+  const result = spawnSync2("which", [binary], {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (result.status === 0) {
+    return { name: "AI provider binary", status: "pass", detail: `${binary} found` };
+  }
+  return {
+    name: "AI provider binary",
+    status: "fail",
+    detail: `${binary} not found in PATH (provider: ${provider})`
+  };
+}
+function checkGlabInstalled() {
+  if (isGlabAvailable()) {
+    return { name: "GitLab CLI (glab)", status: "pass", detail: "installed" };
+  }
+  return {
+    name: "GitLab CLI (glab)",
+    status: "skip",
+    detail: "not installed (optional \u2014 needed for GitLab issue enrichment)"
+  };
+}
+async function checkDataDirectory() {
+  const dataDir = getDataDir();
+  try {
+    await access(dataDir, constants.R_OK | constants.W_OK);
+    return { name: "Data directory", status: "pass", detail: dataDir };
+  } catch {
+    return { name: "Data directory", status: "fail", detail: `${dataDir} not accessible or writable` };
+  }
+}
+async function checkProjectPaths() {
+  const projects = await listProjects();
+  if (projects.length === 0) {
+    return { name: "Project paths", status: "skip", detail: "no projects registered" };
+  }
+  const issues = [];
+  for (const project of projects) {
+    for (const repo of project.repositories) {
+      const validation = await validateProjectPath(repo.path);
+      if (validation !== true) {
+        issues.push(`${project.name}/${repo.name}: ${validation}`);
+        continue;
+      }
+      const gitDir = join4(repo.path, ".git");
+      if (!await fileExists(gitDir)) {
+        issues.push(`${project.name}/${repo.name}: not a git repository`);
+      }
+    }
+  }
+  if (issues.length === 0) {
+    const repoCount = projects.reduce((sum, p) => sum + p.repositories.length, 0);
+    return {
+      name: "Project paths",
+      status: "pass",
+      detail: `${String(repoCount)} repo${repoCount !== 1 ? "s" : ""} verified`
+    };
+  }
+  return { name: "Project paths", status: "fail", detail: issues.join("; ") };
+}
+async function checkCurrentSprint() {
+  const config = await getConfig();
+  const sprintId = config.currentSprint;
+  if (!sprintId) {
+    return { name: "Current sprint", status: "skip", detail: "no current sprint set" };
+  }
+  const sprintPath = getSprintFilePath(sprintId);
+  if (!await fileExists(sprintPath)) {
+    return { name: "Current sprint", status: "fail", detail: `sprint file missing: ${sprintId}` };
+  }
+  try {
+    const sprint = await readValidatedJson(sprintPath, SprintSchema);
+    return { name: "Current sprint", status: "pass", detail: `${sprint.name} (${sprint.status})` };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { name: "Current sprint", status: "fail", detail: `invalid sprint data: ${message}` };
+  }
+}
+async function doctorCommand() {
+  printHeader("System Health Check", icons.info);
+  const results = [];
+  results.push(checkNodeVersion());
+  results.push(checkGitInstalled());
+  results.push(checkGitIdentity());
+  results.push(checkGlabInstalled());
+  const asyncResults = await Promise.all([
+    checkAiProvider(),
+    checkDataDirectory(),
+    checkProjectPaths(),
+    checkCurrentSprint()
+  ]);
+  results.push(...asyncResults);
+  for (const result of results) {
+    if (result.status === "pass") {
+      log.success(`${result.name}${result.detail ? colors.muted(` \u2014 ${result.detail}`) : ""}`);
+    } else if (result.status === "warn") {
+      log.warn(`${result.name}${result.detail ? colors.muted(` \u2014 ${result.detail}`) : ""}`);
+    } else if (result.status === "fail") {
+      log.error(result.name);
+      if (result.detail) {
+        log.dim(`    ${result.detail}`);
+      }
+    } else {
+      log.raw(
+        `${icons.bullet}  ${colors.muted(result.name)} ${colors.muted("\u2014")} ${colors.muted(result.detail ?? "skipped")}`
+      );
+    }
+  }
+  log.newline();
+  const passed = results.filter((r) => r.status === "pass").length;
+  const warned = results.filter((r) => r.status === "warn").length;
+  const failed = results.filter((r) => r.status === "fail").length;
+  const total = results.filter((r) => r.status !== "skip").length;
+  if (failed === 0 && warned === 0) {
+    log.success(`All checks passed (${String(passed)}/${String(total)})`);
+    log.newline();
+    const quote = getQuoteForContext("success");
+    log.dim(`"${quote}"`);
+  } else if (failed === 0) {
+    log.success(
+      `${String(passed)}/${String(total)} checks passed, ${String(warned)} warning${warned !== 1 ? "s" : ""}`
+    );
+    log.newline();
+    const quote = getQuoteForContext("success");
+    log.dim(`"${quote}"`);
+  } else {
+    log.error(`${String(passed)}/${String(total)} checks passed, ${String(failed)} failed`);
+    log.newline();
+    const quote = getQuoteForContext("error");
+    log.dim(`"${quote}"`);
+    process.exitCode = EXIT_ERROR;
+  }
+  log.newline();
+}
+
+// src/interactive/index.ts
+var selectTheme = {
+  icon: { cursor: emoji.donut },
+  style: {
+    highlight: (text) => colors.highlight(text),
+    description: (text) => colors.muted(text)
+  }
+};
+var commandMap = {
+  project: {
+    add: () => projectAddCommand({ interactive: true }),
+    list: () => projectListCommand(),
+    show: () => projectShowCommand([]),
+    remove: () => projectRemoveCommand([]),
+    "repo add": () => projectRepoAddCommand([]),
+    "repo remove": () => projectRepoRemoveCommand([])
+  },
+  sprint: {
+    create: () => sprintCreateCommand({ interactive: true }),
+    list: () => sprintListCommand(),
+    show: () => sprintShowCommand([]),
+    context: () => sprintContextCommand([]),
+    current: () => sprintCurrentCommand(["-"]),
+    refine: () => sprintRefineCommand([]),
+    ideate: () => sprintIdeateCommand([]),
+    plan: () => sprintPlanCommand([]),
+    start: () => sprintStartCommand([]),
+    requirements: () => sprintRequirementsCommand([]),
+    health: () => sprintHealthCommand(),
+    close: () => sprintCloseCommand([]),
+    delete: () => sprintDeleteCommand([]),
+    "progress show": () => progressShowCommand(),
+    "progress log": () => progressLogCommand([])
+  },
+  ticket: {
+    add: () => ticketAddCommand({ interactive: true }),
+    edit: () => ticketEditCommand(void 0, { interactive: true }),
+    list: () => ticketListCommand([]),
+    show: () => ticketShowCommand([]),
+    refine: () => ticketRefineCommand(void 0, { interactive: true }),
+    remove: () => ticketRemoveCommand([])
+  },
+  task: {
+    add: () => taskAddCommand({ interactive: true }),
+    import: () => taskImportCommand([]),
+    list: () => taskListCommand([]),
+    show: () => taskShowCommand([]),
+    status: () => taskStatusCommand([]),
+    next: () => taskNextCommand(),
+    reorder: () => taskReorderCommand([]),
+    remove: () => taskRemoveCommand([])
+  },
+  progress: {
+    log: () => progressLogCommand([]),
+    show: () => progressShowCommand()
+  },
+  doctor: {
+    run: () => doctorCommand()
+  },
+  config: {
+    show: () => configShowCommand(),
+    "set provider": async () => {
+      const choice = await select3({
+        message: `${emoji.donut} Which AI buddy should help with my homework?`,
+        choices: [
+          { name: "Claude Code", value: "claude" },
+          { name: "GitHub Copilot", value: "copilot" }
+        ],
+        default: await getAiProvider() ?? void 0,
+        theme: selectTheme
+      });
+      await configSetCommand(["provider", choice]);
+    }
+  }
+};
+function showFarewell() {
+  const quote = getQuoteForContext("farewell");
+  console.log("");
+  printSeparator();
+  console.log(`  ${emoji.donut}  ${colors.muted(quote)}`);
+  console.log("");
+}
+async function pressEnterToContinue() {
+  const { createInterface } = await import("readline");
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  await new Promise((resolve3) => {
+    rl.question(colors.muted("  Press Enter to continue..."), () => {
+      rl.close();
+      resolve3();
+    });
+  });
+}
+function showWelcomeBanner() {
+  showBanner();
+}
+async function readTasksSafe(sprintId) {
+  try {
+    return await readValidatedJson(getTasksFilePath(sprintId), TasksSchema);
+  } catch {
+    return [];
+  }
+}
+async function getMenuContext() {
+  let dashboardData = null;
+  const ctx = {
+    hasProjects: false,
+    projectCount: 0,
+    currentSprintId: null,
+    currentSprintName: null,
+    currentSprintStatus: null,
+    ticketCount: 0,
+    taskCount: 0,
+    tasksDone: 0,
+    tasksInProgress: 0,
+    pendingRequirements: 0,
+    allRequirementsApproved: false,
+    plannedTicketCount: 0,
+    nextAction: null,
+    aiProvider: null
+  };
+  const [config, projects] = await Promise.all([getConfig().catch(() => null), listProjects().catch(() => [])]);
+  ctx.hasProjects = projects.length > 0;
+  ctx.projectCount = projects.length;
+  ctx.aiProvider = config?.aiProvider ?? null;
+  const sprintId = config?.currentSprint ?? null;
+  if (!sprintId) return { ctx, dashboardData };
+  ctx.currentSprintId = sprintId;
+  const [sprint, tasks] = await Promise.all([getSprint(sprintId).catch(() => null), readTasksSafe(sprintId)]);
+  if (!sprint) return { ctx, dashboardData };
+  ctx.currentSprintName = sprint.name;
+  ctx.currentSprintStatus = sprint.status;
+  ctx.ticketCount = sprint.tickets.length;
+  const pendingTickets = getPendingRequirements(sprint.tickets);
+  ctx.pendingRequirements = pendingTickets.length;
+  ctx.allRequirementsApproved = allRequirementsApproved(sprint.tickets);
+  ctx.taskCount = tasks.length;
+  ctx.tasksDone = tasks.filter((t) => t.status === "done").length;
+  ctx.tasksInProgress = tasks.filter((t) => t.status === "in_progress").length;
+  const ticketIdsWithTasks = new Set(tasks.map((t) => t.ticketId).filter(Boolean));
+  ctx.plannedTicketCount = sprint.tickets.filter((t) => ticketIdsWithTasks.has(t.id)).length;
+  const doneIds = new Set(tasks.filter((t) => t.status === "done").map((t) => t.id));
+  const blockedCount = tasks.filter(
+    (t) => t.status !== "done" && t.blockedBy.length > 0 && !t.blockedBy.every((id) => doneIds.has(id))
+  ).length;
+  dashboardData = {
+    sprint,
+    tasks,
+    approvedCount: sprint.tickets.length - pendingTickets.length,
+    pendingCount: pendingTickets.length,
+    blockedCount,
+    plannedTicketCount: ctx.plannedTicketCount,
+    aiProvider: ctx.aiProvider
+  };
+  ctx.nextAction = getNextAction(dashboardData);
+  return { ctx, dashboardData };
+}
+async function interactiveMode() {
+  let escPressed = false;
+  while (true) {
+    try {
+      const { ctx, dashboardData } = await getMenuContext();
+      clearScreen();
+      showWelcomeBanner();
+      const statusLines = renderStatusHeader(dashboardData);
+      if (statusLines.length > 0) {
+        for (const line2 of statusLines) {
+          console.log(line2);
+        }
+        log.newline();
+      }
+      const { items: mainMenu, defaultValue } = buildMainMenu(ctx);
+      const effectiveDefault = escPressed ? "exit" : defaultValue;
+      escPressed = false;
+      const command = await escapableSelect(
+        {
+          message: `${emoji.donut} What would you like to do?`,
+          choices: mainMenu,
+          default: effectiveDefault,
+          pageSize: 30,
+          loop: true,
+          theme: selectTheme
+        },
+        { escLabel: "exit" }
+      );
+      if (command === null) {
+        escPressed = true;
+        continue;
+      }
+      if (command === "exit") {
+        showFarewell();
+        break;
+      }
+      if (command.startsWith("action:")) {
+        const parts = command.split(":");
+        const group = parts[1] ?? "";
+        const subCommand = parts[2] ?? "";
+        log.newline();
+        await executeCommand(group, subCommand);
+        log.newline();
+        await pressEnterToContinue();
+        continue;
+      }
+      if (command === "wizard") {
+        const { runWizard } = await import("./wizard-LRELAN2J.mjs");
+        await runWizard();
+        continue;
+      }
+      const subMenu = buildSubMenu(command, ctx);
+      if (subMenu) {
+        await handleSubMenu(command, subMenu);
+      }
+    } catch (err) {
+      if (err.name === "ExitPromptError") {
+        showFarewell();
+        break;
+      }
+      throw err;
+    }
+  }
+}
+async function handleSubMenu(commandGroup, initialSubMenu) {
+  let currentTitle = initialSubMenu.title;
+  let currentItems = initialSubMenu.items;
+  while (true) {
+    try {
+      log.newline();
+      const subCommand = await escapableSelect({
+        message: `${emoji.donut} ${currentTitle}`,
+        choices: currentItems,
+        pageSize: 30,
+        loop: true,
+        theme: selectTheme
+      });
+      if (subCommand === null || subCommand === "back") {
+        break;
+      }
+      log.newline();
+      await executeCommand(commandGroup, subCommand);
+      log.newline();
+      if (isWorkflowAction(commandGroup, subCommand)) {
+        break;
+      }
+      const { ctx: refreshedCtx } = await getMenuContext();
+      const refreshedMenu = buildSubMenu(commandGroup, refreshedCtx);
+      if (refreshedMenu) {
+        currentTitle = refreshedMenu.title;
+        currentItems = refreshedMenu.items;
+      }
+    } catch (err) {
+      if (err.name === "ExitPromptError") {
+        break;
+      }
+      throw err;
+    }
+  }
+}
+async function executeCommand(group, subCommand) {
+  const groupHandlers = commandMap[group];
+  const handler = groupHandlers?.[subCommand];
+  if (!handler) {
+    log.error(`Unknown command: ${group} ${subCommand}`);
+    return;
+  }
+  try {
+    await handler();
+  } catch (err) {
+    if (err instanceof Error) {
+      log.error(err.message);
+    }
+  }
+}
+
+// src/commands/project/index.ts
+function registerProjectCommands(program2) {
+  const project = program2.command("project").description("Manage projects");
+  project.addHelpText(
+    "after",
+    `
+Examples:
+  $ ralphctl project add --name api --display-name "API Server" --path ~/code/api
+  $ ralphctl project list
+  $ ralphctl project show api
+  $ ralphctl project repo add api ~/code/api-v2
+`
+  );
+  project.command("add").description("Add/update project").option("--name <name>", "Slug (lowercase, numbers, hyphens)").option("--display-name <name>", "Human-readable name").option("--path <path...>", "Repository path (repeatable)").option("--description <desc>", "Optional description").option("--check-script <cmd>", "Check command (install + verify)").option("-n, --no-interactive", "Non-interactive mode (error on missing params)").action(
+    async (opts) => {
+      await projectAddCommand({
+        name: opts.name,
+        displayName: opts.displayName,
+        paths: opts.path,
+        description: opts.description,
+        checkScript: opts.checkScript,
+        // --no-interactive sets interactive=false, otherwise true (prompt for missing)
+        interactive: opts.interactive !== false
+      });
+    }
+  );
+  project.command("list").description("List all projects").action(projectListCommand);
+  project.command("show [name]").description("Show project details").action(async (name) => {
+    await projectShowCommand(name ? [name] : []);
+  });
+  project.command("remove [name]").description("Remove a project").option("-y, --yes", "Skip confirmation").action(async (name, opts) => {
+    const args = [];
+    if (name) args.push(name);
+    if (opts?.yes) args.push("-y");
+    await projectRemoveCommand(args);
+  });
+  const repo = project.command("repo").description("Manage project repositories");
+  repo.addHelpText(
+    "after",
+    `
+Examples:
+  $ ralphctl project repo add my-app ~/code/new-service
+  $ ralphctl project repo remove my-app ~/code/old-service
+`
+  );
+  repo.command("add [name] [path]").description("Add repository to project").action(async (name, pathArg) => {
+    const args = [];
+    if (name) args.push(name);
+    if (pathArg) args.push(pathArg);
+    await projectRepoAddCommand(args);
+  });
+  repo.command("remove [name] [path]").description("Remove repository from project").option("-y, --yes", "Skip confirmation").action(async (name, pathArg, opts) => {
+    const args = [];
+    if (name) args.push(name);
+    if (pathArg) args.push(pathArg);
+    if (opts?.yes) args.push("-y");
+    await projectRepoRemoveCommand(args);
+  });
+}
+
+// src/commands/sprint/switch.ts
+async function sprintSwitchCommand() {
+  const selectedId = await selectSprint("Select sprint to switch to:");
+  if (!selectedId) return;
+  await setCurrentSprint(selectedId);
+  const sprint = await getSprint(selectedId);
+  showSuccess("Switched to sprint!", [
+    ["ID", sprint.id],
+    ["Name", sprint.name]
+  ]);
+  log.newline();
+}
+
+// src/commands/sprint/index.ts
+function registerSprintCommands(program2) {
+  const sprint = program2.command("sprint").description("Manage sprints");
+  sprint.addHelpText(
+    "after",
+    `
+Examples:
+  $ ralphctl sprint create --name "Sprint 1"
+  $ ralphctl sprint refine              # Refine ticket requirements with AI
+  $ ralphctl sprint plan --auto         # Generate tasks automatically
+  $ ralphctl sprint start -s            # Start with interactive session
+`
+  );
+  sprint.command("create").description("Create a new sprint").option("--name <name>", "Sprint name").option("-n, --no-interactive", "Non-interactive mode (error on missing params)").action(async (opts) => {
+    await sprintCreateCommand({
+      name: opts.name,
+      // --no-interactive sets interactive=false, otherwise true (prompt for missing)
+      interactive: opts.interactive !== false
+    });
+  });
+  sprint.command("list").description("List all sprints").option("--status <status>", "Filter by status (draft, active, closed)").action(async (opts) => {
+    const args = [];
+    if (opts.status) args.push("--status", opts.status);
+    await sprintListCommand(args);
+  });
+  sprint.command("show [id]").description("Show sprint details").action(async (id) => {
+    await sprintShowCommand(id ? [id] : []);
+  });
+  sprint.command("context [id]").description("Output full context for planning").action(async (id) => {
+    await sprintContextCommand(id ? [id] : []);
+  });
+  sprint.command("current [id]").description('Show/set current sprint (use "-" to open selector)').action(async (id) => {
+    await sprintCurrentCommand(id ? [id] : []);
+  });
+  sprint.command("switch").description("Quick sprint switcher (opens selector)").action(async () => {
+    await sprintSwitchCommand();
+  });
+  sprint.command("refine [id]").description("Refine ticket specifications").option("--project <name>", "Only refine tickets for specific project").action(async (id, opts) => {
+    const args = [];
+    if (id) args.push(id);
+    if (opts?.project) args.push("--project", opts.project);
+    await sprintRefineCommand(args);
+  });
+  sprint.command("ideate [id]").description("Quick idea to tasks (refine + plan in one session)").option("--auto", "Run without user interaction (AI decides autonomously)").option("--all-paths", "Explore all project repositories instead of prompting for selection").option("--project <name>", "Pre-select project (skip interactive selection)").action(async (id, opts) => {
+    const args = [];
+    if (id) args.push(id);
+    if (opts?.auto) args.push("--auto");
+    if (opts?.allPaths) args.push("--all-paths");
+    if (opts?.project) args.push("--project", opts.project);
+    await sprintIdeateCommand(args);
+  });
+  sprint.command("plan [id]").description("Generate tasks using AI CLI").option("--auto", "Run without user interaction (AI decides autonomously)").option("--all-paths", "Explore all project repositories instead of prompting for selection").action(async (id, opts) => {
+    const args = [];
+    if (id) args.push(id);
+    if (opts?.auto) args.push("--auto");
+    if (opts?.allPaths) args.push("--all-paths");
+    await sprintPlanCommand(args);
+  });
+  sprint.command("close [id]").description("Close an active sprint").option("--create-pr", "Create pull requests for sprint branches").action(async (id, opts) => {
+    const args = [];
+    if (id) args.push(id);
+    if (opts?.createPr) args.push("--create-pr");
+    await sprintCloseCommand(args);
+  });
+  sprint.command("delete [id]").description("Delete a sprint permanently").option("-y, --yes", "Skip confirmation").action(async (id, opts) => {
+    const args = [];
+    if (id) args.push(id);
+    if (opts?.yes) args.push("-y");
+    await sprintDeleteCommand(args);
+  });
+  sprint.command("requirements [id]").description("Export refined requirements to file").action(async (id) => {
+    await sprintRequirementsCommand(id ? [id] : []);
+  });
+  sprint.command("health").description("Check sprint health").action(async () => {
+    await sprintHealthCommand();
+  });
+  sprint.command("start [id]").description("Run automated implementation loop").option("-s, --session", "Interactive AI session (collaborate with your AI provider)").option("-t, --step", "Step through tasks with approval between each").option("-c, --count <n>", "Limit to N tasks").option("--no-commit", "Skip automatic git commit after each task completes").option("--concurrency <n>", "Max parallel tasks (default: auto based on unique repos)").option("--max-retries <n>", "Max rate-limit retries per task (default: 5)").option("--fail-fast", "Stop launching new tasks on first failure").option("-f, --force", "Skip precondition checks (e.g., unplanned tickets)").option("--refresh-check", "Force re-run check scripts even if they already ran this sprint").option("-b, --branch", "Create sprint branch (ralphctl/<sprint-id>) in all repos").option("--branch-name <name>", "Use a custom branch name for sprint execution").addHelpText(
+    "after",
+    `
+Exit Codes:
+  0 - Success (all requested operations completed)
+  1 - Error (validation, missing params, execution failed)
+  2 - No tasks available
+  3 - All remaining tasks blocked by dependencies
+
+Parallel Execution:
+  Tasks targeting different repos run concurrently by default.
+  At most one task per repository runs at a time to avoid git conflicts.
+  Use --concurrency 1 to force sequential execution.
+  Session (--session) and step (--step) modes always run sequentially.
+
+Branch Management:
+  Use -b/--branch to auto-create a sprint branch in all repos.
+  Use --branch-name <name> to specify a custom branch name.
+  On first run, an interactive prompt offers branch strategy selection.
+  The chosen branch is persisted and reused on subsequent runs.
+`
+  ).action(
+    async (id, opts) => {
+      const args = [];
+      if (id) args.push(id);
+      if (opts?.session) args.push("--session");
+      if (opts?.step) args.push("--step");
+      if (opts?.count) args.push("--count", opts.count);
+      if (opts?.commit === false) args.push("--no-commit");
+      if (opts?.concurrency) args.push("--concurrency", opts.concurrency);
+      if (opts?.maxRetries) args.push("--max-retries", opts.maxRetries);
+      if (opts?.failFast) args.push("--fail-fast");
+      if (opts?.force) args.push("--force");
+      if (opts?.refreshCheck) args.push("--refresh-check");
+      if (opts?.branch) args.push("--branch");
+      if (opts?.branchName) args.push("--branch-name", opts.branchName);
+      await sprintStartCommand(args);
+    }
+  );
+}
+
+// src/commands/task/index.ts
+function registerTaskCommands(program2) {
+  const task = program2.command("task").description("Manage tasks");
+  task.addHelpText(
+    "after",
+    `
+Examples:
+  $ ralphctl task add --name "Implement login" --ticket abc123
+  $ ralphctl task list
+  $ ralphctl task status abc123 done
+  $ ralphctl task next
+`
+  );
+  task.command("add").description("Add task to current sprint").option("--name <name>", "Task name").option("-d, --description <desc>", "Description").option("--step <step...>", "Implementation step (repeatable)").option("--ticket <id>", "Link to ticket ID").option("-p, --project <path>", "Project path").option("-n, --no-interactive", "Non-interactive mode (error on missing params)").action(
+    async (opts) => {
+      await taskAddCommand({
+        name: opts.name,
+        description: opts.description,
+        steps: opts.step,
+        ticket: opts.ticket,
+        project: opts.project,
+        // --no-interactive sets interactive=false, otherwise true (prompt for missing)
+        interactive: opts.interactive !== false
+      });
+    }
+  );
+  task.command("import <file>").description("Import tasks from JSON file").action(async (file) => {
+    await taskImportCommand([file]);
+  });
+  task.command("list").description("List tasks").option("-b, --brief", "Brief format").option("--status <status>", "Filter by status (todo, in_progress, done)").option("--project <name>", "Filter by project path").option("--ticket <id>", "Filter by ticket ID").option("--blocked", "Show only blocked tasks").action(
+    async (opts) => {
+      const args = [];
+      if (opts.brief) args.push("-b");
+      if (opts.status) args.push("--status", opts.status);
+      if (opts.project) args.push("--project", opts.project);
+      if (opts.ticket) args.push("--ticket", opts.ticket);
+      if (opts.blocked) args.push("--blocked");
+      await taskListCommand(args);
+    }
+  );
+  task.command("show [id]").description("Show task details").action(async (id) => {
+    await taskShowCommand(id ? [id] : []);
+  });
+  task.command("remove [id]").description("Remove a task").option("-y, --yes", "Skip confirmation").action(async (id, opts) => {
+    const args = [];
+    if (id) args.push(id);
+    if (opts?.yes) args.push("-y");
+    await taskRemoveCommand(args);
+  });
+  task.command("status [id] [status]").description("Update task status (todo/in_progress/done)").option("-n, --no-interactive", "Non-interactive mode (exit with error codes)").action(async (id, status, opts) => {
+    await taskStatusCommand([], {
+      taskId: id,
+      status,
+      noInteractive: opts?.interactive === false
+    });
+  });
+  task.command("next").description("Get next task").action(taskNextCommand);
+  task.command("reorder [id] [position]").description("Change task priority").action(async (id, position) => {
+    const args = [];
+    if (id) args.push(id);
+    if (position) args.push(position);
+    await taskReorderCommand(args);
+  });
+}
+
+// src/commands/ticket/index.ts
+function registerTicketCommands(program2) {
+  const ticket = program2.command("ticket").description("Manage tickets");
+  ticket.addHelpText(
+    "after",
+    `
+Examples:
+  $ ralphctl ticket add --project api --title "Fix auth bug"
+  $ ralphctl ticket edit abc123 --title "New title"
+  $ ralphctl ticket list -b
+  $ ralphctl ticket show abc123
+`
+  );
+  ticket.command("add").description("Add ticket to current sprint").option("-p, --project <name>", "Project name").option("-t, --title <title>", "Ticket title").option("-d, --description <desc>", "Description").option("--link <url>", "Link to external issue").option("-n, --no-interactive", "Non-interactive mode (error on missing params)").action(
+    async (opts) => {
+      await ticketAddCommand({
+        project: opts.project,
+        title: opts.title,
+        description: opts.description,
+        link: opts.link,
+        // --no-interactive sets interactive=false, otherwise true (prompt for missing)
+        interactive: opts.interactive !== false
+      });
+    }
+  );
+  ticket.command("edit [id]").description("Edit an existing ticket").option("--title <title>", "New title").option("--description <desc>", "New description").option("--link <url>", "New link").option("-n, --no-interactive", "Non-interactive mode").action(
+    async (id, opts) => {
+      await ticketEditCommand(id, {
+        title: opts?.title,
+        description: opts?.description,
+        link: opts?.link,
+        interactive: opts?.interactive !== false
+      });
+    }
+  );
+  ticket.command("list").description("List tickets").option("-b, --brief", "Brief one-liner format").option("--project <name>", "Filter by project").option("--status <status>", "Filter by requirement status (pending, approved)").action(async (opts) => {
+    const args = [];
+    if (opts.brief) args.push("-b");
+    if (opts.project) args.push("--project", opts.project);
+    if (opts.status) args.push("--status", opts.status);
+    await ticketListCommand(args);
+  });
+  ticket.command("show [id]").description("Show ticket details").action(async (id) => {
+    await ticketShowCommand(id ? [id] : []);
+  });
+  ticket.command("refine [id]").description("Re-refine an approved ticket").action(async (id) => {
+    await ticketRefineCommand(id);
+  });
+  ticket.command("remove [id]").description("Remove a ticket").option("-y, --yes", "Skip confirmation").action(async (id, opts) => {
+    const args = [];
+    if (id) args.push(id);
+    if (opts?.yes) args.push("-y");
+    await ticketRemoveCommand(args);
+  });
+}
+
+// src/commands/progress/index.ts
+function registerProgressCommands(program2) {
+  const progress = program2.command("progress").description("Log and view progress");
+  progress.addHelpText(
+    "after",
+    `
+Examples:
+  $ ralphctl progress log "Completed auth flow"
+  $ ralphctl progress show
+`
+  );
+  progress.command("log [message]").description("Append to progress log (opens editor if no message)").action(async (message) => {
+    await progressLogCommand(message ? [message] : []);
+  });
+  progress.command("show").description("Display progress log").action(progressShowCommand);
+}
+
+// src/commands/dashboard/dashboard.ts
+async function dashboardCommand() {
+  await showDashboard();
+}
+
+// src/commands/dashboard/index.ts
+function registerDashboardCommands(program2) {
+  program2.command("status").description("Show current sprint overview").action(dashboardCommand);
+}
+
+// src/commands/config/index.ts
+function registerConfigCommands(program2) {
+  const config = program2.command("config").description("Manage configuration");
+  config.addHelpText(
+    "after",
+    `
+Examples:
+  $ ralphctl config show                    # Show current configuration
+  $ ralphctl config set provider claude     # Use Claude Code
+  $ ralphctl config set provider copilot    # Use GitHub Copilot
+  $ ralphctl config set editor "subl -w"    # Use Sublime Text for multiline input
+  $ ralphctl config set editor "code --wait"  # Use VS Code for multiline input
+  $ ralphctl config set editor vim          # Use Vim for multiline input
+`
+  );
+  config.command("show").description("Show current configuration").action(async () => {
+    await configShowCommand();
+  });
+  config.command("set <key> <value>").description("Set a configuration value").action(async (key, value) => {
+    await configSetCommand([key, value]);
+  });
+}
+
+// src/commands/completion/index.ts
+function registerCompletionCommands(program2) {
+  const completion = program2.command("completion").description("Manage shell tab-completion");
+  completion.addHelpText(
+    "after",
+    `
+Examples:
+  $ ralphctl completion install       # Enable tab-completion for your shell
+  $ ralphctl completion uninstall     # Remove tab-completion
+`
+  );
+  completion.command("install").description("Install shell tab-completion (bash, zsh, fish)").action(async () => {
+    const tabtab = (await import("tabtab")).default;
+    await tabtab.install({ name: "ralphctl", completer: "ralphctl" });
+    showSuccess("Shell completion installed. Restart your shell or source your profile to activate.");
+  });
+  completion.command("uninstall").description("Remove shell tab-completion").action(async () => {
+    const tabtab = (await import("tabtab")).default;
+    await tabtab.uninstall({ name: "ralphctl" });
+    showSuccess("Shell completion removed.");
+  });
+}
+
+// src/commands/doctor/index.ts
+function registerDoctorCommands(program2) {
+  program2.command("doctor").description("Check environment health and diagnose setup issues").addHelpText(
+    "after",
+    `
+Examples:
+  $ ralphctl doctor                         # Run all health checks
+
+Checks performed:
+  - Node.js version (>= 24)
+  - Git installation and identity
+  - AI provider binary (claude or copilot)
+  - Data directory accessibility
+  - Project repository paths
+  - Current sprint validity`
+  ).action(async () => {
+    await doctorCommand();
+  });
+}
+
+// package.json
+var package_default = {
+  name: "ralphctl",
+  version: "0.1.2",
+  description: "Sprint and task management CLI for AI-assisted coding",
+  homepage: "https://github.com/lukas-grigis/ralphctl",
+  type: "module",
+  license: "MIT",
+  author: "Lukas Grigis",
+  repository: {
+    type: "git",
+    url: "https://github.com/lukas-grigis/ralphctl.git"
+  },
+  bugs: {
+    url: "https://github.com/lukas-grigis/ralphctl/issues"
+  },
+  keywords: [
+    "cli",
+    "claude",
+    "ai",
+    "sprint",
+    "task-management",
+    "planning",
+    "anthropic",
+    "developer-tools"
+  ],
+  bin: {
+    ralphctl: "./dist/cli.mjs"
+  },
+  files: [
+    "dist/",
+    "schemas/"
+  ],
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    build: "tsup && mkdir -p dist/prompts && cp src/ai/prompts/*.md dist/prompts/",
+    prepublishOnly: "pnpm build",
+    dev: "tsx src/cli.ts",
+    lint: "eslint .",
+    "lint:fix": "eslint . --fix",
+    format: "prettier --write .",
+    "format:check": "prettier --check .",
+    typecheck: "tsc --noEmit",
+    test: "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    prepare: "husky"
+  },
+  packageManager: "pnpm@10.29.3",
+  engines: {
+    node: ">=24.0.0"
+  },
+  dependencies: {
+    "@inquirer/prompts": "^8.3.0",
+    colorette: "^2.0.20",
+    commander: "^14.0.3",
+    "gradient-string": "^3.0.0",
+    ora: "^9.3.0",
+    tabtab: "^3.0.2",
+    zod: "^4.3.6"
+  },
+  devDependencies: {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^25.3.3",
+    "@types/tabtab": "^3.0.4",
+    eslint: "^10.0.2",
+    "eslint-config-prettier": "^10.1.8",
+    globals: "^17.4.0",
+    husky: "^9.1.7",
+    "lint-staged": "^16.3.1",
+    prettier: "^3.8.1",
+    tsup: "^8.5.1",
+    tsx: "^4.21.0",
+    typescript: "^5.9.3",
+    "typescript-eslint": "^8.56.1",
+    vitest: "^4.0.18"
+  },
+  "lint-staged": {
+    "*.ts": [
+      "eslint --cache --fix",
+      "prettier --write"
+    ],
+    "*.{md,json,yml,yaml}": "prettier --write"
+  }
+};
+
+// src/cli-metadata.ts
+var cliMetadata = {
+  name: "ralphctl",
+  version: package_default.version,
+  description: "I'm helping! Plan sprints and execute tasks with AI"
+};
+
+// src/cli.ts
+var program = new Command();
+program.name(cliMetadata.name).description(cliMetadata.description).version(cliMetadata.version).addHelpText(
+  "after",
+  `
+Examples:
+  $ ralphctl                              # Interactive mode
+  $ ralphctl status                       # Show current sprint status
+  $ ralphctl sprint create --name "v1.0"  # Create sprint
+  $ ralphctl ticket add --project api     # Add ticket
+  $ ralphctl task list -b                 # Brief task list
+
+Run any command with --help for details.
+`
+);
+registerProjectCommands(program);
+registerSprintCommands(program);
+registerTaskCommands(program);
+registerTicketCommands(program);
+registerProgressCommands(program);
+registerDashboardCommands(program);
+registerConfigCommands(program);
+registerCompletionCommands(program);
+registerDoctorCommands(program);
+async function main() {
+  if (process.env["COMP_CWORD"] && process.env["COMP_POINT"] && process.env["COMP_LINE"]) {
+    const { handleCompletionRequest } = await import("./handle-UG5M2OON.mjs");
+    if (await handleCompletionRequest(program)) return;
+  }
+  if (process.argv.length <= 2 || process.argv[2] === "interactive") {
+    await interactiveMode();
+  } else {
+    showBanner();
+    await program.parseAsync(process.argv);
+  }
+}
+main().catch((err) => {
+  console.error(error("Fatal error:"), err);
+  process.exit(1);
+});