@worca/ui 0.16.0 → 0.18.0

package/app/styles.css

@@ -3415,6 +3415,27 @@ sl-details.learnings-panel::part(content) {
   margin: 8px 0 4px;
 }
 
+.pr-verification-banner {
+  margin: 8px 0 4px;
+}
+
+.pr-verified-row {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin-top: 6px;
+  font-size: 13px;
+}
+
+.pr-verified-row .meta-label {
+  color: var(--muted);
+}
+
+.pr-verified-badge {
+  display: inline-flex;
+  align-items: center;
+}
+
 .classification-strip {
   margin-top: 10px;
   padding: 8px 10px;

package/bin/worca-ui.js

@@ -113,6 +113,23 @@ export function parseArgs(argv) {
   return args;
 }
 
+/** Build the argv array for spawning server/index.js. Exported for testing. */
+export function buildSpawnArgs({
+  serverScript,
+  port,
+  host,
+  isGlobal,
+  projectPath,
+}) {
+  const args = [serverScript, '--port', String(port), '--host', host];
+  if (isGlobal) {
+    args.push('--global');
+  } else if (projectPath) {
+    args.push('--project', projectPath);
+  }
+  return args;
+}
+
 /** Resolve log file path based on mode (mirrors PID file location). */
 function resolveLogPath(isGlobal) {
   if (isGlobal) {
@@ -242,7 +259,7 @@ function describePortOccupant(port) {
   return null;
 }
 
-async function start({ port, host, open, global: isGlobal }) {
+async function start({ port, host, open, global: isGlobal, projectPath }) {
   const { pidDir, pidFile } = resolvePidPaths(isGlobal);
 
   const existing = readPidFile(pidFile);
@@ -281,16 +298,13 @@ async function start({ port, host, open, global: isGlobal }) {
     }
   }
 
-  const spawnArgs = [
-    SERVER_SCRIPT,
-    '--port',
-    String(availablePort),
-    '--host',
+  const spawnArgs = buildSpawnArgs({
+    serverScript: SERVER_SCRIPT,
+    port: availablePort,
     host,
-  ];
-  if (isGlobal) {
-    spawnArgs.push('--global');
-  }
+    isGlobal,
+    projectPath,
+  });
 
   // Capture child stdout+stderr to a log file so startup crashes are visible.
   // Without this, errors thrown during module load (missing files, bad imports,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@worca/ui",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "description": "Pipeline monitoring UI for worca-cc",
   "license": "MIT",
   "author": "Sinisha Djukic",
@@ -50,6 +50,7 @@
     "prepublishOnly": "npm run build && npm test",
     "test": "vitest run",
     "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
     "test:browser": "playwright test",
     "test:browser:ui": "playwright test --ui",
     "lint": "biome check",
@@ -70,6 +71,7 @@
   "devDependencies": {
     "@biomejs/biome": "^2.2.4",
     "@playwright/test": "^1.58.2",
+    "@vitest/coverage-v8": "^4.0.15",
     "esbuild": "^0.27.1",
     "jsdom": "^29.0.1",
     "vitest": "^4.0.15"

package/server/argv-parser.js

@@ -0,0 +1,28 @@
+/**
+ * Parse server startup arguments from an argv array.
+ * Returns { port, host, isGlobal, projectPath }.
+ * Pass defaults to seed port/host from env vars before argv overrides them.
+ */
+export function parseServerArgv(argv, defaults = {}) {
+  let port = defaults.port ?? 3400;
+  let host = defaults.host ?? '127.0.0.1';
+  let isGlobal = true;
+  let projectPath = null;
+
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === '--port' && argv[i + 1]) {
+      port = parseInt(argv[++i], 10);
+    } else if (argv[i] === '--host' && argv[i + 1]) {
+      host = argv[++i];
+    } else if (argv[i] === '--global') {
+      isGlobal = true;
+    } else if (argv[i] === '--project') {
+      isGlobal = false;
+      if (argv[i + 1] && !argv[i + 1].startsWith('-')) {
+        projectPath = argv[++i];
+      }
+    }
+  }
+
+  return { port, host, isGlobal, projectPath };
+}

package/server/index.js

@@ -4,21 +4,20 @@ import { createServer } from 'node:http';
 import { homedir, platform } from 'node:os';
 import { join } from 'node:path';
 import { createApp } from './app.js';
+import { parseServerArgv } from './argv-parser.js';
 import { createIntegrations } from './integrations/index.js';
 import { attachWsServer } from './ws.js';
 
-// Parse argv
-let port = parseInt(process.env.PORT, 10) || 3400;
-let host = process.env.HOST || '127.0.0.1';
-let isGlobal = true;
-for (let i = 0; i < process.argv.length; i++) {
-  if (process.argv[i] === '--port' && process.argv[i + 1])
-    port = parseInt(process.argv[++i], 10);
-  if (process.argv[i] === '--host' && process.argv[i + 1])
-    host = process.argv[++i];
-  if (process.argv[i] === '--global') isGlobal = true;
-  if (process.argv[i] === '--project') isGlobal = false;
-}
+// Parse argv (env vars provide defaults; argv flags take precedence)
+const {
+  port,
+  host,
+  isGlobal,
+  projectPath: explicitProjectPath,
+} = parseServerArgv(process.argv, {
+  port: parseInt(process.env.PORT, 10) || 3400,
+  host: process.env.HOST || '127.0.0.1',
+});
 
 // Resolve project root: walk up from cwd until we find .claude/settings.json
 import { existsSync } from 'node:fs';
@@ -44,8 +43,8 @@ if (isGlobal) {
   worcaDir = null;
   settingsPath = null;
 } else {
-  // Per-project mode: resolve from cwd
-  projectRoot = findProjectRoot(process.cwd());
+  // Per-project mode: use explicit path when provided, otherwise walk up from cwd
+  projectRoot = explicitProjectPath ?? findProjectRoot(process.cwd());
   worcaDir = join(projectRoot, '.worca');
   settingsPath = join(projectRoot, '.claude', 'settings.json');
 }

package/server/process-manager.js

@@ -201,12 +201,48 @@ export class ProcessManager {
       }
     }
 
+    // Also scan pipelines.d/ for worktree PIDs (worktree runs never appear in runs/)
+    const pipelinesDir = join(this.worcaDir, 'multi', 'pipelines.d');
+    if (existsSync(pipelinesDir)) {
+      try {
+        for (const entry of readdirSync(pipelinesDir)) {
+          if (!entry.endsWith('.json')) continue;
+          const runId = entry.slice(0, -5);
+          try {
+            const reg = JSON.parse(
+              readFileSync(join(pipelinesDir, entry), 'utf8'),
+            );
+            if (reg.worktree_path) {
+              const wtPidPath = join(
+                reg.worktree_path,
+                '.worca',
+                'runs',
+                runId,
+                'pipeline.pid',
+              );
+              if (existsSync(wtPidPath)) runIds.add(runId);
+            }
+          } catch {
+            /* ignore malformed registry entry */
+          }
+        }
+      } catch {
+        /* ignore */
+      }
+    }
+
     for (const runId of runIds) {
       // Check if this run's process is alive
       const alive = this.getRunningPid(runId);
       if (alive) continue;
 
-      const statusPath = join(this.worcaDir, 'runs', runId, 'status.json');
+      // Route all paths through resolveRunContext so worktree runs use
+      // their worktree dir rather than the project-root runs/ dir.
+      const ctx = this.resolveRunContext(runId);
+      if (!ctx) continue;
+      const { runDir } = ctx;
+
+      const statusPath = join(runDir, 'status.json');
       if (!existsSync(statusPath)) continue;
 
       let status;
@@ -236,7 +272,7 @@ export class ProcessManager {
 
       // Append synthetic terminal event if none exists yet.
       // Use pipeline.run.interrupted for signal-killed runs, pipeline.run.failed otherwise.
-      const eventsPath = join(this.worcaDir, 'runs', runId, 'events.jsonl');
+      const eventsPath = join(runDir, 'events.jsonl');
       let hasTerminalEvent = false;
       if (existsSync(eventsPath)) {
         try {
@@ -269,7 +305,7 @@ export class ProcessManager {
         if (this.settingsPath) {
           dispatches.push(
             dispatchExternal({
-              runDir: join(this.worcaDir, 'runs', runId),
+              runDir,
               settingsPath: this.settingsPath,
               eventType,
               payload,
@@ -744,7 +780,9 @@ export class ProcessManager {
    * @param {string} runId
    */
   _killAgentSubprocess(runId) {
-    const pidPath = join(this.worcaDir, 'runs', runId, 'agent.pid');
+    const ctx = this.resolveRunContext(runId);
+    const runDir = ctx ? ctx.runDir : join(this.worcaDir, 'runs', runId);
+    const pidPath = join(runDir, 'agent.pid');
     if (!existsSync(pidPath)) return;
     try {
       const agentPid = parseInt(readFileSync(pidPath, 'utf8').trim(), 10);

package/server/ws-message-router.js

@@ -158,6 +158,7 @@ export function createMessageRouter({
       }
       const agentName = run.stages?.[stage]?.agent || stage;
       const effectiveRunId = run.run_id || runId;
+      const effectiveWorcaDir = run.worktree_worca_dir || proj.worcaDir;
 
       const iterations = run.stages?.[stage]?.iterations || [];
       const iterationPrompts = iterations.map((iter, idx) => {
@@ -189,7 +190,7 @@ export function createMessageRouter({
         const iterNum = iter.number ?? 0;
         const resolvedCandidates = [
           join(
-            proj.worcaDir,
+            effectiveWorcaDir,
             'runs',
             effectiveRunId,
             'agents',
@@ -197,7 +198,7 @@ export function createMessageRouter({
             `${stage}-${agentName}-iter-${iterNum}.md`,
           ),
           join(
-            proj.worcaDir,
+            effectiveWorcaDir,
             'results',
             effectiveRunId,
             'agents',
@@ -206,7 +207,7 @@ export function createMessageRouter({
           ),
           // Fallback for early W-037 runs without stage prefix
           join(
-            proj.worcaDir,
+            effectiveWorcaDir,
             'runs',
             effectiveRunId,
             'agents',
@@ -214,7 +215,7 @@ export function createMessageRouter({
             `${agentName}-iter-${iterNum}.md`,
           ),
           join(
-            proj.worcaDir,
+            effectiveWorcaDir,
             'results',
             effectiveRunId,
             'agents',
@@ -241,14 +242,14 @@ export function createMessageRouter({
       if (!resolvedPrompt) {
         const templateCandidates = [
           join(
-            proj.worcaDir,
+            effectiveWorcaDir,
             'runs',
             effectiveRunId,
             'agents',
             `${agentName}.md`,
           ),
           join(
-            proj.worcaDir,
+            effectiveWorcaDir,
             'results',
             effectiveRunId,
             'agents',

package/server/ws-status-watcher.js

@@ -37,9 +37,11 @@ const TERMINAL_STATUSES = new Set([
  * @returns {string}
  */
 export function resolveLatestRunDir(worcaDir) {
+  // Collect (runId → runDir) for all live runs from local runs/ and worktree pipelines.d/
+  const liveRuns = new Map();
+
   const runsDir = join(worcaDir, 'runs');
   if (existsSync(runsDir)) {
-    let latest = null;
     try {
       for (const entry of readdirSync(runsDir, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
@@ -49,7 +51,36 @@ export function resolveLatestRunDir(worcaDir) {
           const pid = parseInt(readFileSync(pidPath, 'utf8').trim(), 10);
           if (!Number.isNaN(pid) && pid > 0) {
             process.kill(pid, 0); // throws if dead
-            if (!latest || entry.name > latest) latest = entry.name;
+            liveRuns.set(entry.name, join(runsDir, entry.name));
+          }
+        } catch {
+          /* dead process or invalid PID */
+        }
+      }
+    } catch {
+      /* ignore */
+    }
+  }
+
+  // Also scan pipelines.d/ for worktree PIDs (worktree runs never appear in runs/)
+  const pipelinesDir = join(worcaDir, 'multi', 'pipelines.d');
+  if (existsSync(pipelinesDir)) {
+    try {
+      for (const entry of readdirSync(pipelinesDir)) {
+        if (!entry.endsWith('.json')) continue;
+        const runId = entry.slice(0, -5);
+        try {
+          const reg = JSON.parse(
+            readFileSync(join(pipelinesDir, entry), 'utf8'),
+          );
+          if (!reg.worktree_path) continue;
+          const wtRunDir = join(reg.worktree_path, '.worca', 'runs', runId);
+          const pidPath = join(wtRunDir, 'pipeline.pid');
+          if (!existsSync(pidPath)) continue;
+          const pid = parseInt(readFileSync(pidPath, 'utf8').trim(), 10);
+          if (!Number.isNaN(pid) && pid > 0) {
+            process.kill(pid, 0); // throws if dead
+            liveRuns.set(runId, wtRunDir);
           }
         } catch {
           /* dead process or invalid PID */
@@ -58,9 +89,16 @@ export function resolveLatestRunDir(worcaDir) {
     } catch {
       /* ignore */
     }
-    if (latest) return join(runsDir, latest);
   }
-  return worcaDir; // legacy fallback
+
+  if (liveRuns.size === 0) return worcaDir; // legacy fallback
+
+  // Return the runDir of the latest (alphabetically largest) live run ID
+  let latestId = null;
+  for (const id of liveRuns.keys()) {
+    if (!latestId || id > latestId) latestId = id;
+  }
+  return liveRuns.get(latestId);
 }
 
 /**