@worca/ui 0.12.0 → 0.14.0

package/server/settings-reader.js

@@ -1,4 +1,7 @@
-import { readMergedSettings } from './settings-merge.js';
+import { readFileSync } from 'node:fs';
+import { atomicWriteSync } from './atomic-write.js';
+import { GLOBAL_DEFAULTS } from './keys-schema.js';
+import { deepMerge, readMergedSettings } from './settings-merge.js';
 
 export function readSettings(path) {
   try {
@@ -21,3 +24,30 @@ export function readSettings(path) {
     };
   }
 }
+
+export function readGlobalSettings(globalSettingsPath) {
+  let raw = {};
+  try {
+    raw = JSON.parse(readFileSync(globalSettingsPath, 'utf-8'));
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      // First-run: file doesn't exist yet — return defaults
+    } else if (err instanceof SyntaxError) {
+      console.error(
+        `Invalid JSON in ${globalSettingsPath}: ${err.message}; falling back to defaults`,
+      );
+    } else {
+      throw err;
+    }
+  }
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) raw = {};
+  raw.worca = deepMerge(GLOBAL_DEFAULTS, raw.worca || {});
+  return raw;
+}
+
+export function writeGlobalSettings(globalSettingsPath, partial) {
+  const existing = readGlobalSettings(globalSettingsPath);
+  const merged = deepMerge(existing, partial);
+  atomicWriteSync(globalSettingsPath, `${JSON.stringify(merged, null, 2)}\n`);
+  return merged;
+}

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,7 +10,7 @@
 
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
-import { MultiWatcher } from './multi-watcher.js';
+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';
@@ -32,14 +32,12 @@ export class WatcherSet {
     this._deps = deps;
     this._closed = false;
     this._tier = TIER_POLLING;
-    this._skipMultiWatcher = !!factoryOverrides._skipMultiWatcher;
-    const { _skipMultiWatcher, ...factories } = factoryOverrides;
     this._factories = {
       createStatusWatcher,
       createLogWatcher,
       createBeadsWatcher,
       createEventWatcher,
-      ...factories,
+      ...factoryOverrides,
     };
 
     /** @type {ReturnType<typeof createStatusWatcher> | null} */
@@ -50,8 +48,6 @@ export class WatcherSet {
     this.beadsWatcher = null;
     /** @type {ReturnType<typeof createEventWatcher> | null} */
     this.eventWatcher = null;
-    /** @type {MultiWatcher | null} */
-    this.multiWatcher = null;
   }
 
   get worcaDir() {
@@ -93,28 +89,6 @@ export class WatcherSet {
     if (this._tier === TIER_FULL) {
       this._createSecondaryWatchers();
     }
-    // Start multi-pipeline watcher (skip for pipeline-level WatcherSets to avoid recursion)
-    if (!this._skipMultiWatcher) {
-      this._createMultiWatcher();
-    }
-  }
-
-  /** Create multi-pipeline watcher for this project's .worca/multi/pipelines.d/. */
-  _createMultiWatcher() {
-    try {
-      this.multiWatcher = new MultiWatcher(
-        this.projectId,
-        this._worcaDir,
-        this._deps,
-      );
-      this.multiWatcher.start();
-    } catch (err) {
-      console.error(
-        `[WatcherSet:${this.projectId}] multiWatcher failed:`,
-        err.message,
-      );
-      this.multiWatcher = null;
-    }
   }
 
   /** Create status watcher (always needed). */
@@ -153,8 +127,8 @@ export class WatcherSet {
       try {
         this.logWatcher = this._factories.createLogWatcher({
           broadcaster,
-          resolveActiveRunDir: this.statusWatcher
-            ? this.statusWatcher.resolveActiveRunDir
+          resolveLatestRunDir: this.statusWatcher
+            ? this.statusWatcher.resolveLatestRunDir
             : () => worcaDir,
           worcaDir,
           currentActiveRunId: this.statusWatcher
@@ -190,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,
@@ -236,15 +207,6 @@ export class WatcherSet {
     if (this._closed) return;
     this._closed = true;
 
-    if (this.multiWatcher) {
-      try {
-        this.multiWatcher.destroy();
-      } catch {
-        // ignore cleanup errors
-      }
-      this.multiWatcher = null;
-    }
-
     for (const w of [
       this.statusWatcher,
       this.logWatcher,
@@ -274,11 +236,6 @@ export class WatcherSet {
     return count;
   }
 
-  /** Get multi-pipeline watcher (may be null for pipeline-level WatcherSets). */
-  getMultiWatcher() {
-    return this.multiWatcher;
-  }
-
   /** Delegate to status watcher's scheduleRefresh. */
   scheduleRefresh() {
     this.statusWatcher?.scheduleRefresh();

package/server/watcher.js

@@ -49,28 +49,7 @@ export function discoverRuns(worcaDir) {
   const runs = [];
   const seenIds = new Set();
 
-  // 1. Check active_run pointer for the current run
-  const activeRunPath = join(worcaDir, 'active_run');
-  if (existsSync(activeRunPath)) {
-    try {
-      const activeId = readFileSync(activeRunPath, 'utf8').trim();
-      const runDir = join(worcaDir, 'runs', activeId);
-      const candidate = join(runDir, 'status.json');
-      if (existsSync(candidate)) {
-        let status = JSON.parse(readFileSync(candidate, 'utf8'));
-        status = enrichWithDispatchEvents(status, runDir);
-        const active =
-          !isTerminal(status) && status.pipeline_status === 'running';
-        const id = createRunId(status);
-        runs.push({ id, active, ...status });
-        seenIds.add(id);
-      }
-    } catch {
-      /* ignore */
-    }
-  }
-
-  // 2. Scan .worca/runs/ for other runs
+  // 1. Scan .worca/runs/ for runs
   const runsDir = join(worcaDir, 'runs');
   if (existsSync(runsDir)) {
     for (const entry of readdirSync(runsDir)) {
@@ -92,7 +71,7 @@ export function discoverRuns(worcaDir) {
     }
   }
 
-  // 3. Legacy: flat .worca/status.json
+  // 2. Legacy: flat .worca/status.json
   const statusPath = join(worcaDir, 'status.json');
   if (existsSync(statusPath)) {
     try {
@@ -109,7 +88,7 @@ export function discoverRuns(worcaDir) {
     }
   }
 
-  // 4. Results: handle both dir format (results/{id}/status.json) and file format (results/{id}.json)
+  // 3. Results: handle both dir format (results/{id}/status.json) and file format (results/{id}.json)
   const resultsDir = join(worcaDir, 'results');
   if (existsSync(resultsDir)) {
     for (const entry of readdirSync(resultsDir, { withFileTypes: true })) {
@@ -148,6 +127,51 @@ export function discoverRuns(worcaDir) {
     }
   }
 
+  // 4. Fan out across pipelines.d/ registry entries (worktree runs)
+  const pipelinesDir = join(worcaDir, 'multi', 'pipelines.d');
+  if (existsSync(pipelinesDir)) {
+    for (const entry of readdirSync(pipelinesDir)) {
+      if (!entry.endsWith('.json')) continue;
+      try {
+        const reg = JSON.parse(readFileSync(join(pipelinesDir, entry), 'utf8'));
+        if (!reg.worktree_path) continue;
+        const wtRunsDir = join(reg.worktree_path, '.worca', 'runs');
+        if (!existsSync(wtRunsDir)) continue;
+        for (const runEntry of readdirSync(wtRunsDir)) {
+          const sp = join(wtRunsDir, runEntry, 'status.json');
+          if (!existsSync(sp)) continue;
+          try {
+            let status = JSON.parse(readFileSync(sp, 'utf8'));
+            status = enrichWithDispatchEvents(
+              status,
+              join(wtRunsDir, runEntry),
+            );
+            const id = createRunId(status);
+            if (seenIds.has(id)) continue;
+            seenIds.add(id);
+            const active =
+              !isTerminal(status) && status.pipeline_status === 'running';
+            runs.push({
+              id,
+              active,
+              ...status,
+              worktree_worca_dir: join(reg.worktree_path, '.worca'),
+              is_worktree_run: true,
+              fleet_id: reg.fleet_id || null,
+              workspace_id: reg.workspace_id || null,
+              group_type: reg.group_type || null,
+              target_branch: reg.target_branch || null,
+            });
+          } catch {
+            /* ignore malformed status */
+          }
+        }
+      } catch {
+        /* ignore malformed registry entry */
+      }
+    }
+  }
+
   return runs;
 }
 
@@ -159,23 +183,7 @@ export async function discoverRunsAsync(worcaDir) {
   const runs = [];
   const seenIds = new Set();
 
-  // 1. Active run
-  const activeRunPath = join(worcaDir, 'active_run');
-  try {
-    const activeId = (await readFile(activeRunPath, 'utf8')).trim();
-    const runDir = join(worcaDir, 'runs', activeId);
-    const candidate = join(runDir, 'status.json');
-    let status = JSON.parse(await readFile(candidate, 'utf8'));
-    status = enrichWithDispatchEvents(status, runDir);
-    const active = !isTerminal(status) && status.pipeline_status === 'running';
-    const id = createRunId(status);
-    runs.push({ id, active, ...status });
-    seenIds.add(id);
-  } catch {
-    /* ignore */
-  }
-
-  // 2. Scan .worca/runs/
+  // 1. Scan .worca/runs/
   const runsDir = join(worcaDir, 'runs');
   try {
     const entries = await readdir(runsDir);
@@ -203,7 +211,7 @@ export async function discoverRunsAsync(worcaDir) {
     /* ignore */
   }
 
-  // 3. Legacy flat status.json
+  // 2. Legacy flat status.json
   try {
     const status = JSON.parse(
       await readFile(join(worcaDir, 'status.json'), 'utf8'),
@@ -219,7 +227,7 @@ export async function discoverRunsAsync(worcaDir) {
     /* ignore */
   }
 
-  // 4. Results
+  // 3. Results
   const resultsDir = join(worcaDir, 'results');
   try {
     const entries = await readdir(resultsDir, { withFileTypes: true });
@@ -252,6 +260,67 @@ export async function discoverRunsAsync(worcaDir) {
     /* ignore */
   }
 
+  // 4. Fan out across pipelines.d/ registry entries (worktree runs)
+  const pipelinesDirAsync = join(worcaDir, 'multi', 'pipelines.d');
+  try {
+    const regEntries = await readdir(pipelinesDirAsync);
+    const wtReadPromises = regEntries
+      .filter((e) => e.endsWith('.json'))
+      .map(async (e) => {
+        try {
+          const reg = JSON.parse(
+            await readFile(join(pipelinesDirAsync, e), 'utf8'),
+          );
+          if (!reg.worktree_path) return [];
+          const wtRunsDir = join(reg.worktree_path, '.worca', 'runs');
+          let runEntries;
+          try {
+            runEntries = await readdir(wtRunsDir);
+          } catch {
+            return [];
+          }
+          const results = [];
+          for (const runEntry of runEntries) {
+            try {
+              const sp = join(wtRunsDir, runEntry, 'status.json');
+              let status = JSON.parse(await readFile(sp, 'utf8'));
+              status = enrichWithDispatchEvents(
+                status,
+                join(wtRunsDir, runEntry),
+              );
+              results.push({ status, reg });
+            } catch {
+              /* ignore */
+            }
+          }
+          return results;
+        } catch {
+          return [];
+        }
+      });
+    const wtResults = (await Promise.all(wtReadPromises)).flat();
+    for (const { status, reg } of wtResults) {
+      const id = createRunId(status);
+      if (seenIds.has(id)) continue;
+      seenIds.add(id);
+      const active =
+        !isTerminal(status) && status.pipeline_status === 'running';
+      runs.push({
+        id,
+        active,
+        ...status,
+        worktree_worca_dir: join(reg.worktree_path, '.worca'),
+        is_worktree_run: true,
+        fleet_id: reg.fleet_id || null,
+        workspace_id: reg.workspace_id || null,
+        group_type: reg.group_type || null,
+        target_branch: reg.target_branch || null,
+      });
+    }
+  } catch {
+    /* ignore */
+  }
+
   return runs;
 }
 

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);
+  }
+}