@worca/ui 0.15.2 → 0.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@worca/ui",
-  "version": "0.15.2",
+  "version": "0.16.0",
   "description": "Pipeline monitoring UI for worca-cc",
   "license": "MIT",
   "author": "Sinisha Djukic",

package/server/process-manager.js

@@ -422,10 +422,49 @@ export class ProcessManager {
     if (opts.resume) {
       args.push('--resume');
       if (opts.runId) {
-        const statusDir = resumeCtx
-          ? resumeCtx.runDir
-          : join(this.worcaDir, 'runs', opts.runId);
+        // The runner derives worca_dir from os.path.dirname(status_path) and
+        // builds the per-run dir as <worca_dir>/runs/<run_id>/. We must pass
+        // the worca root, not the per-run dir — passing <worca>/runs/<id>
+        // would make the runner compute a nested <worca>/runs/<id>/runs/<id>/
+        // and write status updates there while the UI keeps reading the
+        // original. _find_active_runs(worca_root) then locates the run.
+        const statusDir = resumeCtx ? resumeCtx.worcaDir : this.worcaDir;
         args.push('--status-dir', statusDir);
+
+        // Worktree runs: registry lives in the parent project's .worca, not
+        // the worktree's. run_worktree.py passes --registry-base on initial
+        // launch; resume must do the same so update_pipeline() lands on the
+        // right registry entry. Without this, the runner's terminal /
+        // resume-flip-to-running registry updates silently no-op against a
+        // non-existent <worktree>/.worca/multi/pipelines.d/<id>.json.
+        if (resumeCtx && resumeCtx.worcaDir !== this.worcaDir) {
+          args.push('--registry-base', this.worcaDir);
+        }
+
+        // _find_active_runs filters out runs whose pipeline_status is in
+        // {completed, interrupted}. To resume an interrupted/failed run, flip
+        // the top-level status to "resuming" so the runner can pick it up;
+        // it'll transition to "running" once it's processing.
+        const statusPath = resumeCtx
+          ? join(resumeCtx.runDir, 'status.json')
+          : join(this.worcaDir, 'runs', opts.runId, 'status.json');
+        try {
+          const s = JSON.parse(readFileSync(statusPath, 'utf8'));
+          if (
+            s.pipeline_status === 'interrupted' ||
+            s.pipeline_status === 'failed'
+          ) {
+            s.pipeline_status = 'resuming';
+            delete s.stop_reason;
+            writeFileSync(
+              statusPath,
+              `${JSON.stringify(s, null, 2)}\n`,
+              'utf8',
+            );
+          }
+        } catch {
+          /* non-fatal — runner will surface a clearer error if the file is missing */
+        }
       }
     } else if (opts.sourceType !== undefined) {
       // New format: separate source and prompt args

package/server/project-routes.js

@@ -71,7 +71,11 @@ function validateRunId(runId) {
 // Re-exported from run-dir-resolver so callers (including older tests) can
 // continue importing from project-routes. The implementation now overlays
 // worktree runs registered in <worcaDir>/multi/pipelines.d/.
-import { findRunStatusPath, readPipelineOverlay } from './run-dir-resolver.js';
+import {
+  findRunStatusPath,
+  readPipelineOverlay,
+  updatePipelineStatus,
+} from './run-dir-resolver.js';
 export { findRunStatusPath };
 
 /** Validate a branch name — alphanumeric, dots, hyphens, underscores, slashes */
@@ -935,7 +939,14 @@ export function createProjectScopedRoutes({
     }
     const { worcaDir, settingsPath } = req.project;
     try {
-      const controlDir = join(worcaDir, 'runs', runId);
+      // Worktree runs read control.json from <worktree>/.worca/runs/<id>/.
+      // Writing it to the parent project's worcaDir leaves the runner
+      // unaware of the stop request — SIGTERM still works, but we lose
+      // graceful-shutdown semantics.
+      const overlay = readPipelineOverlay(worcaDir, runId);
+      const controlDir = overlay?.worktree_path
+        ? join(overlay.worktree_path, '.worca', 'runs', runId)
+        : join(worcaDir, 'runs', runId);
       mkdirSync(controlDir, { recursive: true });
       writeFileSync(
         join(controlDir, 'control.json'),
@@ -1079,6 +1090,11 @@ export function createProjectScopedRoutes({
       st.completed_at = new Date().toISOString();
       writeFileSync(statusPath, `${JSON.stringify(st, null, 2)}\n`, 'utf8');
 
+      // Mirror into the multi-pipeline registry so global-mode views don't
+      // keep reporting the run as "running". Best-effort — the registry entry
+      // only exists for worktree runs.
+      updatePipelineStatus(worcaDir, runId, 'cancelled');
+
       const { broadcast, scheduleRefresh } = req.app.locals;
       if (broadcast) broadcast('run-cancelled', { runId });
       if (scheduleRefresh) scheduleRefresh(req.project?.name);
@@ -1141,7 +1157,12 @@ export function createProjectScopedRoutes({
           pipeline_status: st.pipeline_status,
         });
       }
-      const controlDir = join(worcaDir, 'runs', runId);
+      // Worktree runs read control.json from <worktree>/.worca/runs/<id>/;
+      // writing to the parent's worcaDir is invisible to the runner.
+      const overlay = readPipelineOverlay(worcaDir, runId);
+      const controlDir = overlay?.worktree_path
+        ? join(overlay.worktree_path, '.worca', 'runs', runId)
+        : join(worcaDir, 'runs', runId);
       mkdirSync(controlDir, { recursive: true });
       writeFileSync(
         join(controlDir, 'control.json'),

package/server/run-dir-resolver.js

@@ -13,7 +13,7 @@
  *   3. `<worcaDir>/multi/pipelines.d/<runId>.json` → `<worktree_path>/.worca/runs/<runId>/`
  */
 
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 
 /**
@@ -77,3 +77,37 @@ export function readPipelineOverlay(worcaDir, runId) {
     return null;
   }
 }
+
+/**
+ * Update the multi-pipeline registry entry's status field.
+ *
+ * Mirrors src/worca/orchestrator/registry.py:update_pipeline() — terminal
+ * status (cancelled/completed/failed/interrupted) only. The Python runner
+ * updates the registry on its own terminal paths; this helper exists for
+ * callers (the UI cancel route) that write status.json directly without
+ * going through the runner.
+ *
+ * Returns true when the registry entry existed and was updated, false when
+ * there's no registry entry for this runId (e.g. local in-place run).
+ *
+ * @param {string} worcaDir - the parent project's .worca directory
+ * @param {string} runId
+ * @param {string} status - new status value (e.g. 'cancelled')
+ */
+export function updatePipelineStatus(worcaDir, runId, status) {
+  const regPath = join(worcaDir, 'multi', 'pipelines.d', `${runId}.json`);
+  if (!existsSync(regPath)) return false;
+  try {
+    const data = JSON.parse(readFileSync(regPath, 'utf8'));
+    data.status = status;
+    data.updated_at = new Date().toISOString();
+    // Match Python's atomic write: write to .tmp + rename. Avoids partial
+    // writes if the process crashes mid-write.
+    const tmpPath = `${regPath}.tmp`;
+    writeFileSync(tmpPath, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
+    renameSync(tmpPath, regPath);
+    return true;
+  } catch {
+    return false;
+  }
+}