@oss-autopilot/core 0.42.6 → 0.43.0

package/dist/cli.bundle.cjs

@@ -16301,8 +16301,79 @@ var init_dashboard_templates = __esm({
 // src/commands/dashboard-server.ts
 var dashboard_server_exports = {};
 __export(dashboard_server_exports, {
-  startDashboardServer: () => startDashboardServer
+  findRunningDashboardServer: () => findRunningDashboardServer,
+  getDashboardPidPath: () => getDashboardPidPath,
+  isDashboardServerRunning: () => isDashboardServerRunning,
+  readDashboardServerInfo: () => readDashboardServerInfo,
+  removeDashboardServerInfo: () => removeDashboardServerInfo,
+  startDashboardServer: () => startDashboardServer,
+  writeDashboardServerInfo: () => writeDashboardServerInfo
 });
+function getDashboardPidPath() {
+  return path5.join(getDataDir(), "dashboard-server.pid");
+}
+function writeDashboardServerInfo(info2) {
+  fs5.writeFileSync(getDashboardPidPath(), JSON.stringify(info2), { mode: 384 });
+}
+function readDashboardServerInfo() {
+  try {
+    const content = fs5.readFileSync(getDashboardPidPath(), "utf-8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed !== "object" || parsed === null || typeof parsed.pid !== "number" || typeof parsed.port !== "number" || typeof parsed.startedAt !== "string") {
+      console.error("[DASHBOARD] PID file has invalid structure, ignoring");
+      return null;
+    }
+    return parsed;
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT") {
+      console.error(`[DASHBOARD] Failed to read PID file: ${err.message}`);
+    }
+    return null;
+  }
+}
+function removeDashboardServerInfo() {
+  try {
+    fs5.unlinkSync(getDashboardPidPath());
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT") {
+      console.error(`[DASHBOARD] Failed to remove PID file: ${err.message}`);
+    }
+  }
+}
+function isDashboardServerRunning(port) {
+  return new Promise((resolve5) => {
+    const req = http.get(`http://127.0.0.1:${port}/api/data`, { timeout: 2e3 }, (res) => {
+      res.resume();
+      resolve5(res.statusCode === 200);
+    });
+    req.on("error", () => resolve5(false));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve5(false);
+    });
+  });
+}
+async function findRunningDashboardServer() {
+  const info2 = readDashboardServerInfo();
+  if (!info2) return null;
+  try {
+    process.kill(info2.pid, 0);
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ESRCH" && code !== "EPERM") {
+      console.error(`[DASHBOARD] Unexpected error checking PID ${info2.pid}: ${err.message}`);
+    }
+    removeDashboardServerInfo();
+    return null;
+  }
+  if (await isDashboardServerRunning(info2.port)) {
+    return { port: info2.port, url: `http://localhost:${info2.port}` };
+  }
+  removeDashboardServerInfo();
+  return null;
+}
 function buildDashboardJson(digest, state, commentedIssues) {
   const prsByRepo = computePRsByRepo(digest, state);
   const topRepos = computeTopRepos(prsByRepo);
@@ -16583,6 +16654,7 @@ async function startDashboardServer(options) {
       process.exit(1);
     }
   }
