ralphctl 0.1.2 → 0.1.4

package/dist/cli.mjs

@@ -2,9 +2,8 @@
 import {
   addCheckScriptToRepository,
   projectAddCommand
-} from "./chunk-MRKOFVTM.mjs";
+} from "./chunk-YIB7QYU4.mjs";
 import {
-  TaskNotFoundError,
   addTask,
   areAllTasksDone,
   branchExists,
@@ -50,16 +49,14 @@ import {
   sprintStartCommand,
   updateTaskStatus,
   validateImportTasks
-} from "./chunk-LOR7QBXX.mjs";
+} from "./chunk-M7JV6MKD.mjs";
 import {
   escapableSelect
-} from "./chunk-NTWO2LXB.mjs";
+} from "./chunk-7LZ6GOGN.mjs";
 import {
   sprintCreateCommand
-} from "./chunk-JON4GCLR.mjs";
+} from "./chunk-DZ6HHTM5.mjs";
 import {
-  IssueFetchError,
-  TicketNotFoundError,
   addTicket,
   allRequirementsApproved,
   editorInput,
@@ -73,23 +70,19 @@ import {
   removeTicket,
   ticketAddCommand,
   updateTicket
-} from "./chunk-MNMQC36F.mjs";
+} from "./chunk-F2MMCTB5.mjs";
 import {
   EXIT_ERROR,
   exitWithCode
 } from "./chunk-7TG3EAQ2.mjs";
 import {
-  ProjectNotFoundError,
   addProjectRepo,
   getProject,
   listProjects,
   removeProject,
   removeProjectRepo
-} from "./chunk-WGHJI3OI.mjs";
+} from "./chunk-PDI6HBZ7.mjs";
 import {
-  NoCurrentSprintError,
-  SprintNotFoundError,
-  SprintStatusError,
   assertSprintStatus,
   closeSprint,
   deleteSprint,
@@ -108,7 +101,11 @@ import {
   setCurrentSprint,
   setEditor,
   withFileLock
-} from "./chunk-EKMZZRWI.mjs";
+} from "./chunk-LFDW6MWF.mjs";
+import {
+  ensureError,
+  wrapAsync
+} from "./chunk-OEUJDSHY.mjs";
 import {
   AiProviderSchema,
   IdeateOutputSchema,
@@ -130,7 +127,16 @@ import {
   getTasksFilePath,
   readValidatedJson,
   validateProjectPath
-} from "./chunk-6PYTKGB5.mjs";
+} from "./chunk-W3TY22IS.mjs";
+import {
+  DomainError,
+  NoCurrentSprintError,
+  ProjectNotFoundError,
+  SprintNotFoundError,
+  SprintStatusError,
+  TaskNotFoundError,
+  TicketNotFoundError
+} from "./chunk-EDJX7TT6.mjs";
 import {
   DETAIL_LABEL_WIDTH,
   badge,
@@ -433,7 +439,7 @@ function buildSubMenu(group, ctx) {
 async function loadDashboardData() {
   const sprintId = await getCurrentSprint();
   if (!sprintId) return null;
-  try {
+  const r = await wrapAsync(async () => {
     const sprint = await getSprint(sprintId);
     const tasks = await getTasks(sprintId);
     const pendingTickets = getPendingRequirements(sprint.tickets);
@@ -447,9 +453,8 @@ async function loadDashboardData() {
     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;
-  }
+  }, ensureError);
+  return r.ok ? r.value : null;
 }
 function getNextAction(data) {
   const { sprint, tasks, pendingCount, approvedCount } = data;
@@ -640,34 +645,35 @@ async function projectShowCommand(args) {
     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) {
+  const projectR = await wrapAsync(() => getProject(projectName), ensureError);
+  if (!projectR.ok) {
+    if (projectR.error instanceof ProjectNotFoundError) {
+      showError(`Project not found: ${projectName}`);
       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));
+    } else {
+      throw projectR.error;
     }
+    return;
+  }
+  const project = projectR.value;
+  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();
-  } catch (err) {
-    if (err instanceof ProjectNotFoundError) {
-      showError(`Project not found: ${projectName}`);
-      log.newline();
+    const repoLines = [labelValue("Path", repo.path)];
+    if (repo.checkScript) {
+      repoLines.push(labelValue("Check", colors.info(repo.checkScript)));
     } else {
-      throw err;
+      repoLines.push(muted("No check script configured"));
     }
+    console.log(renderCard(`  ${repo.name}`, repoLines));
   }
+  log.newline();
 }
 
 // src/commands/project/remove.ts
@@ -680,29 +686,30 @@ async function projectRemoveCommand(args) {
     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) {
+  const projectR = await wrapAsync(() => getProject(projectName), ensureError);
+  if (!projectR.ok) {
+    if (projectR.error instanceof ProjectNotFoundError) {
       showError(`Project not found: ${projectName}`);
       console.log("");
     } else {
-      throw err;
+      throw projectR.error;
+    }
+    return;
+  }
+  const project = projectR.value;
+  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("");
 }
 
 // src/commands/project/repo.ts
@@ -720,31 +727,28 @@ async function projectRepoAddCommand(args) {
     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(`
+  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) {
+  const repoWithScripts = await addCheckScriptToRepository(bareRepo);
+  const addR = await wrapAsync(() => addProjectRepo(projectName, repoWithScripts), ensureError);
+  if (!addR.ok) {
+    if (addR.error instanceof ProjectNotFoundError) {
       showError(`Project not found: ${projectName}`);
-      log.newline();
-    } else if (err instanceof Error) {
-      showError(err.message);
-      log.newline();
     } else {
-      throw err;
+      showError(addR.error.message);
     }
+    log.newline();
+    return;
+  }
+  showSuccess("Repository added", [["Project", projectName]]);
+  log.newline();
+  log.info("Current repositories:");
+  for (const repo of addR.value.repositories) {
+    log.item(`${repo.name} \u2192 ${repo.path}`);
   }
+  log.newline();
 }
 async function projectRepoRemoveCommand(args) {
   const skipConfirm = args.includes("-y") || args.includes("--yes");
@@ -756,50 +760,57 @@ async function projectRepoRemoveCommand(args) {
     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 projectR = await wrapAsync(() => getProject(projectName), ensureError);
+  if (!projectR.ok) {
+    if (projectR.error instanceof ProjectNotFoundError) {
+      showError(`Project not found: ${projectName}`);
+    } else {
+      showError(projectR.error.message);
     }
-    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}`);
+    return;
+  }
+  const project = projectR.value;
+  if (!path) {
+    if (project.repositories.length === 0) {
+      console.log(muted("\nNo repositories to remove.\n"));
+      return;
     }
-    log.newline();
-  } catch (err) {
-    if (err instanceof ProjectNotFoundError) {
+    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 removeR = await wrapAsync(() => removeProjectRepo(projectName, path), ensureError);
+  if (!removeR.ok) {
+    if (removeR.error instanceof ProjectNotFoundError) {
       showError(`Project not found: ${projectName}`);
-      log.newline();
-    } else if (err instanceof Error) {
-      showError(err.message);
-      log.newline();
     } else {
-      throw err;
+      showError(removeR.error.message);
     }
+    log.newline();
+    return;
   }
+  showSuccess("Repository removed", [["Project", projectName]]);
+  log.newline();
+  log.info("Remaining repositories:");
+  for (const repo of removeR.value.repositories) {
+    log.item(`${repo.name} \u2192 ${repo.path}`);
+  }
+  log.newline();
 }
 
 // src/commands/sprint/list.ts
@@ -864,12 +875,13 @@ async function sprintListCommand(args = []) {
 async function sprintShowCommand(args) {
   const sprintId = args[0];
   let id;
-  try {
-    id = await resolveSprintId(sprintId);
-  } catch {
+  const idR = await wrapAsync(() => resolveSprintId(sprintId), ensureError);
+  if (!idR.ok) {
     const selected = await selectSprint("Select sprint to show:");
     if (!selected) return;
     id = selected;
+  } else {
+    id = idR.value;
   }
   const sprint = await getSprint(id);
   const tasks = await listTasks(id);
@@ -961,9 +973,8 @@ async function sprintShowCommand(args) {
 async function sprintContextCommand(args) {
   const sprintId = args[0];
   let id;
-  try {
-    id = await resolveSprintId(sprintId);
-  } catch {
+  const idR = await wrapAsync(() => resolveSprintId(sprintId), ensureError);
+  if (!idR.ok) {
     const selected = await selectSprint("Select sprint to show context for:");
     if (!selected) {
       showWarning("No sprints available.");
@@ -972,6 +983,8 @@ async function sprintContextCommand(args) {
       return;
     }
     id = selected;
+  } else {
+    id = idR.value;
   }
   const sprint = await getSprint(id);
   const tasks = await listTasks(id);
@@ -987,11 +1000,11 @@ async function sprintContextCommand(args) {
     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})`);
+      const projectR = await wrapAsync(() => getProject(projectName), ensureError);
+      if (projectR.ok) {
+        const repoPaths = projectR.value.repositories.map((r) => `${r.name} (${r.path})`);
         console.log(`Repositories: ${repoPaths.join(", ")}`);
-      } catch {
+      } else {
         console.log("Repositories: (project not found)");
       }
       console.log("");
@@ -1055,14 +1068,14 @@ async function sprintCurrentCommand(args) {
       log.newline();
       return;
     }
-    try {
-      const sprint = await getSprint(currentSprintId);
+    const sprintR = await wrapAsync(() => getSprint(currentSprintId), ensureError);
+    if (sprintR.ok) {
       printHeader("Current Sprint");
-      console.log(field("ID", sprint.id));
-      console.log(field("Name", sprint.name));
-      console.log(field("Status", formatSprintStatus(sprint.status)));
+      console.log(field("ID", sprintR.value.id));
+      console.log(field("Name", sprintR.value.name));
+      console.log(field("Status", formatSprintStatus(sprintR.value.status)));
       log.newline();
-    } catch {
+    } else {
       showWarning(`Current sprint "${currentSprintId}" no longer exists.`);
       showNextStep("ralphctl sprint current -", "select a different sprint");
       log.newline();
@@ -1080,22 +1093,23 @@ async function sprintCurrentCommand(args) {
     ]);
     log.newline();
   } else {
-    try {
+    const setR = await wrapAsync(async () => {
       const sprint = await getSprint(sprintId);
       await setCurrentSprint(sprintId);
+      return sprint;
+    }, ensureError);
+    if (setR.ok) {
       showSuccess("Current sprint set!", [
-        ["ID", sprint.id],
-        ["Name", sprint.name]
+        ["ID", setR.value.id],
+        ["Name", setR.value.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;
-      }
+    } else if (setR.error instanceof SprintNotFoundError) {
+      showError(`Sprint not found: ${sprintId}`);
+      showNextStep("ralphctl sprint list", "see available sprints");
+      log.newline();
+    } else {
+      throw setR.error;
     }
   }
 }
@@ -1104,6 +1118,7 @@ async function sprintCurrentCommand(args) {
 import { mkdir, readFile, writeFile } from "fs/promises";
 import { join } from "path";
 import { input as input2, select as select2 } from "@inquirer/prompts";
+import { Result } from "typescript-result";
 function parseArgs(args) {
   const options = {
     auto: false,
@@ -1163,13 +1178,11 @@ async function invokeAiAuto(prompt, repoPaths, ideateDir) {
 }
 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 parseR = Result.try(() => JSON.parse(jsonStr));
+  if (!parseR.ok) {
+    throw new Error(`Invalid JSON: ${parseR.error.message}`, { cause: parseR.error });
   }
-  const result = IdeateOutputSchema.safeParse(parsed);
+  const result = IdeateOutputSchema.safeParse(parseR.value);
   if (!result.success) {
     const issues = result.error.issues.map((issue) => {
       const path = issue.path.length > 0 ? `[${issue.path.join(".")}]` : "";
@@ -1182,23 +1195,20 @@ ${issues}`);
 }
 async function sprintIdeateCommand(args) {
   const { sprintId, options } = parseArgs(args);
-  let id;
-  try {
-    id = await resolveSprintId(sprintId);
-  } catch {
+  const idR = await wrapAsync(() => resolveSprintId(sprintId), ensureError);
+  if (!idR.ok) {
     showWarning("No sprint specified and no current sprint set.");
     showNextStep("ralphctl sprint create", "create a new sprint");
     log.newline();
     return;
   }
+  const id = idR.value;
   const sprint = await getSprint(id);
   try {
     assertSprintStatus(sprint, ["draft"], "ideate");
   } catch (err) {
-    if (err instanceof Error) {
-      showError(err.message);
-      log.newline();
-    }
+    showError(err instanceof Error ? err.message : String(err));
+    log.newline();
     return;
   }
   const projects = await listProjects();
@@ -1230,21 +1240,26 @@ async function sprintIdeateCommand(args) {
     log.newline();
     return;
   }
-  let project;
-  try {
-    project = await getProject(projectName);
-  } catch {
+  const projectR = await wrapAsync(() => getProject(projectName), ensureError);
+  if (!projectR.ok) {
     showError(`Project '${projectName}' not found.`);
     log.newline();
     return;
   }
+  const project = projectR.value;
   const ideaTitle = await input2({
     message: "Idea title (short summary):",
     validate: (value) => value.trim().length > 0 ? true : "Title is required"
   });
-  const ideaDescription = await editorInput({
+  const editorR = await editorInput({
     message: "Idea description (what you want to build):"
   });
+  if (!editorR.ok) {
+    showError(`Editor input failed: ${editorR.error.message}`);
+    log.newline();
+    return;
+  }
+  const ideaDescription = editorR.value;
   if (!ideaDescription.trim()) {
     showError("Description is required.");
     log.newline();
@@ -1291,19 +1306,16 @@ async function sprintIdeateCommand(args) {
     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) {
+    const outputR = await wrapAsync(() => invokeAiAuto(prompt, selectedPaths, ideateDir), ensureError);
+    if (!outputR.ok) {
       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();
-      }
+      showError(`Failed to invoke ${providerName}: ${outputR.error.message}`);
+      showTip(`Make sure the ${providerName.toLowerCase()} CLI is installed and configured.`);
+      log.newline();
       return;
     }
+    spinner.succeed(`${providerName} finished`);
+    const output = outputR.value;
     const blockedReason = parsePlanningBlocked(output);
     if (blockedReason) {
       showWarning(`Planning blocked: ${blockedReason}`);
@@ -1311,18 +1323,15 @@ async function sprintIdeateCommand(args) {
       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();
-      }
+    const ideateR = Result.try(() => parseIdeateOutput(output));
+    if (!ideateR.ok) {
+      showError(`Failed to parse ${providerName} output: ${ideateR.error.message}`);
+      log.dim("Raw output:");
+      console.log(output);
+      log.newline();
       return;
     }
+    const ideateOutput = ideateR.value;
     const ticketIdx = sprint.tickets.findIndex((t) => t.id === ticket.id);
     const ticketToUpdate = sprint.tickets[ticketIdx];
     if (ticketIdx !== -1 && ticketToUpdate) {
@@ -1332,16 +1341,13 @@ async function sprintIdeateCommand(args) {
     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();
-      }
+    const parsedTasksR = Result.try(() => parseTasksJson(JSON.stringify(ideateOutput.tasks)));
+    if (!parsedTasksR.ok) {
+      showError(`Failed to parse tasks: ${parsedTasksR.error.message}`);
+      log.newline();
       return;
     }
+    const parsedTasks = parsedTasksR.value;
     if (parsedTasks.length === 0) {
       showWarning("No tasks generated.");
       log.newline();
@@ -1376,37 +1382,29 @@ async function sprintIdeateCommand(args) {
   ${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();
-      }
+    const interactiveR = await wrapAsync(() => invokeAiInteractive(prompt, selectedPaths, ideateDir), ensureError);
+    if (!interactiveR.ok) {
+      showError(`Failed to invoke ${providerName}: ${interactiveR.error.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 {
+      const contentR = await wrapAsync(() => readFile(outputFile, "utf-8"), ensureError);
+      if (!contentR.ok) {
         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();
-        }
+      const ideateR = Result.try(() => parseIdeateOutput(contentR.value));
+      if (!ideateR.ok) {
+        showError(`Failed to parse output file: ${ideateR.error.message}`);
+        log.newline();
         return;
       }
+      const ideateOutput = ideateR.value;
       const ticketIdx = sprint.tickets.findIndex((t) => t.id === ticket.id);
       const ticketToUpdate = sprint.tickets[ticketIdx];
       if (ticketIdx !== -1 && ticketToUpdate) {
@@ -1416,16 +1414,13 @@ async function sprintIdeateCommand(args) {
       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();
-        }
+      const parsedTasksR = Result.try(() => parseTasksJson(JSON.stringify(ideateOutput.tasks)));
+      if (!parsedTasksR.ok) {
+        showError(`Failed to parse tasks: ${parsedTasksR.error.message}`);
+        log.newline();
         return;
       }
+      const parsedTasks = parsedTasksR.value;
       if (parsedTasks.length === 0) {
         showWarning("No tasks in file.");
         log.newline();
@@ -1463,6 +1458,7 @@ async function sprintIdeateCommand(args) {
 // src/commands/sprint/close.ts
 import { spawnSync } from "child_process";
 import { confirm as confirm3 } from "@inquirer/prompts";
+import { Result as Result2 } from "typescript-result";
 async function sprintCloseCommand(args) {
   let sprintId;
   let createPr = false;
@@ -1510,23 +1506,13 @@ async function sprintCloseCommand(args) {
       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) {
+  const closeR = await wrapAsync(async () => {
+    const sprintBeforeClose2 = await getSprint(sprintId);
+    const sprint2 = await closeSprint(sprintId);
+    return { sprintBeforeClose: sprintBeforeClose2, sprint: sprint2 };
+  }, ensureError);
+  if (!closeR.ok) {
+    const err = closeR.error;
     if (err instanceof SprintNotFoundError) {
       showError(`Sprint not found: ${sprintId}`);
       log.newline();
@@ -1536,6 +1522,21 @@ async function sprintCloseCommand(args) {
     } else {
       throw err;
     }
+    return;
+  }
+  const { sprintBeforeClose, sprint } = closeR.value;
+  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();
   }
 }
 async function createPullRequests(sprintId, branchName, sprintName) {
@@ -1548,59 +1549,62 @@ async function createPullRequests(sprintId, branchName, sprintName) {
   const tasks = await listTasks(sprintId);
   const uniquePaths = [...new Set(tasks.map((t) => t.projectPath))];
   for (const projectPath of uniquePaths) {
-    try {
+    const prR = Result2.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], {
+      return { branchExists: branchExists(projectPath, branchName) };
+    });
+    if (!prR.ok) {
+      showWarning(`Error creating PR for ${projectPath}: ${prR.error.message}`);
+      continue;
+    }
+    if (!prR.value.branchExists) {
+      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 (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}"`
       );
-      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();
@@ -1616,51 +1620,51 @@ async function sprintDeleteCommand(args) {
     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) {
+  const sprintR = await wrapAsync(() => getSprint(sprintId), ensureError);
+  if (!sprintR.ok) {
+    if (sprintR.error instanceof SprintNotFoundError) {
       showError(`Sprint not found: ${sprintId}`);
       log.newline();
     } else {
-      throw err;
+      throw sprintR.error;
+    }
+    return;
+  }
+  const sprint = sprintR.value;
+  let taskCount = 0;
+  const tasksR = await wrapAsync(() => listTasks(sprintId), ensureError);
+  if (tasksR.ok) {
+    taskCount = tasksR.value.length;
+  }
+  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();
 }
 
 // src/commands/sprint/requirements.ts
@@ -1668,12 +1672,13 @@ 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 idR = await wrapAsync(() => resolveSprintId(sprintId), ensureError);
+  if (!idR.ok) {
     const selected = await selectSprint("Select sprint to export requirements from:");
     if (!selected) return;
     id = selected;
+  } else {
+    id = idR.value;
   }
   const sprint = await getSprint(id);
   if (sprint.tickets.length === 0) {
@@ -1693,22 +1698,18 @@ async function sprintRequirementsCommand(args = []) {
   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");
-    }
+  const exportR = await wrapAsync(() => exportRequirementsToMarkdown(sprint, outputPath), ensureError);
+  if (!exportR.ok) {
+    showError(`Failed to write requirements: ${exportR.error.message}`);
     return;
   }
+  showSuccess("Requirements written to:");
+  log.item(outputPath);
   log.newline();
 }
 
 // src/commands/sprint/health.ts
+import { Result as Result3 } from "typescript-result";
 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));
@@ -1799,13 +1800,11 @@ function checkBranchConsistency(sprint, tasks) {
   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 {
+    const branchR = Result3.try(() => getCurrentBranch(projectPath));
+    if (!branchR.ok) {
       items.push(`${projectPath} \u2014 unable to determine branch`);
+    } else if (branchR.value !== sprint.branch) {
+      items.push(`${projectPath} \u2014 on '${branchR.value}', expected '${sprint.branch}'`);
     }
   }
   return {
@@ -1837,17 +1836,12 @@ function renderCheckCard(check) {
   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");
-    }
+  const sprintR = await wrapAsync(() => getCurrentSprintOrThrow(), ensureError);
+  if (!sprintR.ok) {
+    showError(sprintR.error.message);
     return;
   }
+  const sprint = sprintR.value;
   const tasks = await getTasks(sprint.id);
   printHeader(`Sprint Health: ${sprint.name}`, icons.sprint);
   const checks = [
@@ -1899,18 +1893,17 @@ async function ticketEditCommand(ticketId, options = {}) {
     }
     resolvedId = selected;
   }
-  let ticket;
-  try {
-    ticket = await getTicket(resolvedId);
-  } catch (err) {
-    if (err instanceof TicketNotFoundError) {
+  const ticketR = await wrapAsync(() => getTicket(resolvedId), ensureError);
+  if (!ticketR.ok) {
+    if (ticketR.error instanceof TicketNotFoundError) {
       showError(`Ticket not found: ${resolvedId}`);
       showNextStep("ralphctl ticket list", "see available tickets");
       if (!isInteractive) exitWithCode(EXIT_ERROR);
       return;
     }
-    throw err;
+    throw ticketR.error;
   }
+  const ticket = ticketR.value;
   let newTitle;
   let newDescription;
   let newLink;
@@ -1924,10 +1917,15 @@ async function ticketEditCommand(ticketId, options = {}) {
       default: ticket.title,
       validate: (v) => v.trim().length > 0 ? true : "Title is required"
     });
-    newDescription = await editorInput({
+    const descR = await editorInput({
       message: "Description:",
       default: ticket.description
     });
+    if (!descR.ok) {
+      showError(`Editor input failed: ${descR.error.message}`);
+      return;
+    }
+    newDescription = descR.value;
     newLink = await input3({
       message: `${icons.info} Link:`,
       default: ticket.link ?? "",
@@ -1978,28 +1976,29 @@ async function ticketEditCommand(ticketId, options = {}) {
     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);
+  const updateR = await wrapAsync(() => updateTicket(ticket.id, updates), ensureError);
+  if (!updateR.ok) {
+    if (updateR.error instanceof SprintStatusError) {
+      showError(updateR.error.message);
     } else {
-      throw err;
+      throw updateR.error;
     }
     if (!isInteractive) exitWithCode(EXIT_ERROR);
+    return;
+  }
+  const updated = updateR.value;
+  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("");
 }
 
 // src/commands/ticket/list.ts
@@ -2067,12 +2066,12 @@ async function ticketListCommand(args) {
   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) {
+    const projectR = await wrapAsync(() => getProject(projectName), ensureError);
+    if (projectR.ok) {
+      for (const repo of projectR.value.repositories) {
         log.raw(`    ${muted(repo.name)} ${muted("\u2192")} ${muted(repo.path)}`, 1);
       }
-    } catch {
+    } else {
       log.raw(`    ${muted("(project not found)")}`, 1);
     }
     log.newline();
@@ -2104,52 +2103,53 @@ async function ticketShowCommand(args) {
     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) {
+  const ticketR = await wrapAsync(() => getTicket(ticketId), ensureError);
+  if (!ticketR.ok) {
+    if (ticketR.error instanceof TicketNotFoundError) {
       showError(`Ticket not found: ${ticketId}`);
       showNextStep("ralphctl ticket list", "see available tickets");
       log.newline();
     } else {
-      throw err;
+      throw ticketR.error;
+    }
+    return;
+  }
+  const ticket = ticketR.value;
+  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));
+  }
+  const projectR = await wrapAsync(() => getProject(ticket.projectName), ensureError);
+  if (projectR.ok) {
+    infoLines.push("");
+    for (const repo of projectR.value.repositories) {
+      infoLines.push(`  ${icons.bullet} ${repo.name} ${muted("\u2192")} ${muted(repo.path)}`);
     }
+  } else {
+    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();
 }
 
 // src/commands/ticket/remove.ts
@@ -2162,7 +2162,7 @@ async function ticketRemoveCommand(args) {
     if (!selected) return;
     ticketId = selected;
   }
-  try {
+  const opR = await wrapAsync(async () => {
     const ticket = await getTicket(ticketId);
     if (!skipConfirm) {
       const confirmed = await confirm5({
@@ -2171,23 +2171,28 @@ async function ticketRemoveCommand(args) {
       });
       if (!confirmed) {
         console.log(muted("\nTicket removal cancelled.\n"));
-        return;
+        return null;
       }
     }
     await removeTicket(ticketId);
-    showSuccess("Ticket removed", [["ID", ticketId]]);
-    log.newline();
-  } catch (err) {
-    if (err instanceof TicketNotFoundError) {
+    return ticket;
+  }, ensureError);
+  if (!opR.ok) {
+    if (opR.error instanceof TicketNotFoundError) {
       showError(`Ticket not found: ${ticketId}`);
       showNextStep("ralphctl ticket list", "see available tickets");
       log.newline();
-    } else if (err instanceof SprintStatusError) {
-      showError(err.message);
+    } else if (opR.error instanceof SprintStatusError) {
+      showError(opR.error.message);
       log.newline();
     } else {
-      throw err;
+      throw opR.error;
     }
+    return;
+  }
+  if (opR.value !== null) {
+    showSuccess("Ticket removed", [["ID", ticketId]]);
+    log.newline();
   }
 }
 
@@ -2195,25 +2200,23 @@ async function ticketRemoveCommand(args) {
 import { mkdir as mkdir2, readFile as readFile2 } from "fs/promises";
 import { join as join3 } from "path";
 import { confirm as confirm6 } from "@inquirer/prompts";
+import { Result as Result4 } from "typescript-result";
 async function ticketRefineCommand(ticketId, options = {}) {
   const isInteractive = options.interactive !== false;
-  let sprintId;
-  try {
-    sprintId = await resolveSprintId();
-  } catch {
+  const sprintIdR = await wrapAsync(() => resolveSprintId(), ensureError);
+  if (!sprintIdR.ok) {
     showWarning("No current sprint set.");
     showTip("Create a sprint first or set one with: ralphctl sprint current");
     log.newline();
     return;
   }
+  const sprintId = sprintIdR.value;
   const sprint = await getSprint(sprintId);
   try {
     assertSprintStatus(sprint, ["draft"], "refine ticket");
   } catch (err) {
-    if (err instanceof Error) {
-      showError(err.message);
-      log.newline();
-    }
+    showError(err instanceof Error ? err.message : String(err));
+    log.newline();
     return;
   }
   const approvedTickets = sprint.tickets.filter((t) => t.requirementStatus === "approved");
@@ -2269,21 +2272,18 @@ async function ticketRefineCommand(ticketId, options = {}) {
   }
   let issueContext = "";
   if (ticket.link) {
+    const ticketLink = 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) {
+    const fetchR = Result4.try(() => fetchIssueFromUrl(ticketLink));
+    if (!fetchR.ok) {
       fetchSpinner.fail("Could not fetch issue data");
-      if (err instanceof IssueFetchError || err instanceof Error) {
-        showWarning(`${err.message} \u2014 continuing without issue context`);
-      }
+      showWarning(`${fetchR.error.message} \u2014 continuing without issue context`);
+    } else if (fetchR.value) {
+      issueContext = formatIssueContext(fetchR.value);
+      fetchSpinner.succeed(`Issue data fetched (${String(fetchR.value.comments.length)} comment(s))`);
+    } else {
+      fetchSpinner.stop();
     }
   }
   const refineDir = getRefinementDir(sprintId, ticket.id);
@@ -2301,41 +2301,34 @@ async function ticketRefineCommand(ticketId, options = {}) {
   log.newline();
   const spinner = createSpinner(`Starting ${providerName} session...`);
   spinner.start();
-  try {
-    await runAiSession(refineDir, prompt, ticket.title);
-    spinner.succeed(`${providerName} session completed`);
-  } catch (err) {
+  const sessionR = await wrapAsync(() => runAiSession(refineDir, prompt, ticket.title), ensureError);
+  if (!sessionR.ok) {
     spinner.fail(`${providerName} session failed`);
-    if (err instanceof Error) {
-      showError(err.message);
-    }
+    showError(sessionR.error.message);
     log.newline();
     return;
   }
+  spinner.succeed(`${providerName} session completed`);
   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 {
+  const contentR = await wrapAsync(() => readFile2(outputFile, "utf-8"), ensureError);
+  if (!contentR.ok) {
     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}`);
-    }
+  const content = contentR.value;
+  const parseR = Result4.try(() => parseRequirementsFile(content));
+  if (!parseR.ok) {
+    showError(`Failed to parse requirements file: ${parseR.error.message}`);
     log.newline();
     return;
   }
+  const refinedRequirements = parseR.value;
   if (refinedRequirements.length === 0) {
     showWarning("No requirements found in output file.");
     log.newline();
@@ -2386,11 +2379,13 @@ 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 statusCheckR = await wrapAsync(async () => {
     const sprintId = await resolveSprintId();
     const sprint = await getSprint(sprintId);
     assertSprintStatus(sprint, ["draft"], "add tasks");
-  } catch (err) {
+  }, ensureError);
+  if (!statusCheckR.ok) {
+    const err = statusCheckR.error;
     if (err instanceof SprintStatusError) {
       const mainError = err.message.split("\n")[0] ?? err.message;
       showError(mainError);
@@ -2441,27 +2436,31 @@ async function taskAddCommand(options = {}) {
     const trimmedTicket = options.ticket?.trim();
     ticketId = trimmedTicket === "" ? void 0 : trimmedTicket;
     if (ticketId) {
-      try {
-        const ticket = await getTicket(ticketId);
+      const resolvedTicketId = ticketId;
+      const ticketProjectR = await wrapAsync(async () => {
+        const ticket = await getTicket(resolvedTicketId);
         const project = await getProject(ticket.projectName);
-        projectPath = project.repositories[0]?.path;
-      } catch {
+        return project.repositories[0]?.path;
+      }, ensureError);
+      if (ticketProjectR.ok) {
+        projectPath = ticketProjectR.value;
+      } else {
         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}`);
+        if (!validation.ok) {
+          showError(`Invalid project path: ${validation.error.message}`);
           exitWithCode(EXIT_ERROR);
         }
         projectPath = resolve2(trimmedProject);
       }
     } else if (trimmedProject) {
       const validation = await validateProjectPath(trimmedProject);
-      if (validation !== true) {
-        showError(`Invalid project path: ${validation}`);
+      if (!validation.ok) {
+        showError(`Invalid project path: ${validation.error.message}`);
         exitWithCode(EXIT_ERROR);
       }
       projectPath = resolve2(trimmedProject);
@@ -2475,10 +2474,15 @@ async function taskAddCommand(options = {}) {
       default: options.name?.trim(),
       validate: (v) => v.trim().length > 0 ? true : "Name is required"
     });
-    description = await editorInput({
+    const descR = await editorInput({
       message: "Description (optional):",
       default: options.description?.trim()
     });
+    if (!descR.ok) {
+      showError(`Editor input failed: ${descR.error.message}`);
+      return;
+    }
+    description = descR.value;
     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?"}`,
@@ -2518,8 +2522,9 @@ async function taskAddCommand(options = {}) {
         ticketId = ticketChoice;
         const ticket = tickets.find((t) => t.id === ticketChoice);
         if (ticket) {
-          try {
-            const project = await getProject(ticket.projectName);
+          const projR = await wrapAsync(() => getProject(ticket.projectName), ensureError);
+          if (projR.ok) {
+            const project = projR.value;
             if (project.repositories.length === 1) {
               projectPath = project.repositories[0]?.path;
             } else {
@@ -2532,18 +2537,21 @@ async function taskAddCommand(options = {}) {
                 }))
               });
             }
-          } catch {
+          } else {
             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 resolvedTicketId = ticketId;
+      const tpR = await wrapAsync(async () => {
+        const ticket = await getTicket(resolvedTicketId);
         const project = await getProject(ticket.projectName);
-        projectPath = project.repositories[0]?.path;
-      } catch {
+        return project.repositories[0]?.path;
+      }, ensureError);
+      if (tpR.ok) {
+        projectPath = tpR.value;
       }
     }
     if (projectPath === void 0) {
@@ -2563,7 +2571,7 @@ async function taskAddCommand(options = {}) {
             default: options.project?.trim() ?? process.cwd(),
             validate: async (v) => {
               const result = await validateProjectPath(v.trim());
-              return result;
+              return result.ok ? true : result.error.message;
             }
           });
           projectPath = resolve2(expandTilde(projectPath.trim()));
@@ -2581,7 +2589,7 @@ async function taskAddCommand(options = {}) {
           default: options.project?.trim() ?? process.cwd(),
           validate: async (v) => {
             const result = await validateProjectPath(v.trim());
-            return result;
+            return result.ok ? true : result.error.message;
           }
         });
         projectPath = resolve2(expandTilde(projectPath.trim()));
@@ -2595,33 +2603,10 @@ async function taskAddCommand(options = {}) {
     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;
+  const addR = await wrapAsync(() => addTask({ name, description, steps, ticketId, projectPath }), ensureError);
+  if (!addR.ok) {
+    if (addR.error instanceof SprintStatusError) {
+      const mainError = addR.error.message.split("\n")[0] ?? addR.error.message;
       showError(mainError);
       showNextSteps([
         ["ralphctl sprint close", "close current sprint"],
@@ -2631,12 +2616,30 @@ async function taskAddCommand(options = {}) {
       if (!isInteractive) exitWithCode(EXIT_ERROR);
       return;
     }
-    throw err;
+    throw addR.error;
+  }
+  const task = addR.value;
+  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("");
 }
 
 // src/commands/task/import.ts
 import { readFile as readFile3 } from "fs/promises";
+import { Result as Result5 } from "typescript-result";
 async function taskImportCommand(args) {
   const filePath = args[0];
   if (!filePath) {
@@ -2660,22 +2663,19 @@ async function taskImportCommand(args) {
     log.newline();
     return;
   }
-  let content;
-  try {
-    content = await readFile3(filePath, "utf-8");
-  } catch {
+  const contentR = await wrapAsync(() => readFile3(filePath, "utf-8"), ensureError);
+  if (!contentR.ok) {
     showError(`Failed to read file: ${filePath}`);
     log.newline();
     return;
   }
-  let data;
-  try {
-    data = JSON.parse(content);
-  } catch {
+  const dataR = Result5.try(() => JSON.parse(contentR.value));
+  if (!dataR.ok) {
     showError("Invalid JSON format.");
     log.newline();
     return;
   }
+  const data = dataR.value;
   const result = ImportTasksSchema.safeParse(data);
   if (!result.success) {
     showError("Invalid task format");
@@ -2709,8 +2709,8 @@ async function taskImportCommand(args) {
   const spinner = createSpinner(`Importing ${String(tasks.length)} task(s)...`).start();
   let imported = 0;
   for (const taskInput of tasks) {
-    try {
-      const task = await addTask({
+    const addR = await wrapAsync(
+      () => addTask({
         name: taskInput.name,
         description: taskInput.description,
         steps: taskInput.steps ?? [],
@@ -2718,29 +2718,31 @@ async function taskImportCommand(args) {
         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) {
+      }),
+      ensureError
+    );
+    if (!addR.ok) {
+      if (addR.error instanceof SprintStatusError) {
         spinner.fail("Import failed");
-        showError(err.message);
+        showError(addR.error.message);
         log.newline();
         return;
       }
       log.itemError(`Failed to add: ${taskInput.name}`);
-      if (err instanceof Error) {
-        console.log(muted(`    ${err.message}`));
-      }
+      console.log(muted(`    ${addR.error.message}`));
+      continue;
     }
+    const task = addR.value;
+    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)})`;
   }
   spinner.text = "Resolving task dependencies...";
   const tasksFilePath = getTasksFilePath(sprintId);
-  await withFileLock(tasksFilePath, async () => {
+  const lockR = 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 !== "");
@@ -2753,6 +2755,11 @@ async function taskImportCommand(args) {
     }
     await saveTasks(allTasks);
   });
+  if (!lockR.ok) {
+    showError(`Failed to update dependencies: ${lockR.error.message}`);
+    log.newline();
+    return;
+  }
   spinner.succeed(`Imported ${String(imported)}/${String(tasks.length)} tasks`);
   for (const { task: taskInput, realId } of createdTasks) {
     log.itemSuccess(`${realId}: ${taskInput.name}`);
@@ -2876,76 +2883,75 @@ async function taskShowCommand(args) {
     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) {
+  const taskR = await wrapAsync(() => getTask(taskId), ensureError);
+  if (!taskR.ok) {
+    if (taskR.error instanceof TaskNotFoundError) {
+      showError(`Task not found: ${taskId}`);
+      showNextStep("ralphctl task list", "see available tasks");
       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));
+    } else {
+      throw taskR.error;
     }
-    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));
+    return;
+  }
+  const task = taskR.value;
+  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}`);
     }
-    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 {
-      }
+  }
+  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}`);
     }
-    if (task.verified) {
+    console.log(renderCard(`${icons.warning} Blocked By`, depLines));
+  }
+  if (task.ticketId) {
+    const taskTicketId = task.ticketId;
+    const ticketR = await wrapAsync(() => getTicket(taskTicketId), ensureError);
+    if (ticketR.ok && ticketR.value.requirements) {
       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));
+      const reqLines = ticketR.value.requirements.split("\n");
+      console.log(renderCard(`${icons.ticket} Requirements`, reqLines));
     }
+  }
+  if (task.verified) {
     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;
+    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();
 }
 
 // src/commands/task/status.ts
@@ -2995,32 +3001,32 @@ async function taskStatusCommand(args, options = {}) {
     }
     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) {
+  const updateR = await wrapAsync(() => updateTaskStatus(taskId, result.data), ensureError);
+  if (!updateR.ok) {
+    if (updateR.error 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);
+    } else if (updateR.error instanceof SprintStatusError) {
+      showError(updateR.error.message);
       log.newline();
       if (options.noInteractive) {
         exitWithCode(EXIT_ERROR);
       }
     } else {
-      throw err;
+      throw updateR.error;
     }
+    return;
   }
+  showSuccess("Task status updated!", [
+    ["ID", updateR.value.id],
+    ["Name", updateR.value.name],
+    ["Status", formatTaskStatus(updateR.value.status)]
+  ]);
+  log.newline();
 }
 
 // src/commands/task/next.ts
@@ -3075,25 +3081,25 @@ async function taskReorderCommand(args) {
   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) {
+  const reorderR = await wrapAsync(() => reorderTask(taskId, newOrder), ensureError);
+  if (!reorderR.ok) {
+    if (reorderR.error instanceof TaskNotFoundError) {
       showError(`Task not found: ${taskId}`);
       log.newline();
-    } else if (err instanceof SprintStatusError) {
-      showError(err.message);
+    } else if (reorderR.error instanceof SprintStatusError) {
+      showError(reorderR.error.message);
       log.newline();
     } else {
-      throw err;
+      throw reorderR.error;
     }
+    return;
   }
+  showSuccess("Task reordered!", [
+    ["ID", reorderR.value.id],
+    ["Name", reorderR.value.name],
+    ["New Order", String(reorderR.value.order)]
+  ]);
+  log.newline();
 }
 
 // src/commands/task/remove.ts
@@ -3106,7 +3112,7 @@ async function taskRemoveCommand(args) {
     if (!selected) return;
     taskId = selected;
   }
-  try {
+  const opR = await wrapAsync(async () => {
     const task = await getTask(taskId);
     if (!skipConfirm) {
       const confirmed = await confirm8({
@@ -3115,32 +3121,39 @@ async function taskRemoveCommand(args) {
       });
       if (!confirmed) {
         console.log(muted("\nTask removal cancelled.\n"));
-        return;
+        return null;
       }
     }
     await removeTask(taskId);
-    showSuccess("Task removed", [["ID", taskId]]);
-    log.newline();
-  } catch (err) {
-    if (err instanceof TaskNotFoundError) {
+    return task;
+  }, ensureError);
+  if (!opR.ok) {
+    if (opR.error instanceof TaskNotFoundError) {
       showError(`Task not found: ${taskId}`);
       log.newline();
-    } else if (err instanceof SprintStatusError) {
-      showError(err.message);
+    } else if (opR.error instanceof SprintStatusError) {
+      showError(opR.error.message);
       log.newline();
     } else {
-      throw err;
+      throw opR.error;
     }
+    return;
+  }
+  if (opR.value !== null) {
+    showSuccess("Task removed", [["ID", taskId]]);
+    log.newline();
   }
 }
 
 // src/commands/progress/log.ts
 async function progressLogCommand(args) {
-  try {
+  const statusCheckR = await wrapAsync(async () => {
     const sprintId = await resolveSprintId();
     const sprint = await getSprint(sprintId);
     assertSprintStatus(sprint, ["active"], "log progress");
-  } catch (err) {
+  }, ensureError);
+  if (!statusCheckR.ok) {
+    const err = statusCheckR.error;
     if (err instanceof SprintStatusError) {
       const mainError = err.message.split("\n")[0] ?? err.message;
       showError(mainError);
@@ -3158,9 +3171,15 @@ async function progressLogCommand(args) {
   }
   let message = args.join(" ").trim();
   if (!message) {
-    message = await editorInput({
+    const editorR = await editorInput({
       message: "Progress message:"
     });
+    if (!editorR.ok) {
+      showError(`Editor input failed: ${editorR.error.message}`);
+      log.newline();
+      return;
+    }
+    message = editorR.value;
     message = message.trim();
   }
   if (!message) {
@@ -3168,18 +3187,18 @@ async function progressLogCommand(args) {
     log.newline();
     return;
   }
-  try {
-    await logProgress(message);
-    showSuccess("Progress logged.");
-    log.newline();
-  } catch (err) {
-    if (err instanceof SprintStatusError) {
-      showError(err.message);
+  const logR = await wrapAsync(() => logProgress(message), ensureError);
+  if (!logR.ok) {
+    if (logR.error instanceof SprintStatusError) {
+      showError(logR.error.message);
       log.newline();
     } else {
-      throw err;
+      throw logR.error;
     }
+    return;
   }
+  showSuccess("Progress logged.");
+  log.newline();
 }
 
 // src/commands/progress/show.ts
@@ -3321,12 +3340,11 @@ function checkGlabInstalled() {
 }
 async function checkDataDirectory() {
   const dataDir = getDataDir();
-  try {
-    await access(dataDir, constants.R_OK | constants.W_OK);
+  const accessR = await wrapAsync(() => access(dataDir, constants.R_OK | constants.W_OK), ensureError);
+  if (accessR.ok) {
     return { name: "Data directory", status: "pass", detail: dataDir };
-  } catch {
-    return { name: "Data directory", status: "fail", detail: `${dataDir} not accessible or writable` };
   }
+  return { name: "Data directory", status: "fail", detail: `${dataDir} not accessible or writable` };
 }
 async function checkProjectPaths() {
   const projects = await listProjects();
@@ -3337,8 +3355,8 @@ async function checkProjectPaths() {
   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}`);
+      if (!validation.ok) {
+        issues.push(`${project.name}/${repo.name}: ${validation.error.message}`);
         continue;
       }
       const gitDir = join4(repo.path, ".git");
@@ -3367,13 +3385,11 @@ async function checkCurrentSprint() {
   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}` };
+  const result = await readValidatedJson(sprintPath, SprintSchema);
+  if (!result.ok) {
+    return { name: "Current sprint", status: "fail", detail: `invalid sprint data: ${result.error.message}` };
   }
+  return { name: "Current sprint", status: "pass", detail: `${result.value.name} (${result.value.status})` };
 }
 async function doctorCommand() {
   printHeader("System Health Check", icons.info);
@@ -3528,11 +3544,9 @@ function showWelcomeBanner() {
   showBanner();
 }
 async function readTasksSafe(sprintId) {
-  try {
-    return await readValidatedJson(getTasksFilePath(sprintId), TasksSchema);
-  } catch {
-    return [];
-  }
+  const result = await readValidatedJson(getTasksFilePath(sprintId), TasksSchema);
+  if (!result.ok) return [];
+  return result.value;
 }
 async function getMenuContext() {
   let dashboardData = null;
@@ -3591,21 +3605,21 @@ async function getMenuContext() {
 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 { ctx, dashboardData } = await getMenuContext();
+    clearScreen();
+    showWelcomeBanner();
+    const statusLines = renderStatusHeader(dashboardData);
+    if (statusLines.length > 0) {
+      for (const line2 of statusLines) {
+        console.log(line2);
       }
-      const { items: mainMenu, defaultValue } = buildMainMenu(ctx);
-      const effectiveDefault = escPressed ? "exit" : defaultValue;
-      escPressed = false;
-      const command = await escapableSelect(
+      log.newline();
+    }
+    const { items: mainMenu, defaultValue } = buildMainMenu(ctx);
+    const effectiveDefault = escPressed ? "exit" : defaultValue;
+    escPressed = false;
+    const commandResult = await wrapAsync(
+      () => escapableSelect(
         {
           message: `${emoji.donut} What would you like to do?`,
           choices: mainMenu,
@@ -3615,40 +3629,43 @@ async function interactiveMode() {
           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") {
+      ),
+      ensureError
+    );
+    if (!commandResult.ok) {
+      if (commandResult.error.name === "ExitPromptError") {
         showFarewell();
         break;
       }
-      throw err;
+      throw commandResult.error;
+    }
+    const command = commandResult.value;
+    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-MCDDXLGE.mjs");
+      await runWizard();
+      continue;
+    }
+    const subMenu = buildSubMenu(command, ctx);
+    if (subMenu) {
+      await handleSubMenu(command, subMenu);
     }
   }
 }
@@ -3656,35 +3673,38 @@ async function handleSubMenu(commandGroup, initialSubMenu) {
   let currentTitle = initialSubMenu.title;
   let currentItems = initialSubMenu.items;
   while (true) {
-    try {
-      log.newline();
-      const subCommand = await escapableSelect({
+    log.newline();
+    const subCommandResult = await wrapAsync(
+      () => 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") {
+      }),
+      ensureError
+    );
+    if (!subCommandResult.ok) {
+      if (subCommandResult.error.name === "ExitPromptError") {
         break;
       }
-      throw err;
+      throw subCommandResult.error;
+    }
+    const subCommand = subCommandResult.value;
+    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;
     }
   }
 }
@@ -3695,12 +3715,9 @@ async function executeCommand(group, subCommand) {
     log.error(`Unknown command: ${group} ${subCommand}`);
     return;
   }
-  try {
-    await handler();
-  } catch (err) {
-    if (err instanceof Error) {
-      log.error(err.message);
-    }
+  const r = await wrapAsync(() => handler(), ensureError);
+  if (!r.ok) {
+    log.error(r.error.message);
   }
 }
 
@@ -4111,7 +4128,7 @@ Checks performed:
 // package.json
 var package_default = {
   name: "ralphctl",
-  version: "0.1.2",
+  version: "0.1.4",
   description: "Sprint and task management CLI for AI-assisted coding",
   homepage: "https://github.com/lukas-grigis/ralphctl",
   type: "module",
@@ -4169,6 +4186,7 @@ var package_default = {
     "gradient-string": "^3.0.0",
     ora: "^9.3.0",
     tabtab: "^3.0.2",
+    "typescript-result": "^3.5.2",
     zod: "^4.3.6"
   },
   devDependencies: {
@@ -4229,7 +4247,7 @@ 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");
+    const { handleCompletionRequest } = await import("./handle-K2AZLTKU.mjs");
     if (await handleCompletionRequest(program)) return;
   }
   if (process.argv.length <= 2 || process.argv[2] === "interactive") {
@@ -4240,6 +4258,10 @@ async function main() {
   }
 }
 main().catch((err) => {
-  console.error(error("Fatal error:"), err);
-  process.exit(1);
+  if (err instanceof DomainError) {
+    showError(err.message);
+    process.exit(EXIT_ERROR);
+  }
+  console.error(error("Unexpected error \u2014 please report this bug:"), err instanceof Error ? err.stack : String(err));
+  process.exit(EXIT_ERROR);
 });