@oss-autopilot/core 0.41.0 → 0.42.1

package/dist/cli.bundle.cjs

@@ -1196,8 +1196,8 @@ var require_command = __commonJS({
   "../../node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/command.js"(exports2) {
     var EventEmitter = require("node:events").EventEmitter;
     var childProcess = require("node:child_process");
-    var path9 = require("node:path");
-    var fs9 = require("node:fs");
+    var path10 = require("node:path");
+    var fs10 = require("node:fs");
     var process2 = require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -2191,7 +2191,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} subcommandName
        */
       _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-        if (fs9.existsSync(executableFile)) return;
+        if (fs10.existsSync(executableFile)) return;
         const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
         const executableMissing = `'${executableFile}' does not exist
  - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
@@ -2209,11 +2209,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path9.resolve(baseDir, baseName);
-          if (fs9.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path9.extname(baseName))) return void 0;
+          const localBin = path10.resolve(baseDir, baseName);
+          if (fs10.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path10.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs9.existsSync(`${localBin}${ext}`)
+            (ext) => fs10.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -2225,21 +2225,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs9.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs10.realpathSync(this._scriptPath);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path9.resolve(
-            path9.dirname(resolvedScriptPath),
+          executableDir = path10.resolve(
+            path10.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path9.basename(
+            const legacyName = path10.basename(
               this._scriptPath,
-              path9.extname(this._scriptPath)
+              path10.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -2250,7 +2250,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path9.extname(executableFile));
+        launchWithNode = sourceExt.includes(path10.extname(executableFile));
         let proc;
         if (process2.platform !== "win32") {
           if (launchWithNode) {
@@ -3165,7 +3165,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path9.basename(filename, path9.extname(filename));
+        this._name = path10.basename(filename, path10.extname(filename));
         return this;
       }
       /**
@@ -3179,9 +3179,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path10) {
-        if (path10 === void 0) return this._executableDir;
-        this._executableDir = path10;
+      executableDir(path11) {
+        if (path11 === void 0) return this._executableDir;
+        this._executableDir = path11;
         return this;
       }
       /**
@@ -3498,6 +3498,16 @@ var init_types = __esm({
 });
 
 // src/core/errors.ts
+function errorMessage(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+function getHttpStatusCode(error) {
+  if (error && typeof error === "object" && "status" in error) {
+    const status = error.status;
+    return typeof status === "number" && Number.isFinite(status) ? status : void 0;
+  }
+  return void 0;
+}
 var OssAutopilotError, ConfigurationError, ValidationError;
 var init_errors = __esm({
   "src/core/errors.ts"() {
@@ -3640,6 +3650,17 @@ function splitRepo(repoFullName) {
   const [owner, repo] = repoFullName.split("/");
   return { owner, repo };
 }
+function isOwnRepo(owner, username) {
+  return owner.toLowerCase() === username.toLowerCase();
+}
+function getCLIVersion() {
+  try {
+    const pkgPath = path.join(path.dirname(process.argv[1]), "..", "package.json");
+    return JSON.parse(fs.readFileSync(pkgPath, "utf-8")).version;
+  } catch {
+    return "0.0.0";
+  }
+}
 function formatRelativeTime(dateStr) {
   const date = new Date(dateStr);
   const diffMs = Date.now() - date.getTime();
@@ -3681,6 +3702,15 @@ function getGitHubToken() {
   }
   return null;
 }
+function requireGitHubToken() {
+  const token = getGitHubToken();
+  if (!token) {
+    throw new ConfigurationError(
+      "GitHub authentication required.\n\nOptions:\n  1. Use gh CLI: gh auth login\n  2. Set GITHUB_TOKEN environment variable\n\nThe gh CLI is recommended - install from https://cli.github.com"
+    );
+  }
+  return token;
+}
 async function getGitHubTokenAsync() {
   if (cachedGitHubToken) {
     return cachedGitHubToken;
@@ -3694,12 +3724,12 @@ async function getGitHubTokenAsync() {
     return cachedGitHubToken;
   }
   try {
-    const token = await new Promise((resolve3, reject) => {
+    const token = await new Promise((resolve5, reject) => {
       (0, import_child_process.execFile)("gh", ["auth", "token"], { encoding: "utf-8", timeout: 2e3 }, (error, stdout) => {
         if (error) {
           reject(error);
         } else {
-          resolve3(stdout.trim());
+          resolve5(stdout.trim());
         }
       });
     });
@@ -3951,8 +3981,7 @@ var init_state = __esm({
           debug(MODULE2, "Migration complete!");
           return true;
         } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          warn(MODULE2, `Failed to migrate state: ${errorMessage}`);
+          warn(MODULE2, `Failed to migrate state: ${errorMessage(error)}`);
           const newStatePath2 = getStatePath();
           if (fs2.existsSync(newStatePath2) && fs2.existsSync(LEGACY_STATE_FILE)) {
             try {
@@ -4104,11 +4133,11 @@ var init_state = __esm({
             try {
               fs2.unlinkSync(path2.join(backupDir, file));
             } catch (error) {
-              warn(MODULE2, `Could not delete old backup ${file}:`, error instanceof Error ? error.message : error);
+              warn(MODULE2, `Could not delete old backup ${file}:`, errorMessage(error));
             }
           }
         } catch (error) {
-          warn(MODULE2, "Could not clean up backups:", error instanceof Error ? error.message : error);
+          warn(MODULE2, "Could not clean up backups:", errorMessage(error));
         }
       }
       /**
@@ -5891,17 +5920,17 @@ function requestLog(octokit) {
     octokit.log.debug("request", options);
     const start = Date.now();
     const requestOptions = octokit.request.endpoint.parse(options);
-    const path9 = requestOptions.url.replace(options.baseUrl, "");
+    const path10 = requestOptions.url.replace(options.baseUrl, "");
     return request2(options).then((response) => {
       const requestId = response.headers["x-github-request-id"];
       octokit.log.info(
-        `${requestOptions.method} ${path9} - ${response.status} with id ${requestId} in ${Date.now() - start}ms`
+        `${requestOptions.method} ${path10} - ${response.status} with id ${requestId} in ${Date.now() - start}ms`
       );
       return response;
     }).catch((error) => {
       const requestId = error.response?.headers["x-github-request-id"] || "UNKNOWN";
       octokit.log.error(
-        `${requestOptions.method} ${path9} - ${error.status} with id ${requestId} in ${Date.now() - start}ms`
+        `${requestOptions.method} ${path10} - ${error.status} with id ${requestId} in ${Date.now() - start}ms`
       );
       throw error;
     });
@@ -8970,8 +8999,8 @@ var require_light = __commonJS({
           return this.Promise.resolve();
         }
         yieldLoop(t = 0) {
-          return new this.Promise(function(resolve3, reject) {
-            return setTimeout(resolve3, t);
+          return new this.Promise(function(resolve5, reject) {
+            return setTimeout(resolve5, t);
           });
         }
         computePenalty() {
@@ -9182,15 +9211,15 @@ var require_light = __commonJS({
           return this._queue.length === 0;
         }
         async _tryToRun() {
-          var args, cb, error, reject, resolve3, returned, task;
+          var args, cb, error, reject, resolve5, returned, task;
           if (this._running < 1 && this._queue.length > 0) {
             this._running++;
-            ({ task, args, resolve: resolve3, reject } = this._queue.shift());
+            ({ task, args, resolve: resolve5, reject } = this._queue.shift());
             cb = await (async function() {
               try {
                 returned = await task(...args);
                 return function() {
-                  return resolve3(returned);
+                  return resolve5(returned);
                 };
               } catch (error1) {
                 error = error1;
@@ -9205,13 +9234,13 @@ var require_light = __commonJS({
           }
         }
         schedule(task, ...args) {
-          var promise, reject, resolve3;
-          resolve3 = reject = null;
+          var promise, reject, resolve5;
+          resolve5 = reject = null;
           promise = new this.Promise(function(_resolve, _reject) {
-            resolve3 = _resolve;
+            resolve5 = _resolve;
             return reject = _reject;
           });
-          this._queue.push({ task, args, resolve: resolve3, reject });
+          this._queue.push({ task, args, resolve: resolve5, reject });
           this._tryToRun();
           return promise;
         }
@@ -9612,14 +9641,14 @@ var require_light = __commonJS({
                 counts = this._states.counts;
                 return counts[0] + counts[1] + counts[2] + counts[3] === at;
               };
-              return new this.Promise((resolve3, reject) => {
+              return new this.Promise((resolve5, reject) => {
                 if (finished()) {
-                  return resolve3();
+                  return resolve5();
                 } else {
                   return this.on("done", () => {
                     if (finished()) {
                       this.removeAllListeners("done");
-                      return resolve3();
+                      return resolve5();
                     }
                   });
                 }
@@ -9712,9 +9741,9 @@ var require_light = __commonJS({
               options = parser$5.load(options, this.jobDefaults);
             }
             task = (...args2) => {
-              return new this.Promise(function(resolve3, reject) {
+              return new this.Promise(function(resolve5, reject) {
                 return fn(...args2, function(...args3) {
-                  return (args3[0] != null ? reject : resolve3)(args3);
+                  return (args3[0] != null ? reject : resolve5)(args3);
                 });
               });
             };
@@ -9882,7 +9911,7 @@ function isAuthRequest(method, pathname) {
 }
 function routeMatcher(paths) {
   const regexes = paths.map(
-    (path9) => path9.split("/").map((c) => c.startsWith("{") ? "(?:.+?)" : c).join("/")
+    (path10) => path10.split("/").map((c) => c.startsWith("{") ? "(?:.+?)" : c).join("/")
   );
   const regex2 = `^(?:${regexes.map((r) => `(?:${r})`).join("|")})[^/]*$`;
   return new RegExp(regex2, "i");
@@ -10210,10 +10239,7 @@ async function cachedRequest(cache, url, fetcher) {
   }
 }
 function isNotModifiedError(err) {
-  if (err && typeof err === "object" && "status" in err) {
-    return err.status === 304;
-  }
-  return false;
+  return getHttpStatusCode(err) === 304;
 }
 var fs3, path3, crypto, MODULE4, DEFAULT_MAX_AGE_MS, HttpCache, _httpCache;
 var init_http_cache = __esm({
@@ -10224,6 +10250,7 @@ var init_http_cache = __esm({
     crypto = __toESM(require("crypto"), 1);
     init_utils();
     init_logger();
+    init_errors();
     MODULE4 = "http-cache";
     DEFAULT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
     HttpCache = class {
@@ -10241,6 +10268,18 @@ var init_http_cache = __esm({
       pathFor(url) {
         return path3.join(this.cacheDir, `${this.keyFor(url)}.json`);
       }
+      /**
+       * Return the cached body if the entry exists and is younger than `maxAgeMs`.
+       * Useful for time-based caching where ETag validation isn't applicable
+       * (e.g., caching aggregated results from paginated API calls).
+       */
+      getIfFresh(key, maxAgeMs) {
+        const entry = this.get(key);
+        if (!entry) return null;
+        const age = Date.now() - new Date(entry.cachedAt).getTime();
+        if (!Number.isFinite(age) || age < 0 || age > maxAgeMs) return null;
+        return entry.body;
+      }
       /**
        * Look up a cached response. Returns `null` if no cache entry exists.
        */
@@ -10804,11 +10843,28 @@ var init_display_utils = __esm({
 });
 
 // src/core/github-stats.ts
-async function fetchUserMergedPRCounts(octokit, githubUsername) {
+function isCachedPRCounts(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const obj = v;
+  return Array.isArray(obj.reposEntries) && typeof obj.monthlyCounts === "object" && obj.monthlyCounts !== null && typeof obj.monthlyOpenedCounts === "object" && obj.monthlyOpenedCounts !== null && typeof obj.dailyActivityCounts === "object" && obj.dailyActivityCounts !== null;
+}
+async function fetchUserPRCounts(octokit, githubUsername, query, label, accumulateRepo) {
   if (!githubUsername) {
     return { repos: /* @__PURE__ */ new Map(), monthlyCounts: {}, monthlyOpenedCounts: {}, dailyActivityCounts: {} };
   }
-  debug(MODULE6, `Fetching merged PR counts for @${githubUsername}...`);
+  const cache = getHttpCache();
+  const cacheKey = `pr-counts:${label}:${githubUsername}`;
+  const cached = cache.getIfFresh(cacheKey, PR_COUNTS_CACHE_TTL_MS);
+  if (cached && isCachedPRCounts(cached)) {
+    debug(MODULE6, `Using cached ${label} PR counts for @${githubUsername}`);
+    return {
+      repos: new Map(cached.reposEntries),
+      monthlyCounts: cached.monthlyCounts,
+      monthlyOpenedCounts: cached.monthlyOpenedCounts,
+      dailyActivityCounts: cached.dailyActivityCounts
+    };
+  }
+  debug(MODULE6, `Fetching ${label} PR counts for @${githubUsername}...`);
   const repos = /* @__PURE__ */ new Map();
   const monthlyCounts = {};
   const monthlyOpenedCounts = {};
@@ -10817,7 +10873,7 @@ async function fetchUserMergedPRCounts(octokit, githubUsername) {
   let fetched = 0;
   while (true) {
     const { data } = await octokit.search.issuesAndPullRequests({
-      q: `is:pr is:merged author:${githubUsername}`,
+      q: `is:pr ${query} author:${githubUsername}`,
       sort: "updated",
       order: "desc",
       per_page: 100,
@@ -10826,25 +10882,18 @@ async function fetchUserMergedPRCounts(octokit, githubUsername) {
     for (const item of data.items) {
       const parsed = extractOwnerRepo(item.html_url);
       if (!parsed) {
-        warn(MODULE6, `Skipping merged PR with unparseable URL: ${item.html_url}`);
+        warn(MODULE6, `Skipping ${label} PR with unparseable URL: ${item.html_url}`);
         continue;
       }
       const { owner } = parsed;
       const repo = `${owner}/${parsed.repo}`;
-      if (owner.toLowerCase() === githubUsername.toLowerCase()) continue;
-      const mergedAt = item.pull_request?.merged_at || item.closed_at || "";
-      const existing = repos.get(repo);
-      if (existing) {
-        existing.count += 1;
-        if (mergedAt && mergedAt > existing.lastMergedAt) {
-          existing.lastMergedAt = mergedAt;
-        }
-      } else {
-        repos.set(repo, { count: 1, lastMergedAt: mergedAt });
-      }
-      if (mergedAt) {
-        const month = mergedAt.slice(0, 7);
+      if (isOwnRepo(owner, githubUsername)) continue;
+      const primaryDate = accumulateRepo(repos, repo, item);
+      if (primaryDate) {
+        const month = primaryDate.slice(0, 7);
         monthlyCounts[month] = (monthlyCounts[month] || 0) + 1;
+        const day = primaryDate.slice(0, 10);
+        if (day.length === 10) dailyActivityCounts[day] = (dailyActivityCounts[day] || 0) + 1;
       }
       if (item.created_at) {
         const openedMonth = item.created_at.slice(0, 7);
@@ -10852,10 +10901,6 @@ async function fetchUserMergedPRCounts(octokit, githubUsername) {
         const openedDay = item.created_at.slice(0, 10);
         if (openedDay.length === 10) dailyActivityCounts[openedDay] = (dailyActivityCounts[openedDay] || 0) + 1;
       }
-      if (mergedAt) {
-        const mergedDay = mergedAt.slice(0, 10);
-        if (mergedDay.length === 10) dailyActivityCounts[mergedDay] = (dailyActivityCounts[mergedDay] || 0) + 1;
-      }
     }
     fetched += data.items.length;
     if (fetched >= data.total_count || fetched >= 1e3 || data.items.length === 0) {
@@ -10863,59 +10908,41 @@ async function fetchUserMergedPRCounts(octokit, githubUsername) {
     }
     page++;
   }
-  debug(MODULE6, `Found ${fetched} merged PRs across ${repos.size} repos`);
+  debug(MODULE6, `Found ${fetched} ${label} PRs across ${repos.size} repos`);
+  cache.set(cacheKey, "", {
+    reposEntries: Array.from(repos.entries()),
+    monthlyCounts,
+    monthlyOpenedCounts,
+    dailyActivityCounts
+  });
   return { repos, monthlyCounts, monthlyOpenedCounts, dailyActivityCounts };
 }
-async function fetchUserClosedPRCounts(octokit, githubUsername) {
-  if (!githubUsername) {
-    return { repos: /* @__PURE__ */ new Map(), monthlyCounts: {}, monthlyOpenedCounts: {}, dailyActivityCounts: {} };
-  }
-  debug(MODULE6, `Fetching closed PR counts for @${githubUsername}...`);
-  const repos = /* @__PURE__ */ new Map();
-  const monthlyCounts = {};
-  const monthlyOpenedCounts = {};
-  const dailyActivityCounts = {};
-  let page = 1;
-  let fetched = 0;
-  while (true) {
-    const { data } = await octokit.search.issuesAndPullRequests({
-      q: `is:pr is:closed is:unmerged author:${githubUsername}`,
-      sort: "updated",
-      order: "desc",
-      per_page: 100,
-      page
-    });
-    for (const item of data.items) {
-      const parsed = extractOwnerRepo(item.html_url);
-      if (!parsed) {
-        warn(MODULE6, `Skipping closed PR with unparseable URL: ${item.html_url}`);
-        continue;
-      }
-      const { owner } = parsed;
-      const repo = `${owner}/${parsed.repo}`;
-      if (owner.toLowerCase() === githubUsername.toLowerCase()) continue;
-      repos.set(repo, (repos.get(repo) || 0) + 1);
-      if (item.closed_at) {
-        const closedMonth = item.closed_at.slice(0, 7);
-        monthlyCounts[closedMonth] = (monthlyCounts[closedMonth] || 0) + 1;
-        const closedDay = item.closed_at.slice(0, 10);
-        if (closedDay.length === 10) dailyActivityCounts[closedDay] = (dailyActivityCounts[closedDay] || 0) + 1;
-      }
-      if (item.created_at) {
-        const openedMonth = item.created_at.slice(0, 7);
-        monthlyOpenedCounts[openedMonth] = (monthlyOpenedCounts[openedMonth] || 0) + 1;
-        const openedDay = item.created_at.slice(0, 10);
-        if (openedDay.length === 10) dailyActivityCounts[openedDay] = (dailyActivityCounts[openedDay] || 0) + 1;
-      }
+function fetchUserMergedPRCounts(octokit, githubUsername) {
+  return fetchUserPRCounts(octokit, githubUsername, "is:merged", "merged", (repos, repo, item) => {
+    if (!item.pull_request?.merged_at) {
+      warn(
+        MODULE6,
+        `merged_at missing for merged PR ${item.html_url}${item.closed_at ? ", falling back to closed_at" : ", no date available"}`
+      );
     }
-    fetched += data.items.length;
-    if (fetched >= data.total_count || fetched >= 1e3 || data.items.length === 0) {
-      break;
+    const mergedAt = item.pull_request?.merged_at || item.closed_at || "";
+    const existing = repos.get(repo);
+    if (existing) {
+      existing.count += 1;
+      if (mergedAt && mergedAt > existing.lastMergedAt) {
+        existing.lastMergedAt = mergedAt;
+      }
+    } else {
+      repos.set(repo, { count: 1, lastMergedAt: mergedAt });
     }
-    page++;
-  }
-  debug(MODULE6, `Found ${fetched} closed (unmerged) PRs across ${repos.size} repos`);
-  return { repos, monthlyCounts, monthlyOpenedCounts, dailyActivityCounts };
+    return mergedAt;
+  });
+}
+function fetchUserClosedPRCounts(octokit, githubUsername) {
+  return fetchUserPRCounts(octokit, githubUsername, "is:closed is:unmerged", "closed", (repos, repo, item) => {
+    repos.set(repo, (repos.get(repo) || 0) + 1);
+    return item.closed_at || "";
+  });
 }
 async function fetchRecentPRs(octokit, config, query, label, days, mapItem) {
   if (!config.githubUsername) {
@@ -10940,7 +10967,7 @@ async function fetchRecentPRs(octokit, config, query, label, days, mapItem) {
       continue;
     }
     const repo = `${parsed.owner}/${parsed.repo}`;
-    if (parsed.owner.toLowerCase() === config.githubUsername.toLowerCase()) continue;
+    if (isOwnRepo(parsed.owner, config.githubUsername)) continue;
     if (config.excludeRepos.includes(repo)) continue;
     if (config.excludeOrgs?.some((org) => parsed.owner.toLowerCase() === org.toLowerCase())) continue;
     results.push(mapItem(item, { owner: parsed.owner, repo, number: parsed.number }));
@@ -10989,14 +11016,15 @@ async function fetchRecentlyMergedPRs(octokit, config, days = 7) {
     }
   );
 }
-var MODULE6;
+var MODULE6, PR_COUNTS_CACHE_TTL_MS;
 var init_github_stats = __esm({
   "src/core/github-stats.ts"() {
     "use strict";
     init_utils();
-    init_errors();
     init_logger();
+    init_http_cache();
     MODULE6 = "github-stats";
+    PR_COUNTS_CACHE_TTL_MS = 60 * 60 * 1e3;
   }
 });
 
@@ -11097,9 +11125,9 @@ var init_pr_monitor = __esm({
                 const pr = await this.fetchPRDetails(item.html_url);
                 if (pr) prs.push(pr);
               } catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                warn("pr-monitor", `Error fetching ${item.html_url}: ${errorMessage}`);
-                failures.push({ prUrl: item.html_url, error: errorMessage });
+                const errMsg = errorMessage(error);
+                warn("pr-monitor", `Error fetching ${item.html_url}: ${errMsg}`);
+                failures.push({ prUrl: item.html_url, error: errMsg });
               }
             },
             MAX_CONCURRENT_REQUESTS
@@ -11146,12 +11174,12 @@ var init_pr_monitor = __esm({
           paginateAll(
             (page) => this.octokit.pulls.listReviewComments({ owner, repo, pull_number: number, per_page: 100, page })
           ).catch((err) => {
-            const status2 = err?.status;
+            const status2 = getHttpStatusCode(err);
             if (status2 === 429) {
               throw err;
             }
             if (status2 === 403) {
-              const msg = (err?.message ?? "").toLowerCase();
+              const msg = errorMessage(err).toLowerCase();
               if (msg.includes("rate limit") || msg.includes("abuse detection")) {
                 throw err;
               }
@@ -11318,7 +11346,7 @@ var init_pr_monitor = __esm({
             this.octokit.repos.getCombinedStatusForRef({ owner, repo, ref: sha }),
             // 404 is expected for repos without check runs configured; log other errors for debugging
             this.octokit.checks.listForRef({ owner, repo, ref: sha }).catch((err) => {
-              const status = err?.status;
+              const status = getHttpStatusCode(err);
               if (status === 404) {
                 debug("pr-monitor", `Check runs 404 for ${owner}/${repo}@${sha.slice(0, 7)} (no checks configured)`);
               } else {
@@ -11344,8 +11372,8 @@ var init_pr_monitor = __esm({
           const combinedAnalysis = analyzeCombinedStatus(combinedStatus);
           return mergeStatuses(checkRunAnalysis, combinedAnalysis, checkRuns.length);
         } catch (error) {
-          const statusCode = error.status;
-          const errorMessage = error instanceof Error ? error.message : String(error);
+          const statusCode = getHttpStatusCode(error);
+          const errMsg = errorMessage(error);
           if (statusCode === 401) {
             warn("pr-monitor", `CI check failed for ${owner}/${repo}: Invalid token`);
           } else if (statusCode === 403) {
@@ -11354,7 +11382,7 @@ var init_pr_monitor = __esm({
             debug("pr-monitor", `CI check 404 for ${owner}/${repo} (no CI configured)`);
             return { status: "unknown", failingCheckNames: [], failingCheckConclusions: /* @__PURE__ */ new Map() };
           } else {
-            warn("pr-monitor", `Failed to check CI for ${owner}/${repo}@${sha.slice(0, 7)}: ${errorMessage}`);
+            warn("pr-monitor", `Failed to check CI for ${owner}/${repo}@${sha.slice(0, 7)}: ${errMsg}`);
           }
           return { status: "unknown", failingCheckNames: [], failingCheckConclusions: /* @__PURE__ */ new Map() };
         }
@@ -11415,10 +11443,7 @@ var init_pr_monitor = __esm({
               results.set(result.value.repo, result.value.stars);
             } else {
               chunkFailures++;
-              warn(
-                MODULE7,
-                `Failed to fetch stars for ${chunk[j]}: ${result.reason instanceof Error ? result.reason.message : result.reason}`
-              );
+              warn(MODULE7, `Failed to fetch stars for ${chunk[j]}: ${errorMessage(result.reason)}`);
             }
           }
           if (chunkFailures === chunk.length && chunk.length > 0) {
@@ -11432,42 +11457,6 @@ var init_pr_monitor = __esm({
         debug(MODULE7, `Fetched star counts for ${results.size}/${repos.length} repos`);
         return results;
       }
-      /**
-       * Shared helper: search for recent PRs and filter out own repos, excluded repos/orgs.
-       * Returns parsed search results that pass all filters.
-       */
-      async fetchRecentPRs(query, label, days, mapItem) {
-        const config = this.stateManager.getState().config;
-        if (!config.githubUsername) {
-          warn(MODULE7, `Skipping recently ${label} PRs fetch: no githubUsername configured. Run /setup-oss to configure.`);
-          return [];
-        }
-        const sinceDate = /* @__PURE__ */ new Date();
-        sinceDate.setDate(sinceDate.getDate() - days);
-        const since = sinceDate.toISOString().split("T")[0];
-        debug(MODULE7, `Fetching recently ${label} PRs for @${config.githubUsername} (since ${since})...`);
-        const { data } = await this.octokit.search.issuesAndPullRequests({
-          q: query.replace("{username}", config.githubUsername).replace("{since}", since),
-          sort: "updated",
-          order: "desc",
-          per_page: 100
-        });
-        const results = [];
-        for (const item of data.items) {
-          const parsed = parseGitHubUrl(item.html_url);
-          if (!parsed) {
-            warn(MODULE7, `Could not parse GitHub URL from API response: ${item.html_url}`);
-            continue;
-          }
-          const repo = `${parsed.owner}/${parsed.repo}`;
-          if (parsed.owner.toLowerCase() === config.githubUsername.toLowerCase()) continue;
-          if (config.excludeRepos.includes(repo)) continue;
-          if (config.excludeOrgs?.some((org) => parsed.owner.toLowerCase() === org.toLowerCase())) continue;
-          results.push(mapItem(item, { owner: parsed.owner, repo, number: parsed.number }));
-        }
-        debug(MODULE7, `Found ${results.length} recently ${label} PRs`);
-        return results;
-      }
       /**
        * Fetch PRs closed without merge in the last N days.
        * Delegates to github-stats module.
@@ -11892,7 +11881,7 @@ var init_issue_vetting = __esm({
             if (_IssueVetter.isRateLimitError(error)) {
               rateLimitFailures++;
             }
-            warn(MODULE8, `Error vetting issue ${url}:`, error instanceof Error ? error.message : error);
+            warn(MODULE8, `Error vetting issue ${url}:`, errorMessage(error));
           });
           pending.push(task);
           if (pending.length >= MAX_CONCURRENT_REQUESTS2) {
@@ -11912,10 +11901,10 @@ var init_issue_vetting = __esm({
       }
       /** Check if an error is a GitHub rate limit error (429 or rate-limit 403). */
       static isRateLimitError(error) {
-        const status = error?.status;
+        const status = getHttpStatusCode(error);
         if (status === 429) return true;
         if (status === 403) {
-          const msg = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+          const msg = errorMessage(error).toLowerCase();
           return msg.includes("rate limit");
         }
         return false;
@@ -11941,12 +11930,12 @@ var init_issue_vetting = __esm({
           });
           return { passed: data.total_count === 0 && linkedPRs.length === 0 };
         } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
+          const errMsg = errorMessage(error);
           warn(
             MODULE8,
-            `Failed to check for existing PRs on ${owner}/${repo}#${issueNumber}: ${errorMessage}. Assuming no existing PR.`
+            `Failed to check for existing PRs on ${owner}/${repo}#${issueNumber}: ${errMsg}. Assuming no existing PR.`
           );
-          return { passed: true, inconclusive: true, reason: errorMessage };
+          return { passed: true, inconclusive: true, reason: errMsg };
         }
       }
       /**
@@ -11962,8 +11951,8 @@ var init_issue_vetting = __esm({
           });
           return data.total_count;
         } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          warn(MODULE8, `Could not check merged PRs in ${owner}/${repo}: ${errorMessage}. Defaulting to 0.`);
+          const errMsg = errorMessage(error);
+          warn(MODULE8, `Could not check merged PRs in ${owner}/${repo}: ${errMsg}. Defaulting to 0.`);
           return 0;
         }
       }
@@ -12006,12 +11995,9 @@ var init_issue_vetting = __esm({
           }
           return { passed: true };
         } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          warn(
-            MODULE8,
-            `Failed to check claim status on ${owner}/${repo}#${issueNumber}: ${errorMessage}. Assuming not claimed.`
-          );
-          return { passed: true, inconclusive: true, reason: errorMessage };
+          const errMsg = errorMessage(error);
+          warn(MODULE8, `Failed to check claim status on ${owner}/${repo}#${issueNumber}: ${errMsg}. Assuming not claimed.`);
+          return { passed: true, inconclusive: true, reason: errMsg };
         }
       }
       async checkProjectHealth(owner, repo) {
@@ -12042,8 +12028,8 @@ var init_issue_vetting = __esm({
               ciStatus = "passing";
             }
           } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            warn(MODULE8, `Failed to check CI status for ${owner}/${repo}: ${errorMessage}. Defaulting to unknown.`);
+            const errMsg = errorMessage(error);
+            warn(MODULE8, `Failed to check CI status for ${owner}/${repo}: ${errMsg}. Defaulting to unknown.`);
           }
           return {
             repo: `${owner}/${repo}`,
@@ -12058,8 +12044,8 @@ var init_issue_vetting = __esm({
             forksCount: repoData.forks_count
           };
         } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          warn(MODULE8, `Error checking project health for ${owner}/${repo}: ${errorMessage}`);
+          const errMsg = errorMessage(error);
+          warn(MODULE8, `Error checking project health for ${owner}/${repo}: ${errMsg}`);
           return {
             repo: `${owner}/${repo}`,
             lastCommitAt: "",
@@ -12069,7 +12055,7 @@ var init_issue_vetting = __esm({
             ciStatus: "unknown",
             isActive: false,
             checkFailed: true,
-            failureReason: errorMessage
+            failureReason: errMsg
           };
         }
       }
@@ -12222,18 +12208,18 @@ var init_issue_discovery = __esm({
           return starredRepos;
         } catch (error) {
           const cachedRepos = this.stateManager.getStarredRepos();
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          warn(MODULE9, "Error fetching starred repos:", errorMessage);
+          const errMsg = errorMessage(error);
+          warn(MODULE9, "Error fetching starred repos:", errMsg);
           if (cachedRepos.length === 0) {
             warn(
               MODULE9,
-              `Failed to fetch starred repositories from GitHub API. No cached repos available. Error: ${errorMessage}
+              `Failed to fetch starred repositories from GitHub API. No cached repos available. Error: ${errMsg}
 Tip: Ensure your GITHUB_TOKEN has the 'read:user' scope and try again.`
             );
           } else {
             warn(
               MODULE9,
-              `Failed to fetch starred repositories from GitHub API. Using ${cachedRepos.length} cached repos instead. Error: ${errorMessage}`
+              `Failed to fetch starred repositories from GitHub API. Using ${cachedRepos.length} cached repos instead. Error: ${errMsg}`
             );
           }
           return cachedRepos;
@@ -12272,10 +12258,10 @@ Tip: Ensure your GITHUB_TOKEN has the 'read:user' scope and try again.`
             warn(MODULE9, this.rateLimitWarning);
           }
         } catch (error) {
-          if (error?.status === 401) {
+          if (getHttpStatusCode(error) === 401) {
             throw error;
           }
-          warn(MODULE9, "Could not check rate limit:", error instanceof Error ? error.message : error);
+          warn(MODULE9, "Could not check rate limit:", errorMessage(error));
         }
         const mergedPRRepos = this.stateManager.getReposWithMergedPRs();
         const mergedPRRepoSet = new Set(mergedPRRepos);
@@ -12441,12 +12427,12 @@ Tip: Ensure your GITHUB_TOKEN has the 'read:user' scope and try again.`
             }
             console.log(`Found ${starFiltered.length} candidates from general search`);
           } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            phase2Error = errorMessage;
+            const errMsg = errorMessage(error);
+            phase2Error = errMsg;
             if (IssueVetter.isRateLimitError(error)) {
               rateLimitHitDuringSearch = true;
             }
-            warn(MODULE9, `Error in general issue search: ${errorMessage}`);
+            warn(MODULE9, `Error in general issue search: ${errMsg}`);
           }
         }
         let phase3Error = null;
@@ -12510,12 +12496,12 @@ Tip: Ensure your GITHUB_TOKEN has the 'read:user' scope and try again.`
             }
             console.log(`Found ${starFiltered.length} candidates from maintained-repo search`);
           } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            phase3Error = errorMessage;
+            const errMsg = errorMessage(error);
+            phase3Error = errMsg;
             if (IssueVetter.isRateLimitError(error)) {
               rateLimitHitDuringSearch = true;
             }
-            warn(MODULE9, `Error in maintained-repo search: ${errorMessage}`);
+            warn(MODULE9, `Error in maintained-repo search: ${errMsg}`);
           }
         }
         if (allCandidates.length === 0) {
@@ -12591,11 +12577,7 @@ Tip: Ensure your GITHUB_TOKEN has the 'read:user' scope and try again.`
               rateLimitFailures++;
             }
             const batchRepos = batch.join(", ");
-            warn(
-              MODULE9,
-              `Error searching issues in batch [${batchRepos}]:`,
-              error instanceof Error ? error.message : error
-            );
+            warn(MODULE9, `Error searching issues in batch [${batchRepos}]:`, errorMessage(error));
           }
         }
         const allBatchesFailed = failedBatches === batches.length && batches.length > 0;
@@ -12789,7 +12771,7 @@ var init_issue_conversation = __esm({
           }
           const { owner, repo } = parsed;
           const repoFullName = `${owner}/${repo}`;
-          if (owner.toLowerCase() === username.toLowerCase()) continue;
+          if (isOwnRepo(owner, username)) continue;
           if (item.user?.login?.toLowerCase() === username.toLowerCase()) continue;
           if (config.excludeRepos.includes(repoFullName)) continue;
           if (config.excludeOrgs?.some((org) => owner.toLowerCase() === org.toLowerCase())) continue;
@@ -12814,7 +12796,7 @@ var init_issue_conversation = __esm({
                 });
               }
             } catch (error) {
-              const msg = error instanceof Error ? error.message : String(error);
+              const msg = errorMessage(error);
               failures.push({ issueUrl: item.html_url, error: msg });
               warn(MODULE10, `Error analyzing issue ${item.html_url}: ${msg}`);
             }
@@ -13368,6 +13350,7 @@ var init_core = __esm({
     init_comment_utils();
     init_github();
     init_utils();
+    init_errors();
     init_logger();
     init_http_cache();
     init_daily_logic();
@@ -13455,25 +13438,9 @@ __export(daily_exports, {
   groupPRsByRepo: () => groupPRsByRepo,
   printDigest: () => printDigest,
   runDaily: () => runDaily,
+  runDailyForDisplay: () => runDailyForDisplay,
   toShelvedPRRef: () => toShelvedPRRef
 });
-async function runDaily(options) {
-  const token = getGitHubToken();
-  try {
-    await runDailyInner(token, options);
-  } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    if (options.json) {
-      outputJsonError(`Daily check failed: ${msg}`);
-    } else {
-      console.error(`[FATAL] Daily check failed: ${msg}`);
-      if (error instanceof Error && error.stack) {
-        console.error(error.stack);
-      }
-    }
-    process.exit(1);
-  }
-}
 async function fetchPRData(prMonitor, token) {
   const { prs, failures } = await prMonitor.fetchUserOpenPRs();
   if (failures.length > 0) {
@@ -13485,15 +13452,15 @@ async function fetchPRData(prMonitor, token) {
       prMonitor.fetchUserMergedPRCounts(),
       prMonitor.fetchUserClosedPRCounts(),
       prMonitor.fetchRecentlyClosedPRs().catch((err) => {
-        console.error(`Warning: Failed to fetch recently closed PRs: ${err instanceof Error ? err.message : err}`);
+        console.error(`Warning: Failed to fetch recently closed PRs: ${errorMessage(err)}`);
         return [];
       }),
       prMonitor.fetchRecentlyMergedPRs().catch((err) => {
-        console.error(`Warning: Failed to fetch recently merged PRs: ${err instanceof Error ? err.message : err}`);
+        console.error(`Warning: Failed to fetch recently merged PRs: ${errorMessage(err)}`);
         return [];
       }),
       issueMonitor.fetchCommentedIssues().catch((error) => {
-        const msg = error instanceof Error ? error.message : String(error);
+        const msg = errorMessage(error);
         if (msg.includes("No GitHub username configured")) {
           console.error(`[DAILY] Issue conversation tracking requires setup: ${msg}`);
         } else {
@@ -13550,10 +13517,7 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
       stateManager2.updateRepoScore(repo, { mergedPRCount: count, lastMergedAt: lastMergedAt || void 0 });
     } catch (error) {
       mergedCountFailures++;
-      console.error(
-        `[DAILY] Failed to update merged count for ${repo}:`,
-        error instanceof Error ? error.message : error
-      );
+      console.error(`[DAILY] Failed to update merged count for ${repo}:`, errorMessage(error));
     }
   }
   if (mergedCountFailures === mergedCounts.size && mergedCounts.size > 0) {
@@ -13573,10 +13537,7 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
       stateManager2.updateRepoScore(repo, { closedWithoutMergeCount: count });
     } catch (error) {
       closedCountFailures++;
-      console.error(
-        `[DAILY] Failed to update closed count for ${repo}:`,
-        error instanceof Error ? error.message : error
-      );
+      console.error(`[DAILY] Failed to update closed count for ${repo}:`, errorMessage(error));
     }
   }
   if (closedCountFailures === closedCounts.size && closedCounts.size > 0) {
@@ -13589,7 +13550,7 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
       stateManager2.updateRepoScore(repo, { signals });
     } catch (error) {
       signalUpdateFailures++;
-      console.error(`[DAILY] Failed to update signals for ${repo}:`, error instanceof Error ? error.message : error);
+      console.error(`[DAILY] Failed to update signals for ${repo}:`, errorMessage(error));
     }
   }
   if (signalUpdateFailures === repoSignals.size && repoSignals.size > 0) {
@@ -13602,7 +13563,7 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
   try {
     starCounts = await prMonitor.fetchRepoStarCounts(allRepos);
   } catch (error) {
-    console.error("[DAILY] Failed to fetch repo star counts:", error instanceof Error ? error.message : error);
+    console.error("[DAILY] Failed to fetch repo star counts:", errorMessage(error));
     console.error(
       "[DAILY] Dashboard minStars filter will use cached star counts (or be skipped for repos without cached data)."
     );
@@ -13614,7 +13575,7 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
       stateManager2.updateRepoScore(repo, { stargazersCount: stars });
     } catch (error) {
       starUpdateFailures++;
-      console.error(`[DAILY] Failed to update star count for ${repo}:`, error instanceof Error ? error.message : error);
+      console.error(`[DAILY] Failed to update star count for ${repo}:`, errorMessage(error));
     }
   }
   if (starUpdateFailures === starCounts.size && starCounts.size > 0) {
@@ -13626,7 +13587,7 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
       stateManager2.addTrustedProject(repo);
     } catch (error) {
       trustSyncFailures++;
-      console.error(`[DAILY] Failed to sync trusted project ${repo}:`, error instanceof Error ? error.message : error);
+      console.error(`[DAILY] Failed to sync trusted project ${repo}:`, errorMessage(error));
     }
   }
   if (trustSyncFailures === mergedCounts.size && mergedCounts.size > 0) {
@@ -13640,12 +13601,12 @@ function updateAnalytics(prs, monthlyCounts, monthlyClosedCounts, openedFromMerg
   try {
     stateManager2.setMonthlyMergedCounts(monthlyCounts);
   } catch (error) {
-    console.error("[DAILY] Failed to store monthly merged counts:", error instanceof Error ? error.message : error);
+    console.error("[DAILY] Failed to store monthly merged counts:", errorMessage(error));
   }
   try {
     stateManager2.setMonthlyClosedCounts(monthlyClosedCounts);
   } catch (error) {
-    console.error("[DAILY] Failed to store monthly closed counts:", error instanceof Error ? error.message : error);
+    console.error("[DAILY] Failed to store monthly closed counts:", errorMessage(error));
   }
   try {
     const combinedOpenedCounts = { ...openedFromMerged };
@@ -13660,10 +13621,7 @@ function updateAnalytics(prs, monthlyCounts, monthlyClosedCounts, openedFromMerg
     }
     stateManager2.setMonthlyOpenedCounts(combinedOpenedCounts);
   } catch (error) {
-    console.error(
-      "[DAILY] Failed to compute/store monthly opened counts:",
-      error instanceof Error ? error.message : error
-    );
+    console.error("[DAILY] Failed to compute/store monthly opened counts:", errorMessage(error));
   }
 }
 function partitionPRs(prMonitor, prs, recentlyClosedPRs, recentlyMergedPRs) {
@@ -13678,7 +13636,7 @@ function partitionPRs(prMonitor, prs, recentlyClosedPRs, recentlyMergedPRs) {
       stateManager2.save();
     }
   } catch (error) {
-    console.error("[DAILY] Failed to expire/persist snoozes:", error instanceof Error ? error.message : error);
+    console.error("[DAILY] Failed to expire/persist snoozes:", errorMessage(error));
   }
   const shelvedPRs = [];
   const autoUnshelvedPRs = [];
@@ -13796,19 +13754,19 @@ async function executeDailyCheckInternal(token) {
   const { activePRs, shelvedPRs, digest } = partitionPRs(prMonitor, prs, recentlyClosedPRs, recentlyMergedPRs);
   return generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, failures);
 }
-async function runDailyInner(token, options) {
-  if (options.json) {
-    const result = await executeDailyCheck(token);
-    outputJson(result);
-  } else {
-    const result = await executeDailyCheckInternal(token);
-    printDigest(result.digest, result.capacity, result.commentedIssues);
-  }
+async function runDaily() {
+  const token = requireGitHubToken();
+  return executeDailyCheck(token);
+}
+async function runDailyForDisplay() {
+  const token = requireGitHubToken();
+  return executeDailyCheckInternal(token);
 }
 var init_daily = __esm({
   "src/commands/daily.ts"() {
     "use strict";
     init_core();
+    init_errors();
     init_json();
     init_core();
   }
@@ -13824,39 +13782,21 @@ async function runStatus(options) {
   const stats = stateManager2.getStats();
   const state = stateManager2.getState();
   const lastUpdated = state.lastDigestAt || state.lastRunAt;
-  if (options.json) {
-    const { totalTracked: _totalTracked, ...outputStats } = stats;
-    const output = {
-      stats: outputStats,
-      lastRunAt: state.lastRunAt
-    };
-    if (options.offline) {
-      output.offline = true;
-      output.lastUpdated = lastUpdated;
-    }
-    outputJson(output);
-  } else {
-    console.log("\n\u{1F4CA} OSS Status\n");
-    console.log(`Merged PRs: ${stats.mergedPRs}`);
-    console.log(`Closed PRs: ${stats.closedPRs}`);
-    console.log(`Merge Rate: ${stats.mergeRate}`);
-    console.log(`Needs Response: ${stats.needsResponse}`);
-    if (options.offline) {
-      console.log(`
-Last Updated: ${lastUpdated || "Never"}`);
-      console.log("(Offline mode: showing cached data)");
-    } else {
-      console.log(`
-Last Run: ${state.lastRunAt || "Never"}`);
-    }
-    console.log("\nRun with --json for structured output");
+  const { totalTracked: _totalTracked, ...outputStats } = stats;
+  const output = {
+    stats: outputStats,
+    lastRunAt: state.lastRunAt
+  };
+  if (options.offline) {
+    output.offline = true;
+    output.lastUpdated = lastUpdated;
   }
+  return output;
 }
 var init_status = __esm({
   "src/commands/status.ts"() {
     "use strict";
     init_core();
-    init_json();
   }
 });
 
@@ -13866,104 +13806,68 @@ __export(search_exports, {
   runSearch: () => runSearch
 });
 async function runSearch(options) {
-  const token = getGitHubToken();
+  const token = requireGitHubToken();
   const discovery = new IssueDiscovery(token);
-  if (!options.json) {
-    console.log(`
-\u{1F50D} Searching for issues (max ${options.maxResults})...
-`);
-  }
   const candidates = await discovery.searchIssues({ maxResults: options.maxResults });
-  if (options.json) {
-    const stateManager2 = getStateManager();
-    const { config } = stateManager2.getState();
-    const excludedRepos = config.excludeRepos || [];
-    const aiPolicyBlocklist = config.aiPolicyBlocklist ?? DEFAULT_CONFIG.aiPolicyBlocklist ?? [];
-    const searchOutput = {
-      candidates: candidates.map((c) => {
-        const repoScoreRecord = stateManager2.getRepoScore(c.issue.repo);
-        return {
-          issue: {
-            repo: c.issue.repo,
-            number: c.issue.number,
-            title: c.issue.title,
-            url: c.issue.url,
-            labels: c.issue.labels
-          },
-          recommendation: c.recommendation,
-          reasonsToApprove: c.reasonsToApprove,
-          reasonsToSkip: c.reasonsToSkip,
-          searchPriority: c.searchPriority,
-          viabilityScore: c.viabilityScore,
-          repoScore: repoScoreRecord ? {
-            score: repoScoreRecord.score,
-            mergedPRCount: repoScoreRecord.mergedPRCount,
-            closedWithoutMergeCount: repoScoreRecord.closedWithoutMergeCount,
-            isResponsive: repoScoreRecord.signals?.isResponsive ?? false,
-            lastMergedAt: repoScoreRecord.lastMergedAt
-          } : void 0
-        };
-      }),
-      excludedRepos,
-      aiPolicyBlocklist
-    };
-    if (discovery.rateLimitWarning) {
-      searchOutput.rateLimitWarning = discovery.rateLimitWarning;
-    }
-    outputJson(searchOutput);
-  } else {
-    if (candidates.length === 0) {
-      if (discovery.rateLimitWarning) {
-        console.warn(`
-\u26A0 ${discovery.rateLimitWarning}
-`);
-      } else {
-        console.log("No matching issues found.");
-      }
-      return;
-    }
-    if (discovery.rateLimitWarning) {
-      console.warn(`
-\u26A0 ${discovery.rateLimitWarning}
-`);
-    }
-    console.log(`Found ${candidates.length} candidates:
-`);
-    for (const candidate of candidates) {
-      console.log(discovery.formatCandidate(candidate));
-      console.log("---");
-    }
+  const stateManager2 = getStateManager();
+  const { config } = stateManager2.getState();
+  const excludedRepos = config.excludeRepos || [];
+  const aiPolicyBlocklist = config.aiPolicyBlocklist ?? DEFAULT_CONFIG.aiPolicyBlocklist ?? [];
+  const searchOutput = {
+    candidates: candidates.map((c) => {
+      const repoScoreRecord = stateManager2.getRepoScore(c.issue.repo);
+      return {
+        issue: {
+          repo: c.issue.repo,
+          number: c.issue.number,
+          title: c.issue.title,
+          url: c.issue.url,
+          labels: c.issue.labels
+        },
+        recommendation: c.recommendation,
+        reasonsToApprove: c.reasonsToApprove,
+        reasonsToSkip: c.reasonsToSkip,
+        searchPriority: c.searchPriority,
+        viabilityScore: c.viabilityScore,
+        repoScore: repoScoreRecord ? {
+          score: repoScoreRecord.score,
+          mergedPRCount: repoScoreRecord.mergedPRCount,
+          closedWithoutMergeCount: repoScoreRecord.closedWithoutMergeCount,
+          isResponsive: repoScoreRecord.signals?.isResponsive ?? false,
+          lastMergedAt: repoScoreRecord.lastMergedAt
+        } : void 0
+      };
+    }),
+    excludedRepos,
+    aiPolicyBlocklist
+  };
+  if (discovery.rateLimitWarning) {
+    searchOutput.rateLimitWarning = discovery.rateLimitWarning;
   }
+  return searchOutput;
 }
 var init_search = __esm({
   "src/commands/search.ts"() {
     "use strict";
     init_core();
-    init_json();
   }
 });
 
 // src/commands/validation.ts
-function validateGitHubUrl(url, pattern, entityType, json) {
+function validateGitHubUrl(url, pattern, entityType) {
   if (pattern.test(url)) return;
   const example = entityType === "PR" ? "https://github.com/owner/repo/pull/123" : "https://github.com/owner/repo/issues/123";
-  const msg = `Invalid ${entityType} URL: ${url}. Expected format: ${example}`;
-  if (json) {
-    outputJsonError(msg);
-  } else {
-    console.error(`Error: ${msg}`);
-  }
-  process.exit(1);
+  throw new ValidationError(`Invalid ${entityType} URL: ${url}. Expected format: ${example}`);
 }
 function validateUrl(url) {
   if (url.length > MAX_URL_LENGTH) {
-    throw new Error(`URL exceeds maximum length of ${MAX_URL_LENGTH} characters`);
+    throw new ValidationError(`URL exceeds maximum length of ${MAX_URL_LENGTH} characters`);
   }
   return url;
 }
 function validateMessage(message) {
   if (message.length > MAX_MESSAGE_LENGTH) {
-    throw new Error(`Message exceeds maximum length of ${MAX_MESSAGE_LENGTH} characters`);
+    throw new ValidationError(`Message exceeds maximum length of ${MAX_MESSAGE_LENGTH} characters`);
   }
   return message;
 }
@@ -13996,7 +13900,6 @@ var init_validation = __esm({
   "src/commands/validation.ts"() {
     "use strict";
     init_errors();
-    init_json();
     PR_URL_PATTERN = /^https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/\d+$/;
     ISSUE_URL_PATTERN = /^https:\/\/github\.com\/[^/]+\/[^/]+\/issues\/\d+$/;
     MAX_URL_LENGTH = 2048;
@@ -14014,38 +13917,28 @@ __export(vet_exports, {
 });
 async function runVet(options) {
   validateUrl(options.issueUrl);
-  const token = getGitHubToken();
+  const token = requireGitHubToken();
   const discovery = new IssueDiscovery(token);
-  if (!options.json) {
-    console.log(`
-\u{1F50D} Vetting issue: ${options.issueUrl}
-`);
-  }
   const candidate = await discovery.vetIssue(options.issueUrl);
-  if (options.json) {
-    outputJson({
-      issue: {
-        repo: candidate.issue.repo,
-        number: candidate.issue.number,
-        title: candidate.issue.title,
-        url: candidate.issue.url,
-        labels: candidate.issue.labels
-      },
-      recommendation: candidate.recommendation,
-      reasonsToApprove: candidate.reasonsToApprove,
-      reasonsToSkip: candidate.reasonsToSkip,
-      projectHealth: candidate.projectHealth,
-      vettingResult: candidate.vettingResult
-    });
-  } else {
-    console.log(discovery.formatCandidate(candidate));
-  }
+  return {
+    issue: {
+      repo: candidate.issue.repo,
+      number: candidate.issue.number,
+      title: candidate.issue.title,
+      url: candidate.issue.url,
+      labels: candidate.issue.labels
+    },
+    recommendation: candidate.recommendation,
+    reasonsToApprove: candidate.reasonsToApprove,
+    reasonsToSkip: candidate.reasonsToSkip,
+    projectHealth: candidate.projectHealth,
+    vettingResult: candidate.vettingResult
+  };
 }
 var init_vet = __esm({
   "src/commands/vet.ts"() {
     "use strict";
     init_core();
-    init_json();
     init_validation();
   }
 });
@@ -14058,59 +13951,37 @@ __export(track_exports, {
 });
 async function runTrack(options) {
   validateUrl(options.prUrl);
-  validateGitHubUrl(options.prUrl, PR_URL_PATTERN, "PR", options.json);
-  const token = getGitHubToken();
+  validateGitHubUrl(options.prUrl, PR_URL_PATTERN, "PR");
+  const token = requireGitHubToken();
   const octokit = getOctokit(token);
   const parsed = parseGitHubUrl(options.prUrl);
   if (!parsed || parsed.type !== "pull") {
-    if (options.json) {
-      outputJsonError(`Invalid PR URL: ${options.prUrl}`);
-    } else {
-      console.error(`Error: Invalid PR URL: ${options.prUrl}`);
-    }
-    process.exit(1);
+    throw new Error(`Invalid PR URL: ${options.prUrl}`);
   }
   const { owner, repo, number } = parsed;
-  if (!options.json) {
-    console.log(`
-\u{1F4CC} Fetching PR: ${options.prUrl}
-`);
-  }
   const { data: ghPR } = await octokit.pulls.get({ owner, repo, pull_number: number });
-  const pr = {
-    repo: `${owner}/${repo}`,
-    number,
-    title: ghPR.title,
-    url: options.prUrl
+  return {
+    pr: {
+      repo: `${owner}/${repo}`,
+      number,
+      title: ghPR.title,
+      url: options.prUrl
+    }
   };
-  if (options.json) {
-    outputJson({ pr });
-  } else {
-    console.log(`PR: ${pr.repo}#${pr.number} - ${pr.title}`);
-    console.log("Note: In v2, PRs are tracked automatically via the daily run.");
-  }
 }
 async function runUntrack(options) {
   validateUrl(options.prUrl);
-  validateGitHubUrl(options.prUrl, PR_URL_PATTERN, "PR", options.json);
-  if (options.json) {
-    outputJson({
-      removed: false,
-      url: options.prUrl,
-      message: "In v2, PRs are fetched fresh on each daily run \u2014 there is no local tracking list to remove from."
-    });
-  } else {
-    console.log(
-      "Note: In v2, PRs are fetched fresh on each daily run \u2014 there is no local tracking list to remove from."
-    );
-    console.log("Use `shelve` to temporarily hide a PR from the daily summary.");
-  }
+  validateGitHubUrl(options.prUrl, PR_URL_PATTERN, "PR");
+  return {
+    removed: false,
+    url: options.prUrl,
+    message: "In v2, PRs are fetched fresh on each daily run \u2014 there is no local tracking list to remove from."
+  };
 }
 var init_track = __esm({
   "src/commands/track.ts"() {
     "use strict";
     init_core();
-    init_json();
     init_validation();
     init_utils();
   }
@@ -14123,30 +13994,19 @@ __export(read_exports, {
 });
 async function runRead(options) {
   if (!options.all && !options.prUrl) {
-    if (options.json) {
-      outputJsonError("PR URL or --all flag required");
-    } else {
-      console.error("Usage: oss-autopilot read <pr-url> or oss-autopilot read --all");
-    }
-    process.exit(1);
+    throw new Error("PR URL or --all flag required");
   }
   if (options.prUrl) {
     validateUrl(options.prUrl);
   }
-  if (options.json) {
-    if (options.all) {
-      outputJson({ markedAsRead: 0, all: true, message: "In v2, PR read state is not tracked locally." });
-    } else {
-      outputJson({ marked: false, url: options.prUrl, message: "In v2, PR read state is not tracked locally." });
-    }
-  } else {
-    console.log("Note: In v2, PR read state is not tracked locally. PRs are fetched fresh on each daily run.");
+  if (options.all) {
+    return { markedAsRead: 0, all: true, message: "In v2, PR read state is not tracked locally." };
   }
+  return { marked: false, url: options.prUrl, message: "In v2, PR read state is not tracked locally." };
 }
 var init_read = __esm({
   "src/commands/read.ts"() {
     "use strict";
-    init_json();
     init_validation();
   }
 });
@@ -14160,47 +14020,44 @@ __export(comments_exports, {
 });
 async function runComments(options) {
   validateUrl(options.prUrl);
-  const token = getGitHubToken();
+  const token = requireGitHubToken();
   const stateManager2 = getStateManager();
   const octokit = getOctokit(token);
   const parsed = parseGitHubUrl(options.prUrl);
   if (!parsed || parsed.type !== "pull") {
-    if (options.json) {
-      outputJsonError("Invalid PR URL format");
-    } else {
-      console.error("Invalid PR URL format");
-    }
-    process.exit(1);
+    throw new Error("Invalid PR URL format");
   }
   const { owner, repo, number: pull_number } = parsed;
   const { data: pr } = await octokit.pulls.get({ owner, repo, pull_number });
-  const reviewComments = await paginateAll(
-    (page) => octokit.pulls.listReviewComments({
-      owner,
-      repo,
-      pull_number,
-      per_page: 100,
-      page
-    })
-  );
-  const issueComments = await paginateAll(
-    (page) => octokit.issues.listComments({
-      owner,
-      repo,
-      issue_number: pull_number,
-      per_page: 100,
-      page
-    })
-  );
-  const reviews = await paginateAll(
-    (page) => octokit.pulls.listReviews({
-      owner,
-      repo,
-      pull_number,
-      per_page: 100,
-      page
-    })
-  );
+  const [reviewComments, issueComments, reviews] = await Promise.all([
+    paginateAll(
+      (page) => octokit.pulls.listReviewComments({
+        owner,
+        repo,
+        pull_number,
+        per_page: 100,
+        page
+      })
+    ),
+    paginateAll(
+      (page) => octokit.issues.listComments({
+        owner,
+        repo,
+        issue_number: pull_number,
+        per_page: 100,
+        page
+      })
+    ),
+    paginateAll(
+      (page) => octokit.pulls.listReviews({
+        owner,
+        repo,
+        pull_number,
+        per_page: 100,
+        page
+      })
+    )
+  ]);
   const username = stateManager2.getState().config.githubUsername;
   const filterComment = (c) => {
     if (!c.user) return false;
@@ -14211,240 +14068,104 @@ async function runComments(options) {
   const relevantReviewComments = reviewComments.filter(filterComment).sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
   const relevantIssueComments = issueComments.filter(filterComment).sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
   const relevantReviews = reviews.filter((r) => filterComment(r) && r.body && r.body.trim()).sort((a, b) => new Date(b.submitted_at || 0).getTime() - new Date(a.submitted_at || 0).getTime());
-  if (options.json) {
-    outputJson({
-      pr: {
-        title: pr.title,
-        state: pr.state,
-        mergeable: pr.mergeable,
-        head: pr.head.ref,
-        base: pr.base.ref,
-        url: pr.html_url
-      },
-      reviews: relevantReviews.map((r) => ({
-        user: r.user?.login,
-        state: r.state,
-        body: r.body,
-        submittedAt: r.submitted_at
-      })),
-      reviewComments: relevantReviewComments.map((c) => ({
-        user: c.user?.login,
-        body: c.body,
-        path: c.path,
-        createdAt: c.created_at
-      })),
-      issueComments: relevantIssueComments.map((c) => ({
-        user: c.user?.login,
-        body: c.body,
-        createdAt: c.created_at
-      })),
-      summary: {
-        reviewCount: relevantReviews.length,
-        inlineCommentCount: relevantReviewComments.length,
-        discussionCommentCount: relevantIssueComments.length
-      }
-    });
-    return;
-  }
-  console.log(`
-\u{1F4AC} Fetching comments for: ${options.prUrl}
-`);
-  console.log(`## ${pr.title}
-`);
-  console.log(`**Status:** ${pr.state} | **Mergeable:** ${pr.mergeable ?? "checking..."}`);
-  console.log(`**Branch:** ${pr.head.ref} \u2192 ${pr.base.ref}`);
-  console.log(`**URL:** ${pr.html_url}
-`);
-  if (relevantReviews.length > 0) {
-    console.log("### Reviews (newest first)\n");
-    for (const review of relevantReviews) {
-      const state = review.state === "APPROVED" ? "\u2705" : review.state === "CHANGES_REQUESTED" ? "\u274C" : "\u{1F4AC}";
-      const time = review.submitted_at ? formatRelativeTime(review.submitted_at) : "";
-      console.log(`${state} **@${review.user?.login}** (${review.state}) - ${time}`);
-      if (review.body) {
-        console.log(`> ${review.body.split("\n").join("\n> ")}
-`);
-      }
-    }
-  }
-  if (relevantReviewComments.length > 0) {
-    console.log("### Inline Comments (newest first)\n");
-    for (const comment of relevantReviewComments) {
-      const time = formatRelativeTime(comment.created_at);
-      console.log(`**@${comment.user?.login}** on \`${comment.path}\` - ${time}`);
-      console.log(`> ${comment.body.split("\n").join("\n> ")}`);
-      if (comment.diff_hunk) {
-        console.log(`\`\`\`diff
-${comment.diff_hunk.slice(-500)}
-\`\`\``);
-      }
-      console.log("");
-    }
-  }
-  if (relevantIssueComments.length > 0) {
-    console.log("### Discussion (newest first)\n");
-    for (const comment of relevantIssueComments) {
-      const time = formatRelativeTime(comment.created_at);
-      console.log(`**@${comment.user?.login}** - ${time}`);
-      console.log(`> ${comment.body?.split("\n").join("\n> ")}
-`);
+  return {
+    pr: {
+      title: pr.title,
+      state: pr.state,
+      mergeable: pr.mergeable,
+      head: pr.head.ref,
+      base: pr.base.ref,
+      url: pr.html_url
+    },
+    reviews: relevantReviews.map((r) => ({
+      user: r.user?.login,
+      state: r.state,
+      body: r.body ?? null,
+      submittedAt: r.submitted_at ?? null
+    })),
+    reviewComments: relevantReviewComments.map((c) => ({
+      user: c.user?.login,
+      body: c.body,
+      path: c.path,
+      createdAt: c.created_at
+    })),
+    issueComments: relevantIssueComments.map((c) => ({
+      user: c.user?.login,
+      body: c.body,
+      createdAt: c.created_at
+    })),
+    summary: {
+      reviewCount: relevantReviews.length,
+      inlineCommentCount: relevantReviewComments.length,
+      discussionCommentCount: relevantIssueComments.length
     }
-  }
-  if (relevantReviewComments.length === 0 && relevantIssueComments.length === 0 && relevantReviews.length === 0) {
-    console.log("No comments from other users.\n");
-  }
-  console.log("---");
-  console.log(
-    `**Summary:** ${relevantReviews.length} reviews, ${relevantReviewComments.length} inline comments, ${relevantIssueComments.length} discussion comments`
-  );
+  };
 }
 async function runPost(options) {
   validateUrl(options.url);
-  const token = getGitHubToken();
-  let message = options.message;
-  if (options.stdin) {
-    const chunks = [];
-    for await (const chunk of process.stdin) {
-      chunks.push(chunk);
-    }
-    message = Buffer.concat(chunks).toString("utf-8").trim();
-  }
-  if (!message) {
-    if (options.json) {
-      outputJsonError("No message provided");
-    } else {
-      console.error("Error: No message provided");
-    }
-    process.exit(1);
-  }
-  try {
-    validateMessage(message);
-  } catch (error) {
-    if (options.json) {
-      outputJsonError(error instanceof Error ? error.message : "Invalid message");
-    } else {
-      console.error(`Error: ${error instanceof Error ? error.message : "Invalid message"}`);
-    }
-    process.exit(1);
+  if (!options.message.trim()) {
+    throw new Error("No message provided");
   }
+  validateMessage(options.message);
+  const token = requireGitHubToken();
   const parsed = parseGitHubUrl(options.url);
   if (!parsed) {
-    if (options.json) {
-      outputJsonError("Invalid GitHub URL format");
-    } else {
-      console.error("Invalid GitHub URL format");
-    }
-    process.exit(1);
+    throw new Error("Invalid GitHub URL format");
   }
   const { owner, repo, number } = parsed;
   const octokit = getOctokit(token);
-  if (!options.json) {
-    console.log("\n\u{1F4DD} Posting comment to:", options.url);
-    console.log("---");
-    console.log(message);
-    console.log("---\n");
-  }
-  try {
-    const { data: comment } = await octokit.issues.createComment({
-      owner,
-      repo,
-      issue_number: number,
-      body: message
-    });
-    if (options.json) {
-      outputJson({
-        commentUrl: comment.html_url,
-        url: options.url
-      });
-    } else {
-      console.log("\u2705 Comment posted successfully!");
-      console.log(`   ${comment.html_url}`);
-    }
-  } catch (error) {
-    if (options.json) {
-      outputJsonError(error instanceof Error ? error.message : "Unknown error");
-    } else {
-      console.error("\u274C Failed to post comment:", error instanceof Error ? error.message : error);
-    }
-    process.exit(1);
-  }
+  const { data: comment } = await octokit.issues.createComment({
+    owner,
+    repo,
+    issue_number: number,
+    body: options.message
+  });
+  return {
+    commentUrl: comment.html_url,
+    url: options.url
+  };
 }
 async function runClaim(options) {
   validateUrl(options.issueUrl);
-  const token = getGitHubToken();
+  const token = requireGitHubToken();
   const message = options.message || "Hi! I'd like to work on this issue. Could you assign it to me?";
-  try {
-    validateMessage(message);
-  } catch (error) {
-    if (options.json) {
-      outputJsonError(error instanceof Error ? error.message : "Invalid message");
-    } else {
-      console.error(`Error: ${error instanceof Error ? error.message : "Invalid message"}`);
-    }
-    process.exit(1);
-  }
+  validateMessage(message);
   const parsed = parseGitHubUrl(options.issueUrl);
   if (!parsed || parsed.type !== "issues") {
-    if (options.json) {
-      outputJsonError("Invalid issue URL format (must be an issue, not a PR)");
-    } else {
-      console.error("Invalid issue URL format (must be an issue, not a PR)");
-    }
-    process.exit(1);
+    throw new Error("Invalid issue URL format (must be an issue, not a PR)");
   }
   const { owner, repo, number } = parsed;
-  if (!options.json) {
-    console.log("\n\u{1F64B} Claiming issue:", options.issueUrl);
-    console.log("---");
-    console.log(message);
-    console.log("---\n");
-  }
   const octokit = getOctokit(token);
-  try {
-    const { data: comment } = await octokit.issues.createComment({
-      owner,
-      repo,
-      issue_number: number,
-      body: message
-    });
-    const stateManager2 = getStateManager();
-    stateManager2.addIssue({
-      id: number,
-      url: options.issueUrl,
-      repo: `${owner}/${repo}`,
-      number,
-      title: "(claimed)",
-      status: "claimed",
-      labels: [],
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      vetted: false
-    });
-    stateManager2.save();
-    if (options.json) {
-      outputJson({
-        commentUrl: comment.html_url,
-        issueUrl: options.issueUrl
-      });
-    } else {
-      console.log("\u2705 Issue claimed!");
-      console.log(`   ${comment.html_url}`);
-    }
-  } catch (error) {
-    if (options.json) {
-      outputJsonError(error instanceof Error ? error.message : "Unknown error");
-    } else {
-      console.error("\u274C Failed to claim issue:", error instanceof Error ? error.message : error);
-    }
-    process.exit(1);
-  }
+  const { data: comment } = await octokit.issues.createComment({
+    owner,
+    repo,
+    issue_number: number,
+    body: message
+  });
+  const stateManager2 = getStateManager();
+  stateManager2.addIssue({
+    id: number,
+    url: options.issueUrl,
+    repo: `${owner}/${repo}`,
+    number,
+    title: "(claimed)",
+    status: "claimed",
+    labels: [],
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    vetted: false
+  });
+  stateManager2.save();
+  return {
+    commentUrl: comment.html_url,
+    issueUrl: options.issueUrl
+  };
 }
 var init_comments = __esm({
   "src/commands/comments.ts"() {
     "use strict";
     init_core();
     init_pagination();
-    init_json();
     init_validation();
   }
 });
@@ -14454,28 +14175,14 @@ var config_exports = {};
 __export(config_exports, {
   runConfig: () => runConfig
 });
-function exitWithError(msg, json) {
-  if (json) {
-    outputJsonError(msg);
-  } else {
-    console.error(msg);
-  }
-  process.exit(1);
-}
 async function runConfig(options) {
   const stateManager2 = getStateManager();
   const currentConfig = stateManager2.getState().config;
   if (!options.key) {
-    if (options.json) {
-      outputJson({ config: currentConfig });
-    } else {
-      console.log("\n\u2699\uFE0F Current Configuration:\n");
-      console.log(JSON.stringify(currentConfig, null, 2));
-    }
-    return;
+    return { config: currentConfig };
   }
   if (!options.value) {
-    exitWithError("Value required", options.json);
+    throw new Error("Value required");
   }
   const value = options.value;
   switch (options.key) {
@@ -14495,9 +14202,8 @@ async function runConfig(options) {
     case "exclude-repo": {
       const parts = value.split("/");
       if (parts.length !== 2 || !parts[0] || !parts[1]) {
-        exitWithError(
-          `Invalid repo format "${value}". Use "owner/repo" format. To exclude an entire org, use: config exclude-org ${value}`,
-          options.json
+        throw new Error(
+          `Invalid repo format "${value}". Use "owner/repo" format. To exclude an entire org, use: config exclude-org ${value}`
         );
       }
       const valueLower = value.toLowerCase();
@@ -14509,9 +14215,8 @@ async function runConfig(options) {
     }
     case "exclude-org": {
       if (value.includes("/")) {
-        exitWithError(
-          `Invalid org name "${value}". Use just the org name (e.g., "facebook"), not "owner/repo" format. To exclude a specific repo, use: config exclude-repo ${value}`,
-          options.json
+        throw new Error(
+          `Invalid org name "${value}". Use just the org name (e.g., "facebook"), not "owner/repo" format. To exclude a specific repo, use: config exclude-repo ${value}`
         );
       }
       const currentOrgs = currentConfig.excludeOrgs ?? [];
@@ -14522,20 +14227,15 @@ async function runConfig(options) {
       break;
     }
     default:
-      exitWithError(`Unknown config key: ${options.key}`, options.json);
+      throw new Error(`Unknown config key: ${options.key}`);
   }
   stateManager2.save();
-  if (options.json) {
-    outputJson({ success: true, key: options.key, value });
-  } else {
-    console.log(`Set ${options.key} to: ${value}`);
-  }
+  return { success: true, key: options.key, value };
 }
 var init_config = __esm({
   "src/commands/config.ts"() {
     "use strict";
     init_core();
-    init_json();
   }
 });
 
@@ -14547,28 +14247,17 @@ __export(init_exports, {
 async function runInit(options) {
   validateGitHubUsername(options.username);
   const stateManager2 = getStateManager();
-  if (!options.json) {
-    console.log(`
-\u{1F680} Initializing for @${options.username}...
-`);
-  }
   stateManager2.updateConfig({ githubUsername: options.username });
   stateManager2.save();
-  if (options.json) {
-    outputJson({
-      username: options.username,
-      message: "Username saved. Run `daily` to fetch your open PRs from GitHub."
-    });
-  } else {
-    console.log(`Username set to @${options.username}.`);
-    console.log("Run `oss-autopilot daily` to fetch your open PRs from GitHub.");
-  }
+  return {
+    username: options.username,
+    message: "Username saved. Run `daily` to fetch your open PRs from GitHub."
+  };
 }
 var init_init = __esm({
   "src/commands/init.ts"() {
     "use strict";
     init_core();
-    init_json();
     init_validation();
   }
 });
@@ -14584,6 +14273,7 @@ async function runSetup(options) {
   const config = stateManager2.getState().config;
   if (options.set && options.set.length > 0) {
     const results = {};
+    const warnings = [];
     for (const setting of options.set) {
       const [key, ...valueParts] = setting.split("=");
       const value = valueParts.join("=");
@@ -14649,15 +14339,11 @@ async function runSetup(options) {
             }
           }
           if (invalid.length > 0) {
-            if (!options.json) {
-              console.warn(`Warning: Skipping invalid entries (expected "owner/repo" format): ${invalid.join(", ")}`);
-            }
+            warnings.push(`Warning: Skipping invalid entries (expected "owner/repo" format): ${invalid.join(", ")}`);
             results["aiPolicyBlocklist_invalidEntries"] = invalid.join(", ");
           }
           if (valid.length === 0 && entries.length > 0) {
-            if (!options.json) {
-              console.warn("Warning: All entries were invalid. Blocklist not updated.");
-            }
+            warnings.push("Warning: All entries were invalid. Blocklist not updated.");
             results[key] = "(all entries invalid)";
             break;
           }
@@ -14672,175 +14358,91 @@ async function runSetup(options) {
           }
           break;
         default:
-          if (!options.json) {
-            console.warn(`Unknown setting: ${key}`);
-          }
+          warnings.push(`Unknown setting: ${key}`);
       }
     }
     stateManager2.save();
-    if (options.json) {
-      outputJson({ success: true, settings: results });
-    } else {
-      for (const [key, value] of Object.entries(results)) {
-        console.log(`\u2713 ${key}: ${value}`);
-      }
-    }
-    return;
+    return { success: true, settings: results, warnings: warnings.length > 0 ? warnings : void 0 };
   }
   if (config.setupComplete && !options.reset) {
-    if (options.json) {
-      outputJson({
-        setupComplete: true,
-        config: {
-          githubUsername: config.githubUsername,
-          maxActivePRs: config.maxActivePRs,
-          dormantThresholdDays: config.dormantThresholdDays,
-          approachingDormantDays: config.approachingDormantDays,
-          languages: config.languages,
-          labels: config.labels
-        }
-      });
-    } else {
-      console.log("\n\u2699\uFE0F  OSS Autopilot Setup\n");
-      console.log("\u2713 Setup already complete!\n");
-      console.log("Current settings:");
-      console.log(`  GitHub username:    ${config.githubUsername || "(not set)"}`);
-      console.log(`  Max active PRs:     ${config.maxActivePRs}`);
-      console.log(`  Dormant threshold:  ${config.dormantThresholdDays} days`);
-      console.log(`  Approaching dormant: ${config.approachingDormantDays} days`);
-      console.log(`  Languages:          ${config.languages.join(", ")}`);
-      console.log(`  Labels:             ${config.labels.join(", ")}`);
-      console.log(`
-Run 'setup --reset' to reconfigure.`);
-    }
-    return;
-  }
-  if (options.json) {
-    outputJson({
-      setupRequired: true,
-      prompts: [
-        {
-          setting: "username",
-          prompt: "What is your GitHub username?",
-          current: config.githubUsername || null,
-          required: true,
-          type: "string"
-        },
-        {
-          setting: "maxActivePRs",
-          prompt: "How many PRs do you want to work on at once?",
-          current: config.maxActivePRs,
-          default: 10,
-          type: "number"
-        },
-        {
-          setting: "dormantDays",
-          prompt: "After how many days of inactivity should a PR be considered dormant?",
-          current: config.dormantThresholdDays,
-          default: 30,
-          type: "number"
-        },
-        {
-          setting: "approachingDays",
-          prompt: "At how many days should we warn about approaching dormancy?",
-          current: config.approachingDormantDays,
-          default: 25,
-          type: "number"
-        },
-        {
-          setting: "languages",
-          prompt: "What programming languages do you want to contribute to?",
-          current: config.languages,
-          default: ["typescript", "javascript"],
-          type: "list"
-        },
-        {
-          setting: "labels",
-          prompt: "What issue labels should we search for?",
-          current: config.labels,
-          default: ["good first issue", "help wanted"],
-          type: "list"
-        },
-        {
-          setting: "aiPolicyBlocklist",
-          prompt: "Repos with anti-AI contribution policies to block (owner/repo, comma-separated)?",
-          current: config.aiPolicyBlocklist ?? DEFAULT_CONFIG.aiPolicyBlocklist,
-          default: ["matplotlib/matplotlib"],
-          type: "list"
-        }
-      ]
-    });
-  } else {
-    console.log("\n\u2699\uFE0F  OSS Autopilot Setup\n");
-    console.log("SETUP_REQUIRED");
-    console.log("---");
-    console.log("Please configure the following settings:\n");
-    console.log("SETTING: username");
-    console.log("PROMPT: What is your GitHub username?");
-    console.log(`CURRENT: ${config.githubUsername || "(not set)"}`);
-    console.log("REQUIRED: true");
-    console.log("");
-    console.log("SETTING: maxActivePRs");
-    console.log("PROMPT: How many PRs do you want to work on at once?");
-    console.log(`CURRENT: ${config.maxActivePRs}`);
-    console.log("DEFAULT: 10");
-    console.log("TYPE: number");
-    console.log("");
-    console.log("SETTING: dormantDays");
-    console.log("PROMPT: After how many days of inactivity should a PR be considered dormant?");
-    console.log(`CURRENT: ${config.dormantThresholdDays}`);
-    console.log("DEFAULT: 30");
-    console.log("TYPE: number");
-    console.log("");
-    console.log("SETTING: approachingDays");
-    console.log("PROMPT: At how many days should we warn about approaching dormancy?");
-    console.log(`CURRENT: ${config.approachingDormantDays}`);
-    console.log("DEFAULT: 25");
-    console.log("TYPE: number");
-    console.log("");
-    console.log("SETTING: languages");
-    console.log("PROMPT: What programming languages do you want to contribute to? (comma-separated)");
-    console.log(`CURRENT: ${config.languages.join(", ")}`);
-    console.log("DEFAULT: typescript, javascript");
-    console.log("TYPE: list");
-    console.log("");
-    console.log("SETTING: labels");
-    console.log("PROMPT: What issue labels should we search for? (comma-separated)");
-    console.log(`CURRENT: ${config.labels.join(", ")}`);
-    console.log("DEFAULT: good first issue, help wanted");
-    console.log("TYPE: list");
-    console.log("");
-    console.log("SETTING: aiPolicyBlocklist");
-    console.log("PROMPT: Repos with anti-AI contribution policies to block? (owner/repo, comma-separated)");
-    console.log(`CURRENT: ${(config.aiPolicyBlocklist ?? DEFAULT_CONFIG.aiPolicyBlocklist ?? []).join(", ")}`);
-    console.log("DEFAULT: matplotlib/matplotlib");
-    console.log("TYPE: list");
-    console.log("");
-    console.log("---");
-    console.log("END_SETUP_PROMPTS");
+    return {
+      setupComplete: true,
+      config: {
+        githubUsername: config.githubUsername,
+        maxActivePRs: config.maxActivePRs,
+        dormantThresholdDays: config.dormantThresholdDays,
+        approachingDormantDays: config.approachingDormantDays,
+        languages: config.languages,
+        labels: config.labels
+      }
+    };
   }
+  return {
+    setupRequired: true,
+    prompts: [
+      {
+        setting: "username",
+        prompt: "What is your GitHub username?",
+        current: config.githubUsername || null,
+        required: true,
+        type: "string"
+      },
+      {
+        setting: "maxActivePRs",
+        prompt: "How many PRs do you want to work on at once?",
+        current: config.maxActivePRs,
+        default: 10,
+        type: "number"
+      },
+      {
+        setting: "dormantDays",
+        prompt: "After how many days of inactivity should a PR be considered dormant?",
+        current: config.dormantThresholdDays,
+        default: 30,
+        type: "number"
+      },
+      {
+        setting: "approachingDays",
+        prompt: "At how many days should we warn about approaching dormancy?",
+        current: config.approachingDormantDays,
+        default: 25,
+        type: "number"
+      },
+      {
+        setting: "languages",
+        prompt: "What programming languages do you want to contribute to?",
+        current: config.languages,
+        default: ["typescript", "javascript"],
+        type: "list"
+      },
+      {
+        setting: "labels",
+        prompt: "What issue labels should we search for?",
+        current: config.labels,
+        default: ["good first issue", "help wanted"],
+        type: "list"
+      },
+      {
+        setting: "aiPolicyBlocklist",
+        prompt: "Repos with anti-AI contribution policies to block (owner/repo, comma-separated)?",
+        current: config.aiPolicyBlocklist ?? DEFAULT_CONFIG.aiPolicyBlocklist ?? null,
+        default: ["matplotlib/matplotlib"],
+        type: "list"
+      }
+    ]
+  };
 }
-async function runCheckSetup(options) {
+async function runCheckSetup() {
   const stateManager2 = getStateManager();
-  if (options.json) {
-    outputJson({
-      setupComplete: stateManager2.isSetupComplete(),
-      username: stateManager2.getState().config.githubUsername
-    });
-  } else {
-    if (stateManager2.isSetupComplete()) {
-      console.log("SETUP_COMPLETE");
-      console.log(`username=${stateManager2.getState().config.githubUsername}`);
-    } else {
-      console.log("SETUP_INCOMPLETE");
-    }
-  }
+  return {
+    setupComplete: stateManager2.isSetupComplete(),
+    username: stateManager2.getState().config.githubUsername
+  };
 }
 var init_setup = __esm({
   "src/commands/setup.ts"() {
     "use strict";
     init_core();
-    init_json();
     init_validation();
   }
 });
@@ -14853,17 +14455,17 @@ async function fetchDashboardData(token) {
   const [{ prs, failures }, recentlyClosedPRs, recentlyMergedPRs, mergedResult, closedResult, fetchedIssues] = await Promise.all([
     prMonitor.fetchUserOpenPRs(),
     prMonitor.fetchRecentlyClosedPRs().catch((err) => {
-      console.error(`Warning: Failed to fetch recently closed PRs: ${err instanceof Error ? err.message : err}`);
+      console.error(`Warning: Failed to fetch recently closed PRs: ${errorMessage(err)}`);
       return [];
     }),
     prMonitor.fetchRecentlyMergedPRs().catch((err) => {
-      console.error(`Warning: Failed to fetch recently merged PRs: ${err instanceof Error ? err.message : err}`);
+      console.error(`Warning: Failed to fetch recently merged PRs: ${errorMessage(err)}`);
       return [];
     }),
     prMonitor.fetchUserMergedPRCounts(),
     prMonitor.fetchUserClosedPRCounts(),
     issueMonitor.fetchCommentedIssues().catch((error) => {
-      const msg = error instanceof Error ? error.message : String(error);
+      const msg = errorMessage(error);
       if (msg.includes("No GitHub username configured")) {
         console.error(`[DASHBOARD] Issue conversation tracking requires setup: ${msg}`);
       } else {
@@ -14887,12 +14489,12 @@ async function fetchDashboardData(token) {
   try {
     stateManager2.setMonthlyMergedCounts(monthlyCounts);
   } catch (error) {
-    console.error("[DASHBOARD] Failed to store monthly merged counts:", error instanceof Error ? error.message : error);
+    console.error("[DASHBOARD] Failed to store monthly merged counts:", errorMessage(error));
   }
   try {
     stateManager2.setMonthlyClosedCounts(monthlyClosedCounts);
   } catch (error) {
-    console.error("[DASHBOARD] Failed to store monthly closed counts:", error instanceof Error ? error.message : error);
+    console.error("[DASHBOARD] Failed to store monthly closed counts:", errorMessage(error));
   }
   try {
     const combinedOpenedCounts = { ...openedFromMerged };
@@ -14907,7 +14509,7 @@ async function fetchDashboardData(token) {
     }
     stateManager2.setMonthlyOpenedCounts(combinedOpenedCounts);
   } catch (error) {
-    console.error("[DASHBOARD] Failed to store monthly opened counts:", error instanceof Error ? error.message : error);
+    console.error("[DASHBOARD] Failed to store monthly opened counts:", errorMessage(error));
   }
   const digest = prMonitor.generateDigest(prs, recentlyClosedPRs, recentlyMergedPRs);
   const shelvedUrls = new Set(stateManager2.getState().config.shelvedPRUrls || []);
@@ -14947,6 +14549,7 @@ var init_dashboard_data = __esm({
   "src/commands/dashboard-data.ts"() {
     "use strict";
     init_core();
+    init_errors();
     init_daily();
   }
 });
@@ -16532,64 +16135,380 @@ var init_dashboard_templates = __esm({
   }
 });
 
-// src/commands/dashboard.ts
-var dashboard_exports = {};
-__export(dashboard_exports, {
-  runDashboard: () => runDashboard,
-  writeDashboardFromState: () => writeDashboardFromState
+// src/commands/dashboard-server.ts
+var dashboard_server_exports = {};
+__export(dashboard_server_exports, {
+  startDashboardServer: () => startDashboardServer
 });
-async function runDashboard(options) {
-  const stateManager2 = getStateManager();
-  const token = options.offline ? null : getGitHubToken();
-  let digest;
-  let commentedIssues = [];
-  if (options.offline) {
-    const state2 = stateManager2.getState();
-    digest = state2.lastDigest;
-    if (!digest) {
-      if (options.json) {
-        outputJson({ error: "No cached data found. Run without --offline first.", offline: true });
-      } else {
-        console.error("No cached data found. Run without --offline first.");
+function buildDashboardJson(digest, state, commentedIssues) {
+  const prsByRepo = computePRsByRepo(digest, state);
+  const topRepos = computeTopRepos(prsByRepo);
+  const { monthlyMerged } = getMonthlyData(state);
+  const stats = buildDashboardStats(digest, state);
+  const issueResponses = commentedIssues.filter((i) => i.status === "new_response");
+  return {
+    stats,
+    prsByRepo,
+    topRepos: topRepos.map(([repo, data]) => ({ repo, ...data })),
+    monthlyMerged,
+    activePRs: digest.openPRs || [],
+    shelvedPRUrls: state.config.shelvedPRUrls || [],
+    commentedIssues,
+    issueResponses
+  };
+}
+function readBody(req, maxBytes = MAX_BODY_BYTES) {
+  return new Promise((resolve5, reject) => {
+    const chunks = [];
+    let totalLength = 0;
+    let aborted = false;
+    req.on("data", (chunk) => {
+      if (aborted) return;
+      totalLength += chunk.length;
+      if (totalLength > maxBytes) {
+        aborted = true;
+        req.destroy();
+        reject(new Error("Body too large"));
+        return;
       }
-      return;
-    }
-    const lastUpdated = digest.generatedAt || state2.lastDigestAt || state2.lastRunAt;
-    console.error(`Offline mode: using cached data from ${lastUpdated}`);
-  } else if (token) {
-    console.error("Fetching fresh data from GitHub...");
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      if (!aborted) resolve5(Buffer.concat(chunks).toString("utf-8"));
+    });
+    req.on("error", (err) => {
+      if (!aborted) reject(err);
+    });
+  });
+}
+function sendJson(res, statusCode, data) {
+  const body = JSON.stringify(data);
+  res.writeHead(statusCode, {
+    "Content-Type": "application/json",
+    "Content-Length": Buffer.byteLength(body)
+  });
+  res.end(body);
+}
+function sendError(res, statusCode, message) {
+  sendJson(res, statusCode, { error: message });
+}
+async function startDashboardServer(options) {
+  const { port: requestedPort, assetsDir, token, open } = options;
+  const stateManager2 = getStateManager();
+  const resolvedAssetsDir = path5.resolve(assetsDir);
+  let cachedDigest;
+  let cachedCommentedIssues = [];
+  if (token) {
     try {
+      console.error("Fetching dashboard data from GitHub...");
       const result = await fetchDashboardData(token);
-      digest = result.digest;
-      commentedIssues = result.commentedIssues;
+      cachedDigest = result.digest;
+      cachedCommentedIssues = result.commentedIssues;
     } catch (error) {
-      console.error("Failed to fetch fresh data:", error instanceof Error ? error.message : error);
-      console.error("Falling back to cached data (issue conversations unavailable)...");
-      digest = stateManager2.getState().lastDigest;
+      console.error("Failed to fetch data from GitHub:", error);
+      console.error("Falling back to cached data...");
+      cachedDigest = stateManager2.getState().lastDigest;
     }
   } else {
-    digest = stateManager2.getState().lastDigest;
+    cachedDigest = stateManager2.getState().lastDigest;
   }
-  if (!digest) {
-    if (options.json) {
-      outputJson({ error: "No data available. Run daily check first with GITHUB_TOKEN." });
-    } else {
-      console.error("No dashboard data available. Run the daily check first:");
-      console.error("  GITHUB_TOKEN=$(gh auth token) npm start -- daily");
-    }
-    return;
+  if (!cachedDigest) {
+    console.error("No dashboard data available. Run the daily check first:");
+    console.error("  GITHUB_TOKEN=$(gh auth token) npm start -- daily");
+    process.exit(1);
   }
-  const state = stateManager2.getState();
-  const prsByRepo = computePRsByRepo(digest, state);
-  const topRepos = computeTopRepos(prsByRepo);
-  const { monthlyMerged, monthlyClosed, monthlyOpened } = getMonthlyData(state);
-  const stats = buildDashboardStats(digest, state);
-  if (options.json) {
-    const issueResponses2 = commentedIssues.filter((i) => i.status === "new_response");
-    const jsonData = {
-      stats,
-      prsByRepo,
-      topRepos: topRepos.map(([repo, data]) => ({ repo, ...data })),
+  let cachedJsonData;
+  try {
+    cachedJsonData = buildDashboardJson(cachedDigest, stateManager2.getState(), cachedCommentedIssues);
+  } catch (error) {
+    console.error("Failed to build dashboard data from cached digest:", error);
+    console.error("Your state data may be corrupted. Try running: daily --json");
+    process.exit(1);
+  }
+  const server = http.createServer(async (req, res) => {
+    const method = req.method || "GET";
+    const url = req.url || "/";
+    try {
+      if (url === "/api/data" && method === "GET") {
+        sendJson(res, 200, cachedJsonData);
+        return;
+      }
+      if (url === "/api/action" && method === "POST") {
+        await handleAction(req, res);
+        return;
+      }
+      if (url === "/api/refresh" && method === "POST") {
+        await handleRefresh(req, res);
+        return;
+      }
+      if (method === "GET") {
+        serveStaticFile(url, res);
+        return;
+      }
+      sendError(res, 405, "Method not allowed");
+    } catch (error) {
+      console.error("Unhandled request error:", method, url, error);
+      if (!res.headersSent) {
+        sendError(res, 500, "Internal server error");
+      }
+    }
+  });
+  async function handleAction(req, res) {
+    let body;
+    try {
+      const raw = await readBody(req);
+      body = JSON.parse(raw);
+    } catch (e) {
+      const isBodyTooLarge = e instanceof Error && e.message === "Body too large";
+      sendError(res, isBodyTooLarge ? 413 : 400, isBodyTooLarge ? "Request body too large" : "Invalid JSON body");
+      return;
+    }
+    if (!body.action || !VALID_ACTIONS.has(body.action)) {
+      sendError(res, 400, `Invalid action. Must be one of: ${[...VALID_ACTIONS].join(", ")}`);
+      return;
+    }
+    if (!body.url || typeof body.url !== "string") {
+      sendError(res, 400, 'Missing or invalid "url" field');
+      return;
+    }
+    try {
+      switch (body.action) {
+        case "shelve":
+          stateManager2.shelvePR(body.url);
+          break;
+        case "unshelve":
+          stateManager2.unshelvePR(body.url);
+          break;
+        case "snooze":
+          stateManager2.snoozePR(body.url, body.reason || "Snoozed via dashboard", body.days || 7);
+          break;
+        case "unsnooze":
+          stateManager2.unsnoozePR(body.url);
+          break;
+      }
+      stateManager2.save();
+    } catch (error) {
+      console.error("Action failed:", body.action, body.url, error);
+      sendError(res, 500, `Action failed: ${errorMessage(error)}`);
+      return;
+    }
+    if (cachedDigest) {
+      cachedJsonData = buildDashboardJson(cachedDigest, stateManager2.getState(), cachedCommentedIssues);
+    }
+    sendJson(res, 200, cachedJsonData);
+  }
+  async function handleRefresh(_req, res) {
+    const currentToken = token || getGitHubToken();
+    if (!currentToken) {
+      sendError(res, 401, "No GitHub token available. Cannot refresh data.");
+      return;
+    }
+    try {
+      console.error("Refreshing dashboard data from GitHub...");
+      const result = await fetchDashboardData(currentToken);
+      cachedDigest = result.digest;
+      cachedCommentedIssues = result.commentedIssues;
+      cachedJsonData = buildDashboardJson(cachedDigest, stateManager2.getState(), cachedCommentedIssues);
+      sendJson(res, 200, cachedJsonData);
+    } catch (error) {
+      console.error("Dashboard refresh failed:", error);
+      sendError(res, 500, `Refresh failed: ${errorMessage(error)}`);
+    }
+  }
+  function serveStaticFile(requestUrl, res) {
+    let urlPath;
+    try {
+      urlPath = decodeURIComponent(requestUrl.split("?")[0]);
+    } catch (err) {
+      console.error("Malformed URL received:", requestUrl, err);
+      sendError(res, 400, "Malformed URL");
+      return;
+    }
+    if (urlPath.includes("..")) {
+      sendError(res, 403, "Forbidden");
+      return;
+    }
+    const relativePath = urlPath === "/" ? "index.html" : urlPath.replace(/^\/+/, "");
+    let filePath = path5.join(resolvedAssetsDir, relativePath);
+    if (!filePath.startsWith(resolvedAssetsDir + path5.sep) && filePath !== resolvedAssetsDir) {
+      sendError(res, 403, "Forbidden");
+      return;
+    }
+    try {
+      const stat = fs5.statSync(filePath);
+      if (stat.isDirectory()) {
+        filePath = path5.join(resolvedAssetsDir, "index.html");
+      }
+    } catch (err) {
+      const nodeErr = err;
+      if (nodeErr.code === "ENOENT") {
+        filePath = path5.join(resolvedAssetsDir, "index.html");
+      } else {
+        console.error("Failed to stat file:", filePath, err);
+        sendError(res, 500, "Internal server error");
+        return;
+      }
+    }
+    const ext = path5.extname(filePath).toLowerCase();
+    const contentType = MIME_TYPES[ext] || "application/octet-stream";
+    try {
+      const content = fs5.readFileSync(filePath);
+      res.writeHead(200, {
+        "Content-Type": contentType,
+        "Content-Length": content.length
+      });
+      res.end(content);
+    } catch (error) {
+      const nodeErr = error;
+      if (nodeErr.code === "ENOENT") {
+        sendError(res, 404, "Not found");
+      } else {
+        console.error("Failed to serve static file:", filePath, error);
+        sendError(res, 500, "Failed to read file");
+      }
+    }
+  }
+  const MAX_PORT_ATTEMPTS = 10;
+  let actualPort = requestedPort;
+  for (let attempt = 0; attempt < MAX_PORT_ATTEMPTS; attempt++) {
+    try {
+      await new Promise((resolve5, reject) => {
+        server.once("error", reject);
+        server.listen(actualPort, "127.0.0.1", () => resolve5());
+      });
+      break;
+    } catch (err) {
+      const nodeErr = err;
+      if (nodeErr.code === "EADDRINUSE" && attempt < MAX_PORT_ATTEMPTS - 1) {
+        console.error(`Port ${actualPort} is in use, trying ${actualPort + 1}...`);
+        actualPort++;
+        continue;
+      }
+      console.error(`Failed to start server: ${nodeErr.message}`);
+      process.exit(1);
+    }
+  }
+  const serverUrl = `http://localhost:${actualPort}`;
+  console.error(`Dashboard server running at ${serverUrl}`);
+  if (open) {
+    const { execFile: execFile4 } = await import("child_process");
+    let openCmd;
+    let args;
+    switch (process.platform) {
+      case "darwin":
+        openCmd = "open";
+        args = [serverUrl];
+        break;
+      case "win32":
+        openCmd = "cmd";
+        args = ["/c", "start", "", serverUrl];
+        break;
+      default:
+        openCmd = "xdg-open";
+        args = [serverUrl];
+        break;
+    }
+    execFile4(openCmd, args, (error) => {
+      if (error) {
+        console.error("Failed to open browser:", error.message);
+        console.error(`Open manually: ${serverUrl}`);
+      }
+    });
+  }
+  const shutdown = () => {
+    console.error("\nShutting down dashboard server...");
+    server.close(() => {
+      process.exit(0);
+    });
+    setTimeout(() => process.exit(0), 3e3).unref();
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+var http, fs5, path5, VALID_ACTIONS, MAX_BODY_BYTES, MIME_TYPES;
+var init_dashboard_server = __esm({
+  "src/commands/dashboard-server.ts"() {
+    "use strict";
+    http = __toESM(require("http"), 1);
+    fs5 = __toESM(require("fs"), 1);
+    path5 = __toESM(require("path"), 1);
+    init_core();
+    init_errors();
+    init_dashboard_data();
+    init_dashboard_templates();
+    VALID_ACTIONS = /* @__PURE__ */ new Set(["shelve", "unshelve", "snooze", "unsnooze"]);
+    MAX_BODY_BYTES = 10240;
+    MIME_TYPES = {
+      ".html": "text/html",
+      ".js": "application/javascript",
+      ".css": "text/css",
+      ".svg": "image/svg+xml",
+      ".json": "application/json",
+      ".png": "image/png",
+      ".ico": "image/x-icon"
+    };
+  }
+});
+
+// src/commands/dashboard.ts
+var dashboard_exports = {};
+__export(dashboard_exports, {
+  runDashboard: () => runDashboard,
+  serveDashboard: () => serveDashboard,
+  writeDashboardFromState: () => writeDashboardFromState
+});
+async function runDashboard(options) {
+  const stateManager2 = getStateManager();
+  const token = options.offline ? null : getGitHubToken();
+  let digest;
+  let commentedIssues = [];
+  if (options.offline) {
+    const state2 = stateManager2.getState();
+    digest = state2.lastDigest;
+    if (!digest) {
+      if (options.json) {
+        outputJson({ error: "No cached data found. Run without --offline first.", offline: true });
+      } else {
+        console.error("No cached data found. Run without --offline first.");
+      }
+      return;
+    }
+    const lastUpdated = digest.generatedAt || state2.lastDigestAt || state2.lastRunAt;
+    console.error(`Offline mode: using cached data from ${lastUpdated}`);
+  } else if (token) {
+    console.error("Fetching fresh data from GitHub...");
+    try {
+      const result = await fetchDashboardData(token);
+      digest = result.digest;
+      commentedIssues = result.commentedIssues;
+    } catch (error) {
+      console.error("Failed to fetch fresh data:", errorMessage(error));
+      console.error("Falling back to cached data (issue conversations unavailable)...");
+      digest = stateManager2.getState().lastDigest;
+    }
+  } else {
+    digest = stateManager2.getState().lastDigest;
+  }
+  if (!digest) {
+    if (options.json) {
+      outputJson({ error: "No data available. Run daily check first with GITHUB_TOKEN." });
+    } else {
+      console.error("No dashboard data available. Run the daily check first:");
+      console.error("  GITHUB_TOKEN=$(gh auth token) npm start -- daily");
+    }
+    return;
+  }
+  const state = stateManager2.getState();
+  const prsByRepo = computePRsByRepo(digest, state);
+  const topRepos = computeTopRepos(prsByRepo);
+  const { monthlyMerged, monthlyClosed, monthlyOpened } = getMonthlyData(state);
+  const stats = buildDashboardStats(digest, state);
+  if (options.json) {
+    const issueResponses2 = commentedIssues.filter((i) => i.status === "new_response");
+    const jsonData = {
+      stats,
+      prsByRepo,
+      topRepos: topRepos.map(([repo, data]) => ({ repo, ...data })),
       monthlyMerged,
       activePRs: digest.openPRs || [],
       commentedIssues,
@@ -16605,8 +16524,8 @@ async function runDashboard(options) {
   const issueResponses = commentedIssues.filter((i) => i.status === "new_response");
   const html = generateDashboardHtml(stats, monthlyMerged, monthlyClosed, monthlyOpened, digest, state, issueResponses);
   const dashboardPath = getDashboardPath();
-  fs5.writeFileSync(dashboardPath, html, { mode: 420 });
-  fs5.chmodSync(dashboardPath, 420);
+  fs6.writeFileSync(dashboardPath, html, { mode: 420 });
+  fs6.chmodSync(dashboardPath, 420);
   if (options.offline) {
     const lastUpdated = digest.generatedAt || state.lastDigestAt || state.lastRunAt;
     console.log(`
@@ -16641,17 +16560,59 @@ function writeDashboardFromState() {
   const stats = buildDashboardStats(digest, state);
   const html = generateDashboardHtml(stats, monthlyMerged, monthlyClosed, monthlyOpened, digest, state);
   const dashboardPath = getDashboardPath();
-  fs5.writeFileSync(dashboardPath, html, { mode: 420 });
-  fs5.chmodSync(dashboardPath, 420);
+  fs6.writeFileSync(dashboardPath, html, { mode: 420 });
+  fs6.chmodSync(dashboardPath, 420);
   return dashboardPath;
 }
-var fs5, import_child_process2;
+function resolveAssetsDir() {
+  const devPath = path6.resolve(__dirname, "../../dashboard/dist");
+  if (fs6.existsSync(path6.join(devPath, "index.html"))) {
+    return devPath;
+  }
+  const bundlePath = path6.resolve(path6.dirname(process.argv[1]), "../../dashboard/dist");
+  if (fs6.existsSync(path6.join(bundlePath, "index.html"))) {
+    return bundlePath;
+  }
+  try {
+    const dashboardPkgPath = require.resolve("@oss-autopilot/dashboard/package.json");
+    const dashboardDist = path6.join(path6.dirname(dashboardPkgPath), "dist");
+    if (fs6.existsSync(path6.join(dashboardDist, "index.html"))) {
+      return dashboardDist;
+    }
+  } catch (error) {
+    const code = error.code;
+    if (code !== "MODULE_NOT_FOUND") {
+      console.error("Error resolving dashboard package:", error);
+    }
+  }
+  return null;
+}
+async function serveDashboard(options) {
+  const assetsDir = resolveAssetsDir();
+  if (!assetsDir) {
+    console.error("Could not find dashboard SPA assets.");
+    console.error("Make sure packages/dashboard has been built:");
+    console.error("  cd packages/dashboard && pnpm run build");
+    process.exit(1);
+  }
+  const token = getGitHubToken();
+  const { startDashboardServer: startDashboardServer2 } = await Promise.resolve().then(() => (init_dashboard_server(), dashboard_server_exports));
+  await startDashboardServer2({
+    port: options.port,
+    assetsDir,
+    token,
+    open: options.open
+  });
+}
+var fs6, path6, import_child_process2;
 var init_dashboard = __esm({
   "src/commands/dashboard.ts"() {
     "use strict";
-    fs5 = __toESM(require("fs"), 1);
+    fs6 = __toESM(require("fs"), 1);
+    path6 = __toESM(require("path"), 1);
     import_child_process2 = require("child_process");
     init_core();
+    init_errors();
     init_json();
     init_dashboard_data();
     init_dashboard_templates();
@@ -16682,7 +16643,7 @@ function extractTitle(line) {
   cleaned = cleaned.replace(/\[[ xX]\]\s*/, "");
   cleaned = cleaned.replace(/~~/g, "");
   cleaned = cleaned.replace(/\b(Done|DONE|done)\b/g, "");
-  cleaned = cleaned.replace(/^[\s\-–—:]+/, "").replace(/[\s\-–—:]+$/, "");
+  cleaned = cleaned.replace(/^[\s\-\u2013\u2014:]+/, "").replace(/[\s\-\u2013\u2014:]+$/, "");
   return cleaned.trim();
 }
 function isCompleted(line) {
@@ -16729,57 +16690,26 @@ function parseIssueList(content) {
   };
 }
 async function runParseList(options) {
-  const filePath = path5.resolve(options.filePath);
-  if (!fs6.existsSync(filePath)) {
-    if (options.json) {
-      outputJsonError(`File not found: ${filePath}`);
-    } else {
-      console.error(`Error: File not found: ${filePath}`);
-    }
-    process.exit(1);
+  const filePath = path7.resolve(options.filePath);
+  if (!fs7.existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
   }
   let content;
   try {
-    content = fs6.readFileSync(filePath, "utf-8");
+    content = fs7.readFileSync(filePath, "utf-8");
   } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    if (options.json) {
-      outputJsonError(`Failed to read file: ${msg}`);
-    } else {
-      console.error(`Error: Failed to read file: ${msg}`);
-    }
-    process.exit(1);
-  }
-  const result = parseIssueList(content);
-  if (options.json) {
-    outputJson(result);
-  } else {
-    console.log(`
-\u{1F4CB} Issue List: ${filePath}
-`);
-    console.log(`Available: ${result.availableCount} | Completed: ${result.completedCount}
-`);
-    if (result.available.length > 0) {
-      console.log("--- Available ---");
-      for (const item of result.available) {
-        console.log(`  [${item.tier}] ${item.repo}#${item.number}: ${item.title}`);
-      }
-    }
-    if (result.completed.length > 0) {
-      console.log("\n--- Completed ---");
-      for (const item of result.completed) {
-        console.log(`  [${item.tier}] ${item.repo}#${item.number}: ${item.title}`);
-      }
-    }
+    const msg = errorMessage(error);
+    throw new Error(`Failed to read file: ${msg}`, { cause: error });
   }
+  return parseIssueList(content);
 }
-var fs6, path5;
+var fs7, path7;
 var init_parse_list = __esm({
   "src/commands/parse-list.ts"() {
     "use strict";
-    fs6 = __toESM(require("fs"), 1);
-    path5 = __toESM(require("path"), 1);
-    init_json();
+    fs7 = __toESM(require("fs"), 1);
+    path7 = __toESM(require("path"), 1);
+    init_errors();
   }
 });
 
@@ -16789,25 +16719,25 @@ __export(check_integration_exports, {
   runCheckIntegration: () => runCheckIntegration
 });
 function getImportName(filePath) {
-  const ext = path6.extname(filePath);
-  const base = path6.basename(filePath, ext);
+  const ext = path8.extname(filePath);
+  const base = path8.basename(filePath, ext);
   if (base === "index") {
-    return path6.basename(path6.dirname(filePath));
+    return path8.basename(path8.dirname(filePath));
   }
   return base;
 }
 function suggestEntryPoints(newFile, existingFiles) {
-  const dir = path6.dirname(newFile);
+  const dir = path8.dirname(newFile);
   const suggestions = [];
   for (const ext of [".ts", ".tsx", ".js", ".jsx"]) {
-    const indexFile = path6.join(dir, `index${ext}`);
+    const indexFile = path8.join(dir, `index${ext}`);
     if (existingFiles.includes(indexFile)) {
       suggestions.push(indexFile);
     }
   }
-  const parentDir = path6.dirname(dir);
+  const parentDir = path8.dirname(dir);
   for (const ext of [".ts", ".tsx", ".js", ".jsx"]) {
-    const parentIndex = path6.join(parentDir, `index${ext}`);
+    const parentIndex = path8.join(parentDir, `index${ext}`);
     if (existingFiles.includes(parentIndex)) {
       suggestions.push(parentIndex);
     }
@@ -16818,33 +16748,22 @@ async function runCheckIntegration(options) {
   const base = options.base;
   let newFiles;
   try {
-    const output2 = (0, import_child_process3.execFileSync)("git", ["diff", "--name-only", "--diff-filter=A", `${base}...HEAD`], {
+    const output = (0, import_child_process3.execFileSync)("git", ["diff", "--name-only", "--diff-filter=A", `${base}...HEAD`], {
       encoding: "utf-8",
       timeout: 1e4
     }).trim();
-    newFiles = output2 ? output2.split("\n").filter(Boolean) : [];
+    newFiles = output ? output.split("\n").filter(Boolean) : [];
   } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    if (options.json) {
-      outputJsonError(`Failed to run git diff: ${msg}`);
-    } else {
-      console.error(`Error: Failed to run git diff: ${msg}`);
-    }
-    process.exit(1);
+    const msg = errorMessage(error);
+    throw new Error(`Failed to run git diff: ${msg}`, { cause: error });
   }
   const codeFiles = newFiles.filter((f) => {
-    const ext = path6.extname(f);
+    const ext = path8.extname(f);
     if (!CODE_EXTENSIONS.has(ext)) return false;
     return !IGNORED_PATTERNS.some((p) => p.test(f));
   });
   if (codeFiles.length === 0) {
-    const result = { newFiles: [], unreferencedCount: 0 };
-    if (options.json) {
-      outputJson(result);
-    } else {
-      console.log("\nNo new code files to check.");
-    }
-    return;
+    return { newFiles: [], unreferencedCount: 0 };
   }
   let allFiles;
   try {
@@ -16879,10 +16798,10 @@ async function runCheckIntegration(options) {
           referencedBy.push(...matches);
         }
       } catch (error) {
-        const exitCode = error && typeof error === "object" && "status" in error ? error.status : null;
-        if (exitCode !== null && exitCode !== 1) {
-          const msg = error instanceof Error ? error.message : String(error);
-          console.error(`Warning: git grep failed for "${pattern}": ${msg}`);
+        const exitCode = error && typeof error === "object" && "status" in error ? error.status : void 0;
+        if (exitCode !== void 0 && exitCode !== 1) {
+          const msg = errorMessage(error);
+          debug("check-integration", `git grep failed for "${pattern}": ${msg}`);
         }
       }
     }
@@ -16899,37 +16818,16 @@ async function runCheckIntegration(options) {
     results.push(info);
   }
   const unreferencedCount = results.filter((r) => !r.isIntegrated).length;
-  const output = { newFiles: results, unreferencedCount };
-  if (options.json) {
-    outputJson(output);
-  } else {
-    console.log(`
-\u{1F50D} Integration Check (base: ${base})
-`);
-    console.log(`New files: ${results.length} | Unreferenced: ${unreferencedCount}
-`);
-    for (const file of results) {
-      const status = file.isIntegrated ? "\u2705" : "\u26A0\uFE0F";
-      console.log(`${status} ${file.path}`);
-      if (file.isIntegrated) {
-        console.log(`   Referenced by: ${file.referencedBy.join(", ")}`);
-      } else {
-        console.log("   Not referenced by any file");
-        if (file.suggestedEntryPoints && file.suggestedEntryPoints.length > 0) {
-          console.log(`   Suggested entry points: ${file.suggestedEntryPoints.join(", ")}`);
-        }
-      }
-    }
-  }
+  return { newFiles: results, unreferencedCount };
 }
-var path6, import_child_process3, CODE_EXTENSIONS, IGNORED_PATTERNS;
+var path8, import_child_process3, CODE_EXTENSIONS, IGNORED_PATTERNS;
 var init_check_integration = __esm({
   "src/commands/check-integration.ts"() {
     "use strict";
-    path6 = __toESM(require("path"), 1);
+    path8 = __toESM(require("path"), 1);
     import_child_process3 = require("child_process");
-    init_json();
     init_core();
+    init_errors();
     CODE_EXTENSIONS = /* @__PURE__ */ new Set([
       ".ts",
       ".tsx",
@@ -17005,7 +16903,7 @@ function getCurrentBranch(repoPath) {
 function scanForRepos(scanPaths) {
   const repos = {};
   for (const scanPath of scanPaths) {
-    if (!fs7.existsSync(scanPath)) continue;
+    if (!fs8.existsSync(scanPath)) continue;
     let gitDirs;
     try {
       const output = (0, import_child_process4.execFileSync)("find", [scanPath, "-maxdepth", "4", "-name", ".git", "-type", "d"], {
@@ -17019,7 +16917,7 @@ function scanForRepos(scanPaths) {
       continue;
     }
     for (const gitDir of gitDirs) {
-      const repoPath = path7.dirname(gitDir);
+      const repoPath = path9.dirname(gitDir);
       const remote = getGitHubRemote(repoPath);
       if (!remote) continue;
       const currentBranch = getCurrentBranch(repoPath);
@@ -17035,79 +16933,49 @@ function scanForRepos(scanPaths) {
 async function runLocalRepos(options) {
   const stateManager2 = getStateManager();
   const state = stateManager2.getState();
-  const scanPaths = options.paths?.map((p) => path7.resolve(p)) ?? state.config.localRepoScanPaths ?? DEFAULT_SCAN_PATHS.filter((p) => fs7.existsSync(p));
+  const scanPaths = options.paths?.map((p) => path9.resolve(p)) ?? state.config.localRepoScanPaths ?? DEFAULT_SCAN_PATHS.filter((p) => fs8.existsSync(p));
   if (!options.scan && state.localRepoCache) {
     const cache = state.localRepoCache;
-    const result2 = {
+    return {
       repos: cache.repos,
       scanPaths: cache.scanPaths,
       cachedAt: cache.cachedAt,
       fromCache: true
     };
-    if (options.json) {
-      outputJson(result2);
-    } else {
-      console.log(`
-\u{1F4C1} Local Repos (cached ${cache.cachedAt})
-`);
-      printRepos(cache.repos);
-    }
-    return;
-  }
-  if (!options.json) {
-    console.log(`
-\u{1F50D} Scanning for local repos in ${scanPaths.length} directories...
-`);
   }
   const repos = scanForRepos(scanPaths);
-  const repoCount = Object.keys(repos).length;
   const cachedAt = (/* @__PURE__ */ new Date()).toISOString();
   try {
     stateManager2.setLocalRepoCache({ repos, scanPaths, cachedAt });
     stateManager2.save();
   } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    console.error(`Warning: Failed to cache scan results: ${msg}`);
+    const msg = errorMessage(error);
+    debug("local-repos", `Failed to cache scan results: ${msg}`);
   }
-  const result = {
+  return {
     repos,
     scanPaths,
     cachedAt,
     fromCache: false
   };
-  if (options.json) {
-    outputJson(result);
-  } else {
-    console.log(`Found ${repoCount} repos:
-`);
-    printRepos(repos);
-  }
-}
-function printRepos(repos) {
-  const entries = Object.entries(repos).sort(([a], [b]) => a.localeCompare(b));
-  for (const [remote, info] of entries) {
-    const branch = info.currentBranch ? ` (${info.currentBranch})` : "";
-    console.log(`  ${remote}${branch}`);
-    console.log(`    ${info.path}`);
-  }
 }
-var fs7, path7, os2, import_child_process4, DEFAULT_SCAN_PATHS;
+var fs8, path9, os2, import_child_process4, DEFAULT_SCAN_PATHS;
 var init_local_repos = __esm({
   "src/commands/local-repos.ts"() {
     "use strict";
-    fs7 = __toESM(require("fs"), 1);
-    path7 = __toESM(require("path"), 1);
+    fs8 = __toESM(require("fs"), 1);
+    path9 = __toESM(require("path"), 1);
     os2 = __toESM(require("os"), 1);
     import_child_process4 = require("child_process");
     init_core();
-    init_json();
+    init_errors();
     DEFAULT_SCAN_PATHS = [
-      path7.join(os2.homedir(), "Documents", "oss"),
-      path7.join(os2.homedir(), "dev"),
-      path7.join(os2.homedir(), "projects"),
-      path7.join(os2.homedir(), "src"),
-      path7.join(os2.homedir(), "code"),
-      path7.join(os2.homedir(), "repos")
+      path9.join(os2.homedir(), "Documents", "oss"),
+      path9.join(os2.homedir(), "dev"),
+      path9.join(os2.homedir(), "projects"),
+      path9.join(os2.homedir(), "src"),
+      path9.join(os2.homedir(), "code"),
+      path9.join(os2.homedir(), "repos")
     ];
   }
 });
@@ -17120,15 +16988,6 @@ __export(startup_exports, {
   parseIssueListPathFromConfig: () => parseIssueListPathFromConfig,
   runStartup: () => runStartup
 });
-function getVersion() {
-  try {
-    const pkgPath = path8.join(path8.dirname(process.argv[1]), "..", "package.json");
-    return JSON.parse(fs8.readFileSync(pkgPath, "utf-8")).version;
-  } catch (error) {
-    console.error("[STARTUP] Failed to detect CLI version:", error instanceof Error ? error.message : error);
-    return "0.0.0";
-  }
-}
 function parseIssueListPathFromConfig(configContent) {
   const match = configContent.match(/^---\n([\s\S]*?)\n---/);
   if (!match) return void 0;
@@ -17155,22 +17014,22 @@ function detectIssueList() {
   let issueListPath = "";
   let source = "auto-detected";
   const configPath = ".claude/oss-autopilot/config.md";
-  if (fs8.existsSync(configPath)) {
+  if (fs9.existsSync(configPath)) {
     try {
-      const configContent = fs8.readFileSync(configPath, "utf-8");
+      const configContent = fs9.readFileSync(configPath, "utf-8");
       const configuredPath = parseIssueListPathFromConfig(configContent);
-      if (configuredPath && fs8.existsSync(configuredPath)) {
+      if (configuredPath && fs9.existsSync(configuredPath)) {
         issueListPath = configuredPath;
         source = "configured";
       }
     } catch (error) {
-      console.error("[STARTUP] Failed to read config:", error instanceof Error ? error.message : error);
+      console.error("[STARTUP] Failed to read config:", errorMessage(error));
     }
   }
   if (!issueListPath) {
     const probes = ["open-source/potential-issue-list.md", "oss/issue-list.md", "issues.md"];
     for (const probe of probes) {
-      if (fs8.existsSync(probe)) {
+      if (fs9.existsSync(probe)) {
         issueListPath = probe;
         source = "auto-detected";
         break;
@@ -17179,14 +17038,11 @@ function detectIssueList() {
   }
   if (!issueListPath) return void 0;
   try {
-    const content = fs8.readFileSync(issueListPath, "utf-8");
+    const content = fs9.readFileSync(issueListPath, "utf-8");
     const { availableCount, completedCount } = countIssueListItems(content);
     return { path: issueListPath, source, availableCount, completedCount };
   } catch (error) {
-    console.error(
-      `[STARTUP] Failed to read issue list at ${issueListPath}:`,
-      error instanceof Error ? error.message : error
-    );
+    console.error(`[STARTUP] Failed to read issue list at ${issueListPath}:`, errorMessage(error));
     return { path: issueListPath, source, availableCount: 0, completedCount: 0 };
   }
 }
@@ -17200,82 +17056,52 @@ function openInBrowser(filePath) {
     }
   });
 }
-async function runStartup(options) {
-  const version = getVersion();
+async function runStartup() {
+  const version = getCLIVersion();
   const stateManager2 = getStateManager();
   if (!stateManager2.isSetupComplete()) {
-    if (options.json) {
-      outputJson({ version, setupComplete: false });
-    } else {
-      console.log("Setup incomplete. Run /setup-oss first.");
-    }
-    return;
+    return { version, setupComplete: false };
   }
   const token = getGitHubToken();
   if (!token) {
-    if (options.json) {
-      outputJson({
-        version,
-        setupComplete: true,
-        authError: 'GitHub authentication required. Install GitHub CLI (https://cli.github.com/) and run "gh auth login", or set GITHUB_TOKEN.'
-      });
-    } else {
-      console.error("Error: GitHub authentication required.");
-    }
-    return;
+    return {
+      version,
+      setupComplete: true,
+      authError: 'GitHub authentication required. Install GitHub CLI (https://cli.github.com/) and run "gh auth login", or set GITHUB_TOKEN.'
+    };
   }
+  const daily = await executeDailyCheck(token);
+  let dashboardPath;
+  let dashboardOpened = false;
   try {
-    const daily = await executeDailyCheck(token);
-    let dashboardPath;
-    let dashboardOpened = false;
-    try {
-      dashboardPath = writeDashboardFromState();
-      if (daily.digest.summary.totalActivePRs > 0) {
-        openInBrowser(dashboardPath);
-        dashboardOpened = true;
-      }
-    } catch (error) {
-      console.error("[STARTUP] Dashboard generation failed:", error instanceof Error ? error.message : error);
-    }
-    if (dashboardOpened) {
-      daily.briefSummary += " | Dashboard opened in browser";
-    }
-    const issueList = detectIssueList();
-    if (options.json) {
-      outputJson({
-        version,
-        setupComplete: true,
-        daily,
-        dashboardPath,
-        issueList
-      });
-    } else {
-      console.log(`OSS Autopilot v${version}`);
-      console.log(daily.briefSummary);
-      if (dashboardPath) console.log(`Dashboard: ${dashboardPath}`);
+    dashboardPath = writeDashboardFromState();
+    if (daily.digest.summary.totalActivePRs > 0) {
+      openInBrowser(dashboardPath);
+      dashboardOpened = true;
     }
   } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    if (options.json) {
-      outputJsonError(`Daily check failed: ${msg}`);
-    } else {
-      console.error(`[FATAL] Daily check failed: ${msg}`);
-      if (error instanceof Error && error.stack) {
-        console.error(error.stack);
-      }
-    }
-    process.exit(1);
+    console.error("[STARTUP] Dashboard generation failed:", errorMessage(error));
   }
+  if (dashboardOpened) {
+    daily.briefSummary += " | Dashboard opened in browser";
+  }
+  const issueList = detectIssueList();
+  return {
+    version,
+    setupComplete: true,
+    daily,
+    dashboardPath,
+    issueList
+  };
 }
-var fs8, path8, import_child_process5;
+var fs9, import_child_process5;
 var init_startup = __esm({
   "src/commands/startup.ts"() {
     "use strict";
-    fs8 = __toESM(require("fs"), 1);
-    path8 = __toESM(require("path"), 1);
+    fs9 = __toESM(require("fs"), 1);
     import_child_process5 = require("child_process");
     init_core();
-    init_json();
+    init_errors();
     init_daily();
     init_dashboard();
   }
@@ -17290,44 +17116,28 @@ __export(shelve_exports, {
 });
 async function runShelve(options) {
   validateUrl(options.prUrl);
-  validateGitHubUrl(options.prUrl, PR_URL_PATTERN, "PR", options.json);
+  validateGitHubUrl(options.prUrl, PR_URL_PATTERN, "PR");
   const stateManager2 = getStateManager();
   const added = stateManager2.shelvePR(options.prUrl);
   if (added) {
     stateManager2.save();
   }
-  if (options.json) {
-    outputJson({ shelved: added, url: options.prUrl });
-  } else if (added) {
-    console.log(`Shelved: ${options.prUrl}`);
-    console.log("This PR is now excluded from capacity and actionable issues.");
-    console.log("It will auto-unshelve if a maintainer engages.");
-  } else {
-    console.log("PR is already shelved.");
-  }
+  return { shelved: added, url: options.prUrl };
 }
 async function runUnshelve(options) {
   validateUrl(options.prUrl);
-  validateGitHubUrl(options.prUrl, PR_URL_PATTERN, "PR", options.json);
+  validateGitHubUrl(options.prUrl, PR_URL_PATTERN, "PR");
   const stateManager2 = getStateManager();
   const removed = stateManager2.unshelvePR(options.prUrl);
   if (removed) {
     stateManager2.save();
   }
-  if (options.json) {
-    outputJson({ unshelved: removed, url: options.prUrl });
-  } else if (removed) {
-    console.log(`Unshelved: ${options.prUrl}`);
-    console.log("This PR is now active again.");
-  } else {
-    console.log("PR was not shelved.");
-  }
+  return { unshelved: removed, url: options.prUrl };
 }
 var init_shelve = __esm({
   "src/commands/shelve.ts"() {
     "use strict";
     init_core();
-    init_json();
     init_validation();
   }
 });
@@ -17341,44 +17151,28 @@ __export(dismiss_exports, {
 });
 async function runDismiss(options) {
   validateUrl(options.issueUrl);
-  validateGitHubUrl(options.issueUrl, ISSUE_URL_PATTERN, "issue", options.json);
+  validateGitHubUrl(options.issueUrl, ISSUE_URL_PATTERN, "issue");
   const stateManager2 = getStateManager();
   const added = stateManager2.dismissIssue(options.issueUrl, (/* @__PURE__ */ new Date()).toISOString());
   if (added) {
     stateManager2.save();
   }
-  if (options.json) {
-    outputJson({ dismissed: added, url: options.issueUrl });
-  } else if (added) {
-    console.log(`Dismissed: ${options.issueUrl}`);
-    console.log("Issue reply notifications are now muted.");
-    console.log("New responses after this point will resurface automatically.");
-  } else {
-    console.log("Issue is already dismissed.");
-  }
+  return { dismissed: added, url: options.issueUrl };
 }
 async function runUndismiss(options) {
   validateUrl(options.issueUrl);
-  validateGitHubUrl(options.issueUrl, ISSUE_URL_PATTERN, "issue", options.json);
+  validateGitHubUrl(options.issueUrl, ISSUE_URL_PATTERN, "issue");
   const stateManager2 = getStateManager();
   const removed = stateManager2.undismissIssue(options.issueUrl);
   if (removed) {
     stateManager2.save();
   }
-  if (options.json) {
-    outputJson({ undismissed: removed, url: options.issueUrl });
-  } else if (removed) {
-    console.log(`Undismissed: ${options.issueUrl}`);
-    console.log("Issue reply notifications are active again.");
-  } else {
-    console.log("Issue was not dismissed.");
-  }
+  return { undismissed: removed, url: options.issueUrl };
 }
 var init_dismiss = __esm({
   "src/commands/dismiss.ts"() {
     "use strict";
     init_core();
-    init_json();
     init_validation();
   }
 });
@@ -17391,77 +17185,41 @@ __export(snooze_exports, {
 });
 async function runSnooze(options) {
   validateUrl(options.prUrl);
-  validateGitHubUrl(options.prUrl, PR_URL_PATTERN, "PR", options.json);
+  validateGitHubUrl(options.prUrl, PR_URL_PATTERN, "PR");
   validateMessage(options.reason);
   const days = options.days ?? DEFAULT_SNOOZE_DAYS;
   if (!Number.isFinite(days) || days <= 0) {
-    if (options.json) {
-      outputJsonError("Snooze duration must be a positive number of days.");
-    } else {
-      console.error("Error: Snooze duration must be a positive number of days.");
-    }
-    process.exit(1);
+    throw new Error("Snooze duration must be a positive number of days.");
   }
-  try {
-    const stateManager2 = getStateManager();
-    const added = stateManager2.snoozePR(options.prUrl, options.reason, days);
-    if (added) {
-      stateManager2.save();
-    }
-    const snoozeInfo = stateManager2.getSnoozeInfo(options.prUrl);
-    if (options.json) {
-      outputJson({
-        snoozed: added,
-        url: options.prUrl,
-        days,
-        reason: options.reason,
-        expiresAt: snoozeInfo?.expiresAt
-      });
-    } else if (added) {
-      console.log(`Snoozed: ${options.prUrl}`);
-      console.log(`Reason: ${options.reason}`);
-      console.log(`Duration: ${days} day${days === 1 ? "" : "s"}`);
-      console.log(`Expires: ${snoozeInfo?.expiresAt ? new Date(snoozeInfo.expiresAt).toLocaleString() : "unknown"}`);
-      console.log("CI failure notifications are now muted for this PR.");
-    } else {
-      console.log("PR is already snoozed.");
-      if (snoozeInfo) {
-        console.log(`Expires: ${new Date(snoozeInfo.expiresAt).toLocaleString()}`);
-      }
-    }
-  } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    if (options.json) {
-      outputJsonError(`Snooze failed: ${msg}`);
-    } else {
-      console.error(`Error: Snooze failed: ${msg}`);
-    }
-    process.exit(1);
+  const stateManager2 = getStateManager();
+  const added = stateManager2.snoozePR(options.prUrl, options.reason, days);
+  if (added) {
+    stateManager2.save();
   }
+  const snoozeInfo = stateManager2.getSnoozeInfo(options.prUrl);
+  return {
+    snoozed: added,
+    url: options.prUrl,
+    days,
+    reason: options.reason,
+    expiresAt: snoozeInfo?.expiresAt
+  };
 }
 async function runUnsnooze(options) {
   validateUrl(options.prUrl);
-  validateGitHubUrl(options.prUrl, PR_URL_PATTERN, "PR", options.json);
+  validateGitHubUrl(options.prUrl, PR_URL_PATTERN, "PR");
   const stateManager2 = getStateManager();
   const removed = stateManager2.unsnoozePR(options.prUrl);
   if (removed) {
     stateManager2.save();
   }
-  if (options.json) {
-    outputJson({ unsnoozed: removed, url: options.prUrl });
-  } else if (removed) {
-    console.log(`Unsnoozed: ${options.prUrl}`);
-    console.log("CI failure notifications are active again for this PR.");
-  } else {
-    console.log("PR was not snoozed.");
-  }
+  return { unsnoozed: removed, url: options.prUrl };
 }
 var DEFAULT_SNOOZE_DAYS;
 var init_snooze = __esm({
   "src/commands/snooze.ts"() {
     "use strict";
     init_core();
-    init_json();
     init_validation();
     DEFAULT_SNOOZE_DAYS = 7;
   }
@@ -17486,16 +17244,26 @@ var {
 
 // src/cli.ts
 init_core();
-var VERSION10 = (() => {
-  try {
-    const fs9 = require("fs");
-    const path9 = require("path");
-    const pkgPath = path9.join(path9.dirname(process.argv[1]), "..", "package.json");
-    return JSON.parse(fs9.readFileSync(pkgPath, "utf-8")).version;
-  } catch (_err) {
-    return "0.0.0";
+init_errors();
+init_json();
+function printRepos(repos) {
+  const entries = Object.entries(repos).sort(([a], [b]) => a.localeCompare(b));
+  for (const [remote, info] of entries) {
+    const branch = info.currentBranch ? ` (${info.currentBranch})` : "";
+    console.log(`  ${remote}${branch}`);
+    console.log(`    ${info.path}`);
   }
-})();
+}
+function handleCommandError(err, json) {
+  const msg = errorMessage(err);
+  if (json) {
+    outputJsonError(msg);
+  } else {
+    console.error(`Error: ${msg}`);
+  }
+  process.exit(1);
+}
+var VERSION10 = getCLIVersion();
 var LOCAL_ONLY_COMMANDS = [
   "help",
   "status",
@@ -17506,6 +17274,7 @@ var LOCAL_ONLY_COMMANDS = [
   "setup",
   "checkSetup",
   "dashboard",
+  "serve",
   "parse-issue-list",
   "check-integration",
   "local-repos",
@@ -17520,106 +17289,571 @@ var LOCAL_ONLY_COMMANDS = [
 var program2 = new Command();
 program2.name("oss-autopilot").description("AI-powered autopilot for managing open source contributions").version(VERSION10).option("--debug", "Enable debug logging");
 program2.command("daily").description("Run daily check on all tracked PRs").option("--json", "Output as JSON").action(async (options) => {
-  const { runDaily: runDaily2 } = await Promise.resolve().then(() => (init_daily(), daily_exports));
-  await runDaily2({ json: options.json });
+  try {
+    if (options.json) {
+      const { runDaily: runDaily2 } = await Promise.resolve().then(() => (init_daily(), daily_exports));
+      const data = await runDaily2();
+      outputJson(data);
+    } else {
+      const { runDailyForDisplay: runDailyForDisplay2, printDigest: printDigest2 } = await Promise.resolve().then(() => (init_daily(), daily_exports));
+      const result = await runDailyForDisplay2();
+      printDigest2(result.digest, result.capacity, result.commentedIssues);
+    }
+  } catch (err) {
+    handleCommandError(err, options.json);
+  }
 });
 program2.command("status").description("Show current status and stats").option("--json", "Output as JSON").option("--offline", "Use cached data only (no GitHub API calls)").action(async (options) => {
-  const { runStatus: runStatus2 } = await Promise.resolve().then(() => (init_status(), status_exports));
-  await runStatus2({ json: options.json, offline: options.offline });
+  try {
+    const { runStatus: runStatus2 } = await Promise.resolve().then(() => (init_status(), status_exports));
+    const data = await runStatus2({ offline: options.offline });
+    if (options.json) {
+      outputJson(data);
+    } else {
+      console.log("\n\u{1F4CA} OSS Status\n");
+      console.log(`Merged PRs: ${data.stats.mergedPRs}`);
+      console.log(`Closed PRs: ${data.stats.closedPRs}`);
+      console.log(`Merge Rate: ${data.stats.mergeRate}`);
+      console.log(`Needs Response: ${data.stats.needsResponse}`);
+      if (data.offline) {
+        console.log(`
+Last Updated: ${data.lastUpdated || "Never"}`);
+        console.log("(Offline mode: showing cached data)");
+      } else {
+        console.log(`
+Last Run: ${data.lastRunAt || "Never"}`);
+      }
+      console.log("\nRun with --json for structured output");
+    }
+  } catch (err) {
+    handleCommandError(err, options.json);
+  }
 });
 program2.command("search [count]").description("Search for new issues to work on").option("--json", "Output as JSON").action(async (count, options) => {
-  const { runSearch: runSearch2 } = await Promise.resolve().then(() => (init_search(), search_exports));
-  await runSearch2({ maxResults: parseInt(count) || 5, json: options.json });
+  try {
+    const { runSearch: runSearch2 } = await Promise.resolve().then(() => (init_search(), search_exports));
+    if (!options.json) {
+      console.log(`
+Searching for issues (max ${parseInt(count) || 5})...
+`);
+    }
+    const data = await runSearch2({ maxResults: parseInt(count) || 5 });
+    if (options.json) {
+      outputJson(data);
+    } else {
+      if (data.candidates.length === 0) {
+        if (data.rateLimitWarning) {
+          console.warn(`
+${data.rateLimitWarning}
+`);
+        } else {
+          console.log("No matching issues found.");
+        }
+        return;
+      }
+      if (data.rateLimitWarning) {
+        console.warn(`
+${data.rateLimitWarning}
+`);
+      }
+      console.log(`Found ${data.candidates.length} candidates:
+`);
+      for (const candidate of data.candidates) {
+        const { issue, recommendation, reasonsToApprove, reasonsToSkip, viabilityScore } = candidate;
+        console.log(`[${recommendation.toUpperCase()}] ${issue.repo}#${issue.number}: ${issue.title}`);
+        console.log(`  URL: ${issue.url}`);
+        console.log(`  Viability: ${viabilityScore}/100`);
+        if (reasonsToApprove.length > 0) console.log(`  Approve: ${reasonsToApprove.join(", ")}`);
+        if (reasonsToSkip.length > 0) console.log(`  Skip: ${reasonsToSkip.join(", ")}`);
+        console.log("---");
+      }
+    }
+  } catch (err) {
+    handleCommandError(err, options.json);
+  }
 });
 program2.command("vet <issue-url>").description("Vet a specific issue before working on it").option("--json", "Output as JSON").action(async (issueUrl, options) => {
-  const { runVet: runVet2 } = await Promise.resolve().then(() => (init_vet(), vet_exports));
-  await runVet2({ issueUrl, json: options.json });
+  try {
+    const { runVet: runVet2 } = await Promise.resolve().then(() => (init_vet(), vet_exports));
+    const data = await runVet2({ issueUrl });
+    if (options.json) {
+      outputJson(data);
+    } else {
+      const { issue, recommendation, reasonsToApprove, reasonsToSkip } = data;
+      console.log(`
+Vetting issue: ${issueUrl}
+`);
+      console.log(`[${recommendation.toUpperCase()}] ${issue.repo}#${issue.number}: ${issue.title}`);
+      console.log(`  URL: ${issue.url}`);
+      if (reasonsToApprove.length > 0) console.log(`  Approve: ${reasonsToApprove.join(", ")}`);
+      if (reasonsToSkip.length > 0) console.log(`  Skip: ${reasonsToSkip.join(", ")}`);
+    }
+  } catch (err) {
+    handleCommandError(err, options.json);
+  }
 });
 program2.command("track <pr-url>").description("Add a PR to track").option("--json", "Output as JSON").action(async (prUrl, options) => {
-  const { runTrack: runTrack2 } = await Promise.resolve().then(() => (init_track(), track_exports));
-  await runTrack2({ prUrl, json: options.json });
+  try {
+    const { runTrack: runTrack2 } = await Promise.resolve().then(() => (init_track(), track_exports));
+    const data = await runTrack2({ prUrl });
+    if (options.json) {
+      outputJson(data);
+    } else {
+      console.log(`
+PR: ${data.pr.repo}#${data.pr.number} - ${data.pr.title}`);
+      console.log("Note: In v2, PRs are tracked automatically via the daily run.");
+    }
+  } catch (err) {
+    handleCommandError(err, options.json);
+  }
 });
 program2.command("untrack <pr-url>").description("Stop tracking a PR").option("--json", "Output as JSON").action(async (prUrl, options) => {
-  const { runUntrack: runUntrack2 } = await Promise.resolve().then(() => (init_track(), track_exports));
-  await runUntrack2({ prUrl, json: options.json });
+  try {
+    const { runUntrack: runUntrack2 } = await Promise.resolve().then(() => (init_track(), track_exports));
+    const data = await runUntrack2({ prUrl });
+    if (options.json) {
+      outputJson(data);
+    } else {
+      console.log(
+        "Note: In v2, PRs are fetched fresh on each daily run \u2014 there is no local tracking list to remove from."
+      );
+      console.log("Use `shelve` to temporarily hide a PR from the daily summary.");
+    }
+  } catch (err) {
+    handleCommandError(err, options.json);
+  }
 });
 program2.command("read [pr-url]").description("Mark PR comments as read").option("--all", "Mark all PRs as read").option("--json", "Output as JSON").action(async (prUrl, options) => {
-  const { runRead: runRead2 } = await Promise.resolve().then(() => (init_read(), read_exports));
-  await runRead2({ prUrl, all: options.all, json: options.json });
+  try {
+    const { runRead: runRead2 } = await Promise.resolve().then(() => (init_read(), read_exports));
+    const data = await runRead2({ prUrl, all: options.all });
+    if (options.json) {
+      outputJson(data);
+    } else {
+      console.log("Note: In v2, PR read state is not tracked locally. PRs are fetched fresh on each daily run.");
+    }
+  } catch (err) {
+    handleCommandError(err, options.json);
+  }
 });
 program2.command("comments <pr-url>").description("Show all comments on a PR").option("--bots", "Include bot comments").option("--json", "Output as JSON").action(async (prUrl, options) => {
-  const { runComments: runComments2 } = await Promise.resolve().then(() => (init_comments(), comments_exports));
-  await runComments2({ prUrl, showBots: options.bots, json: options.json });
+  try {
+    const { runComments: runComments2 } = await Promise.resolve().then(() => (init_comments(), comments_exports));
+    const data = await runComments2({ prUrl, showBots: options.bots });
+    if (options.json) {
+      outputJson(data);
+    } else {
+      console.log(`
+Fetching comments for: ${prUrl}
+`);
+      console.log(`## ${data.pr.title}
+`);
+      console.log(`**Status:** ${data.pr.state} | **Mergeable:** ${data.pr.mergeable ?? "checking..."}`);
+      console.log(`**Branch:** ${data.pr.head} -> ${data.pr.base}`);
+      console.log(`**URL:** ${data.pr.url}
+`);
+      const REVIEW_STATE_LABELS = {
+        APPROVED: "[Approved]",
+        CHANGES_REQUESTED: "[Changes]"
+      };
+      if (data.reviews.length > 0) {
+        console.log("### Reviews (newest first)\n");
+        for (const review of data.reviews) {
+          const state = REVIEW_STATE_LABELS[review.state] ?? "[Comment]";
+          const time = review.submittedAt ? formatRelativeTime(review.submittedAt) : "";
+          console.log(`${state} **@${review.user}** (${review.state}) - ${time}`);
+          if (review.body) {
+            console.log(`> ${review.body.split("\n").join("\n> ")}
+`);
+          }
+        }
+      }
+      if (data.reviewComments.length > 0) {
+        console.log("### Inline Comments (newest first)\n");
+        for (const comment of data.reviewComments) {
+          const time = formatRelativeTime(comment.createdAt);
+          console.log(`**@${comment.user}** on \`${comment.path}\` - ${time}`);
+          console.log(`> ${comment.body.split("\n").join("\n> ")}`);
+          console.log("");
+        }
+      }
+      if (data.issueComments.length > 0) {
+        console.log("### Discussion (newest first)\n");
+        for (const comment of data.issueComments) {
+          const time = formatRelativeTime(comment.createdAt);
+          console.log(`**@${comment.user}** - ${time}`);
+          console.log(`> ${comment.body?.split("\n").join("\n> ")}
+`);
+        }
+      }
+      if (data.reviewComments.length === 0 && data.issueComments.length === 0 && data.reviews.length === 0) {
+        console.log("No comments from other users.\n");
+      }
+      console.log("---");
+      console.log(
+        `**Summary:** ${data.summary.reviewCount} reviews, ${data.summary.inlineCommentCount} inline comments, ${data.summary.discussionCommentCount} discussion comments`
+      );
+    }
+  } catch (err) {
+    handleCommandError(err, options.json);
+  }
 });
 program2.command("post <url> [message...]").description("Post a comment to a PR or issue").option("--stdin", "Read message from stdin").option("--json", "Output as JSON").action(async (url, messageParts, options) => {
-  const { runPost: runPost2 } = await Promise.resolve().then(() => (init_comments(), comments_exports));
-  const message = options.stdin ? void 0 : messageParts.join(" ");
-  await runPost2({ url, message, stdin: options.stdin, json: options.json });
+  try {
+    let message;
+    if (options.stdin) {
+      const chunks = [];
+      for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+      }
+      message = Buffer.concat(chunks).toString("utf-8").trim();
+    } else {
+      message = messageParts.join(" ");
+    }
+    const { runPost: runPost2 } = await Promise.resolve().then(() => (init_comments(), comments_exports));
+    const data = await runPost2({ url, message });
+    if (options.json) {
+      outputJson(data);
+    } else {
+      console.log(`Comment posted: ${data.commentUrl}`);
+    }
+  } catch (err) {
+    handleCommandError(err, options.json);
+  }
 });
 program2.command("claim <issue-url> [message...]").description("Claim an issue by posting a comment").option("--json", "Output as JSON").action(async (issueUrl, messageParts, options) => {
-  const { runClaim: runClaim2 } = await Promise.resolve().then(() => (init_comments(), comments_exports));
-  const message = messageParts.length > 0 ? messageParts.join(" ") : void 0;
-  await runClaim2({ issueUrl, message, json: options.json });
+  try {
+    const { runClaim: runClaim2 } = await Promise.resolve().then(() => (init_comments(), comments_exports));
+    const message = messageParts.length > 0 ? messageParts.join(" ") : void 0;
+    const data = await runClaim2({ issueUrl, message });
+    if (options.json) {
+      outputJson(data);
+    } else {
+      console.log(`Issue claimed: ${data.commentUrl}`);
+    }
+  } catch (err) {
+    handleCommandError(err, options.json);
+  }
 });
 program2.command("config [key] [value]").description("Show or update configuration").option("--json", "Output as JSON").action(async (key, value, options) => {
-  const { runConfig: runConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-  await runConfig2({ key, value, json: options.json });
+  try {
+    const { runConfig: runConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    const data = await runConfig2({ key, value });
+    if (options.json) {
+      outputJson(data);
+    } else if ("config" in data) {
+      console.log("\n\u2699\uFE0F Current Configuration:\n");
+      console.log(JSON.stringify(data.config, null, 2));
+    } else {
+      console.log(`Set ${data.key} to: ${data.value}`);
+    }
+  } catch (err) {
+    handleCommandError(err, options.json);
+  }
 });
 program2.command("init <username>").description("Initialize with your GitHub username and import open PRs").option("--json", "Output as JSON").action(async (username, options) => {
-  const { runInit: runInit2 } = await Promise.resolve().then(() => (init_init(), init_exports));
-  await runInit2({ username, json: options.json });
+  try {
+    const { runInit: runInit2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+    const data = await runInit2({ username });
+    if (options.json) {
+      outputJson(data);
+    } else {
+      console.log(`
+Username set to @${data.username}.`);
+      console.log("Run `oss-autopilot daily` to fetch your open PRs from GitHub.");
+    }
+  } catch (err) {
+    handleCommandError(err, options.json);
+  }
 });
 program2.command("setup").description("Interactive setup / configuration").option("--reset", "Re-run setup even if already complete").option("--set <settings...>", "Set specific values (key=value)").option("--json", "Output as JSON").action(async (options) => {
-  const { runSetup: runSetup2 } = await Promise.resolve().then(() => (init_setup(), setup_exports));
-  await runSetup2({ reset: options.reset, set: options.set, json: options.json });
+  try {
+    const { runSetup: runSetup2 } = await Promise.resolve().then(() => (init_setup(), setup_exports));
+    const data = await runSetup2({ reset: options.reset, set: options.set });
+    if (options.json) {
+      outputJson(data);
+    } else if ("success" in data) {
+      for (const [key, value] of Object.entries(data.settings)) {
+        console.log(`\u2713 ${key}: ${value}`);
+      }
+      if (data.warnings) {
+        for (const w of data.warnings) {
+          console.warn(w);
+        }
+      }
+    } else if ("setupComplete" in data && data.setupComplete) {
+      console.log("\n\u2699\uFE0F  OSS Autopilot Setup\n");
+      console.log("\u2713 Setup already complete!\n");
+      console.log("Current settings:");
+      console.log(`  GitHub username:    ${data.config.githubUsername || "(not set)"}`);
+      console.log(`  Max active PRs:     ${data.config.maxActivePRs}`);
+      console.log(`  Dormant threshold:  ${data.config.dormantThresholdDays} days`);
+      console.log(`  Approaching dormant: ${data.config.approachingDormantDays} days`);
+      console.log(`  Languages:          ${data.config.languages.join(", ")}`);
+      console.log(`  Labels:             ${data.config.labels.join(", ")}`);
+      console.log(`
+Run 'setup --reset' to reconfigure.`);
+    } else if ("setupRequired" in data) {
+      console.log("\n\u2699\uFE0F  OSS Autopilot Setup\n");
+      console.log("SETUP_REQUIRED");
+      console.log("---");
+      console.log("Please configure the following settings:\n");
+      for (const prompt of data.prompts) {
+        console.log(`SETTING: ${prompt.setting}`);
+        console.log(`PROMPT: ${prompt.prompt}`);
+        const currentVal = Array.isArray(prompt.current) ? prompt.current.join(", ") : prompt.current;
+        console.log(`CURRENT: ${currentVal ?? "(not set)"}`);
+        if (prompt.required) console.log("REQUIRED: true");
+        if (prompt.default !== void 0) {
+          const defaultVal = Array.isArray(prompt.default) ? prompt.default.join(", ") : prompt.default;
+          console.log(`DEFAULT: ${defaultVal}`);
+        }
+        if (prompt.type) console.log(`TYPE: ${prompt.type}`);
+        console.log("");
+      }
+      console.log("---");
+      console.log("END_SETUP_PROMPTS");
+    }
+  } catch (err) {
+    handleCommandError(err, options.json);
+  }
 });
 program2.command("checkSetup").description("Check if setup is complete").option("--json", "Output as JSON").action(async (options) => {
-  const { runCheckSetup: runCheckSetup2 } = await Promise.resolve().then(() => (init_setup(), setup_exports));
-  await runCheckSetup2({ json: options.json });
+  try {
+    const { runCheckSetup: runCheckSetup2 } = await Promise.resolve().then(() => (init_setup(), setup_exports));
+    const data = await runCheckSetup2();
+    if (options.json) {
+      outputJson(data);
+    } else if (data.setupComplete) {
+      console.log("SETUP_COMPLETE");
+      console.log(`username=${data.username}`);
+    } else {
+      console.log("SETUP_INCOMPLETE");
+    }
+  } catch (err) {
+    handleCommandError(err, options.json);
+  }
 });
-program2.command("dashboard").description("Generate HTML stats dashboard").option("--open", "Open in browser").option("--json", "Output as JSON").option("--offline", "Use cached data only (no GitHub API calls)").action(async (options) => {
+var dashboardCmd = program2.command("dashboard").description("Dashboard commands");
+dashboardCmd.command("serve").description("Start interactive dashboard server").option("--port <port>", "Port to listen on", "3000").option("--no-open", "Do not open browser automatically").action(async (options) => {
+  const port = parseInt(options.port, 10);
+  if (isNaN(port) || port < 1 || port > 65535) {
+    console.error(`Invalid port number: "${options.port}". Must be an integer between 1 and 65535.`);
+    process.exit(1);
+  }
+  const { serveDashboard: serveDashboard2 } = await Promise.resolve().then(() => (init_dashboard(), dashboard_exports));
+  await serveDashboard2({ port, open: options.open });
+});
+dashboardCmd.option("--open", "Open in browser").option("--json", "Output as JSON").option("--offline", "Use cached data only (no GitHub API calls)").action(async (options) => {
   const { runDashboard: runDashboard2 } = await Promise.resolve().then(() => (init_dashboard(), dashboard_exports));
   await runDashboard2({ open: options.open, json: options.json, offline: options.offline });
 });
 program2.command("parse-issue-list <path>").description("Parse a markdown issue list into structured JSON").option("--json", "Output as JSON").action(async (filePath, options) => {
-  const { runParseList: runParseList2 } = await Promise.resolve().then(() => (init_parse_list(), parse_list_exports));
-  await runParseList2({ filePath, json: options.json });
+  try {
+    const { runParseList: runParseList2 } = await Promise.resolve().then(() => (init_parse_list(), parse_list_exports));
+    const data = await runParseList2({ filePath });
+    if (options.json) {
+      outputJson(data);
+    } else {
+      const path10 = await import("path");
+      const resolvedPath = path10.resolve(filePath);
+      console.log(`
+\u{1F4CB} Issue List: ${resolvedPath}
+`);
+      console.log(`Available: ${data.availableCount} | Completed: ${data.completedCount}
+`);
+      if (data.available.length > 0) {
+        console.log("--- Available ---");
+        for (const item of data.available) {
+          console.log(`  [${item.tier}] ${item.repo}#${item.number}: ${item.title}`);
+        }
+      }
+      if (data.completed.length > 0) {
+        console.log("\n--- Completed ---");
+        for (const item of data.completed) {
+          console.log(`  [${item.tier}] ${item.repo}#${item.number}: ${item.title}`);
+        }
+      }
+    }
+  } catch (err) {
+    handleCommandError(err, options.json);
+  }
 });
 program2.command("check-integration").description("Detect new files not referenced by the codebase").option("--base <branch>", "Base branch to compare against", "main").option("--json", "Output as JSON").action(async (options) => {
-  const { runCheckIntegration: runCheckIntegration2 } = await Promise.resolve().then(() => (init_check_integration(), check_integration_exports));
-  await runCheckIntegration2({ base: options.base, json: options.json });
+  try {
+    const { runCheckIntegration: runCheckIntegration2 } = await Promise.resolve().then(() => (init_check_integration(), check_integration_exports));
+    const data = await runCheckIntegration2({ base: options.base });
+    if (options.json) {
+      outputJson(data);
+    } else if (data.newFiles.length === 0) {
+      console.log("\nNo new code files to check.");
+    } else {
+      console.log(`
+\u{1F50D} Integration Check (base: ${options.base})
+`);
+      console.log(`New files: ${data.newFiles.length} | Unreferenced: ${data.unreferencedCount}
+`);
+      for (const file of data.newFiles) {
+        const status = file.isIntegrated ? "\u2705" : "\u26A0\uFE0F";
+        console.log(`${status} ${file.path}`);
+        if (file.isIntegrated) {
+          console.log(`   Referenced by: ${file.referencedBy.join(", ")}`);
+        } else {
+          console.log("   Not referenced by any file");
+          if (file.suggestedEntryPoints && file.suggestedEntryPoints.length > 0) {
+            console.log(`   Suggested entry points: ${file.suggestedEntryPoints.join(", ")}`);
+          }
+        }
+      }
+    }
+  } catch (err) {
+    handleCommandError(err, options.json);
+  }
 });
 program2.command("local-repos").description("Scan filesystem for local git clones").option("--scan", "Force re-scan (ignores cache)").option("--paths <dirs...>", "Directories to scan").option("--json", "Output as JSON").action(async (options) => {
-  const { runLocalRepos: runLocalRepos2 } = await Promise.resolve().then(() => (init_local_repos(), local_repos_exports));
-  await runLocalRepos2({ scan: options.scan, paths: options.paths, json: options.json });
+  try {
+    const { runLocalRepos: runLocalRepos2 } = await Promise.resolve().then(() => (init_local_repos(), local_repos_exports));
+    const data = await runLocalRepos2({ scan: options.scan, paths: options.paths });
+    if (options.json) {
+      outputJson(data);
+    } else if (data.fromCache) {
+      console.log(`
+\u{1F4C1} Local Repos (cached ${data.cachedAt})
+`);
+      printRepos(data.repos);
+    } else {
+      console.log(`Found ${Object.keys(data.repos).length} repos:
+`);
+      printRepos(data.repos);
+    }
+  } catch (err) {
+    handleCommandError(err, options.json);
+  }
 });
 program2.command("startup").description("Run all pre-flight checks and daily fetch in one call").option("--json", "Output as JSON").action(async (options) => {
-  const { runStartup: runStartup2 } = await Promise.resolve().then(() => (init_startup(), startup_exports));
-  await runStartup2({ json: options.json });
+  try {
+    const { runStartup: runStartup2 } = await Promise.resolve().then(() => (init_startup(), startup_exports));
+    const data = await runStartup2();
+    if (options.json) {
+      outputJson(data);
+    } else {
+      if (!data.setupComplete) {
+        console.log("Setup incomplete. Run /setup-oss first.");
+      } else if (data.authError) {
+        console.error(`Error: ${data.authError}`);
+      } else {
+        console.log(`OSS Autopilot v${data.version}`);
+        console.log(data.daily?.briefSummary ?? "");
+        if (data.dashboardPath) console.log(`Dashboard: ${data.dashboardPath}`);
+      }
+    }
+  } catch (err) {
+    handleCommandError(err, options.json);
+  }
 });
 program2.command("shelve <pr-url>").description("Shelve a PR (exclude from capacity and actionable issues)").option("--json", "Output as JSON").action(async (prUrl, options) => {
-  const { runShelve: runShelve2 } = await Promise.resolve().then(() => (init_shelve(), shelve_exports));
-  await runShelve2({ prUrl, json: options.json });
+  try {
+    const { runShelve: runShelve2 } = await Promise.resolve().then(() => (init_shelve(), shelve_exports));
+    const data = await runShelve2({ prUrl });
+    if (options.json) {
+      outputJson(data);
+    } else if (data.shelved) {
+      console.log(`Shelved: ${prUrl}`);
+      console.log("This PR is now excluded from capacity and actionable issues.");
+      console.log("It will auto-unshelve if a maintainer engages.");
+    } else {
+      console.log("PR is already shelved.");
+    }
+  } catch (err) {
+    handleCommandError(err, options.json);
+  }
 });
 program2.command("unshelve <pr-url>").description("Unshelve a PR (include in capacity and actionable issues again)").option("--json", "Output as JSON").action(async (prUrl, options) => {
-  const { runUnshelve: runUnshelve2 } = await Promise.resolve().then(() => (init_shelve(), shelve_exports));
-  await runUnshelve2({ prUrl, json: options.json });
+  try {
+    const { runUnshelve: runUnshelve2 } = await Promise.resolve().then(() => (init_shelve(), shelve_exports));
+    const data = await runUnshelve2({ prUrl });
+    if (options.json) {
+      outputJson(data);
+    } else if (data.unshelved) {
+      console.log(`Unshelved: ${prUrl}`);
+      console.log("This PR is now active again.");
+    } else {
+      console.log("PR was not shelved.");
+    }
+  } catch (err) {
+    handleCommandError(err, options.json);
+  }
 });
 program2.command("dismiss <issue-url>").description("Dismiss issue reply notifications (resurfaces on new activity)").option("--json", "Output as JSON").action(async (issueUrl, options) => {
-  const { runDismiss: runDismiss2 } = await Promise.resolve().then(() => (init_dismiss(), dismiss_exports));
-  await runDismiss2({ issueUrl, json: options.json });
+  try {
+    const { runDismiss: runDismiss2 } = await Promise.resolve().then(() => (init_dismiss(), dismiss_exports));
+    const data = await runDismiss2({ issueUrl });
+    if (options.json) {
+      outputJson(data);
+    } else if (data.dismissed) {
+      console.log(`Dismissed: ${issueUrl}`);
+      console.log("Issue reply notifications are now muted.");
+      console.log("New responses after this point will resurface automatically.");
+    } else {
+      console.log("Issue is already dismissed.");
+    }
+  } catch (err) {
+    handleCommandError(err, options.json);
+  }
 });
 program2.command("undismiss <issue-url>").description("Undismiss an issue (re-enable reply notifications)").option("--json", "Output as JSON").action(async (issueUrl, options) => {
-  const { runUndismiss: runUndismiss2 } = await Promise.resolve().then(() => (init_dismiss(), dismiss_exports));
-  await runUndismiss2({ issueUrl, json: options.json });
+  try {
+    const { runUndismiss: runUndismiss2 } = await Promise.resolve().then(() => (init_dismiss(), dismiss_exports));
+    const data = await runUndismiss2({ issueUrl });
+    if (options.json) {
+      outputJson(data);
+    } else if (data.undismissed) {
+      console.log(`Undismissed: ${issueUrl}`);
+      console.log("Issue reply notifications are active again.");
+    } else {
+      console.log("Issue was not dismissed.");
+    }
+  } catch (err) {
+    handleCommandError(err, options.json);
+  }
 });
 program2.command("snooze <pr-url>").description("Snooze CI failure notifications for a PR").requiredOption("--reason <reason>", 'Reason for snoozing (e.g., "upstream infrastructure issue")').option("--days <days>", "Number of days to snooze (default: 7)", "7").option("--json", "Output as JSON").action(async (prUrl, options) => {
-  const { runSnooze: runSnooze2 } = await Promise.resolve().then(() => (init_snooze(), snooze_exports));
-  await runSnooze2({ prUrl, reason: options.reason, days: parseInt(options.days, 10), json: options.json });
+  try {
+    const { runSnooze: runSnooze2 } = await Promise.resolve().then(() => (init_snooze(), snooze_exports));
+    const data = await runSnooze2({ prUrl, reason: options.reason, days: parseInt(options.days, 10) });
+    if (options.json) {
+      outputJson(data);
+    } else if (data.snoozed) {
+      console.log(`Snoozed: ${prUrl}`);
+      console.log(`Reason: ${data.reason}`);
+      console.log(`Duration: ${data.days} day${data.days === 1 ? "" : "s"}`);
+      console.log(`Expires: ${data.expiresAt ? new Date(data.expiresAt).toLocaleString() : "unknown"}`);
+      console.log("CI failure notifications are now muted for this PR.");
+    } else {
+      console.log("PR is already snoozed.");
+      if (data.expiresAt) {
+        console.log(`Expires: ${new Date(data.expiresAt).toLocaleString()}`);
+      }
+    }
+  } catch (err) {
+    handleCommandError(err, options.json);
+  }
 });
 program2.command("unsnooze <pr-url>").description("Unsnooze a PR (re-enable CI failure notifications)").option("--json", "Output as JSON").action(async (prUrl, options) => {
-  const { runUnsnooze: runUnsnooze2 } = await Promise.resolve().then(() => (init_snooze(), snooze_exports));
-  await runUnsnooze2({ prUrl, json: options.json });
+  try {
+    const { runUnsnooze: runUnsnooze2 } = await Promise.resolve().then(() => (init_snooze(), snooze_exports));
+    const data = await runUnsnooze2({ prUrl });
+    if (options.json) {
+      outputJson(data);
+    } else if (data.unsnoozed) {
+      console.log(`Unsnoozed: ${prUrl}`);
+      console.log("CI failure notifications are active again for this PR.");
+    } else {
+      console.log("PR was not snoozed.");
+    }
+  } catch (err) {
+    handleCommandError(err, options.json);
+  }
 });
 program2.hook("preAction", async (thisCommand, actionCommand) => {
   const globalOpts = thisCommand.opts();