@worca/ui 0.19.0 → 0.21.0

package/server/settings-validator.js

@@ -1,6 +1,7 @@
 // server/settings-validator.js
 import { STAGE_ORDER } from '../app/utils/stage-order.js';
 import { GLOBAL_ONLY_KEYS } from './keys-schema.js';
+import { DEFAULT_MODELS, deriveValidModels } from './model-validation.js';
 
 const VALID_AGENTS = [
   'planner',
@@ -13,7 +14,7 @@ const VALID_AGENTS = [
   'learner',
 ];
 const VALID_STAGES = STAGE_ORDER;
-export const VALID_MODELS = ['opus', 'sonnet', 'haiku'];
+export const VALID_MODELS = DEFAULT_MODELS;
 const VALID_LOOPS = [
   'implement_test',
   'pr_changes',
@@ -27,7 +28,7 @@ const VALID_GUARDS = [
   'block_force_push',
   'restrict_git_commit',
 ];
-const VALID_PRICING_MODELS = ['opus', 'sonnet'];
+const DEFAULT_PRICING_MODELS = ['opus', 'sonnet'];
 const VALID_PRICING_FIELDS = [
   'input_per_mtok',
   'output_per_mtok',
@@ -48,6 +49,7 @@ export function validateSettingsPayload(body) {
       return { valid: false, details };
     }
     const w = body.worca;
+    const validModels = deriveValidModels(w);
 
     // agents
     if (w.agents !== undefined) {
@@ -63,7 +65,7 @@ export function validateSettingsPayload(body) {
             details.push(`Unknown agent name: "${name}"`);
             continue;
           }
-          if (cfg.model !== undefined && !VALID_MODELS.includes(cfg.model)) {
+          if (cfg.model !== undefined && !validModels.includes(cfg.model)) {
             details.push(`Invalid model "${cfg.model}" for agent "${name}"`);
           }
           if (cfg.max_turns !== undefined) {
@@ -192,6 +194,9 @@ export function validateSettingsPayload(body) {
         details.push('pricing must be an object');
       } else {
         const p = w.pricing;
+        const validPricingModels = [
+          ...new Set([...DEFAULT_PRICING_MODELS, ...validModels]),
+        ];
         if (p.models !== undefined) {
           if (
             typeof p.models !== 'object' ||
@@ -201,7 +206,7 @@ export function validateSettingsPayload(body) {
             details.push('pricing.models must be an object');
           } else {
             for (const [model, costs] of Object.entries(p.models)) {
-              if (!VALID_PRICING_MODELS.includes(model)) {
+              if (!validPricingModels.includes(model)) {
                 details.push(`Unknown pricing model: "${model}"`);
                 continue;
               }
@@ -864,12 +869,13 @@ export function validateGlobalSettings(prefs) {
     }
   }
 
+  const globalValidModels = deriveValidModels(w);
   if (
     w.circuit_breaker?.classifier_model !== undefined &&
-    !VALID_MODELS.includes(w.circuit_breaker.classifier_model)
+    !globalValidModels.includes(w.circuit_breaker.classifier_model)
   ) {
     details.push(
-      `circuit_breaker.classifier_model must be one of: ${VALID_MODELS.join(', ')}`,
+      `circuit_breaker.classifier_model must be one of: ${globalValidModels.join(', ')}`,
     );
   }
 

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/worktree-ops.js

@@ -2,33 +2,37 @@
  * Shared worktree operations — single owner of `git worktree remove` shell-out.
  */
 
-import { execFileSync } from 'node:child_process';
-import {
-  existsSync,
-  lstatSync,
-  readFileSync,
-  rmSync,
-  unlinkSync,
-} from 'node:fs';
+import { execFile } from 'node:child_process';
+import { existsSync, lstatSync } from 'node:fs';
+import { readFile, rm, unlink } from 'node:fs/promises';
 import { join } from 'node:path';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
 
 /**
  * Remove a worktree and its registry entry.
  * Mirrors WorktreeSource.remove from src/worca/cli/cleanup.py:
  *   1. Attempt `git worktree remove --force <path>` from the project root
- *   2. On failure (e.g. non-worktree temp dir in tests), fall back to rmSync
+ *   2. On failure (e.g. non-worktree temp dir in tests), fall back to rm (async)
  *   3. Run `git worktree prune` so git's metadata (`.git/worktrees/<id>/`)
  *      drops the entry even when the directory was removed manually
+ *      (skipped when skipPrune is true — caller is responsible for pruning later)
  *   4. Delete the registry file
  */
-export function removeWorktree(worcaDir, runId) {
+export async function removeWorktree(
+  worcaDir,
+  runId,
+  { skipPrune = false } = {},
+) {
   const regFile = join(worcaDir, 'multi', 'pipelines.d', `${runId}.json`);
   const projectRoot = join(worcaDir, '..');
   let worktreePath = null;
 
   if (existsSync(regFile)) {
     try {
-      const reg = JSON.parse(readFileSync(regFile, 'utf8'));
+      const content = await readFile(regFile, 'utf8');
+      const reg = JSON.parse(content);
       worktreePath = reg.worktree_path || null;
     } catch {
       /* ignore */
@@ -37,11 +41,15 @@ export function removeWorktree(worcaDir, runId) {
 
   if (worktreePath && existsSync(worktreePath)) {
     try {
-      execFileSync('git', ['worktree', 'remove', '--force', worktreePath], {
-        cwd: projectRoot,
-        stdio: 'pipe',
-        timeout: 30_000,
-      });
+      await execFileAsync(
+        'git',
+        ['worktree', 'remove', '--force', worktreePath],
+        {
+          cwd: projectRoot,
+          stdio: 'pipe',
+          timeout: 30_000,
+        },
+      );
     } catch {
       let isRealDir = false;
       try {
@@ -51,13 +59,36 @@ export function removeWorktree(worcaDir, runId) {
         /* ignore */
       }
       if (isRealDir) {
-        rmSync(worktreePath, { recursive: true, force: true });
+        await rm(worktreePath, { recursive: true, force: true });
       }
     }
   }
 
+  if (!skipPrune) {
+    try {
+      await execFileAsync('git', ['worktree', 'prune'], {
+        cwd: projectRoot,
+        stdio: 'pipe',
+        timeout: 30_000,
+      });
+    } catch {
+      /* non-fatal */
+    }
+  }
+
+  if (existsSync(regFile)) {
+    await unlink(regFile);
+  }
+}
+
+/**
+ * Run `git worktree prune` once for the project at worcaDir.
+ * Use after a batch of removeWorktree({ skipPrune: true }) calls.
+ */
+export async function pruneWorktrees(worcaDir) {
+  const projectRoot = join(worcaDir, '..');
   try {
-    execFileSync('git', ['worktree', 'prune'], {
+    await execFileAsync('git', ['worktree', 'prune'], {
       cwd: projectRoot,
       stdio: 'pipe',
       timeout: 30_000,
@@ -65,8 +96,4 @@ export function removeWorktree(worcaDir, runId) {
   } catch {
     /* non-fatal */
   }
-
-  if (existsSync(regFile)) {
-    unlinkSync(regFile);
-  }
 }

package/server/worktrees-routes.js

@@ -3,14 +3,56 @@
  *
  * GET  /worktrees          — list worktree entries enriched with disk/age/group data
  * DELETE /worktrees/:run_id — remove a worktree (409 if running, 412 if resumable/grouped without ?force=1)
+ * POST /worktrees/cleanup  — batch remove (always returns 200 with `{ok, results, failed_count}`)
  *
  * Expects req.project.worcaDir to be set by projectResolver middleware.
+ *
+ * NOTE on disk semantics: `disk_bytes` reflects project files only — vendored
+ * and derived directories listed in WALK_SKIP_DIRS (node_modules, .git, .venv,
+ * dist, build, .next, etc.) are skipped during the walk. This answers "how
+ * much project disk would I free?" rather than raw on-disk bytes, and makes
+ * cold first loads ~10× faster on node_modules-heavy worktrees. The route
+ * surfaces `disk_walk_skip_dirs` in the GET response so clients can document
+ * the discrepancy with `du -sh`.
  */
 
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import * as fsp from 'node:fs/promises';
 import { join } from 'node:path';
 import { Router } from 'express';
-import { removeWorktree } from './worktree-ops.js';
+import { pruneWorktrees, removeWorktree } from './worktree-ops.js';
+
+const CLEANUP_CONCURRENCY = 4;
+
+/**
+ * Run an array of `{run_id, fn}` tasks with bounded concurrency.
+ * Tasks are expected to return a result object — but if one throws,
+ * the limiter converts the throw into an attributable failure result
+ * so a single bad task can't halt the rest of the batch.
+ */
+async function runWithConcurrencyLimit(tasks, limit) {
+  const results = new Array(tasks.length);
+  let nextIdx = 0;
+  async function worker() {
+    while (nextIdx < tasks.length) {
+      const idx = nextIdx++;
+      const { run_id, fn } = tasks[idx];
+      try {
+        results[idx] = await fn();
+      } catch (err) {
+        results[idx] = {
+          run_id,
+          ok: false,
+          error: err?.message || String(err),
+        };
+      }
+    }
+  }
+  await Promise.all(
+    Array.from({ length: Math.min(limit, tasks.length) }, worker),
+  );
+  return results;
+}
 
 const RESUMABLE_STATUSES = new Set(['failed', 'paused', 'cancelled']);
 
@@ -18,61 +60,103 @@ const RESUMABLE_STATUSES = new Set(['failed', 'paused', 'cancelled']);
 const _diskCache = new Map();
 const DISK_CACHE_TTL_MS = 30_000;
 
+/**
+ * Directory names skipped during the disk walk. These are vendored or derived
+ * trees that dominate file count without changing the user's mental model of
+ * "project disk". Excluding them drops the walked file count by ~10–20× on
+ * typical worktrees and keeps `disk_bytes` focused on the project's own
+ * source files — closing the gap between "raw on-disk bytes" and "bytes I
+ * would actually free by cleaning up this worktree".
+ */
+export const WALK_SKIP_DIRS = new Set([
+  'node_modules',
+  '.git',
+  '.venv',
+  'venv',
+  '__pycache__',
+  '.pytest_cache',
+  '.mypy_cache',
+  '.ruff_cache',
+  'dist',
+  'build',
+  '.next',
+  '.turbo',
+  '.cache',
+]);
+
 /**
  * Sum file sizes under a directory tree. Cross-platform: prior `du -sb`
  * relied on GNU coreutils and silently returned 0 on macOS / BSD du,
  * which is why the Worktrees view always showed "0 B".
  *
- * Skips symlinks (don't follow into other trees) and is bounded by
+ * Skips symlinks (don't follow into other trees), skips directory names in
+ * WALK_SKIP_DIRS (node_modules, .git, build/cache dirs), and is bounded by
  * MAX_WALK_FILES so a runaway directory can't hang the request.
+ * Override the cap with WORCA_DISK_WALK_MAX (positive integer); the
+ * raised default of 1M handles node_modules-heavy worktrees, but very
+ * large monorepos may still want a higher ceiling.
  * Errors on individual entries are swallowed so a transiently-locked
  * file doesn't poison the whole sum.
  */
-const MAX_WALK_FILES = 100_000;
-function _walkDirSize(rootPath) {
-  let total = 0;
+function _resolveWalkCap() {
+  const raw = process.env.WORCA_DISK_WALK_MAX;
+  if (raw) {
+    const n = Number.parseInt(raw, 10);
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  return 1_000_000;
+}
+const MAX_WALK_FILES = _resolveWalkCap();
+export async function walkDirSize(rootPath, maxFiles = MAX_WALK_FILES) {
+  let bytes = 0;
   let count = 0;
   const stack = [rootPath];
-  while (stack.length > 0 && count < MAX_WALK_FILES) {
+  while (stack.length > 0 && count < maxFiles) {
     const cur = stack.pop();
-    let entries;
+    let dir;
     try {
-      entries = readdirSync(cur, { withFileTypes: true });
+      dir = await fsp.opendir(cur);
     } catch {
       continue;
     }
-    for (const e of entries) {
+    for await (const e of dir) {
       count++;
-      if (count >= MAX_WALK_FILES) break;
+      if (count >= maxFiles) break;
       const child = join(cur, e.name);
       if (e.isSymbolicLink()) continue;
       if (e.isDirectory()) {
-        stack.push(child);
+        if (!WALK_SKIP_DIRS.has(e.name)) stack.push(child);
       } else if (e.isFile()) {
         try {
-          total += statSync(child).size;
+          const st = await fsp.stat(child);
+          bytes += st.size;
         } catch {
           /* ignore — file vanished mid-walk */
         }
       }
     }
   }
-  return total;
+  return { bytes, truncated: count >= maxFiles };
 }
 
-function _getDiskBytes(worktreePath) {
+async function _getDiskBytes(worktreePath) {
   const now = Date.now();
   const hit = _diskCache.get(worktreePath);
-  if (hit && hit.expiry > now) return hit.bytes;
+  if (hit && hit.expiry > now)
+    return { bytes: hit.bytes, truncated: hit.truncated };
 
-  let bytes = 0;
+  let result = { bytes: 0, truncated: false };
   try {
-    bytes = _walkDirSize(worktreePath);
+    result = await walkDirSize(worktreePath);
   } catch {
-    bytes = 0;
+    result = { bytes: 0, truncated: false };
   }
-  _diskCache.set(worktreePath, { bytes, expiry: now + DISK_CACHE_TTL_MS });
-  return bytes;
+  _diskCache.set(worktreePath, {
+    bytes: result.bytes,
+    truncated: result.truncated,
+    expiry: now + DISK_CACHE_TTL_MS,
+  });
+  return result;
 }
 
 /**
@@ -108,7 +192,7 @@ function _readWorktreeStatus(worktreePath) {
   return null;
 }
 
-function _listWorktrees(worcaDir) {
+async function _listWorktrees(worcaDir) {
   const pipelinesDir = join(worcaDir, 'multi', 'pipelines.d');
   if (!existsSync(pipelinesDir)) return [];
 
@@ -142,12 +226,18 @@ function _listWorktrees(worcaDir) {
       }
     }
 
+    let diskInfo = { bytes: 0, truncated: false };
+    if (worktreeExists) {
+      diskInfo = await _getDiskBytes(worktreePath);
+    }
+
     entries.push({
       run_id: reg.run_id || '',
       title: reg.title || '',
       branch: reg.branch || '',
       worktree_path: worktreePath,
-      disk_bytes: worktreeExists ? _getDiskBytes(worktreePath) : 0,
+      disk_bytes: diskInfo.bytes,
+      truncated: diskInfo.truncated,
       age_seconds: ageSeconds,
       // started_at lets the client sort with the same sortByStartDesc helper
       // used by run-list, keeping ordering consistent across views.
@@ -182,7 +272,7 @@ export function createWorktreesRouter() {
   const router = Router({ mergeParams: true });
 
   // GET /worktrees
-  router.get('/', (req, res) => {
+  router.get('/', async (req, res) => {
     const worcaDir = req.project?.worcaDir;
     if (!worcaDir) {
       return res
@@ -190,15 +280,21 @@ export function createWorktreesRouter() {
         .json({ ok: false, error: 'worcaDir not configured' });
     }
     try {
-      const worktrees = _listWorktrees(worcaDir);
-      res.json({ ok: true, worktrees });
+      const worktrees = await _listWorktrees(worcaDir);
+      res.json({
+        ok: true,
+        worktrees,
+        // Documents the semantics shift in `disk_bytes` (project files only).
+        // Clients can render this as a caveat next to disk totals.
+        disk_walk_skip_dirs: [...WALK_SKIP_DIRS],
+      });
     } catch (err) {
       res.status(500).json({ ok: false, error: err.message });
     }
   });
 
   // DELETE /worktrees/:run_id
-  router.delete('/:run_id', (req, res) => {
+  router.delete('/:run_id', async (req, res) => {
     const worcaDir = req.project?.worcaDir;
     if (!worcaDir) {
       return res
@@ -261,12 +357,125 @@ export function createWorktreesRouter() {
         });
       }
 
-      removeWorktree(worcaDir, run_id);
+      await removeWorktree(worcaDir, run_id);
+      if (reg.worktree_path) _diskCache.delete(reg.worktree_path);
       res.json({ ok: true, run_id });
     } catch (err) {
       res.status(500).json({ ok: false, error: err.message });
     }
   });
 
+  // POST /worktrees/cleanup
+  //
+  // Batch worktree removal. Always responds with HTTP 200 and a JSON body of
+  // shape `{ ok, results, failed_count }`, where `ok` is the AND of per-id
+  // outcomes and `failed_count` is the number of entries with `ok: false`.
+  // Per-entry errors carry a `code` field (`running`, `resumable_or_grouped`)
+  // when actionable. Clients must inspect `results[]` — a single bad id never
+  // aborts the batch, and partial failures are not signalled via HTTP status.
+  router.post('/cleanup', async (req, res) => {
+    const worcaDir = req.project?.worcaDir;
+    if (!worcaDir) {
+      return res
+        .status(501)
+        .json({ ok: false, error: 'worcaDir not configured' });
+    }
+
+    const { run_ids, force = false } = req.body || {};
+    if (!Array.isArray(run_ids) || run_ids.length === 0) {
+      return res
+        .status(400)
+        .json({ ok: false, error: 'run_ids must be a non-empty array' });
+    }
+    for (const id of run_ids) {
+      if (!_validateRunId(id)) {
+        return res
+          .status(400)
+          .json({ ok: false, error: `Invalid run ID: ${id}` });
+      }
+    }
+
+    const tasks = run_ids.map((run_id) => ({
+      run_id,
+      fn: async () => {
+        const regFile = join(
+          worcaDir,
+          'multi',
+          'pipelines.d',
+          `${run_id}.json`,
+        );
+        if (!existsSync(regFile)) {
+          return {
+            run_id,
+            ok: false,
+            error: `Worktree "${run_id}" not found`,
+          };
+        }
+
+        let reg;
+        try {
+          reg = JSON.parse(readFileSync(regFile, 'utf8'));
+        } catch {
+          return {
+            run_id,
+            ok: false,
+            error: 'Failed to read registry entry',
+          };
+        }
+
+        let status = reg.status || 'unknown';
+        if (reg.worktree_path && existsSync(reg.worktree_path)) {
+          const actual = _readWorktreeStatus(reg.worktree_path);
+          if (actual) status = actual;
+        }
+
+        if (status === 'running') {
+          return {
+            run_id,
+            ok: false,
+            error: 'Cannot remove a running worktree',
+            code: 'running',
+          };
+        }
+
+        const isResumable = RESUMABLE_STATUSES.has(status);
+        const isGrouped = !!(reg.fleet_id || reg.workspace_id);
+        if (!force && (isResumable || isGrouped)) {
+          return {
+            run_id,
+            ok: false,
+            error:
+              'Removing this worktree prevents resuming the run. Pass force=true to confirm.',
+            code: 'resumable_or_grouped',
+          };
+        }
+
+        try {
+          await removeWorktree(worcaDir, run_id, { skipPrune: true });
+          if (reg.worktree_path) _diskCache.delete(reg.worktree_path);
+          return { run_id, ok: true };
+        } catch (err) {
+          return { run_id, ok: false, error: err.message };
+        }
+      },
+    }));
+
+    let results;
+    try {
+      results = await runWithConcurrencyLimit(tasks, CLEANUP_CONCURRENCY);
+    } catch (err) {
+      return res.status(500).json({ ok: false, error: err.message });
+    }
+
+    try {
+      await pruneWorktrees(worcaDir);
+    } catch {
+      /* non-fatal */
+    }
+
+    const failed_count = results.reduce((n, r) => (r.ok ? n : n + 1), 0);
+    res.json({ ok: failed_count === 0, failed_count, results });
+  });
+
   return router;
 }

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,
           },