@worca/ui 0.19.0 → 0.20.0

package/app/styles.css

@@ -3436,29 +3436,27 @@ sl-details.learnings-panel::part(content) {
   align-items: center;
 }
 
-.pr-details-section {
-  margin-top: 8px;
-}
-
-.pr-details-table {
-  border-collapse: collapse;
+.pr-info-strip {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px 20px;
   font-size: 13px;
-  width: 100%;
-}
-
-.pr-details-table td {
-  padding: 3px 8px 3px 0;
-  vertical-align: middle;
+  color: var(--muted);
+  margin-top: 8px;
+  padding-top: 8px;
+  border-top: 1px solid var(--border-subtle);
+  align-items: center;
 }
 
-.pr-details-table td.meta-label {
+.pr-info-item {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
   white-space: nowrap;
-  width: 1%;
-  padding-right: 10px;
 }
 
-.pr-commit-cell {
-  display: flex;
+.pr-info-strip .run-pr-link {
+  display: inline-flex;
   align-items: center;
   gap: 4px;
 }
@@ -3472,13 +3470,8 @@ sl-details.learnings-panel::part(content) {
   border: 1px solid var(--border-subtle);
 }
 
-.pr-branch-flow {
-  font-family: monospace;
-  font-size: 12px;
-}
-
 .pr-title-badge {
-  margin-left: 6px;
+  /* spacing handled by parent .pipeline-stage-header gap */
 }
 
 .classification-strip {

package/app/utils/stage-order.js

@@ -14,6 +14,8 @@ export const STAGE_ORDER = [
   'learn',
 ];
 
+export const STAGE_VALUES = new Set(STAGE_ORDER);
+
 /** Stage order with orchestrator prepended (for log display). */
 export const STAGE_ORDER_WITH_ORCHESTRATOR = ['orchestrator', ...STAGE_ORDER];
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@worca/ui",
-  "version": "0.19.0",
+  "version": "0.20.0",
   "description": "Pipeline monitoring UI for worca-cc",
   "license": "MIT",
   "author": "Sinisha Djukic",

package/server/bd-daemon.js

@@ -0,0 +1,43 @@
+import { execFile } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * Ensure the bd daemon is running for the project at worcaDir.
+ * Best-effort — all errors swallowed.
+ *
+ * Probes `bd daemon status` first. The `daemon.stopped` sentinel only blocks
+ * auto-start; if the daemon is already running (e.g. started manually outside
+ * worca), we report it as up regardless of the sentinel.
+ */
+export async function ensureBdDaemon(worcaDir) {
+  const beadsDir = resolve(join(worcaDir, '..', '.beads'));
+  if (!existsSync(beadsDir)) return false;
+
+  const workspaceDir = dirname(beadsDir);
+  const opts = {
+    encoding: 'utf8',
+    timeout: 5000,
+    env: { ...process.env, BEADS_DIR: beadsDir },
+    cwd: workspaceDir,
+  };
+
+  try {
+    await execFileAsync('bd', ['daemon', 'status'], opts);
+    return true;
+  } catch {
+    // not running — sentinel may block auto-start below
+  }
+
+  if (existsSync(join(beadsDir, 'daemon.stopped'))) return false;
+
+  try {
+    await execFileAsync('bd', ['daemon', 'start'], opts);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/server/beads-reader.js

@@ -49,7 +49,10 @@ export function dbExists(beadsDb) {
 export async function listIssues(beadsDb) {
   try {
     const issues = await runBd(['list', '--limit', '0'], beadsDb);
-    return enrichWithDeps(issues, beadsDb);
+    // Must await here — without it, an enrichWithDeps rejection (e.g. bd show
+    // SIGTERM under daemon contention) escapes the try/catch and propagates
+    // to the WS handler as an unhandled rejection, crashing Node.
+    return await enrichWithDeps(issues, beadsDb);
   } catch {
     return [];
   }
@@ -61,7 +64,7 @@ export async function listIssuesByLabel(beadsDb, label) {
       ['list', '--label-any', label, '--all', '--limit', '0'],
       beadsDb,
     );
-    return enrichWithDeps(issues, beadsDb);
+    return await enrichWithDeps(issues, beadsDb);
   } catch {
     return [];
   }
@@ -92,37 +95,48 @@ export async function listUnlinkedIssues(beadsDb) {
 /**
  * Returns { runId: { total, done } } for every run:<id> label in the beads db.
  *
- * `total` comes from the cheap `bd label list-all` count. `done` requires
- * looking at issue status, so we query `bd list --label-any run:<id>` per
- * run and count statuses === "closed". N+1 queries, but N is bounded by
- * the number of pipeline runs and this endpoint is called on app load /
- * project switch only, not on every render.
+ * Single-pass: bd label list-all (totals) + bd list --all (ids) +
+ * bd show <all-ids> (labels + statuses), then group by run labels in JS.
+ * Always 3 bd calls regardless of run-label count.
+ *
+ * Called by the beads watcher on every db change (counts are included in the
+ * broadcast payload) and by the list-beads-counts endpoint for initial load
+ * and project switch.
  */
 export async function countIssuesByRunLabel(beadsDb) {
   try {
     const rows = await runBd(['label', 'list-all'], beadsDb);
     const counts = {};
     const runLabels = rows.filter((r) => r.label.startsWith('run:'));
+    if (runLabels.length === 0) return counts;
     for (const row of runLabels) {
       counts[row.label.replace('run:', '')] = { total: row.count, done: 0 };
     }
-    // Count closed issues per label in parallel.
-    await Promise.all(
-      runLabels.map(async (row) => {
-        const runId = row.label.replace('run:', '');
-        try {
-          const issues = await runBd(
-            ['list', '--label-any', row.label, '--all', '--limit', '0'],
-            beadsDb,
-          );
-          counts[runId].done = issues.filter(
-            (i) => i.status === 'closed',
-          ).length;
-        } catch {
-          /* leave done at 0 on per-run failure */
+    try {
+      const issues = await runBd(['list', '--all', '--limit', '0'], beadsDb);
+      if (issues.length === 0) return counts;
+      const detailed = await runBd(
+        ['show', ...issues.map((i) => i.id)],
+        beadsDb,
+      );
+      for (const issue of detailed) {
+        if (issue.status !== 'closed') continue;
+        for (const label of issue.labels || []) {
+          if (label.startsWith('run:')) {
+            const runId = label.replace('run:', '');
+            if (counts[runId]) counts[runId].done++;
+          }
         }
-      }),
-    );
+      }
+    } catch (err) {
+      // Leave done=0 for all runs on list/show failure. Logged so a stale
+      // "0/N" badge can be traced back to bd subprocess timeout (typically
+      // daemon contention) rather than mistaken for "no closed issues."
+      // The next watcher tick recomputes and corrects.
+      console.warn(
+        `[countIssuesByRunLabel] bd list/show failed; counts.done left at 0: ${err?.message || err}`,
+      );
+    }
     return counts;
   } catch {
     return {};

package/server/watcher-set.js

@@ -10,6 +10,7 @@
 
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
+import { ensureBdDaemon } from './bd-daemon.js';
 import { resolveRunDir } from './run-dir-resolver.js';
 import { createBeadsWatcher } from './ws-beads-watcher.js';
 import { createEventWatcher } from './ws-event-watcher.js';
@@ -146,6 +147,7 @@ export class WatcherSet {
 
     // Beads watcher
     if (!this.beadsWatcher) {
+      ensureBdDaemon(worcaDir).catch(() => {});
       try {
         this.beadsWatcher = this._factories.createBeadsWatcher({
           worcaDir,

package/server/ws-beads-watcher.js

@@ -6,7 +6,7 @@
 
 import { existsSync, unwatchFile, watch, watchFile } from 'node:fs';
 import { join, resolve } from 'node:path';
-import { listIssues } from './beads-reader.js';
+import { countIssuesByRunLabel, listIssues } from './beads-reader.js';
 
 const BEADS_DEBOUNCE_MS = 500;
 const BEADS_POLL_MS = 2000;
@@ -26,11 +26,15 @@ export function createBeadsWatcher({ worcaDir, broadcaster, projectId }) {
     BEADS_REFRESH_TIMER = setTimeout(async () => {
       BEADS_REFRESH_TIMER = null;
       try {
-        const issues = await listIssues(beadsDbPath);
+        const [issues, counts] = await Promise.all([
+          listIssues(beadsDbPath),
+          countIssuesByRunLabel(beadsDbPath).catch(() => ({})),
+        ]);
         broadcaster.broadcast(
           'beads-update',
           {
             issues,
+            counts,
             dbExists: true,
             dbPath: beadsDbPath,
           },