ralphctl 0.1.2 → 0.1.4

package/dist/{chunk-LOR7QBXX.mjs → chunk-M7JV6MKD.mjs}

@@ -1,9 +1,8 @@
 #!/usr/bin/env node
 import {
   escapableSelect
-} from "./chunk-NTWO2LXB.mjs";
+} from "./chunk-7LZ6GOGN.mjs";
 import {
-  IssueFetchError,
   allRequirementsApproved,
   fetchIssueFromUrl,
   formatIssueContext,
@@ -12,7 +11,7 @@ import {
   getPendingRequirements,
   groupTicketsByProject,
   listTickets
-} from "./chunk-MNMQC36F.mjs";
+} from "./chunk-F2MMCTB5.mjs";
 import {
   EXIT_ALL_BLOCKED,
   EXIT_ERROR,
@@ -22,13 +21,10 @@ import {
   exitWithCode
 } from "./chunk-7TG3EAQ2.mjs";
 import {
-  ProjectNotFoundError,
   getProject,
   listProjects
-} from "./chunk-WGHJI3OI.mjs";
+} from "./chunk-PDI6HBZ7.mjs";
 import {
-  SprintNotFoundError,
-  SprintStatusError,
   activateSprint,
   assertSprintStatus,
   closeSprint,
@@ -43,7 +39,12 @@ import {
   setAiProvider,
   summarizeProgressForContext,
   withFileLock
-} from "./chunk-EKMZZRWI.mjs";
+} from "./chunk-LFDW6MWF.mjs";
+import {
+  ensureError,
+  unwrapOrThrow,
+  wrapAsync
+} from "./chunk-OEUJDSHY.mjs";
 import {
   ImportTasksSchema,
   RefinedRequirementsSchema,
@@ -59,7 +60,17 @@ import {
   getTasksFilePath,
   readValidatedJson,
   writeValidatedJson
-} from "./chunk-6PYTKGB5.mjs";
+} from "./chunk-W3TY22IS.mjs";
+import {
+  DependencyCycleError,
+  IOError,
+  IssueFetchError,
+  ProjectNotFoundError,
+  SpawnError,
+  SprintNotFoundError,
+  SprintStatusError,
+  TaskNotFoundError
+} from "./chunk-EDJX7TT6.mjs";
 import {
   colors,
   createSpinner,
@@ -95,6 +106,7 @@ import {
 import { mkdir, readFile } from "fs/promises";
 import { join as join4 } from "path";
 import { confirm } from "@inquirer/prompts";
+import { Result as Result3 } from "typescript-result";
 
 // src/ai/prompts/index.ts
 import { existsSync, readFileSync } from "fs";
@@ -211,6 +223,7 @@ function providerDisplayName(provider) {
 // src/commands/ticket/refine-utils.ts
 import { writeFile as writeFile2 } from "fs/promises";
 import { join as join3 } from "path";
+import { Result as Result2 } from "typescript-result";
 
 // src/ai/session.ts
 import { spawn, spawnSync } from "child_process";
@@ -357,8 +370,7 @@ var ProcessManager = class _ProcessManager {
       try {
         callback();
       } catch (err) {
-        const error2 = err;
-        console.error("Error in cleanup callback:", error2.message);
+        console.error("Error in cleanup callback:", err instanceof Error ? err.message : String(err));
       }
     }
     this.cleanupCallbacks.clear();
@@ -399,6 +411,7 @@ var ProcessManager = class _ProcessManager {
 };
 
 // src/providers/claude.ts
+import { Result } from "typescript-result";
 var claudeAdapter = {
   name: "claude",
   displayName: "Claude",
@@ -412,15 +425,15 @@ var claudeAdapter = {
     return ["-p", "--output-format", "json", ...this.baseArgs, ...extraArgs];
   },
   parseJsonOutput(stdout) {
-    try {
-      const parsed = JSON.parse(stdout);
-      return {
-        result: parsed.result ?? stdout,
-        sessionId: parsed.session_id ?? null
-      };
-    } catch {
+    const jsonResult = Result.try(() => JSON.parse(stdout));
+    if (!jsonResult.ok) {
       return { result: stdout, sessionId: null };
     }
+    const parsed = jsonResult.value;
+    return {
+      result: parsed.result ?? stdout,
+      sessionId: parsed.session_id ?? null
+    };
   },
   detectRateLimit(stderr) {
     const patterns = [/rate.?limit/i, /\b429\b/, /too many requests/i, /overloaded/i, /\b529\b/];
@@ -456,22 +469,23 @@ var copilotAdapter = {
     return { result: stdout.trim(), sessionId: null };
   },
   async extractSessionId(cwd) {
-    try {
-      const files = await readdir(cwd);
-      const shareFile = files.find((f) => /^copilot-session-[a-zA-Z0-9_][a-zA-Z0-9_-]*\.md$/.test(f));
-      if (!shareFile) return null;
-      const match = /^copilot-session-([a-zA-Z0-9_][a-zA-Z0-9_-]{0,127})\.md$/.exec(shareFile);
-      if (!match?.[1]) return null;
-      const filePath = join2(cwd, shareFile);
-      const stat = await lstat(filePath).catch(() => null);
-      if (stat?.isFile()) {
-        await unlink(filePath).catch(() => {
-        });
-      }
-      return match[1];
-    } catch {
-      return null;
+    const filesResult = await wrapAsync(
+      () => readdir(cwd),
+      (err) => new IOError(`Failed to read directory: ${cwd}`, err instanceof Error ? err : void 0)
+    );
+    if (!filesResult.ok) return null;
+    const files = filesResult.value;
+    const shareFile = files.find((f) => /^copilot-session-[a-zA-Z0-9_][a-zA-Z0-9_-]*\.md$/.test(f));
+    if (!shareFile) return null;
+    const match = /^copilot-session-([a-zA-Z0-9_][a-zA-Z0-9_-]{0,127})\.md$/.exec(shareFile);
+    if (!match?.[1]) return null;
+    const filePath = join2(cwd, shareFile);
+    const stat = await lstat(filePath).catch(() => null);
+    if (stat?.isFile()) {
+      await unlink(filePath).catch(() => {
+      });
     }
+    return match[1];
   },
   detectRateLimit(stderr) {
     const patterns = [/rate.?limit/i, /\b429\b/, /too many requests/i, /overloaded/i, /\b529\b/];
@@ -507,34 +521,6 @@ async function getActiveProvider() {
 }
 
 // src/ai/session.ts
-var SpawnError = class extends Error {
-  stderr;
-  exitCode;
-  rateLimited;
-  retryAfterMs;
-  /** Session ID if available (for resume after rate limit) */
-  sessionId;
-  constructor(message, stderr, exitCode, sessionId, provider) {
-    super(message);
-    this.name = "SpawnError";
-    this.stderr = stderr;
-    this.exitCode = exitCode;
-    this.sessionId = sessionId ?? null;
-    const rl = provider ? provider.detectRateLimit(stderr) : detectRateLimitFallback(stderr);
-    this.rateLimited = rl.rateLimited;
-    this.retryAfterMs = rl.retryAfterMs;
-  }
-};
-function detectRateLimitFallback(stderr) {
-  const patterns = [/rate.?limit/i, /\b429\b/, /too many requests/i, /overloaded/i, /\b529\b/];
-  const isRateLimited = patterns.some((p) => p.test(stderr));
-  if (!isRateLimited) {
-    return { rateLimited: false, retryAfterMs: null };
-  }
-  const retryMatch = /retry.?after:?\s*(\d+)/i.exec(stderr);
-  const retryAfterMs = retryMatch?.[1] ? parseInt(retryMatch[1], 10) * 1e3 : null;
-  return { rateLimited: true, retryAfterMs };
-}
 function spawnInteractive(prompt, options, provider) {
   assertSafeCwd(options.cwd);
   const p = provider ?? {
@@ -570,7 +556,7 @@ async function spawnHeadlessRaw(options, provider) {
     const allArgs = p.buildHeadlessArgs(options.args ?? []);
     if (options.resumeSessionId) {
       if (!/^[a-zA-Z0-9_][a-zA-Z0-9_-]{0,127}$/.test(options.resumeSessionId)) {
-        reject(new SpawnError("Invalid session ID format", "", 1, null, p));
+        reject(new SpawnError("Invalid session ID format", "", 1));
         return;
       }
       allArgs.push("--resume", options.resumeSessionId);
@@ -584,13 +570,13 @@ async function spawnHeadlessRaw(options, provider) {
     try {
       manager.registerChild(child);
     } catch {
-      reject(new SpawnError("Cannot spawn during shutdown", "", 1, null, p));
+      reject(new SpawnError("Cannot spawn during shutdown", "", 1));
       return;
     }
     const MAX_PROMPT_SIZE = 1e6;
     if (options.prompt) {
       if (options.prompt.length > MAX_PROMPT_SIZE) {
-        reject(new SpawnError("Prompt exceeds maximum size (1MB)", "", 1, null, p));
+        reject(new SpawnError("Prompt exceeds maximum size (1MB)", "", 1));
         return;
       }
       child.stdin.write(options.prompt);
@@ -615,19 +601,18 @@ async function spawnHeadlessRaw(options, provider) {
               `${p.displayName} CLI exited with code ${String(exitCode)}: ${stderr}`,
               stderr,
               exitCode,
-              sessionId,
-              p
+              sessionId
             )
           );
         } else {
           resolve({ stdout: result, stderr, exitCode: 0, sessionId });
         }
       })().catch((err) => {
-        reject(new SpawnError(`Unexpected error in close handler: ${String(err)}`, "", 1, null, p));
+        reject(new SpawnError(`Unexpected error in close handler: ${String(err)}`, "", 1));
       });
     });
     child.on("error", (err) => {
-      reject(new SpawnError(`Failed to spawn ${p.binary} CLI: ${err.message}`, "", 1, null, p));
+      reject(new SpawnError(`Failed to spawn ${p.binary} CLI: ${err.message}`, "", 1));
     });
   });
 }
@@ -650,24 +635,23 @@ async function spawnWithRetry(options, retryOptions, provider) {
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     const elapsed = Date.now() - startTime;
     if (attempt > 0 && elapsed >= totalTimeoutMs) {
-      throw new SpawnError(`Total retry timeout exceeded (${String(totalTimeoutMs)}ms)`, "", 1, resumeSessionId, p);
+      throw new SpawnError(`Total retry timeout exceeded (${String(totalTimeoutMs)}ms)`, "", 1, resumeSessionId);
     }
-    try {
-      return await spawnHeadlessRaw({ ...options, resumeSessionId }, p);
-    } catch (err) {
-      if (!(err instanceof SpawnError) || !err.rateLimited) {
-        throw err;
-      }
-      if (err.sessionId) {
-        resumeSessionId = err.sessionId;
-      }
-      if (attempt >= maxRetries) {
-        throw err;
-      }
-      const delay = Math.min(err.retryAfterMs ?? BASE_DELAY_MS * Math.pow(2, attempt), MAX_DELAY_MS) + jitter();
-      retryOptions?.onRetry?.(attempt + 1, delay, err);
-      await sleep(delay);
+    const r = await wrapAsync(async () => spawnHeadlessRaw({ ...options, resumeSessionId }, p), ensureError);
+    if (r.ok) return r.value;
+    const err = r.error;
+    if (!(err instanceof SpawnError) || !err.rateLimited) {
+      throw err;
+    }
+    if (err.sessionId) {
+      resumeSessionId = err.sessionId;
     }
+    if (attempt >= maxRetries) {
+      throw err;
+    }
+    const delay = Math.min(err.retryAfterMs ?? BASE_DELAY_MS * Math.pow(2, attempt), MAX_DELAY_MS) + jitter();
+    retryOptions?.onRetry?.(attempt + 1, delay, err);
+    await sleep(delay);
   }
   throw new Error("Max retries exceeded");
 }
@@ -732,12 +716,11 @@ function formatTicketForPrompt(ticket) {
 }
 function parseRequirementsFile(content) {
   const jsonStr = extractJsonArray(content);
-  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 = Result2.try(() => JSON.parse(jsonStr));
+  if (!parseR.ok) {
+    throw new Error(`Invalid JSON: ${parseR.error.message}`, { cause: parseR.error });
   }
+  const parsed = parseR.value;
   if (!Array.isArray(parsed)) {
     throw new Error("Expected JSON array");
   }
@@ -787,23 +770,20 @@ function parseArgs(args) {
 }
 async function sprintRefineCommand(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.");
     showTip("Specify a sprint ID or create one first.");
     log.newline();
     return;
   }
+  const id = idR.value;
   const sprint = await getSprint(id);
   try {
     assertSprintStatus(sprint, ["draft"], "refine");
   } catch (err) {
-    if (err instanceof Error) {
-      showError(err.message);
-      log.newline();
-    }
+    showError(err instanceof Error ? err.message : String(err));
+    log.newline();
     return;
   }
   if (sprint.tickets.length === 0) {
@@ -861,9 +841,8 @@ async function sprintRefineCommand(args) {
       console.log(fieldMultiline("Description", ticket.description, 14));
     }
     log.newline();
-    try {
-      await getProject(ticket.projectName);
-    } catch {
+    const projectR = await wrapAsync(() => getProject(ticket.projectName), ensureError);
+    if (!projectR.ok) {
       showWarning(`Project '${ticket.projectName}' not found.`);
       log.dim("Skipping this ticket.");
       log.newline();
@@ -884,21 +863,20 @@ async function sprintRefineCommand(args) {
     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) {
+      const link = ticket.link;
+      const issueR = Result3.try(() => fetchIssueFromUrl(link));
+      if (issueR.ok && issueR.value) {
+        issueContext = formatIssueContext(issueR.value);
+        fetchSpinner.succeed(`Issue data fetched (${String(issueR.value.comments.length)} comment(s))`);
+      } else if (!issueR.ok) {
         fetchSpinner.fail("Could not fetch issue data");
-        if (err instanceof IssueFetchError) {
-          showWarning(`${err.message} \u2014 continuing without issue context`);
-        } else if (err instanceof Error) {
-          showWarning(`${err.message} \u2014 continuing without issue context`);
+        if (issueR.error instanceof IssueFetchError) {
+          showWarning(`${issueR.error.message} \u2014 continuing without issue context`);
+        } else {
+          showWarning(`${issueR.error.message} \u2014 continuing without issue context`);
         }
+      } else {
+        fetchSpinner.stop();
       }
     }
     const refineDir = getRefinementDir(id, ticket.id);
@@ -911,40 +889,32 @@ async function sprintRefineCommand(args) {
     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();
       skipped++;
       continue;
     }
+    spinner.succeed(`${providerName} session completed`);
     log.newline();
     if (await fileExists(outputFile)) {
-      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 requirements file: ${outputFile}`);
         log.newline();
         skipped++;
         continue;
       }
-      let refinedRequirements;
-      try {
-        refinedRequirements = parseRequirementsFile(content);
-      } catch (err) {
-        if (err instanceof Error) {
-          showError(`Failed to parse requirements file: ${err.message}`);
-        }
+      const parseR = Result3.try(() => parseRequirementsFile(contentR.value));
+      if (!parseR.ok) {
+        showError(`Failed to parse requirements file: ${parseR.error.message}`);
         log.newline();
         skipped++;
         continue;
       }
+      const refinedRequirements = parseR.value;
       if (refinedRequirements.length === 0) {
         showWarning("No requirements found in output file.");
         log.newline();
@@ -1012,15 +982,11 @@ ${text}`;
     showSuccess("All requirements approved!");
     const sprintDir = getSprintDir(id);
     const outputPath = join4(sprintDir, "requirements.md");
-    try {
-      await exportRequirementsToMarkdown(updatedSprint, outputPath);
+    const exportR = await wrapAsync(() => exportRequirementsToMarkdown(updatedSprint, outputPath), ensureError);
+    if (exportR.ok) {
       log.dim(`Requirements saved to: ${outputPath}`);
-    } catch (err) {
-      if (err instanceof Error) {
-        showError(`Failed to write requirements: ${err.message}`);
-      } else {
-        showError("Failed to write requirements: Unknown error");
-      }
+    } else {
+      showError(`Failed to write requirements: ${exportR.error.message}`);
     }
     showTip('Run "ralphctl sprint plan" to generate tasks.');
   } else {
@@ -1034,31 +1000,19 @@ ${text}`;
 import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
 import { join as join5 } from "path";
 import { confirm as confirm3 } from "@inquirer/prompts";
+import { Result as Result4 } from "typescript-result";
 
 // src/store/task.ts
-var TaskNotFoundError = class extends Error {
-  taskId;
-  constructor(taskId) {
-    super(`Task not found: ${taskId}`);
-    this.name = "TaskNotFoundError";
-    this.taskId = taskId;
-  }
-};
-var DependencyCycleError = class extends Error {
-  cycle;
-  constructor(cycle) {
-    super(`Dependency cycle detected: ${cycle.join(" \u2192 ")}`);
-    this.name = "DependencyCycleError";
-    this.cycle = cycle;
-  }
-};
 async function getTasks(sprintId) {
   const id = await resolveSprintId(sprintId);
-  return readValidatedJson(getTasksFilePath(id), TasksSchema);
+  const result = await readValidatedJson(getTasksFilePath(id), TasksSchema);
+  if (!result.ok) throw result.error;
+  return result.value;
 }
 async function saveTasks(tasks, sprintId) {
   const id = await resolveSprintId(sprintId);
-  await writeValidatedJson(getTasksFilePath(id), tasks, TasksSchema);
+  const result = await writeValidatedJson(getTasksFilePath(id), tasks, TasksSchema);
+  if (!result.ok) throw result.error;
 }
 async function getTask(taskId, sprintId) {
   const tasks = await getTasks(sprintId);
@@ -1073,7 +1027,7 @@ async function addTask(input3, sprintId) {
   const sprint = await getSprint(id);
   assertSprintStatus(sprint, ["draft"], "add tasks");
   const tasksFilePath = getTasksFilePath(id);
-  return withFileLock(tasksFilePath, async () => {
+  const lockResult = await withFileLock(tasksFilePath, async () => {
     const tasks = await getTasks(id);
     const maxOrder = tasks.reduce((max, t) => Math.max(max, t.order), 0);
     const task = {
@@ -1092,13 +1046,15 @@ async function addTask(input3, sprintId) {
     await saveTasks(tasks, id);
     return task;
   });
+  if (!lockResult.ok) throw lockResult.error;
+  return lockResult.value;
 }
 async function removeTask(taskId, sprintId) {
   const id = await resolveSprintId(sprintId);
   const sprint = await getSprint(id);
   assertSprintStatus(sprint, ["draft"], "remove tasks");
   const tasksFilePath = getTasksFilePath(id);
-  await withFileLock(tasksFilePath, async () => {
+  const lockResult = await withFileLock(tasksFilePath, async () => {
     const tasks = await getTasks(id);
     const index = tasks.findIndex((t) => t.id === taskId);
     if (index === -1) {
@@ -1107,13 +1063,14 @@ async function removeTask(taskId, sprintId) {
     tasks.splice(index, 1);
     await saveTasks(tasks, id);
   });
+  if (!lockResult.ok) throw lockResult.error;
 }
 async function updateTaskStatus(taskId, status, sprintId) {
   const id = await resolveSprintId(sprintId);
   const sprint = await getSprint(id);
   assertSprintStatus(sprint, ["active"], "update task status");
   const tasksFilePath = getTasksFilePath(id);
-  return withFileLock(tasksFilePath, async () => {
+  const lockResult = await withFileLock(tasksFilePath, async () => {
     const tasks = await getTasks(id);
     const task = tasks.find((t) => t.id === taskId);
     if (!task) {
@@ -1123,13 +1080,15 @@ async function updateTaskStatus(taskId, status, sprintId) {
     await saveTasks(tasks, id);
     return task;
   });
+  if (!lockResult.ok) throw lockResult.error;
+  return lockResult.value;
 }
 async function updateTask(taskId, updates, sprintId) {
   const id = await resolveSprintId(sprintId);
   const sprint = await getSprint(id);
   assertSprintStatus(sprint, ["active"], "update task");
   const tasksFilePath = getTasksFilePath(id);
-  return withFileLock(tasksFilePath, async () => {
+  const lockResult = await withFileLock(tasksFilePath, async () => {
     const tasks = await getTasks(id);
     const task = tasks.find((t) => t.id === taskId);
     if (!task) {
@@ -1144,6 +1103,8 @@ async function updateTask(taskId, updates, sprintId) {
     await saveTasks(tasks, id);
     return task;
   });
+  if (!lockResult.ok) throw lockResult.error;
+  return lockResult.value;
 }
 async function isTaskBlocked(taskId, sprintId) {
   const tasks = await getTasks(sprintId);
@@ -1175,7 +1136,7 @@ async function reorderTask(taskId, newOrder, sprintId) {
   const sprint = await getSprint(id);
   assertSprintStatus(sprint, ["draft"], "reorder tasks");
   const tasksFilePath = getTasksFilePath(id);
-  return withFileLock(tasksFilePath, async () => {
+  const lockResult = await withFileLock(tasksFilePath, async () => {
     const tasks = await getTasks(id);
     const task = tasks.find((t) => t.id === taskId);
     if (!task) {
@@ -1198,6 +1159,8 @@ async function reorderTask(taskId, newOrder, sprintId) {
     await saveTasks(tasks, id);
     return task;
   });
+  if (!lockResult.ok) throw lockResult.error;
+  return lockResult.value;
 }
 async function listTasks(sprintId) {
   const tasks = await getTasks(sprintId);
@@ -1240,7 +1203,7 @@ function topologicalSort(tasks) {
 async function reorderByDependencies(sprintId) {
   const id = await resolveSprintId(sprintId);
   const tasksFilePath = getTasksFilePath(id);
-  await withFileLock(tasksFilePath, async () => {
+  const lockResult = await withFileLock(tasksFilePath, async () => {
     const tasks = await getTasks(id);
     if (tasks.length === 0) return;
     const sorted = topologicalSort(tasks);
@@ -1249,6 +1212,7 @@ async function reorderByDependencies(sprintId) {
     });
     await saveTasks(sorted, id);
   });
+  if (!lockResult.ok) throw lockResult.error;
 }
 function validateImportTasks(importTasks2, existingTasks, ticketIds) {
   const errors = [];
@@ -1331,7 +1295,7 @@ async function selectProject(message = "Select project:") {
       default: true
     });
     if (create) {
-      const { projectAddCommand } = await import("./add-MRGCS3US.mjs");
+      const { projectAddCommand } = await import("./add-DVEYDCTR.mjs");
       await projectAddCommand({ interactive: true });
       const updated = await listProjects();
       if (updated.length === 0) return null;
@@ -1404,7 +1368,7 @@ async function selectSprint(message = "Select sprint:", filter) {
       default: true
     });
     if (create) {
-      const { sprintCreateCommand } = await import("./create-MG7E7PLQ.mjs");
+      const { sprintCreateCommand } = await import("./create-MQ4OHZAX.mjs");
       await sprintCreateCommand({ interactive: true });
       const updated = await listSprints();
       const refiltered = filter ? updated.filter((s) => filter.includes(s.status)) : updated;
@@ -1439,7 +1403,7 @@ async function selectTicket(message = "Select ticket:", filter) {
         default: true
       });
       if (create) {
-        const { ticketAddCommand } = await import("./add-HGJCLWED.mjs");
+        const { ticketAddCommand } = await import("./add-7LBVENXM.mjs");
         await ticketAddCommand({ interactive: true });
         const updated = await listTickets();
         const refiltered = filter ? updated.filter(filter) : updated;
@@ -1569,7 +1533,7 @@ async function importTasksAppend(tasks, sprintId) {
   const localToRealId = /* @__PURE__ */ new Map();
   const createdTasks = [];
   for (const taskInput of tasks) {
-    try {
+    const addR = await wrapAsync(async () => {
       const projectPath = taskInput.projectPath;
       const task = await addTask(
         {
@@ -1583,32 +1547,36 @@ async function importTasksAppend(tasks, sprintId) {
         },
         sprintId
       );
+      return task;
+    }, ensureError);
+    if (addR.ok) {
+      const task = addR.value;
       if (taskInput.id) {
         localToRealId.set(taskInput.id, task.id);
       }
       createdTasks.push({ task: taskInput, realId: task.id });
       log.itemSuccess(`${task.id}: ${task.name}`);
-    } catch (err) {
+    } else {
       log.itemError(`Failed to add: ${taskInput.name}`);
-      if (err instanceof Error) {
-        console.log(muted(`    ${err.message}`));
-      }
+      console.log(muted(`    ${addR.error.message}`));
     }
   }
   const tasksFilePath = getTasksFilePath(sprintId);
-  await withFileLock(tasksFilePath, async () => {
-    const allTasks = await getTasks(sprintId);
-    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;
+  unwrapOrThrow(
+    await withFileLock(tasksFilePath, async () => {
+      const allTasks = await getTasks(sprintId);
+      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, sprintId);
-  });
+      await saveTasks(allTasks, sprintId);
+    })
+  );
   return createdTasks.length;
 }
 async function importTasksReplace(tasks, sprintId) {
@@ -1669,17 +1637,17 @@ async function getSprintContext(sprintName, ticketsByProject, existingTasks) {
   for (const [projectName, tickets] of ticketsByProject) {
     lines.push("");
     lines.push(`## Project: ${projectName}`);
-    try {
-      const project = await getProject(projectName);
+    const projectR = await wrapAsync(() => getProject(projectName), ensureError);
+    if (projectR.ok) {
       lines.push("");
       lines.push("### Repositories");
-      for (const repo of project.repositories) {
+      for (const repo of projectR.value.repositories) {
         lines.push(`- **${repo.name}**: ${repo.path}`);
         if (repo.checkScript) {
           lines.push(`  - Check: \`${repo.checkScript}\``);
         }
       }
-    } catch {
+    } else {
       lines.push("Repositories: (project not found)");
     }
     lines.push("");
@@ -1758,23 +1726,20 @@ async function invokeAiAuto(prompt, repoPaths, planDir) {
 }
 async function sprintPlanCommand(args) {
   const { sprintId, options } = parseArgs2(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"], "plan");
   } catch (err) {
-    if (err instanceof Error) {
-      showError(err.message);
-      log.newline();
-    }
+    showError(err instanceof Error ? err.message : String(err));
+    log.newline();
     return;
   }
   if (sprint.tickets.length === 0) {
@@ -1831,11 +1796,10 @@ async function sprintPlanCommand(args) {
   const defaultPaths = [];
   for (const ticket of ticketsToProcess) {
     if (reposByProject.has(ticket.projectName)) continue;
-    try {
-      const project = await getProject(ticket.projectName);
-      reposByProject.set(ticket.projectName, project.repositories);
-      if (project.repositories[0]) defaultPaths.push(project.repositories[0].path);
-    } catch {
+    const projectR = await wrapAsync(() => getProject(ticket.projectName), ensureError);
+    if (projectR.ok) {
+      reposByProject.set(ticket.projectName, projectR.value.repositories);
+      if (projectR.value.repositories[0]) defaultPaths.push(projectR.value.repositories[0].path);
     }
   }
   const savedPaths = /* @__PURE__ */ new Set();
@@ -1900,19 +1864,16 @@ async function sprintPlanCommand(args) {
     const prompt = buildAutoPrompt(context, schema);
     const spinner = createSpinner(`${providerName} is planning tasks...`);
     spinner.start();
-    let output;
-    try {
-      output = await invokeAiAuto(prompt, selectedPaths, planDir);
-      spinner.succeed(`${providerName} finished planning`);
-    } catch (err) {
+    const outputR = await wrapAsync(() => invokeAiAuto(prompt, selectedPaths, planDir), ensureError);
+    if (!outputR.ok) {
       spinner.fail(`${providerName} planning 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 planning`);
+    const output = outputR.value;
     const blockedReason = parsePlanningBlocked(output);
     if (blockedReason) {
       showWarning(`Planning blocked: ${blockedReason}`);
@@ -1920,18 +1881,15 @@ async function sprintPlanCommand(args) {
       return;
     }
     console.log(muted("Parsing response..."));
-    let parsedTasks;
-    try {
-      parsedTasks = parseTasksJson(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 parsedR = Result4.try(() => parseTasksJson(output));
+    if (!parsedR.ok) {
+      showError(`Failed to parse ${providerName} output: ${parsedR.error.message}`);
+      log.dim("Raw output:");
+      console.log(output);
+      log.newline();
       return;
     }
+    const parsedTasks = parsedR.value;
     if (parsedTasks.length === 0) {
       showWarning("No tasks generated.");
       log.newline();
@@ -1972,37 +1930,29 @@ async function sprintPlanCommand(args) {
   ${providerName} will read planning-context.md and explore the repos.`));
     console.log(muted(`  When done, ask ${providerName} to write tasks to: ${outputFile}
 `));
-    try {
-      await invokeAiInteractive(prompt, selectedPaths, planDir);
-    } 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, planDir), 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("Task file found. Processing...");
-      let content;
-      try {
-        content = await readFile3(outputFile, "utf-8");
-      } catch {
+      const contentR = await wrapAsync(() => readFile3(outputFile, "utf-8"), ensureError);
+      if (!contentR.ok) {
         showError(`Failed to read task file: ${outputFile}`);
         log.newline();
         return;
       }
-      let parsedTasks;
-      try {
-        parsedTasks = parseTasksJson(content);
-      } catch (err) {
-        if (err instanceof Error) {
-          showError(`Failed to parse task file: ${err.message}`);
-          log.newline();
-        }
+      const parsedR = Result4.try(() => parseTasksJson(contentR.value));
+      if (!parsedR.ok) {
+        showError(`Failed to parse task file: ${parsedR.error.message}`);
+        log.newline();
         return;
       }
+      const parsedTasks = parsedR.value;
       if (parsedTasks.length === 0) {
         showWarning("No tasks in file.");
         log.newline();
@@ -2038,8 +1988,12 @@ async function sprintPlanCommand(args) {
   }
 }
 
+// src/commands/sprint/start.ts
+import { Result as Result8 } from "typescript-result";
+
 // src/ai/runner.ts
 import { confirm as confirm5, input as input2, select as select2 } from "@inquirer/prompts";
+import { Result as Result7 } from "typescript-result";
 
 // src/ai/executor.ts
 import { confirm as confirm4 } from "@inquirer/prompts";
@@ -2141,11 +2095,13 @@ var RateLimitCoordinator = class {
 import { execSync } from "child_process";
 import { writeFile as writeFile4 } from "fs/promises";
 import { join as join7 } from "path";
+import { Result as Result6 } from "typescript-result";
 
 // src/ai/permissions.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { join as join6 } from "path";
 import { homedir } from "os";
+import { Result as Result5 } from "typescript-result";
 function getProviderPermissions(projectPath, provider) {
   const permissions = {
     allow: [],
@@ -2156,30 +2112,34 @@ function getProviderPermissions(projectPath, provider) {
   }
   const projectSettingsPath = join6(projectPath, ".claude", "settings.local.json");
   if (existsSync2(projectSettingsPath)) {
-    try {
+    const projectResult = Result5.try(() => {
       const content = readFileSync2(projectSettingsPath, "utf-8");
-      const settings = JSON.parse(content);
+      return JSON.parse(content);
+    });
+    if (projectResult.ok) {
+      const settings = projectResult.value;
       if (settings.permissions?.allow) {
         permissions.allow.push(...settings.permissions.allow);
       }
       if (settings.permissions?.deny) {
         permissions.deny.push(...settings.permissions.deny);
       }
-    } catch {
     }
   }
   const userSettingsPath = join6(homedir(), ".claude", "settings.json");
   if (existsSync2(userSettingsPath)) {
-    try {
+    const userResult = Result5.try(() => {
       const content = readFileSync2(userSettingsPath, "utf-8");
-      const settings = JSON.parse(content);
+      return JSON.parse(content);
+    });
+    if (userResult.ok) {
+      const settings = userResult.value;
       if (settings.permissions?.allow) {
         permissions.allow.push(...settings.permissions.allow);
       }
       if (settings.permissions?.deny) {
         permissions.deny.push(...settings.permissions.deny);
       }
-    } catch {
     }
   }
   return permissions;
@@ -2251,7 +2211,7 @@ function checkTaskPermissions(projectPath, options) {
 
 // src/ai/task-context.ts
 function getRecentGitHistory(projectPath, count = 20) {
-  try {
+  const r = Result6.try(() => {
     assertSafeCwd(projectPath);
     const result = execSync(`git log -${String(count)} --oneline --no-decorate`, {
       cwd: projectPath,
@@ -2259,9 +2219,8 @@ function getRecentGitHistory(projectPath, count = 20) {
       stdio: ["pipe", "pipe", "pipe"]
     });
     return result.trim();
-  } catch {
-    return "(Unable to retrieve git history)";
-  }
+  });
+  return r.ok ? r.value : "(Unable to retrieve git history)";
 }
 function getEffectiveCheckScript(project, projectPath) {
   if (project) {
@@ -2390,14 +2349,10 @@ async function getProjectForTask(task, sprint) {
   if (!task.ticketId) return void 0;
   const ticket = sprint.tickets.find((t) => t.id === task.ticketId);
   if (!ticket) return void 0;
-  try {
-    return await getProject(ticket.projectName);
-  } catch (err) {
-    if (err instanceof ProjectNotFoundError) {
-      return void 0;
-    }
-    throw err;
-  }
+  const r = await wrapAsync(async () => getProject(ticket.projectName), ensureError);
+  if (r.ok) return r.value;
+  if (r.error instanceof ProjectNotFoundError) return void 0;
+  throw r.error;
 }
 function runPermissionCheck(ctx, noCommit, provider) {
   const checkScript = getEffectiveCheckScript(ctx.project, ctx.task.projectPath);
@@ -2479,10 +2434,7 @@ async function executeTask(ctx, options, sprintId, resumeSessionId, provider, ch
         sessionId: null
       };
     } finally {
-      try {
-        await unlink2(contextFile);
-      } catch {
-      }
+      await unlink2(contextFile).catch(() => void 0);
     }
   }
   let spawnResult;
@@ -2552,10 +2504,7 @@ async function executeTask(ctx, options, sprintId, resumeSessionId, provider, ch
       throw err;
     } finally {
       deregister();
-      try {
-        await unlink2(contextFile);
-      } catch {
-      }
+      await unlink2(contextFile).catch(() => void 0);
     }
   }
   const parsed = parseExecutionResult(spawnResult.stdout);
@@ -2923,43 +2872,28 @@ Resuming ${String(inProgressTasks.length)} in-progress task(s):`));
           }
           inFlightPaths.add(task.projectPath);
           const taskPromise = (async () => {
-            try {
-              const ctx = { sprint, task, project };
-              const result = await executeTask(
-                ctx,
-                options,
-                sprintId,
-                resumeId,
-                provider,
-                checkResults?.get(task.projectPath)
-              );
-              if (result.sessionId) {
-                taskSessionIds.set(task.id, result.sessionId);
-              }
-              return { task, result, error: null, isRateLimited: false };
-            } catch (err) {
+            const ctx = { sprint, task, project };
+            const resultR = await wrapAsync(
+              () => executeTask(ctx, options, sprintId, resumeId, provider, checkResults?.get(task.projectPath)),
+              ensureError
+            );
+            inFlightPaths.delete(task.projectPath);
+            if (!resultR.ok) {
+              const err = resultR.error;
               if (err instanceof SpawnError && err.rateLimited) {
                 if (err.sessionId) {
                   taskSessionIds.set(task.id, err.sessionId);
                 }
-                const delay = err.retryAfterMs ?? 6e4;
-                coordinator.pause(delay);
-                return {
-                  task,
-                  result: null,
-                  error: err,
-                  isRateLimited: true
-                };
+                coordinator.pause(err.retryAfterMs ?? 6e4);
+                return { task, result: null, error: err, isRateLimited: true };
               }
-              return {
-                task,
-                result: null,
-                error: err instanceof Error ? err : new Error(String(err)),
-                isRateLimited: false
-              };
-            } finally {
-              inFlightPaths.delete(task.projectPath);
+              return { task, result: null, error: err, isRateLimited: false };
+            }
+            const result = resultR.value;
+            if (result.sessionId) {
+              taskSessionIds.set(task.id, result.sessionId);
             }
+            return { task, result, error: null, isRateLimited: false };
           })();
           running.set(task.id, taskPromise);
         }
@@ -3286,22 +3220,19 @@ async function ensureSprintBranches(sprintId, sprint, branchName) {
   const uniquePaths = [...new Set(remainingTasks.map((t) => t.projectPath))];
   if (uniquePaths.length === 0) return;
   for (const projectPath of uniquePaths) {
-    try {
-      if (hasUncommittedChanges(projectPath)) {
-        throw new Error(
-          `Repository at ${projectPath} has uncommitted changes. Commit or stash them before starting the sprint.`
-        );
-      }
-    } catch (err) {
-      if (err instanceof Error && err.message.includes("uncommitted changes")) {
-        throw err;
-      }
+    const uncommittedR = Result7.try(() => hasUncommittedChanges(projectPath));
+    if (!uncommittedR.ok) {
       log.dim(`  Skipping ${projectPath} \u2014 not a git repository`);
       continue;
     }
+    if (uncommittedR.value) {
+      throw new Error(
+        `Repository at ${projectPath} has uncommitted changes. Commit or stash them before starting the sprint.`
+      );
+    }
   }
   for (const projectPath of uniquePaths) {
-    try {
+    const branchR = Result7.try(() => {
       const currentBranch = getCurrentBranch(projectPath);
       if (currentBranch === branchName) {
         log.dim(`  Already on branch '${branchName}' in ${projectPath}`);
@@ -3309,11 +3240,11 @@ async function ensureSprintBranches(sprintId, sprint, branchName) {
         createAndCheckoutBranch(projectPath, branchName);
         log.success(`  Branch '${branchName}' ready in ${projectPath}`);
       }
-    } catch (err) {
-      throw new Error(
-        `Failed to create branch '${branchName}' in ${projectPath}: ${err instanceof Error ? err.message : String(err)}`,
-        { cause: err }
-      );
+    });
+    if (!branchR.ok) {
+      throw new Error(`Failed to create branch '${branchName}' in ${projectPath}: ${branchR.error.message}`, {
+        cause: branchR.error
+      });
     }
   }
   if (sprint.branch !== branchName) {
@@ -3322,16 +3253,13 @@ async function ensureSprintBranches(sprintId, sprint, branchName) {
   }
 }
 function verifySprintBranch(projectPath, expectedBranch) {
-  try {
-    if (verifyCurrentBranch(projectPath, expectedBranch)) {
-      return true;
-    }
+  const r = Result7.try(() => {
+    if (verifyCurrentBranch(projectPath, expectedBranch)) return true;
     log.dim(`  Branch mismatch in ${projectPath} \u2014 checking out '${expectedBranch}'`);
     createAndCheckoutBranch(projectPath, expectedBranch);
     return verifyCurrentBranch(projectPath, expectedBranch);
-  } catch {
-    return false;
-  }
+  });
+  return r.ok ? r.value : false;
 }
 async function runCheckScripts(sprintId, sprint, refreshCheck = false) {
   const results = /* @__PURE__ */ new Map();
@@ -3461,28 +3389,26 @@ async function runSprint(sprintId, options) {
     log.info(`Branch: ${branchName}`);
   }
   if (branchName) {
-    try {
-      await ensureSprintBranches(id, sprint, branchName);
-    } catch (err) {
+    const ensureR = await wrapAsync(() => ensureSprintBranches(id, sprint, branchName), ensureError);
+    if (!ensureR.ok) {
       log.newline();
-      showError(err instanceof Error ? err.message : String(err));
+      showError(ensureR.error.message);
       log.newline();
       return void 0;
     }
   }
-  try {
-    await reorderByDependencies(id);
-    log.dim("Tasks reordered by dependencies");
-  } catch (err) {
-    if (err instanceof DependencyCycleError) {
+  const reorderR = await wrapAsync(() => reorderByDependencies(id), ensureError);
+  if (!reorderR.ok) {
+    if (reorderR.error instanceof DependencyCycleError) {
       log.newline();
-      showWarning(err.message);
+      showWarning(reorderR.error.message);
       log.dim("Fix the dependency cycle before starting.");
       log.newline();
       return void 0;
     }
-    throw err;
+    throw reorderR.error;
   }
+  log.dim("Tasks reordered by dependencies");
   const checkResult = await runCheckScripts(id, sprint, options.refreshCheck);
   if (!checkResult.success) {
     log.newline();
@@ -3595,25 +3521,16 @@ function parseArgs3(args) {
   return { sprintId, options };
 }
 async function sprintStartCommand(args) {
-  let sprintId;
-  let options;
-  try {
-    const parsed = parseArgs3(args);
-    sprintId = parsed.sprintId;
-    options = parsed.options;
-  } catch (err) {
-    if (err instanceof Error) {
-      showError(err.message);
-      log.newline();
-    }
+  const parseR = Result8.try(() => parseArgs3(args));
+  if (!parseR.ok) {
+    showError(parseR.error.message);
+    log.newline();
     exitWithCode(EXIT_ERROR);
   }
-  try {
-    const summary = await runSprint(sprintId, options);
-    if (summary) {
-      exitWithCode(summary.exitCode);
-    }
-  } catch (err) {
+  const { sprintId, options } = parseR.value;
+  const runR = await wrapAsync(() => runSprint(sprintId, options), ensureError);
+  if (!runR.ok) {
+    const err = runR.error;
     if (err instanceof SprintNotFoundError) {
       showError(`Sprint not found: ${sprintId ?? "unknown"}`);
       log.newline();
@@ -3622,7 +3539,7 @@ async function sprintStartCommand(args) {
       showError(err.message);
       log.newline();
       exitWithCode(EXIT_ERROR);
-    } else if (err instanceof Error && err.message.includes("No sprint specified")) {
+    } else if (err.message.includes("No sprint specified")) {
       showWarning("No sprint specified and no active sprint set.");
       showNextStep("ralphctl sprint start <id>", "specify a sprint ID");
       log.newline();
@@ -3630,11 +3547,15 @@ async function sprintStartCommand(args) {
     } else {
       throw err;
     }
+    return;
+  }
+  const summary = runR.value;
+  if (summary) {
+    exitWithCode(summary.exitCode);
   }
 }
 
 export {
-  TaskNotFoundError,
   getTasks,
   saveTasks,
   getTask,