+  writeDashboardServerInfo({ pid: process.pid, port: actualPort, startedAt: (/* @__PURE__ */ new Date()).toISOString() });
   const serverUrl = `http://localhost:${actualPort}`;
   console.error(`Dashboard server running at ${serverUrl}`);
   if (open) {
@@ -16612,6 +16684,7 @@ async function startDashboardServer(options) {
   }
   const shutdown = () => {
     console.error("\nShutting down dashboard server...");
+    removeDashboardServerInfo();
     server.close(() => {
       process.exit(0);
     });
@@ -16649,6 +16722,7 @@ var init_dashboard_server = __esm({
 // src/commands/dashboard.ts
 var dashboard_exports = {};
 __export(dashboard_exports, {
+  resolveAssetsDir: () => resolveAssetsDir,
   runDashboard: () => runDashboard,
   serveDashboard: () => serveDashboard,
   writeDashboardFromState: () => writeDashboardFromState
@@ -17176,6 +17250,78 @@ var init_local_repos = __esm({
   }
 });
 
+// src/commands/dashboard-lifecycle.ts
+function sleep(ms) {
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
+}
+async function launchDashboardServer(options) {
+  const assetsDir = resolveAssetsDir();
+  if (!assetsDir) {
+    return null;
+  }
+  const existing = await findRunningDashboardServer();
+  if (existing) {
+    return { url: existing.url, port: existing.port, alreadyRunning: true };
+  }
+  const port = options?.port ?? DEFAULT_PORT;
+  const cliPath = process.argv[1];
+  const child = (0, import_child_process5.spawn)("node", [cliPath, "dashboard", "serve", "--port", String(port), "--no-open"], {
+    detached: true,
+    stdio: "ignore"
+  });
+  let spawnFailed = false;
+  let childExited = false;
+  child.on("error", (err) => {
+    spawnFailed = true;
+    console.error(`[STARTUP] Failed to spawn dashboard server: ${err.message}`);
+  });
+  child.on("exit", (code) => {
+    childExited = true;
+    if (code !== 0 && code !== null) {
+      console.error(`[STARTUP] Dashboard server exited prematurely (code ${code})`);
+    }
+  });
+  child.unref();
+  for (let i = 0; i < MAX_POLL_ATTEMPTS; i++) {
+    await sleep(POLL_INTERVAL_MS);
+    if (spawnFailed || childExited) {
+      return null;
+    }
+    const info2 = readDashboardServerInfo();
+    if (info2) {
+      if (await isDashboardServerRunning(info2.port)) {
+        return { url: `http://localhost:${info2.port}`, port: info2.port, alreadyRunning: false };
+      }
+    }
+  }
+  console.error("[STARTUP] Dashboard server failed to start within 5 seconds");
+  if (child.pid) {
+    try {
+      process.kill(child.pid, "SIGTERM");
+    } catch (err) {
+      const code = err.code;
+      if (code !== "ESRCH") {
+        console.error(
+          `[STARTUP] Failed to kill orphan dashboard process (PID ${child.pid}): ${err.message}`
+        );
+      }
+    }
+  }
+  return null;
+}
+var import_child_process5, DEFAULT_PORT, POLL_INTERVAL_MS, MAX_POLL_ATTEMPTS;
+var init_dashboard_lifecycle = __esm({
+  "src/commands/dashboard-lifecycle.ts"() {
+    "use strict";
+    import_child_process5 = require("child_process");
+    init_dashboard_server();
+    init_dashboard();
+    DEFAULT_PORT = 3e3;
+    POLL_INTERVAL_MS = 200;
+    MAX_POLL_ATTEMPTS = 25;
+  }
+});
+
 // src/commands/startup.ts
 var startup_exports = {};
 __export(startup_exports, {
@@ -17243,10 +17389,23 @@ function detectIssueList() {
   }
 }
 function openInBrowser(filePath) {
-  const isWindows = process.platform === "win32";
-  const openCmd = process.platform === "darwin" ? "open" : isWindows ? "cmd" : "xdg-open";
-  const args = isWindows ? ["/c", "start", "", filePath] : [filePath];
-  (0, import_child_process5.execFile)(openCmd, args, (error) => {
+  let openCmd;
+  let args;
+  switch (process.platform) {
+    case "darwin":
+      openCmd = "open";
+      args = [filePath];
+      break;
+    case "win32":
+      openCmd = "cmd";
+      args = ["/c", "start", "", filePath];
+      break;
+    default:
+      openCmd = "xdg-open";
+      args = [filePath];
+      break;
+  }
+  (0, import_child_process6.execFile)(openCmd, args, (error) => {
     if (error) {
       console.error(`[STARTUP] Failed to open dashboard in browser: ${error.message}`);
     }
@@ -17268,15 +17427,28 @@ async function runStartup() {
   }
   const daily = await executeDailyCheck(token);
   let dashboardPath;
-  let dashboardOpened = false;
   try {
     dashboardPath = writeDashboardFromState();
-    if (daily.digest.summary.totalActivePRs > 0) {
+  } catch (error) {
+    console.error("[STARTUP] Dashboard generation failed:", errorMessage(error));
+  }
+  let dashboardUrl;
+  let dashboardOpened = false;
+  if (daily.digest.summary.totalActivePRs > 0) {
+    let spaResult = null;
+    try {
+      spaResult = await launchDashboardServer();
+    } catch (error) {
+      console.error("[STARTUP] SPA dashboard launch failed:", errorMessage(error));
+    }
+    if (spaResult) {
+      dashboardUrl = spaResult.url;
+      openInBrowser(spaResult.url);
+      dashboardOpened = true;
+    } else if (dashboardPath) {
       openInBrowser(dashboardPath);
       dashboardOpened = true;
     }
-  } catch (error) {
-    console.error("[STARTUP] Dashboard generation failed:", errorMessage(error));
   }
   if (dashboardOpened) {
     daily.briefSummary += " | Dashboard opened in browser";
@@ -17287,19 +17459,21 @@ async function runStartup() {
     setupComplete: true,
     daily,
     dashboardPath,
+    dashboardUrl,
     issueList
   };
 }
-var fs9, import_child_process5;
+var fs9, import_child_process6;
 var init_startup = __esm({
   "src/commands/startup.ts"() {
     "use strict";
     fs9 = __toESM(require("fs"), 1);
-    import_child_process5 = require("child_process");
+    import_child_process6 = require("child_process");
     init_core();
     init_errors();
     init_daily();
     init_dashboard();
+    init_dashboard_lifecycle();
   }
 });
 

package/dist/commands/dashboard-lifecycle.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Dashboard server lifecycle management.
+ * Handles launching the interactive SPA dashboard as a background process
+ * and detecting whether a server is already running.
+ */
+export interface LaunchResult {
+    url: string;
+    port: number;
+    alreadyRunning: boolean;
+}
+/**
+ * Launch the interactive dashboard SPA server as a detached background process.
+ *
+ * Returns the server URL if launched successfully, or null if the SPA assets
+ * are not available (caller should fall back to static HTML).
+ *
+ * If a server is already running (detected via PID file + health probe),
+ * returns its URL without launching a new one.
+ */
+export declare function launchDashboardServer(options?: {
+    port?: number;
+}): Promise<LaunchResult | null>;

package/dist/commands/dashboard-lifecycle.js

@@ -0,0 +1,87 @@
+/**
+ * Dashboard server lifecycle management.
+ * Handles launching the interactive SPA dashboard as a background process
+ * and detecting whether a server is already running.
+ */
+import { spawn } from 'child_process';
+import { findRunningDashboardServer, isDashboardServerRunning, readDashboardServerInfo } from './dashboard-server.js';
+import { resolveAssetsDir } from './dashboard.js';
+const DEFAULT_PORT = 3000;
+const POLL_INTERVAL_MS = 200;
+const MAX_POLL_ATTEMPTS = 25; // 5 seconds total
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Launch the interactive dashboard SPA server as a detached background process.
+ *
+ * Returns the server URL if launched successfully, or null if the SPA assets
+ * are not available (caller should fall back to static HTML).
+ *
+ * If a server is already running (detected via PID file + health probe),
+ * returns its URL without launching a new one.
+ */
+export async function launchDashboardServer(options) {
+    // 1. Check if SPA assets exist
+    const assetsDir = resolveAssetsDir();
+    if (!assetsDir) {
+        return null;
+    }
+    // 2. Check if a server is already running
+    const existing = await findRunningDashboardServer();
+    if (existing) {
+        return { url: existing.url, port: existing.port, alreadyRunning: true };
+    }
+    // 3. Launch as detached child process
+    const port = options?.port ?? DEFAULT_PORT;
+    // process.argv[1] is the CLI entry point (cli.bundle.cjs in production, cli.ts in dev)
+    const cliPath = process.argv[1];
+    const child = spawn('node', [cliPath, 'dashboard', 'serve', '--port', String(port), '--no-open'], {
+        detached: true,
+        stdio: 'ignore',
+    });
+    // Track spawn failures and early exits so the polling loop can bail early
+    let spawnFailed = false;
+    let childExited = false;
+    child.on('error', (err) => {
+        spawnFailed = true;
+        console.error(`[STARTUP] Failed to spawn dashboard server: ${err.message}`);
+    });
+    child.on('exit', (code) => {
+        childExited = true;
+        if (code !== 0 && code !== null) {
+            console.error(`[STARTUP] Dashboard server exited prematurely (code ${code})`);
+        }
+    });
+    child.unref();
+    // 4. Poll for PID file to appear (server writes it after binding)
+    for (let i = 0; i < MAX_POLL_ATTEMPTS; i++) {
+        await sleep(POLL_INTERVAL_MS);
+        // Bail early if spawn failed or child crashed before writing PID file
+        if (spawnFailed || childExited) {
+            return null;
+        }
+        const info = readDashboardServerInfo();
+        if (info) {
+            // PID file appeared — verify the server is responding
+            if (await isDashboardServerRunning(info.port)) {
+                return { url: `http://localhost:${info.port}`, port: info.port, alreadyRunning: false };
+            }
+        }
+    }
+    // 5. Timeout — server didn't start in time; kill orphan process
+    console.error('[STARTUP] Dashboard server failed to start within 5 seconds');
+    if (child.pid) {
+        try {
+            process.kill(child.pid, 'SIGTERM');
+        }
+        catch (err) {
+            // ESRCH = process already exited, which is fine
+            const code = err.code;
+            if (code !== 'ESRCH') {
+                console.error(`[STARTUP] Failed to kill orphan dashboard process (PID ${child.pid}): ${err.message}`);
+            }
+        }
+    }
+    return null;
+}

package/dist/commands/dashboard-server.d.ts

@@ -11,4 +11,18 @@ export interface DashboardServerOptions {
     token: string | null;
     open: boolean;
 }
+export interface DashboardServerInfo {
+    pid: number;
+    port: number;
+    startedAt: string;
+}
+export declare function getDashboardPidPath(): string;
+export declare function writeDashboardServerInfo(info: DashboardServerInfo): void;
+export declare function readDashboardServerInfo(): DashboardServerInfo | null;
+export declare function removeDashboardServerInfo(): void;
+export declare function isDashboardServerRunning(port: number): Promise<boolean>;
+export declare function findRunningDashboardServer(): Promise<{
+    port: number;
+    url: string;
+} | null>;
 export declare function startDashboardServer(options: DashboardServerOptions): Promise<void>;

package/dist/commands/dashboard-server.js

@@ -8,7 +8,7 @@
 import * as http from 'http';
 import * as fs from 'fs';
 import * as path from 'path';
-import { getStateManager, getGitHubToken } from '../core/index.js';
+import { getStateManager, getGitHubToken, getDataDir } from '../core/index.js';
 import { errorMessage, ValidationError } from '../core/errors.js';
 import { validateUrl, validateGitHubUrl, validateMessage, PR_URL_PATTERN } from './validation.js';
 import { fetchDashboardData, computePRsByRepo, computeTopRepos, getMonthlyData } from './dashboard-data.js';
@@ -25,6 +25,87 @@ const MIME_TYPES = {
     '.png': 'image/png',
     '.ico': 'image/x-icon',
 };
+// ── PID File Management ──────────────────────────────────────────────────────
+export function getDashboardPidPath() {
+    return path.join(getDataDir(), 'dashboard-server.pid');
+}
+export function writeDashboardServerInfo(info) {
+    fs.writeFileSync(getDashboardPidPath(), JSON.stringify(info), { mode: 0o600 });
+}
+export function readDashboardServerInfo() {
+    try {
+        const content = fs.readFileSync(getDashboardPidPath(), 'utf-8');
+        const parsed = JSON.parse(content);
+        if (typeof parsed !== 'object' ||
+            parsed === null ||
+            typeof parsed.pid !== 'number' ||
+            typeof parsed.port !== 'number' ||
+            typeof parsed.startedAt !== 'string') {
+            console.error('[DASHBOARD] PID file has invalid structure, ignoring');
+            return null;
+        }
+        return parsed;
+    }
+    catch (err) {
+        const code = err.code;
+        if (code !== 'ENOENT') {
+            console.error(`[DASHBOARD] Failed to read PID file: ${err.message}`);
+        }
+        return null;
+    }
+}
+export function removeDashboardServerInfo() {
+    try {
+        fs.unlinkSync(getDashboardPidPath());
+    }
+    catch (err) {
+        const code = err.code;
+        if (code !== 'ENOENT') {
+            console.error(`[DASHBOARD] Failed to remove PID file: ${err.message}`);
+        }
+    }
+}
+// ── Health Probe ─────────────────────────────────────────────────────────────
+export function isDashboardServerRunning(port) {
+    return new Promise((resolve) => {
+        const req = http.get(`http://127.0.0.1:${port}/api/data`, { timeout: 2000 }, (res) => {
+            // Consume response data to free up memory
+            res.resume();
+            resolve(res.statusCode === 200);
+        });
+        req.on('error', () => resolve(false));
+        req.on('timeout', () => {
+            req.destroy();
+            resolve(false);
+        });
+    });
+}
+export async function findRunningDashboardServer() {
+    const info = readDashboardServerInfo();
+    if (!info)
+        return null;
+    // Check if process is alive (signal 0 = existence check only)
+    try {
+        process.kill(info.pid, 0);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code !== 'ESRCH' && code !== 'EPERM') {
+            console.error(`[DASHBOARD] Unexpected error checking PID ${info.pid}: ${err.message}`);
+        }
+        // ESRCH = no process at that PID; EPERM = PID recycled to another user's process
+        // Either way, our dashboard server is no longer running — clean up stale PID file
+        removeDashboardServerInfo();
+        return null;
+    }
+    // Process exists — verify it's actually our server via HTTP probe
+    if (await isDashboardServerRunning(info.port)) {
+        return { port: info.port, url: `http://localhost:${info.port}` };
+    }
+    // Process exists but not responding on expected port — stale
+    removeDashboardServerInfo();
+    return null;
+}
 // ── Helpers ────────────────────────────────────────────────────────────────────
 /**
  * Build the JSON payload that the SPA expects from GET /api/data.
@@ -359,6 +440,8 @@ export async function startDashboardServer(options) {
             process.exit(1);
         }
     }
+    // Write PID file so other processes can detect this running server
+    writeDashboardServerInfo({ pid: process.pid, port: actualPort, startedAt: new Date().toISOString() });
     const serverUrl = `http://localhost:${actualPort}`;
     console.error(`Dashboard server running at ${serverUrl}`);
     // ── Open browser ─────────────────────────────────────────────────────────
@@ -390,6 +473,7 @@ export async function startDashboardServer(options) {
     // ── Clean shutdown ───────────────────────────────────────────────────────
     const shutdown = () => {
         console.error('\nShutting down dashboard server...');
+        removeDashboardServerInfo();
         server.close(() => {
             process.exit(0);
         });

package/dist/commands/dashboard.d.ts

@@ -19,5 +19,10 @@ interface ServeOptions {
     port: number;
     open: boolean;
 }
+/**
+ * Resolve the SPA assets directory from packages/dashboard/dist/.
+ * Tries multiple strategies to locate it across dev (tsx) and bundled (cjs) modes.
+ */
+export declare function resolveAssetsDir(): string | null;
 export declare function serveDashboard(options: ServeOptions): Promise<void>;
 export {};

package/dist/commands/dashboard.js

@@ -138,7 +138,7 @@ export function writeDashboardFromState() {
  * Resolve the SPA assets directory from packages/dashboard/dist/.
  * Tries multiple strategies to locate it across dev (tsx) and bundled (cjs) modes.
  */
-function resolveAssetsDir() {
+export function resolveAssetsDir() {
     // Strategy 1: relative to this source file (works in dev with tsx)
     const devPath = path.resolve(__dirname, '../../dashboard/dist');
     if (fs.existsSync(path.join(devPath, 'index.html'))) {

package/dist/commands/startup.d.ts

@@ -31,7 +31,7 @@ export declare function detectIssueList(): IssueListInfo | undefined;
  * Returns StartupOutput with one of three shapes:
  * 1. Setup incomplete: { version, setupComplete: false }
  * 2. Auth failure: { version, setupComplete: true, authError: "..." }
- * 3. Success: { version, setupComplete: true, daily, dashboardPath?, issueList? }
+ * 3. Success: { version, setupComplete: true, daily, dashboardPath?, dashboardUrl?, issueList? }
  *
  * Errors from the daily check propagate to the caller.
  */

package/dist/commands/startup.js

@@ -12,6 +12,7 @@ import { getStateManager, getGitHubToken, getCLIVersion } from '../core/index.js
 import { errorMessage } from '../core/errors.js';
 import { executeDailyCheck } from './daily.js';
 import { writeDashboardFromState } from './dashboard.js';
+import { launchDashboardServer } from './dashboard-lifecycle.js';
 /**
  * Parse issueListPath from a config file's YAML frontmatter.
  * Returns the path string or undefined if not found.
@@ -93,9 +94,22 @@ export function detectIssueList() {
     }
 }
 function openInBrowser(filePath) {
-    const isWindows = process.platform === 'win32';
-    const openCmd = process.platform === 'darwin' ? 'open' : isWindows ? 'cmd' : 'xdg-open';
-    const args = isWindows ? ['/c', 'start', '', filePath] : [filePath];
+    let openCmd;
+    let args;
+    switch (process.platform) {
+        case 'darwin':
+            openCmd = 'open';
+            args = [filePath];
+            break;
+        case 'win32':
+            openCmd = 'cmd';
+            args = ['/c', 'start', '', filePath];
+            break;
+        default:
+            openCmd = 'xdg-open';
+            args = [filePath];
+            break;
+    }
     execFile(openCmd, args, (error) => {
         if (error) {
             console.error(`[STARTUP] Failed to open dashboard in browser: ${error.message}`);
@@ -107,7 +121,7 @@ function openInBrowser(filePath) {
  * Returns StartupOutput with one of three shapes:
  * 1. Setup incomplete: { version, setupComplete: false }
  * 2. Auth failure: { version, setupComplete: true, authError: "..." }
- * 3. Success: { version, setupComplete: true, daily, dashboardPath?, issueList? }
+ * 3. Success: { version, setupComplete: true, daily, dashboardPath?, dashboardUrl?, issueList? }
  *
  * Errors from the daily check propagate to the caller.
  */
@@ -129,31 +143,49 @@ export async function runStartup() {
     }
     // 3. Run daily check
     const daily = await executeDailyCheck(token);
-    // 4. Generate dashboard from state (just saved by daily)
-    // Skip opening on first run (0 PRs) — the welcome flow handles onboarding
+    // 4. Generate static HTML dashboard (always — serves as fallback + snapshot)
     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:', errorMessage(error));
     }
+    // 5. Launch interactive SPA dashboard (preferred) with static HTML fallback
+    // Skip opening on first run (0 PRs) — the welcome flow handles onboarding
+    let dashboardUrl;
+    let dashboardOpened = false;
+    if (daily.digest.summary.totalActivePRs > 0) {
+        let spaResult = null;
+        try {
+            spaResult = await launchDashboardServer();
+        }
+        catch (error) {
+            console.error('[STARTUP] SPA dashboard launch failed:', errorMessage(error));
+        }
+        if (spaResult) {
+            dashboardUrl = spaResult.url;
+            openInBrowser(spaResult.url);
+            dashboardOpened = true;
+        }
+        else if (dashboardPath) {
+            // SPA unavailable (assets not built) — fall back to static HTML
+            openInBrowser(dashboardPath);
+            dashboardOpened = true;
+        }
+    }
     // Append dashboard status to brief summary (only startup opens the browser, not daily)
     if (dashboardOpened) {
         daily.briefSummary += ' | Dashboard opened in browser';
     }
-    // 5. Detect issue list
+    // 6. Detect issue list
     const issueList = detectIssueList();
     return {
         version,
         setupComplete: true,
         daily,
         dashboardPath,
+        dashboardUrl,
         issueList,
     };
 }

package/dist/formatters/json.d.ts

@@ -200,7 +200,7 @@ export interface IssueListInfo {
  * Three valid shapes:
  * 1. Setup incomplete: { version, setupComplete: false }
  * 2. Auth failure: { version, setupComplete: true, authError: "..." }
- * 3. Success: { version, setupComplete: true, daily, dashboardPath?, issueList? }
+ * 3. Success: { version, setupComplete: true, daily, dashboardPath?, dashboardUrl?, issueList? }
  */
 export interface StartupOutput {
     version: string;
@@ -208,6 +208,8 @@ export interface StartupOutput {
     authError?: string;
     daily?: DailyOutput;
     dashboardPath?: string;
+    /** URL of the interactive SPA dashboard server, when running (e.g., "http://localhost:3000") */
+    dashboardUrl?: string;
     issueList?: IssueListInfo;
 }
 /** A single parsed issue from a markdown list (#82) */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oss-autopilot/core",
-  "version": "0.42.6",
+  "version": "0.43.0",
   "description": "CLI and core library for managing open source contributions",
   "type": "module",
   "bin": {