@worca/ui 0.19.0 → 0.21.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 {
@@ -4657,3 +4650,167 @@ sl-tooltip.bead-tooltip::part(body) {
   justify-content: flex-end;
   width: 100%;
 }
+
+/* ─── Models tab — model cards + env rows ──────────────────────────── */
+.models-cards {
+  grid-template-columns: repeat(auto-fill, minmax(440px, 1fr));
+}
+
+.model-card {
+  display: flex;
+  flex-direction: column;
+  transition: border-color 0.15s ease, box-shadow 0.15s ease;
+}
+
+.model-card.is-dirty {
+  border-color: var(--status-running, #3b82f6);
+  box-shadow: 0 0 0 1px var(--status-running, #3b82f6);
+}
+
+.model-delete-btn {
+  /* Aligned left in the footer action row via the flex layout (the status
+     span between it and Discard/Save has flex:1 and grows). */
+}
+
+.model-id-input::part(input) {
+  font-family: var(--sl-font-mono);
+  font-size: 12px;
+}
+
+.settings-label-row {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 8px;
+}
+
+.settings-muted-small {
+  font-size: 11px;
+  color: var(--muted);
+  font-weight: 500;
+  text-transform: uppercase;
+  letter-spacing: 0.03em;
+}
+
+.model-env-table {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
+.model-env-row {
+  display: grid;
+  grid-template-columns: minmax(0, 240px) minmax(0, 1fr) 18px 30px;
+  gap: 6px;
+  align-items: center;
+}
+
+.model-env-key::part(input) {
+  font-family: var(--sl-font-mono);
+  font-size: 12px;
+}
+
+.model-env-key.is-invalid::part(base) {
+  border-color: var(--status-failed, #ef4444);
+}
+
+.model-env-value::part(input) {
+  font-size: 12px;
+}
+
+.model-env-warn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  color: var(--status-failed, #ef4444);
+  font-size: 14px;
+  line-height: 1;
+  cursor: help;
+}
+
+.model-env-warn-spacer {
+  display: inline-block;
+  width: 18px;
+}
+
+.model-env-remove {
+  color: var(--muted);
+  --sl-spacing-medium: 0;
+}
+
+.model-env-add-btn {
+  align-self: flex-start;
+  margin-top: 4px;
+}
+
+.model-card-actions {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin-top: 14px;
+  padding-top: 12px;
+  border-top: 1px solid var(--border-subtle);
+}
+
+.model-card-status {
+  flex: 1;
+  font-size: 11px;
+  color: var(--muted);
+  font-style: italic;
+  text-align: center;
+}
+
+.settings-tab-description {
+  font-size: 12px;
+  color: var(--muted);
+  margin: 0 0 16px 0;
+  line-height: 1.5;
+}
+
+.settings-tab-description code {
+  background: var(--bg-tertiary);
+  padding: 1px 5px;
+  border-radius: 3px;
+  font-family: var(--sl-font-mono);
+  font-size: 11px;
+  color: var(--fg);
+}
+
+.models-add-row {
+  margin-top: 24px;
+  padding-top: 16px;
+  border-top: 1px solid var(--border-subtle);
+}
+
+.models-add-controls {
+  display: flex;
+  gap: 8px;
+  align-items: flex-end;
+}
+
+.models-add-controls sl-input {
+  flex: 1;
+}
+
+/* ─── Confirmation dialog — "cannot be undone" warning row ────────── */
+.confirm-warning {
+  display: flex;
+  align-items: flex-start;
+  gap: 8px;
+  margin: 0.75rem 0 0;
+  padding: 8px 10px;
+  background: rgba(245, 158, 11, 0.08);
+  border-left: 3px solid var(--status-paused, #f59e0b);
+  border-radius: 4px;
+  color: var(--fg);
+  font-size: 13px;
+  font-weight: 500;
+  line-height: 1.4;
+}
+
+.confirm-warning > span:first-child {
+  color: var(--status-paused, #f59e0b);
+  font-size: 15px;
+  line-height: 1.2;
+  flex: 0 0 auto;
+}

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.21.0",
   "description": "Pipeline monitoring UI for worca-cc",
   "license": "MIT",
   "author": "Sinisha Djukic",
@@ -25,6 +25,7 @@
     "bin/worca-ui.js",
     "server/**/*.js",
     "server/schemas/keys.json",
+    "server/reserved-env-keys.json",
     "!server/**/*.test.js",
     "!server/test/**",
     "!server/**/test/**",

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/model-env-routes.js

@@ -0,0 +1,189 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { Router } from 'express';
+import { atomicWriteSync } from './atomic-write.js';
+import { localPathFor } from './settings-merge.js';
+
+const require = createRequire(import.meta.url);
+const denylist = require('./reserved-env-keys.json');
+const RESERVED_KEYS = new Set(denylist.keys);
+const RESERVED_PREFIXES = denylist.prefixes;
+
+function isReservedKey(key) {
+  if (RESERVED_KEYS.has(key)) return true;
+  return RESERVED_PREFIXES.some((p) => key.startsWith(p));
+}
+
+function readJsonOr(path, fallback) {
+  if (!existsSync(path)) return fallback;
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+export function createModelEnvRouter({ settingsPath: staticPath } = {}) {
+  const router = Router({ mergeParams: true });
+
+  function resolveSettingsPath(req) {
+    return req.project?.settingsPath || staticPath;
+  }
+
+  router.put('/', (req, res) => {
+    const { model, id, env } = req.body || {};
+
+    if (!model || typeof model !== 'string') {
+      return res
+        .status(400)
+        .json({ ok: false, error: 'model name is required' });
+    }
+    if (id != null && typeof id !== 'string') {
+      return res.status(400).json({ ok: false, error: 'id must be a string' });
+    }
+    if (env != null && (typeof env !== 'object' || Array.isArray(env))) {
+      return res
+        .status(400)
+        .json({ ok: false, error: 'env must be an object' });
+    }
+
+    const envIn = env || {};
+    for (const [key, value] of Object.entries(envIn)) {
+      if (typeof key !== 'string' || key === '') {
+        return res
+          .status(400)
+          .json({ ok: false, error: 'env keys must be non-empty strings' });
+      }
+      if (isReservedKey(key)) {
+        return res.status(400).json({
+          ok: false,
+          key,
+          error: `Key "${key}" is reserved and cannot be used as a model env var`,
+        });
+      }
+      if (typeof value !== 'string') {
+        return res.status(400).json({
+          ok: false,
+          key,
+          error: `value for "${key}" must be a string`,
+        });
+      }
+    }
+
+    const settingsPath = resolveSettingsPath(req);
+    if (!settingsPath) {
+      return res
+        .status(501)
+        .json({ ok: false, error: 'settingsPath not configured' });
+    }
+
+    // Storage split (deliberate after the W-051 simplification):
+    //   settings.json       — public model entry: string id or { id }, NEVER env
+    //   settings.local.json — { env } only, NEVER id
+    //
+    // Writing env to local while leaving env behind in settings.json would
+    // let deep-merge resurrect deleted keys (a key removed in the UI but
+    // still present in settings.json would reappear on next load). So PUT
+    // actively strips env from the settings.json entry whenever it writes
+    // env to local, and conversely never lets id leak into local.
+    const localPath = localPathFor(settingsPath);
+    const local = readJsonOr(localPath, {});
+    if (!local.worca) local.worca = {};
+    if (!local.worca.models) local.worca.models = {};
+
+    if (Object.keys(envIn).length === 0) {
+      delete local.worca.models[model];
+    } else {
+      local.worca.models[model] = { env: { ...envIn } };
+    }
+    atomicWriteSync(localPath, `${JSON.stringify(local, null, 2)}\n`);
+
+    // settings.json: keep/update id, drop env entirely. If the model
+    // doesn't exist there and no id was supplied, skip the file. If id is
+    // explicitly an empty string, treat it as "no id" and drop the entry.
+    const base = readJsonOr(settingsPath, {});
+    if (!base.worca) base.worca = {};
+    if (!base.worca.models) base.worca.models = {};
+
+    const baseEntry = base.worca.models[model];
+    let resolvedId = id;
+    if (resolvedId == null) {
+      if (typeof baseEntry === 'string') resolvedId = baseEntry;
+      else if (baseEntry && typeof baseEntry === 'object')
+        resolvedId = baseEntry.id;
+    }
+
+    let baseChanged = false;
+    if (resolvedId) {
+      // Prefer string form when there's no other metadata — keeps JSON minimal.
+      const nextBaseEntry = resolvedId;
+      if (JSON.stringify(baseEntry) !== JSON.stringify(nextBaseEntry)) {
+        base.worca.models[model] = nextBaseEntry;
+        baseChanged = true;
+      }
+    } else if (baseEntry !== undefined) {
+      delete base.worca.models[model];
+      baseChanged = true;
+    }
+    if (baseChanged) {
+      atomicWriteSync(settingsPath, `${JSON.stringify(base, null, 2)}\n`);
+    }
+
+    res.json({ ok: true, model, id: resolvedId || null, env: { ...envIn } });
+  });
+
+  router.delete('/', (req, res) => {
+    const model =
+      req.body?.model ||
+      (typeof req.query?.model === 'string' ? req.query.model : null);
+
+    if (!model) {
+      return res
+        .status(400)
+        .json({ ok: false, error: 'model name is required' });
+    }
+
+    const settingsPath = resolveSettingsPath(req);
+    if (!settingsPath) {
+      return res
+        .status(501)
+        .json({ ok: false, error: 'settingsPath not configured' });
+    }
+
+    // Remove from BOTH files so deep-merge can't resurrect the entry. The
+    // settings POST endpoint deep-merges and cannot remove a key, so we
+    // operate on disk directly. This is intentional — "Delete model" in
+    // the UI means the model goes away, full stop.
+    let removedFromBase = false;
+    let removedFromLocal = false;
+
+    if (existsSync(settingsPath)) {
+      const base = readJsonOr(settingsPath, {});
+      if (base?.worca?.models && model in base.worca.models) {
+        delete base.worca.models[model];
+        atomicWriteSync(settingsPath, `${JSON.stringify(base, null, 2)}\n`);
+        removedFromBase = true;
+      }
+    }
+
+    const localPath = localPathFor(settingsPath);
+    if (existsSync(localPath)) {
+      const local = readJsonOr(localPath, {});
+      if (local?.worca?.models && model in local.worca.models) {
+        delete local.worca.models[model];
+        atomicWriteSync(localPath, `${JSON.stringify(local, null, 2)}\n`);
+        removedFromLocal = true;
+      }
+    }
+
+    res.json({
+      ok: true,
+      model,
+      removed: removedFromBase || removedFromLocal,
+      fromBase: removedFromBase,
+      fromLocal: removedFromLocal,
+    });
+  });
+
+  return router;
+}

package/server/model-validation.js

@@ -0,0 +1,13 @@
+const DEFAULT_MODELS = ['opus', 'sonnet', 'haiku'];
+
+export function deriveValidModels(worcaObj) {
+  const configuredModels =
+    worcaObj?.models &&
+    typeof worcaObj.models === 'object' &&
+    !Array.isArray(worcaObj.models)
+      ? Object.keys(worcaObj.models)
+      : [];
+  return [...new Set([...DEFAULT_MODELS, ...configuredModels])];
+}
+
+export { DEFAULT_MODELS };

package/server/preferences-routes.js

@@ -1,9 +1,9 @@
 import { join } from 'node:path';
 import { Router } from 'express';
+import { deriveValidModels } from './model-validation.js';
 import { readGlobalSettings, writeGlobalSettings } from './settings-reader.js';
 
 const VALID_CLEANUP_POLICIES = ['never', 'on-success', 'manual-only'];
-const VALID_MODELS = ['opus', 'sonnet', 'haiku'];
 const MIN_DISK_BYTES = 500_000_000;
 const MAX_DISK_BYTES = 50_000_000_000;
 
@@ -73,9 +73,10 @@ export function validateGlobalSettingsPayload(body) {
       ) {
         details.push('worca.circuit_breaker must be an object');
       } else if (w.circuit_breaker.classifier_model !== undefined) {
-        if (!VALID_MODELS.includes(w.circuit_breaker.classifier_model)) {
+        const validModels = deriveValidModels(w);
+        if (!validModels.includes(w.circuit_breaker.classifier_model)) {
           details.push(
-            `classifier_model must be one of: ${VALID_MODELS.join(', ')}`,
+            `classifier_model must be one of: ${validModels.join(', ')}`,
           );
         }
       }

package/server/project-routes.js

@@ -27,6 +27,7 @@ import { dispatchExternal } from './dispatch-external.js';
 import { ensureWebhookForUi } from './ensure-webhook.js';
 import { extractAndStripGlobalKeys } from './global-keys.js';
 import { LaunchLock } from './launch-lock.js';
+import { createModelEnvRouter } from './model-env-routes.js';
 import { readPreferences } from './preferences.js';
 import { ProcessManager } from './process-manager.js';
 import { countRunningPipelinesAcrossProjects } from './process-registry.js';
@@ -430,6 +431,9 @@ export function createProjectScopedRoutes({
     res.json({ ok: true, files });
   });
 
+  // --- Model env endpoints (writes wholesale to settings.local.json) ---
+  router.use('/settings/model-env', createModelEnvRouter());
+
   // --- Project-scoped settings endpoints ---
 
   // GET /api/projects/:projectId/settings
@@ -578,6 +582,7 @@ export function createProjectScopedRoutes({
   // DELETE /api/projects/:projectId/settings/:section
   const SECTION_KEYS = {
     agents: { worca: ['agents'] },
+    models: { worca: ['models'] },
     pipeline: { worca: ['stages', 'loops', 'plan_path_template', 'defaults'] },
     governance: { worca: ['governance'], top: ['permissions'] },
     pricing: { worca: ['pricing'] },

package/server/reserved-env-keys.json

@@ -0,0 +1,19 @@
+{
+  "keys": [
+    "PATH",
+    "CLAUDECODE",
+    "WORCA_AGENT",
+    "WORCA_PROJECT_ROOT",
+    "WORCA_RUN_ID",
+    "WORCA_RUN_DIR",
+    "WORCA_PLAN_FILE",
+    "WORCA_EVENTS_PATH",
+    "WORCA_TARGET_BRANCH",
+    "WORCA_COVERAGE",
+    "WORCA_SKIP_BEADS",
+    "WORCA_CLAUDE_BIN"
+  ],
+  "prefixes": [
+    "WORCA_"
+  ]
+}