@worca/ui 0.8.1 → 0.9.0

package/server/project-routes.js

@@ -23,6 +23,7 @@ import { dbExists, getIssue, listIssues } from './beads-reader.js';
 import { readPreferences } from './preferences.js';
 import { ProcessManager } from './process-manager.js';
 import {
+  getMaxProjects,
   readProjects,
   removeProject,
   SLUG_RE,
@@ -36,6 +37,8 @@ import {
   readMergedSettings,
 } from './settings-merge.js';
 import { validateSettingsPayload } from './settings-validator.js';
+import { isVersionBehind } from './version-check.js';
+import { getVersionInfo } from './versions.js';
 import { discoverRuns } from './watcher.js';
 import {
   checkWorcaInstalled,
@@ -182,15 +185,114 @@ export function createProjectRoutes({ prefsDir, projectRoot }) {
     res.json({ ok: true, removed: id });
   });
 
+  // POST /api/projects/batch — register multiple projects atomically
+  router.post('/batch', (req, res) => {
+    const { projects: batch } = req.body || {};
+    if (!Array.isArray(batch) || batch.length === 0) {
+      return res
+        .status(400)
+        .json({ ok: false, error: 'projects must be a non-empty array' });
+    }
+
+    // Validate all entries first (all-or-nothing)
+    const failed = [];
+    for (const entry of batch) {
+      const validation = validateProjectEntry(entry);
+      if (!validation.valid) {
+        failed.push({ name: entry?.name ?? '', error: validation.error });
+        continue;
+      }
+      if (!existsSync(entry.path)) {
+        failed.push({
+          name: entry.name,
+          error: `directory does not exist: ${entry.path}`,
+        });
+      }
+    }
+    if (failed.length > 0) {
+      return res.status(400).json({
+        ok: false,
+        error: `${failed.length} project${failed.length > 1 ? 's' : ''} failed validation`,
+        failed,
+      });
+    }
+
+    // Check for intra-batch duplicate names
+    const batchNames = batch.map((e) => e?.name).filter(Boolean);
+    if (new Set(batchNames).size < batchNames.length) {
+      return res
+        .status(400)
+        .json({ ok: false, error: 'Duplicate names within batch' });
+    }
+
+    // Check for intra-batch duplicate paths
+    const batchPaths = batch.map((e) => e?.path).filter(Boolean);
+    if (new Set(batchPaths).size < batchPaths.length) {
+      return res
+        .status(400)
+        .json({ ok: false, error: 'Duplicate paths within batch' });
+    }
+
+    // Check for duplicate paths against existing projects
+    const existing = readProjects(prefsDir);
+    const existingPaths = new Set(
+      existing.map((p) => p.path.replace(/\/+$/, '')),
+    );
+    const duplicates = batch.filter((entry) =>
+      existingPaths.has(entry.path.replace(/\/+$/, '')),
+    );
+    if (duplicates.length > 0) {
+      return res.status(400).json({
+        ok: false,
+        error: `${duplicates.length} project${duplicates.length > 1 ? 's' : ''} already registered`,
+        failed: duplicates.map((entry) => ({
+          name: entry.name,
+          error: `path already registered: ${entry.path}`,
+        })),
+      });
+    }
+
+    // Check max projects limit
+    const max = getMaxProjects(prefsDir);
+    if (existing.length + batch.length > max) {
+      return res.status(400).json({
+        ok: false,
+        error: `adding ${batch.length} project${batch.length > 1 ? 's' : ''} would exceed the limit of ${max}`,
+      });
+    }
+
+    // Write all projects — roll back on partial failure
+    const written = [];
+    try {
+      for (const entry of batch) {
+        writeProject(prefsDir, entry);
+        written.push(entry.name);
+      }
+      res.status(201).json({ ok: true, projects: batch });
+    } catch (err) {
+      for (const name of written) {
+        try {
+          removeProject(prefsDir, name);
+        } catch {
+          // ignore rollback errors
+        }
+      }
+      res.status(400).json({ ok: false, error: err.message });
+    }
+  });
+
   return router;
 }
 
 /**
  * Router for project-scoped sub-routes.
  * The projectResolver middleware must run before this to set req.project.
+ * @param {{ prefsDir?: string|null }} [options] — prefsDir enables active
+ *   worca-cc version lookup for /worca-status' `outdated` flag.
  */
