@worca/ui 0.9.0-rc.4 → 0.9.0-rc.6

package/app/styles.css

@@ -22,9 +22,9 @@
   --status-paused: #f59e0b;
   --status-completed: #22c55e;
   --status-failed: #ef4444;
-  --status-resuming: #3b82f6;
   --status-skipped: #94a3b8;
   --status-interrupted: #f59e0b;
+  --status-cancelled: #94a3b8;
   /* legacy */
   --status-in-progress: #3b82f6;
   --status-error: #ef4444;
@@ -1125,8 +1125,8 @@ sl-details.log-history-panel::part(content) {
   color: var(--status-failed);
 }
 
-.status-resuming {
-  color: var(--status-resuming);
+.status-cancelled {
+  color: var(--status-cancelled);
 }
 
 /* --- 18b. Control Buttons --- */
@@ -1281,11 +1281,11 @@ sl-details.log-history-panel::part(content) {
 
 /* Status-colored left border accent on run cards */
 .run-card.status-running  { border-left: 3px solid var(--status-running); }
-.run-card.status-resuming { border-left: 3px solid var(--status-resuming); }
 .run-card.status-paused   { border-left: 3px solid var(--status-paused); }
 .run-card.status-completed { border-left: 3px solid var(--status-completed); }
 .run-card.status-failed   { border-left: 3px solid var(--status-failed); }
 .run-card.status-pending  { border-left: 3px solid var(--status-pending); }
+.run-card.status-cancelled { border-left: 3px solid var(--status-cancelled); }
 
 /* --- 21. Dashboard --- */
 .dashboard {
@@ -3991,6 +3991,7 @@ sl-details.learnings-panel::part(content) {
 .pipeline-succeeded { border-left-color: var(--status-completed); }
 .pipeline-failed { border-left-color: var(--status-failed); }
 .pipeline-paused { border-left-color: var(--status-paused); }
+.pipeline-cancelled { border-left-color: var(--status-cancelled); }
 .pipeline-unknown { border-left-color: var(--muted); }
 
 .pipeline-card-header {

package/app/utils/state-actions.js

@@ -0,0 +1,55 @@
+export const STATES = [
+  'pending',
+  'running',
+  'paused',
+  'completed',
+  'failed',
+  'interrupted',
+  'cancelled',
+];
+
+const ACTION_MATRIX = {
+  stop: { running: true },
+  pause: { running: true },
+  resume: { paused: true, failed: true, interrupted: true },
+  cancel: {
+    pending: true,
+    running: true,
+    paused: true,
+    failed: true,
+    interrupted: true,
+  },
+  archive: {
+    pending: true,
+    paused: true,
+    completed: true,
+    failed: true,
+    interrupted: true,
+    cancelled: true,
+  },
+  unarchive: {
+    completed: true,
+    failed: true,
+    interrupted: true,
+    cancelled: true,
+  },
+  delete: {
+    pending: true,
+    paused: true,
+    completed: true,
+    failed: true,
+    interrupted: true,
+    cancelled: true,
+  },
+  learn: {
+    paused: true,
+    completed: true,
+    failed: true,
+    interrupted: true,
+    cancelled: true,
+  },
+};
+
+export function actionAllowed(action, status) {
+  return Boolean(ACTION_MATRIX[action]?.[status]);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@worca/ui",
-  "version": "0.9.0-rc.4",
+  "version": "0.9.0-rc.6",
   "description": "Pipeline monitoring UI for worca-cc",
   "license": "MIT",
   "author": "Sinisha Djukic",
@@ -35,6 +35,7 @@
     "app/vendor/",
     "app/protocol.js",
     "app/utils/stage-order.js",
+    "app/utils/state-actions.js",
     "scripts/build-frontend.js"
   ],
   "engines": {

package/server/app.js

@@ -20,6 +20,7 @@ import {
 } from './project-routes.js';
 import { validateIntegrationsConfig } from './settings-validator.js';
 import { discoverSubagents } from './subagents-discovery.js';
+import { checkWorcaVersion } from './version-check.js';
 import { getVersionInfo } from './versions.js';
 import { createInbox } from './webhook-inbox.js';
 
@@ -105,6 +106,7 @@ export function createApp(options = {}) {
           ? new ProcessManager({
               worcaDir,
               projectRoot: projectRoot || process.cwd(),
+              settingsPath,
             })
           : null,
       };
@@ -502,6 +504,10 @@ export function createApp(options = {}) {
   app.get('/api/versions', async (req, res) => {
     const force = req.query.force === '1';
     const prefsPath = prefsDir ? join(prefsDir, 'preferences.json') : null;
+    // Re-check installed worca-cc version on force refresh
+    if (force) {
+      app.locals.worcaVersion = await checkWorcaVersion();
+    }
     const worcaVersion = app.locals.worcaVersion || null;
     try {
       const data = await getVersionInfo({ prefsPath, worcaVersion, force });

package/server/beads-reader.js

@@ -5,7 +5,7 @@ import { promisify } from 'node:util';
 const execFileAsync = promisify(execFile);
 
 async function runBd(args, dbPath) {
-  const fullArgs = [...args, '--json', '--db', dbPath, '--readonly'];
+  const fullArgs = [...args, '--json', '--db', dbPath];
   const { stdout } = await execFileAsync('bd', fullArgs, {
     encoding: 'utf8',
     timeout: 10000,

package/server/dispatch-external.js

@@ -0,0 +1,106 @@
+import { spawn } from 'node:child_process';
+
+const DEFAULT_TIMEOUT_MS = 30_000;
+
+export function resolvePythonCmd() {
+  if (process.env.WORCA_PYTHON) {
+    return [process.env.WORCA_PYTHON];
+  }
+  if (process.platform === 'win32') {
+    return ['py', 'python3', 'python'];
+  }
+  return ['python3', 'python'];
+}
+
+export function dispatchExternal({
+  runDir,
+  settingsPath,
+  eventType,
+  payload,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+}) {
+  const candidates = resolvePythonCmd();
+  const args = [
+    '-m',
+    'worca.events.dispatch_external',
+    '--run-dir',
+    runDir,
+    '--settings',
+    settingsPath,
+    '--event-type',
+    eventType,
+    '--payload-json',
+    JSON.stringify(payload),
+  ];
+
+  let candidateIdx = 0;
+
+  function trySpawn(resolve) {
+    if (candidateIdx >= candidates.length) {
+      resolve({ ok: false, reason: 'python_not_found' });
+      return;
+    }
+
+    const cmd = candidates[candidateIdx];
+    const spawnArgs = cmd === 'py' ? ['-3', ...args] : args;
+
+    const child = spawn(cmd, spawnArgs, { stdio: ['ignore', 'pipe', 'pipe'] });
+
+    let stdoutBuf = '';
+    let stderrBuf = '';
+    let settled = false;
+
+    const timer = setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        child.kill();
+        resolve({ ok: false, reason: 'timeout' });
+      }
+    }, timeoutMs);
+
+    child.stdout.on('data', (chunk) => {
+      stdoutBuf += chunk;
+    });
+    child.stderr.on('data', (chunk) => {
+      stderrBuf += chunk;
+    });
+
+    child.on('error', (err) => {
+      if (!settled && err.code === 'ENOENT') {
+        clearTimeout(timer);
+        candidateIdx++;
+        trySpawn(resolve);
+        return;
+      }
+      if (!settled) {
+        settled = true;
+        clearTimeout(timer);
+        resolve({ ok: false, reason: 'spawn_error', stderr: err.message });
+      }
+    });
+
+    child.on('close', (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+
+      if (code !== 0) {
+        resolve({
+          ok: false,
+          reason: `exit_code_${code}`,
+          stderr: stderrBuf,
+        });
+        return;
+      }
+
+      try {
+        const parsed = JSON.parse(stdoutBuf);
+        resolve(parsed);
+      } catch {
+        resolve({ ok: false, reason: 'invalid_response', stdout: stdoutBuf });
+      }
+    });
+  }
+
+  return new Promise((resolve) => trySpawn(resolve));
+}

package/server/process-manager.js

@@ -13,12 +13,15 @@ import {
   openSync,
   readdirSync,
   readFileSync,
+  rmSync,
   unlinkSync,
   writeFileSync,
   writeSync,
 } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
+
+import { dispatchExternal } from './dispatch-external.js';
 
 /** Byte threshold — must match claude_cli.py _ARG_INLINE_LIMIT */
 const ARG_INLINE_LIMIT = 128 * 1024;
@@ -73,11 +76,12 @@ function cleanupPromptFile(filePath) {
  */
 export class ProcessManager {
   /**
-   * @param {{ worcaDir: string, projectRoot?: string }} options
+   * @param {{ worcaDir: string, projectRoot?: string, settingsPath?: string }} options
    */
-  constructor({ worcaDir, projectRoot }) {
+  constructor({ worcaDir, projectRoot, settingsPath }) {
     this.worcaDir = worcaDir;
     this.projectRoot = projectRoot || process.cwd();
+    this.settingsPath = settingsPath ?? null;
   }
 
   /**
@@ -128,8 +132,9 @@ export class ProcessManager {
    *
    * @returns {boolean} true if any status was fixed
    */
-  reconcileStatus() {
+  async reconcileStatus() {
     let fixed = false;
+    const dispatches = [];
 
     // Collect run IDs to check: scan runs/*/pipeline.pid + active_run fallback
     const runIds = new Set();
@@ -180,8 +185,7 @@ export class ProcessManager {
       if (!status.stop_reason) {
         status.stop_reason = 'stale';
       }
-      status.pipeline_status =
-        status.stop_reason === 'stale' ? 'interrupted' : 'failed';
+      status.pipeline_status = 'failed';
       try {
         writeFileSync(
           statusPath,
@@ -193,7 +197,8 @@ export class ProcessManager {
         /* ignore */
       }
 
-      // Append synthetic interrupted event if no terminal event exists yet
+      // Append synthetic failed event if no terminal event exists yet.
+      // Status is "failed" (process crash), so the event type must match.
       const eventsPath = join(this.worcaDir, 'runs', runId, 'events.jsonl');
       let hasTerminalEvent = false;
       if (existsSync(eventsPath)) {
@@ -214,30 +219,44 @@ export class ProcessManager {
         }
       }
       if (!hasTerminalEvent) {
-        try {
-          const evt = {
-            schema_version: '1',
-            event_id: randomUUID(),
-            event_type: 'pipeline.run.interrupted',
-            timestamp: new Date().toISOString(),
-            run_id: status.run_id ?? runId,
-            pipeline: {
-              branch: status.branch ?? null,
-              work_request: status.work_request ?? null,
-            },
-            payload: {
-              interrupted_stage: status.current_stage ?? 'unknown',
-              elapsed_ms: elapsedMsSince(status.started_at),
-              source: 'reconcile',
-            },
-          };
-          appendFileSync(eventsPath, `${JSON.stringify(evt)}\n`, 'utf8');
-        } catch {
-          /* ignore */
+        const payload = {
+          failed_stage: status.current_stage ?? 'unknown',
+          elapsed_ms: elapsedMsSince(status.started_at),
+          source: 'stale',
+        };
+
+        if (this.settingsPath) {
+          dispatches.push(
+            dispatchExternal({
+              runDir: join(this.worcaDir, 'runs', runId),
+              settingsPath: this.settingsPath,
+              eventType: 'pipeline.run.failed',
+              payload,
+            }).catch(() => {}),
+          );
+        } else {
+          try {
+            const evt = {
+              schema_version: '1',
+              event_id: randomUUID(),
+              event_type: 'pipeline.run.failed',
+              timestamp: new Date().toISOString(),
+              run_id: status.run_id ?? runId,
+              pipeline: {
+                branch: status.branch ?? null,
+                work_request: status.work_request ?? null,
+              },
+              payload: { ...payload, source: 'reconcile' },
+            };
+            appendFileSync(eventsPath, `${JSON.stringify(evt)}\n`, 'utf8');
+          } catch {
+            /* ignore */
+          }
         }
       }
     }
 
+    await Promise.all(dispatches);
     return fixed;
   }
 
@@ -443,17 +462,18 @@ export class ProcessManager {
       throw err;
     }
 
-    // Watchdog: SIGKILL after 10s if still alive, then reconcile status
+    // Watchdog: SIGKILL after 10s if still alive, then reconcile status.
+    // Fire-and-forget: reconcileStatus is async but we intentionally don't
+    // await it — this is a background cleanup path after the response is sent.
     const worcaDir = this.worcaDir;
+    const { settingsPath } = this;
     const watchdog = setTimeout(() => {
       try {
         process.kill(pid, 0); // check alive
         process.kill(pid, 'SIGKILL');
-        // Give the OS a moment to reap the process, then fix stale status
-        setTimeout(() => reconcileStatus(worcaDir), 500);
+        setTimeout(() => reconcileStatus(worcaDir, settingsPath), 500);
       } catch {
-        // Already dead — reconcile in case signal handler didn't save
-        reconcileStatus(worcaDir);
+        reconcileStatus(worcaDir, settingsPath);
       }
     }, 10000);
     watchdog.unref();
@@ -470,6 +490,80 @@ export class ProcessManager {
     return { pid, stopped: true };
   }
 
+  /**
+   * Synchronous-style stop: control.json + signal + poll for exit.
+   * @param {string} runId
+   * @param {{ timeoutMs?: number }} [opts]
+   * @returns {Promise<{ pid: number, exitCode: null, forced?: boolean }>}
+   */
+  async stopPipelineSync(runId, { timeoutMs } = {}) {
+    if (timeoutMs === undefined) {
+      timeoutMs = process.platform === 'win32' ? 30000 : 5000;
+    }
+
+    const running = this.getRunningPid(runId);
+    if (!running) {
+      const e = new Error('not running');
+      e.code = 'not_running';
+      throw e;
+    }
+    const { pid } = running;
+
+    const controlDir = join(this.worcaDir, 'runs', runId);
+    mkdirSync(controlDir, { recursive: true });
+    writeFileSync(
+      join(controlDir, 'control.json'),
+      `${JSON.stringify({ action: 'stop', requested_at: new Date().toISOString(), source: 'ui' }, null, 2)}\n`,
+      'utf8',
+    );
+
+    if (process.platform !== 'win32') {
+      try {
+        process.kill(pid, 'SIGTERM');
+      } catch {
+        /* already dead */
+      }
+    } else {
+      this._killAgentSubprocess(runId);
+    }
+
+    const pollMs = timeoutMs > 10000 ? 500 : 100;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      try {
+        process.kill(pid, 0);
+      } catch {
+        return { pid, exitCode: null };
+      }
+      await new Promise((r) => setTimeout(r, pollMs));
+    }
+
+    try {
+      process.kill(pid, 'SIGKILL');
+    } catch {
+      /* already dead */
+    }
+    return { pid, exitCode: null, forced: true };
+  }
+
+  /**
+   * Kill the agent subprocess (claude CLI) via agent.pid.
+   * Used on Windows where SIGTERM doesn't propagate to child processes.
+   * @param {string} runId
+   */
+  _killAgentSubprocess(runId) {
+    const pidPath = join(this.worcaDir, 'runs', runId, 'agent.pid');
+    if (!existsSync(pidPath)) return;
+    try {
+      const agentPid = parseInt(readFileSync(pidPath, 'utf8').trim(), 10);
+      if (!Number.isNaN(agentPid) && agentPid > 0) {
+        process.kill(agentPid, 'SIGTERM');
+      }
+    } catch {
+      /* agent already dead or pid file invalid */
+    }
+  }
+
   /**
    * Read the active_run file to get the current run ID.
    * @returns {string|null}
@@ -485,6 +579,51 @@ export class ProcessManager {
     }
   }
 
+  /**
+   * Delete a run directory and clean up references.
+   * Refuses if the pipeline is currently running.
+   * @param {string} runId
+   * @returns {{ deleted: boolean }}
+   */
+  deleteRun(runId) {
+    const running = this.getRunningPid(runId);
+    if (running) {
+      const err = new Error(
+        'Cannot delete a running pipeline — stop or cancel it first',
+      );
+      err.code = 'still_running';
+      throw err;
+    }
+
+    const runsParent = resolve(this.worcaDir, 'runs');
+    const runDir = resolve(runsParent, runId);
+    if (!runDir.startsWith(runsParent)) {
+      const err = new Error('Invalid runId');
+      err.code = 'invalid_id';
+      throw err;
+    }
+    if (!existsSync(runDir)) {
+      const err = new Error(`Run "${runId}" not found`);
+      err.code = 'not_found';
+      throw err;
+    }
+
+    rmSync(runDir, { recursive: true, force: true });
+
+    // Clear active_run pointer if it references this run
+    const activeRunPath = join(this.worcaDir, 'active_run');
+    if (existsSync(activeRunPath)) {
+      try {
+        const activeId = readFileSync(activeRunPath, 'utf8').trim();
+        if (activeId === runId) unlinkSync(activeRunPath);
+      } catch {
+        /* ignore */
+      }
+    }
+
+    return { deleted: true };
+  }
+
   /**
    * Pause a running pipeline by writing a control file.
    * @param {string} runId - Pipeline run identifier
@@ -640,9 +779,9 @@ export function getRunningPid(worcaDir, runId) {
   return new ProcessManager({ worcaDir }).getRunningPid(runId);
 }
 
-/** @param {string} worcaDir */
-export function reconcileStatus(worcaDir) {
-  return new ProcessManager({ worcaDir }).reconcileStatus();
+/** @param {string} worcaDir @param {string} [settingsPath] */
+export function reconcileStatus(worcaDir, settingsPath) {
+  return new ProcessManager({ worcaDir, settingsPath }).reconcileStatus();
 }
 
 /** @param {string} worcaDir @param {object} opts */