@worca/ui 0.13.0 → 0.14.0

package/server/settings-validator.js

@@ -1,5 +1,6 @@
 // server/settings-validator.js
 import { STAGE_ORDER } from '../app/utils/stage-order.js';
+import { GLOBAL_ONLY_KEYS } from './keys-schema.js';
 
 const VALID_AGENTS = [
   'planner',
@@ -12,7 +13,7 @@ const VALID_AGENTS = [
   'learner',
 ];
 const VALID_STAGES = STAGE_ORDER;
-const VALID_MODELS = ['opus', 'sonnet', 'haiku'];
+export const VALID_MODELS = ['opus', 'sonnet', 'haiku'];
 const VALID_LOOPS = [
   'implement_test',
   'pr_changes',
@@ -265,6 +266,70 @@ export function validateSettingsPayload(body) {
       }
     }
 
+    // parallel
+    if (w.parallel !== undefined) {
+      if (
+        typeof w.parallel !== 'object' ||
+        w.parallel === null ||
+        Array.isArray(w.parallel)
+      ) {
+        details.push('worca.parallel must be an object');
+      } else {
+        const p = w.parallel;
+        if (
+          p.worktree_base_dir !== undefined &&
+          (typeof p.worktree_base_dir !== 'string' ||
+            p.worktree_base_dir.length === 0)
+        ) {
+          details.push('parallel.worktree_base_dir must be a non-empty string');
+        }
+        if (
+          p.default_base_branch !== undefined &&
+          (typeof p.default_base_branch !== 'string' ||
+            p.default_base_branch.length === 0)
+        ) {
+          details.push(
+            'parallel.default_base_branch must be a non-empty string',
+          );
+        }
+      }
+    }
+
+    // circuit_breaker
+    if (w.circuit_breaker !== undefined) {
+      if (
+        typeof w.circuit_breaker !== 'object' ||
+        w.circuit_breaker === null ||
+        Array.isArray(w.circuit_breaker)
+      ) {
+        details.push('worca.circuit_breaker must be an object');
+      } else {
+        const cb = w.circuit_breaker;
+        if (cb.enabled !== undefined && typeof cb.enabled !== 'boolean') {
+          details.push('circuit_breaker.enabled must be a boolean');
+        }
+        if (
+          cb.max_consecutive_failures !== undefined &&
+          (!Number.isInteger(cb.max_consecutive_failures) ||
+            cb.max_consecutive_failures < 1 ||
+            cb.max_consecutive_failures > 10)
+        ) {
+          details.push(
+            'circuit_breaker.max_consecutive_failures must be an integer between 1 and 10',
+          );
+        }
+      }
+    }
+
+    // reject misplaced global keys in project settings
+    for (const [section, key] of GLOBAL_ONLY_KEYS) {
+      if (w?.[section]?.[key] !== undefined) {
+        details.push(
+          `worca.${section}.${key} is a global preference (~/.worca/settings.json), not a project setting. Configure it in the global Preferences tab.`,
+        );
+      }
+    }
+
     // governance
     if (w.governance !== undefined) {
       if (
@@ -782,3 +847,49 @@ export function validateIntegrationsConfig(cfg) {
 
   return details.length ? { valid: false, details } : { valid: true };
 }
+
+const VALID_CLEANUP_POLICIES = ['never', 'on-success', 'manual-only'];
+
+export function validateGlobalSettings(prefs) {
+  const details = [];
+  const w = prefs?.worca;
+  if (!w) return { ok: true };
+
+  if (w.ui?.worktree_disk_warning_bytes !== undefined) {
+    const v = w.ui.worktree_disk_warning_bytes;
+    if (!Number.isInteger(v) || v < 500_000_000 || v > 50_000_000_000) {
+      details.push(
+        'ui.worktree_disk_warning_bytes must be an integer between 500_000_000 (500 MB) and 50_000_000_000 (50 GB)',
+      );
+    }
+  }
+
+  if (
+    w.circuit_breaker?.classifier_model !== undefined &&
+    !VALID_MODELS.includes(w.circuit_breaker.classifier_model)
+  ) {
+    details.push(
+      `circuit_breaker.classifier_model must be one of: ${VALID_MODELS.join(', ')}`,
+    );
+  }
+
+  if (
+    w.parallel?.cleanup_policy !== undefined &&
+    !VALID_CLEANUP_POLICIES.includes(w.parallel.cleanup_policy)
+  ) {
+    details.push(
+      `parallel.cleanup_policy must be one of: ${VALID_CLEANUP_POLICIES.join(', ')}`,
+    );
+  }
+
+  if (w.parallel?.max_concurrent_pipelines !== undefined) {
+    const n = w.parallel.max_concurrent_pipelines;
+    if (!Number.isInteger(n) || n < 1 || n > 20) {
+      details.push(
+        'parallel.max_concurrent_pipelines must be an integer between 1 and 20',
+      );
+    }
+  }
+
+  return details.length === 0 ? { ok: true } : { ok: false, details };
+}

package/server/status-routes.js

@@ -0,0 +1,23 @@
+import { join } from 'node:path';
+import { Router } from 'express';
+import { countRunningPipelinesAcrossProjects } from './process-registry.js';
+import { readGlobalSettings } from './settings-reader.js';
+
+export function createStatusRouter({ prefsDir }) {
+  const router = Router();
+
+  router.get('/runs-count', (_req, res) => {
+    try {
+      const totalRunning = countRunningPipelinesAcrossProjects(prefsDir);
+      const globalSettingsPath = join(prefsDir, 'settings.json');
+      const globalSettings = readGlobalSettings(globalSettingsPath);
+      const cap =
+        globalSettings.worca?.parallel?.max_concurrent_pipelines ?? 10;
+      res.json({ ok: true, totalRunning, cap });
+    } catch (err) {
+      res.status(500).json({ ok: false, error: err.message });
+    }
+  });
+
+  return router;
+}

package/server/watcher-set.js

@@ -10,6 +10,7 @@
 
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
+import { resolveRunDir } from './run-dir-resolver.js';
 import { createBeadsWatcher } from './ws-beads-watcher.js';
 import { createEventWatcher } from './ws-event-watcher.js';
 import { createLogWatcher } from './ws-log-watcher.js';
@@ -163,16 +164,13 @@ export class WatcherSet {
     // Event watcher
     if (!this.eventWatcher) {
       try {
-        const resolveRunDirById = (runId) => {
-          const candidates = [
-            join(worcaDir, 'runs', runId),
-            join(worcaDir, 'results', runId),
-          ];
-          for (const c of candidates) {
-            if (existsSync(c)) return c;
-          }
-          return join(worcaDir, 'runs', runId);
-        };
+        // Use the shared overlay resolver so worktree-hosted runs (registered
+        // in <worcaDir>/multi/pipelines.d/<runId>.json) resolve to their
+        // <worktree_path>/.worca/runs/<runId>/ directory. Falls back to the
+        // legacy local path for non-existent runs so the existing `watch()`
+        // call keeps working when the file is created later.
+        const resolveRunDirById = (runId) =>
+          resolveRunDir(worcaDir, runId) || join(worcaDir, 'runs', runId);
 
         this.eventWatcher = this._factories.createEventWatcher({
           broadcaster,

package/server/worktree-ops.js

@@ -0,0 +1,72 @@
+/**
+ * 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 { join } from 'node:path';
+
+/**
+ * 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
+ *   3. Run `git worktree prune` so git's metadata (`.git/worktrees/<id>/`)
+ *      drops the entry even when the directory was removed manually
+ *   4. Delete the registry file
+ */
+export function removeWorktree(worcaDir, runId) {
+  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'));
+      worktreePath = reg.worktree_path || null;
+    } catch {
+      /* ignore */
+    }
+  }
+
+  if (worktreePath && existsSync(worktreePath)) {
+    try {
+      execFileSync('git', ['worktree', 'remove', '--force', worktreePath], {
+        cwd: projectRoot,
+        stdio: 'pipe',
+        timeout: 30_000,
+      });
+    } catch {
+      let isRealDir = false;
+      try {
+        const st = lstatSync(worktreePath);
+        isRealDir = st.isDirectory() && !st.isSymbolicLink();
+      } catch {
+        /* ignore */
+      }
+      if (isRealDir) {
+        rmSync(worktreePath, { recursive: true, force: true });
+      }
+    }
+  }
+
+  try {
+    execFileSync('git', ['worktree', 'prune'], {
+      cwd: projectRoot,
+      stdio: 'pipe',
+      timeout: 30_000,
+    });
+  } catch {
+    /* non-fatal */
+  }
+
+  if (existsSync(regFile)) {
+    unlinkSync(regFile);
+  }
+}

package/server/worktrees-routes.js

@@ -7,18 +7,10 @@
  * Expects req.project.worcaDir to be set by projectResolver middleware.
  */
 
-import { execFileSync } from 'node:child_process';
-import {
-  existsSync,
-  lstatSync,
-  readdirSync,
-  readFileSync,
-  rmSync,
-  statSync,
-  unlinkSync,
-} from 'node:fs';
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { Router } from 'express';
+import { removeWorktree } from './worktree-ops.js';
 
 const RESUMABLE_STATUSES = new Set(['failed', 'paused', 'cancelled']);
 
@@ -172,75 +164,6 @@ function _listWorktrees(worcaDir) {
   return entries;
 }
 
-/**
- * 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
- *   3. Run `git worktree prune` so git's metadata (`.git/worktrees/<id>/`)
- *      drops the entry even when the directory was removed manually
- *   4. Delete the registry file
- */
-function _removeWorktree(worcaDir, runId) {
-  const regFile = join(worcaDir, 'multi', 'pipelines.d', `${runId}.json`);
-  // worcaDir is `<projectRoot>/.worca` — git commands must run inside the
-  // project repo, not the server's cwd, or `git worktree remove` errors out
-  // and the .git/worktrees/<id>/ metadata is left as `prunable`.
-  const projectRoot = join(worcaDir, '..');
-  let worktreePath = null;
-
-  if (existsSync(regFile)) {
-    try {
-      const reg = JSON.parse(readFileSync(regFile, 'utf8'));
-      worktreePath = reg.worktree_path || null;
-    } catch {
-      /* ignore */
-    }
-  }
-
-  if (worktreePath && existsSync(worktreePath)) {
-    try {
-      execFileSync('git', ['worktree', 'remove', '--force', worktreePath], {
-        cwd: projectRoot,
-        stdio: 'pipe',
-        timeout: 30_000,
-      });
-    } catch {
-      // Path is not a registered git worktree — brute-force remove.
-      // Refuse to follow symlinks: rmSync on a symlink to a real directory
-      // would delete the link itself (good), but we don't want to risk a
-      // user-symlinked path here being mistaken for a worktree we own.
-      let isRealDir = false;
-      try {
-        const st = lstatSync(worktreePath);
-        isRealDir = st.isDirectory() && !st.isSymbolicLink();
-      } catch {
-        /* ignore */
-      }
-      if (isRealDir) {
-        rmSync(worktreePath, { recursive: true, force: true });
-      }
-    }
-  }
-
-  // Always prune — covers (a) successful remove leaving residual metadata,
-  // (b) brute-force rmSync path, and (c) entries already left prunable by
-  // earlier failures. Errors are non-fatal (e.g. project not a git repo).
-  try {
-    execFileSync('git', ['worktree', 'prune'], {
-      cwd: projectRoot,
-      stdio: 'pipe',
-      timeout: 30_000,
-    });
-  } catch {
-    /* non-fatal */
-  }
-
-  if (existsSync(regFile)) {
-    unlinkSync(regFile);
-  }
-}
-
 const RUN_ID_RE = /^[a-zA-Z0-9_-]+$/;
 function _validateRunId(runId) {
   return (
@@ -338,7 +261,7 @@ export function createWorktreesRouter() {
         });
       }
 
-      _removeWorktree(worcaDir, run_id);
+      removeWorktree(worcaDir, run_id);
       res.json({ ok: true, run_id });
     } catch (err) {
       res.status(500).json({ ok: false, error: err.message });

package/server/ws-log-watcher.js

@@ -54,16 +54,21 @@ export function createLogWatcher({
     logByteOffsets.clear();
   }
 
-  function watchSingleLogFile(stage, filePath, iteration) {
-    const key =
-      iteration != null
-        ? `${stage}__iter${iteration}`
-        : stage || '__orchestrator__';
+  function _watcherKey(runId, stage, iteration, suffix = '') {
+    const stagePart = stage || '__orchestrator__';
+    const iterPart = iteration != null ? `__iter${iteration}` : '';
+    const runPart = runId ? `${runId}__` : '';
+    return `${runPart}${stagePart}${iterPart}${suffix}`;
+  }
+
+  function watchSingleLogFile(stage, filePath, iteration, options = {}) {
+    const explicitRunId = options.runId || null;
+    const key = _watcherKey(explicitRunId, stage, iteration);
     if (logWatchers.has(key)) return;
     try {
       if (!existsSync(filePath)) return;
       logByteOffsets.set(key, fileByteLength(filePath));
-      const watcherRunId = currentActiveRunId();
+      const watcherRunId = explicitRunId || currentActiveRunId();
       const watcher = watch(filePath, (eventType) => {
         if (eventType === 'change') {
           try {
@@ -99,62 +104,66 @@ export function createLogWatcher({
     }
   }
 
-  function watchStageDir(stage, stageDir) {
-    const dirKey = `${stage}__dir`;
+  function watchStageDir(stage, stageDir, options = {}) {
+    const explicitRunId = options.runId || null;
+    const dirKey = _watcherKey(explicitRunId, stage, null, '__dir');
     if (logWatchers.has(dirKey)) return;
     try {
       const dirWatcher = watch(stageDir, (_eventType, filename) => {
         if (filename && /^iter-\d+\.log$/.test(filename)) {
           const iterNum = parseInt(filename.match(/\d+/)[0], 10);
           const iterPath = join(stageDir, filename);
-          watchSingleLogFile(stage, iterPath, iterNum);
+          watchSingleLogFile(stage, iterPath, iterNum, options);
         }
       });
       logWatchers.set(dirKey, dirWatcher);
-      const logsBase = resolveLogsBaseDir();
+      const logsBase = options.runDir || resolveLogsBaseDir();
       const backfill = listIterationFiles(logsBase, stage);
       for (const { iteration, path } of backfill) {
-        watchSingleLogFile(stage, path, iteration);
+        watchSingleLogFile(stage, path, iteration, options);
       }
     } catch {
       /* ignore */
     }
   }
 
-  function watchLogFile(stage) {
-    const logsBase = resolveLogsBaseDir();
+  function watchLogFile(stage, options = {}) {
+    const logsBase = options.runDir || resolveLogsBaseDir();
     if (!stage) {
       const logPath = resolveLogPath(logsBase, null);
-      watchSingleLogFile(null, logPath, null);
+      watchSingleLogFile(null, logPath, null, options);
       return;
     }
     const stageDir = resolveLogPath(logsBase, stage);
     if (existsSync(stageDir) && statSync(stageDir).isDirectory()) {
       const iters = listIterationFiles(logsBase, stage);
       for (const { iteration, path } of iters) {
-        watchSingleLogFile(stage, path, iteration);
+        watchSingleLogFile(stage, path, iteration, options);
       }
-      watchStageDir(stage, stageDir);
+      watchStageDir(stage, stageDir, options);
     } else {
       const logPath = join(logsBase, 'logs', `${stage}.log`);
       if (existsSync(logPath)) {
-        watchSingleLogFile(stage, logPath, null);
+        watchSingleLogFile(stage, logPath, null, options);
       }
     }
   }
 
-  function watchAllLogFiles() {
-    const logsBase = resolveLogsBaseDir();
+  function watchAllLogFiles(options = {}) {
+    const logsBase = options.runDir || resolveLogsBaseDir();
     const logFiles = listLogFiles(logsBase);
     const watchedStages = new Set();
     for (const { stage } of logFiles) {
       if (watchedStages.has(stage)) continue;
       watchedStages.add(stage);
       const actualStage = stage === 'orchestrator' ? null : stage;
-      watchLogFile(actualStage);
+      watchLogFile(actualStage, options);
     }
     const logsDir = join(logsBase, 'logs');
-    const dirKey = '__logs_dir__';
+    const explicitRunId = options.runId || null;
+    const dirKey = explicitRunId
+      ? `${explicitRunId}__logs_dir__`
+      : '__logs_dir__';
     if (logWatchers.has(dirKey)) return;
     if (!existsSync(logsDir)) return;
     try {
@@ -163,16 +172,16 @@ export function createLogWatcher({
         if (filename.endsWith('.log')) {
           const stage = filename.replace('.log', '');
           const actualStage = stage === 'orchestrator' ? null : stage;
-          watchLogFile(actualStage);
+          watchLogFile(actualStage, options);
         } else {
           const stagePath = join(logsDir, filename);
           try {
             if (existsSync(stagePath) && statSync(stagePath).isDirectory()) {
               const iters = listIterationFiles(logsBase, filename);
               for (const { iteration, path } of iters) {
-                watchSingleLogFile(filename, path, iteration);
+                watchSingleLogFile(filename, path, iteration, options);
               }
-              watchStageDir(filename, stagePath);
+              watchStageDir(filename, stagePath, options);
             }
           } catch {
             /* ignore */

package/server/ws-message-router.js

@@ -32,6 +32,7 @@ import {
   stopPipeline as pmStopPipeline,
   reconcileStatus,
 } from './process-manager.js';
+import { resolveRunDir } from './run-dir-resolver.js';
 import { readSettings } from './settings-reader.js';
 import { discoverRuns } from './watcher.js';
 
@@ -342,90 +343,100 @@ export function createMessageRouter({
 
       if (!proj.wset.logWatcher) return;
 
-      const archivedRunDir = runId
-        ? join(proj.worcaDir, 'results', runId)
-        : null;
-      const archivedLogDir = archivedRunDir
-        ? join(archivedRunDir, 'logs')
-        : null;
-      const isArchived = archivedLogDir && existsSync(archivedLogDir);
-
-      if (isArchived) {
-        proj.wset.logWatcher.sendArchivedLogs(
-          ws,
-          archivedLogDir,
-          stage,
-          iteration,
-        );
+      // Resolve runId → on-disk run dir. Handles local active (runs/<id>),
+      // archived (results/<id>), and worktree overlay (pipelines.d/<id>.json
+      // → worktree_path/.worca/runs/<id>). Falls back to the project's
+      // latest-active-run base when no runId is given.
+      let logsBase;
+      let watchOptions;
+      if (runId) {
+        const runDir = resolveRunDir(proj.worcaDir, runId);
+        if (runDir) {
+          logsBase = runDir;
+          // Tail only when the run is still alive (pipeline.pid present);
+          // archived dirs get backfill but no live watcher.
+          watchOptions = existsSync(join(runDir, 'pipeline.pid'))
+            ? { runDir, runId }
+            : null;
+        } else {
+          // Run not found anywhere; nothing to send or watch.
+          return;
+        }
       } else {
-        const logsBase = proj.wset.logWatcher.resolveLogsBaseDir();
-        if (stage) {
-          if (iteration != null) {
-            const logPath = resolveIterationLogPath(logsBase, stage, iteration);
-            const lines = readLastLines(logPath, 200);
-            if (lines.length > 0) {
-              ws.send(
-                JSON.stringify({
-                  id: `evt-${Date.now()}`,
-                  ok: true,
-                  type: 'log-bulk',
-                  payload: { stage, iteration, lines },
-                }),
-              );
-            }
-          } else {
-            const stageDir = resolveLogPath(logsBase, stage);
-            if (existsSync(stageDir) && statSync(stageDir).isDirectory()) {
-              const iters = listIterationFiles(logsBase, stage);
-              for (const { iteration: iterNum, path } of iters) {
-                const lines = readLastLines(path, 200);
-                if (lines.length > 0) {
-                  ws.send(
-                    JSON.stringify({
-                      id: `evt-${Date.now()}-iter${iterNum}`,
-                      ok: true,
-                      type: 'log-bulk',
-                      payload: { stage, iteration: iterNum, lines },
-                    }),
-                  );
-                }
-              }
-            } else {
-              const logPath = join(logsBase, 'logs', `${stage}.log`);
-              const lines = readLastLines(logPath, 200);
+        logsBase = proj.wset.logWatcher.resolveLogsBaseDir();
+        watchOptions = {};
+      }
+
+      if (stage) {
+        if (iteration != null) {
+          const logPath = resolveIterationLogPath(logsBase, stage, iteration);
+          const lines = readLastLines(logPath, 200);
+          if (lines.length > 0) {
+            ws.send(
+              JSON.stringify({
+                id: `evt-${Date.now()}`,
+                ok: true,
+                type: 'log-bulk',
+                payload: { stage, iteration, lines },
+              }),
+            );
+          }
+        } else {
+          const stageDir = resolveLogPath(logsBase, stage);
+          if (existsSync(stageDir) && statSync(stageDir).isDirectory()) {
+            const iters = listIterationFiles(logsBase, stage);
+            for (const { iteration: iterNum, path } of iters) {
+              const lines = readLastLines(path, 200);
               if (lines.length > 0) {
                 ws.send(
                   JSON.stringify({
-                    id: `evt-${Date.now()}`,
+                    id: `evt-${Date.now()}-iter${iterNum}`,
                     ok: true,
                     type: 'log-bulk',
-                    payload: { stage, lines },
+                    payload: { stage, iteration: iterNum, lines },
                   }),
                 );
               }
             }
-          }
-          proj.wset.logWatcher.watchLogFile(stage);
-        } else {
-          const logFiles = listLogFiles(logsBase);
-          for (const { stage: s2, iteration: iterNum, path } of logFiles) {
-            const lines = readLastLines(path, 200);
+          } else {
+            const logPath = join(logsBase, 'logs', `${stage}.log`);
+            const lines = readLastLines(logPath, 200);
             if (lines.length > 0) {
               ws.send(
                 JSON.stringify({
-                  id: `evt-${Date.now()}-${s2}-${iterNum || 0}`,
+                  id: `evt-${Date.now()}`,
                   ok: true,
                   type: 'log-bulk',
-                  payload: {
-                    stage: s2,
-                    iteration: iterNum ?? undefined,
-                    lines,
-                  },
+                  payload: { stage, lines },
                 }),
               );
             }
           }
-          proj.wset.logWatcher.watchAllLogFiles();
+        }
+        if (watchOptions) {
+          proj.wset.logWatcher.watchLogFile(stage, watchOptions);
+        }
+      } else {
+        const logFiles = listLogFiles(logsBase);
+        for (const { stage: s2, iteration: iterNum, path } of logFiles) {
+          const lines = readLastLines(path, 200);
+          if (lines.length > 0) {
+            ws.send(
+              JSON.stringify({
+                id: `evt-${Date.now()}-${s2}-${iterNum || 0}`,
+                ok: true,
+                type: 'log-bulk',
+                payload: {
+                  stage: s2,
+                  iteration: iterNum ?? undefined,
+                  lines,
+                },
+              }),
+            );
+          }
+        }
+        if (watchOptions) {
+          proj.wset.logWatcher.watchAllLogFiles(watchOptions);
         }
       }
       return;