-export function createProjectScopedRoutes() {
+export function createProjectScopedRoutes({ prefsDir = null } = {}) {
   const router = Router({ mergeParams: true });
+  const prefsPath = prefsDir ? join(prefsDir, 'preferences.json') : null;
 
   // Guard: run-related, cost, and pipeline routes require worcaDir
   function requireWorcaDir(req, res, next) {
@@ -1213,10 +1315,35 @@ export function createProjectScopedRoutes() {
     res.json({ ok: true, templates });
   });
 
-  // GET /api/projects/:projectId/worca-status — check worca installation state
-  router.get('/worca-status', (req, res) => {
-    const installed = checkWorcaInstalled(req.project.projectRoot);
-    res.json({ ok: true, installed });
+  // GET /api/projects/:projectId/worca-status — check worca installation state.
+  // `outdated` is true when the project's installed worca-cc version is
+  // strictly behind the active (dev-path or globally-installed) worca-cc.
+  router.get('/worca-status', async (req, res) => {
+    const { projectRoot } = req.project;
+    const installed = checkWorcaInstalled(projectRoot);
+    if (!installed) {
+      return res.json({
+        ok: true,
+        installed: false,
+        version: null,
+        outdated: false,
+      });
+    }
+    const version = readProjectWorcaVersion(projectRoot);
+    let outdated = false;
+    if (version != null) {
+      try {
+        const versionInfo = await getVersionInfo({
+          prefsPath,
+          worcaVersion: req.app.locals.worcaVersion || null,
+        });
+        outdated = isVersionBehind(version, versionInfo.activeWorcaCc);
+      } catch {
+        // Best-effort — if version lookup fails, treat as not outdated
+        outdated = false;
+      }
+    }
+    res.json({ ok: true, installed: true, version, outdated });
   });
 
   // POST /api/projects/:projectId/worca-setup — install or update worca

package/server/settings-validator.js

@@ -323,8 +323,35 @@ export function validateSettingsPayload(body) {
                 continue;
               }
               for (const v of val) {
-                if (!VALID_AGENTS.includes(v)) {
-                  details.push(`Unknown agent "${v}" in dispatch for "${key}"`);
+                if (typeof v !== 'string') {
+                  details.push(`Dispatch entry for "${key}" must be a string`);
+                }
+              }
+            }
+          }
+        }
+        if (g.subagent_dispatch !== undefined) {
+          if (
+            typeof g.subagent_dispatch !== 'object' ||
+            g.subagent_dispatch === null ||
+            Array.isArray(g.subagent_dispatch)
+          ) {
+            details.push('governance.subagent_dispatch must be an object');
+          } else {
+            for (const [key, val] of Object.entries(g.subagent_dispatch)) {
+              if (!VALID_AGENTS.includes(key)) {
+                details.push(`Unknown subagent_dispatch agent: "${key}"`);
+                continue;
+              }
+              if (!Array.isArray(val)) {
+                details.push(`subagent_dispatch for "${key}" must be an array`);
+                continue;
+              }
+              for (const v of val) {
+                if (typeof v !== 'string') {
+                  details.push(
+                    `subagent_dispatch entry for "${key}" must be a string`,
+                  );
                 }
               }
             }

package/server/subagents-discovery.js

@@ -0,0 +1,116 @@
+/**
+ * Subagent discovery for the settings dispatch-rule editor.
+ *
+ * Walks three sources (built-ins, user-global, plugin cache) and returns a
+ * deduplicated list matching the shape used by `worca-ui/app/views/
+ * dispatch-tag-state.js` (`{name, label, group}`).
+ *
+ * The three sources:
+ *   1. Built-ins — hardcoded Claude Code types that are not on disk.
+ *   2. User — `<userDir>/*.md`, one file per subagent.
+ *   3. Plugins — `<pluginCacheDir>/<marketplace>/<plugin>/<version>/agents/*.md`.
+ *      Deduped by the qualified name `<plugin>:<agent>` — first file wins
+ *      across versions (the set of agents within a plugin is stable in
+ *      practice; when two versions disagree we prefer filesystem order for
+ *      determinism rather than trying to parse semver from directory names).
+ */
+
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { basename, join } from 'node:path';
+
+// Built-in Claude Code subagents — shipped with a factory CC install, no
+// plugins required. Mirror this list in worca-ui/app/views/
+// dispatch-tag-state.js (KNOWN_TYPES) so the UI falls back to the same set
+// when the /api/subagents fetch fails.
+export const BUILTINS = [
+  { name: 'Explore', label: '(built-in)', group: 'Built-in' },
+  { name: 'general-purpose', label: '(built-in)', group: 'Built-in' },
+  { name: 'Plan', label: '(built-in)', group: 'Built-in' },
+  { name: 'statusline-setup', label: '(built-in)', group: 'Built-in' },
+  { name: 'claude-code-guide', label: '(built-in)', group: 'Built-in' },
+];
+
+function listMarkdownBasenames(dir) {
+  if (!dir || !existsSync(dir)) return [];
+  try {
+    return readdirSync(dir)
+      .filter((n) => n.endsWith('.md'))
+      .map((n) => basename(n, '.md'));
+  } catch {
+    return [];
+  }
+}
+
+function listSubdirs(dir) {
+  if (!existsSync(dir)) return [];
+  try {
+    return readdirSync(dir).filter((n) => {
+      try {
+        return statSync(join(dir, n)).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Discover all subagent types reachable from the given directories.
+ *
+ * @param {object} options
+ * @param {Array<{name:string,label:string,group:string}>} [options.builtins]
+ * @param {string} [options.userDir]           e.g. ~/.claude/agents
+ * @param {string} [options.pluginCacheDir]    e.g. ~/.claude/plugins/cache
+ * @param {string} [options.projectAgentsDir]  e.g. <project>/.claude/agents
+ * @returns {Array<{name:string,label:string,group:string}>}
+ */
+export function discoverSubagents({
+  builtins = BUILTINS,
+  userDir,
+  pluginCacheDir,
+  projectAgentsDir,
+} = {}) {
+  const result = [...builtins];
+  const seen = new Set(result.map((t) => t.name));
+
+  for (const name of listMarkdownBasenames(userDir)) {
+    if (!seen.has(name)) {
+      seen.add(name);
+      result.push({ name, label: '(user)', group: 'User' });
+    }
+  }
+
+  if (pluginCacheDir && existsSync(pluginCacheDir)) {
+    for (const marketplace of listSubdirs(pluginCacheDir)) {
+      const marketplaceDir = join(pluginCacheDir, marketplace);
+      for (const plugin of listSubdirs(marketplaceDir)) {
+        const pluginDir = join(marketplaceDir, plugin);
+        for (const version of listSubdirs(pluginDir)) {
+          const agentsDir = join(pluginDir, version, 'agents');
+          for (const agent of listMarkdownBasenames(agentsDir)) {
+            const qualified = `${plugin}:${agent}`;
+            if (!seen.has(qualified)) {
+              seen.add(qualified);
+              result.push({
+                name: qualified,
+                label: '(plugin)',
+                group: 'Plugin',
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+
+  for (const name of listMarkdownBasenames(projectAgentsDir)) {
+    if (!seen.has(name)) {
+      seen.add(name);
+      result.push({ name, label: '(project)', group: 'Project' });
+    }
+  }
+
+  return result;
+}

package/server/version-check.js

@@ -40,6 +40,41 @@ export function meetsMinimum(installed, minimum) {
   return true; // equal
 }
 
+/**
+ * Parse a version string into comparable parts, tracking RC suffixes.
+ * "0.6.0rc7" → { parts: [0, 6, 0], rc: 7 }
+ * "0.6.0"    → { parts: [0, 6, 0], rc: Infinity } (stable > any rc)
+ * "0.1.0-rc.5" → { parts: [0, 1, 0], rc: 5 }
+ */
+export function parseVersion(v) {
+  if (!v) return { parts: [], rc: Infinity };
+  const rcMatch = v.match(/^(.+?)[-.]?rc\.?(\d+)$/);
+  const base = rcMatch ? rcMatch[1] : v;
+  const rc = rcMatch ? parseInt(rcMatch[2], 10) : Infinity;
+  const parts = base.split('.').map((s) => parseInt(s, 10) || 0);
+  return { parts, rc };
+}
+
+/**
+ * Returns true if `project` version is strictly behind `active`.
+ * RC-aware: "0.6.0rc3" is behind "0.6.0". Returns false if either arg is falsy.
+ */
+export function isVersionBehind(project, active) {
+  if (!project || !active) return false;
+  const p = parseVersion(project);
+  const a = parseVersion(active);
+  const len = Math.max(p.parts.length, a.parts.length);
+  for (let i = 0; i < len; i++) {
+    const pv = p.parts[i] || 0;
+    const av = a.parts[i] || 0;
+    if (pv < av) return true;
+    if (pv > av) return false;
+  }
+  // Same base version — compare RC numbers
+  if (p.rc < a.rc) return true;
+  return false;
+}
+
 /**
  * Run `worca --version` and check compatibility.
  * @returns {Promise<{ok: boolean, installed: string|null, minimum: string, message: string}>}

package/server/watcher.js

@@ -2,6 +2,25 @@ import { createHash } from 'node:crypto';
 import { existsSync, readdirSync, readFileSync, watch } from 'node:fs';
 import { readdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import {
+  assignEventsToIterations,
+  readDispatchEventsFromJsonl,
+} from './dispatch-events-aggregator.js';
+
+/**
+ * Enrich a status object with dispatch events read from events.jsonl in the
+ * same run directory. Mutates `status.stages` by adding `dispatch_events` to
+ * matching iterations. No-op when events.jsonl is missing (e.g. a run that
+ * started before the emit was wired, or a run with no dispatches).
+ */
+function enrichWithDispatchEvents(status, runDir) {
+  if (!status?.stages) return status;
+  const eventsPath = join(runDir, 'events.jsonl');
+  const events = readDispatchEventsFromJsonl(eventsPath);
+  if (events.length === 0) return status;
+  status.stages = assignEventsToIterations(events, status.stages);
+  return status;
+}
 
 export function createRunId(status) {
   // Prefer run_id from status (new per-run format)
@@ -35,9 +54,11 @@ export function discoverRuns(worcaDir) {
   if (existsSync(activeRunPath)) {
     try {
       const activeId = readFileSync(activeRunPath, 'utf8').trim();
-      const candidate = join(worcaDir, 'runs', activeId, 'status.json');
+      const runDir = join(worcaDir, 'runs', activeId);
+      const candidate = join(runDir, 'status.json');
       if (existsSync(candidate)) {
-        const status = JSON.parse(readFileSync(candidate, 'utf8'));
+        let status = JSON.parse(readFileSync(candidate, 'utf8'));
+        status = enrichWithDispatchEvents(status, runDir);
         const active =
           !isTerminal(status) && status.pipeline_status === 'running';
         const id = createRunId(status);
@@ -53,10 +74,12 @@ export function discoverRuns(worcaDir) {
   const runsDir = join(worcaDir, 'runs');
   if (existsSync(runsDir)) {
     for (const entry of readdirSync(runsDir)) {
-      const statusPath = join(runsDir, entry, 'status.json');
+      const runDir = join(runsDir, entry);
+      const statusPath = join(runDir, 'status.json');
       if (!existsSync(statusPath)) continue;
       try {
-        const status = JSON.parse(readFileSync(statusPath, 'utf8'));
+        let status = JSON.parse(readFileSync(statusPath, 'utf8'));
+        status = enrichWithDispatchEvents(status, runDir);
         const id = createRunId(status);
         if (seenIds.has(id)) continue;
         seenIds.add(id);
@@ -140,8 +163,10 @@ export async function discoverRunsAsync(worcaDir) {
   const activeRunPath = join(worcaDir, 'active_run');
   try {
     const activeId = (await readFile(activeRunPath, 'utf8')).trim();
-    const candidate = join(worcaDir, 'runs', activeId, 'status.json');
-    const status = JSON.parse(await readFile(candidate, 'utf8'));
+    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 });
@@ -156,15 +181,17 @@ export async function discoverRunsAsync(worcaDir) {
     const entries = await readdir(runsDir);
     const readPromises = entries.map(async (entry) => {
       try {
-        const statusPath = join(runsDir, entry, 'status.json');
+        const runDir = join(runsDir, entry);
+        const statusPath = join(runDir, 'status.json');
         const status = JSON.parse(await readFile(statusPath, 'utf8'));
-        return status;
+        return { status, runDir };
       } catch {
         return null;
       }
     });
-    for (const status of await Promise.all(readPromises)) {
-      if (!status) continue;
+    for (const result of await Promise.all(readPromises)) {
+      if (!result) continue;
+      const status = enrichWithDispatchEvents(result.status, result.runDir);
       const id = createRunId(status);
       if (seenIds.has(id)) continue;
       seenIds.add(id);

package/server/worca-setup.js

@@ -20,10 +20,24 @@ export function checkWorcaInstalled(projectPath) {
 }
 
 /**
- * Read the worca-cc version from a project's .claude/worca/__init__.py.
+ * Read the worca-cc version from a project's worca installation.
+ * Tries .claude/worca/version.json first, then falls back to __init__.py.
  * Returns the version string or null if not found.
  */
 export function readProjectWorcaVersion(projectPath) {
+  // Try version.json first (preferred format)
+  try {
+    const versionJson = JSON.parse(
+      readFileSync(
+        join(projectPath, '.claude', 'worca', 'version.json'),
+        'utf8',
+      ),
+    );
+    if (versionJson.version) return versionJson.version;
+  } catch {
+    // fall through to __init__.py
+  }
+  // Fall back to __init__.py
   try {
     const initPy = readFileSync(
       join(projectPath, '.claude', 'worca', '__init__.py'),

package/server/ws-modular.js

@@ -11,6 +11,7 @@ import { join } from 'node:path';
 import { WebSocketServer } from 'ws';
 import { readProjects, synthesizeDefaultProject } from './project-registry.js';
 import { TIER_FULL, TIER_POLLING, WatcherSet } from './watcher-set.js';
+import { readProjectWorcaVersion } from './worca-setup.js';
 import { createBroadcaster } from './ws-broadcaster.js';
 import { createClientManager } from './ws-client-manager.js';
 import { createMessageRouter } from './ws-message-router.js';
@@ -157,9 +158,12 @@ export function attachWsServer(httpServer, config) {
     }
 
     // Broadcast projects-updated to all clients
+    // Shape must match GET /api/projects so frontend state stays consistent
+    // (include worcaVersion — without it, clients would show "unknown" after
+    // the WS event clobbers the enriched REST response on add/remove)
     const projectList = freshProjects.map((p) => ({
-      name: p.name,
-      path: p.path,
+      ...p,
+      worcaVersion: readProjectWorcaVersion(p.path),
     }));
     broadcaster.broadcast('projects-updated', { projects: projectList });
   }