@worca/ui 0.12.0 → 0.14.0

package/server/process-manager.js

@@ -22,6 +22,8 @@ import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
 
 import { dispatchExternal } from './dispatch-external.js';
+import { readGlobalSettings } from './settings-reader.js';
+import { removeWorktree } from './worktree-ops.js';
 
 /** Byte threshold — must match claude_cli.py _ARG_INLINE_LIMIT */
 const ARG_INLINE_LIMIT = 128 * 1024;
@@ -78,10 +80,48 @@ export class ProcessManager {
   /**
    * @param {{ worcaDir: string, projectRoot?: string, settingsPath?: string }} options
    */
-  constructor({ worcaDir, projectRoot, settingsPath }) {
+  constructor({ worcaDir, projectRoot, settingsPath, prefsDir }) {
     this.worcaDir = worcaDir;
     this.projectRoot = projectRoot || process.cwd();
     this.settingsPath = settingsPath ?? null;
+    this.prefsDir = prefsDir ?? null;
+  }
+
+  /**
+   * Resolve the worcaDir and runDir for a given run ID.
+   * Checks root runs/ first, then pipelines.d/ registry for worktree_path.
+   * @param {string} runId
+   * @returns {{ worcaDir: string, runDir: string } | null}
+   */
+  resolveRunContext(runId) {
+    const rootPath = join(this.worcaDir, 'runs', runId, 'status.json');
+    if (existsSync(rootPath)) {
+      return {
+        worcaDir: this.worcaDir,
+        runDir: join(this.worcaDir, 'runs', runId),
+      };
+    }
+    const regPath = join(
+      this.worcaDir,
+      'multi',
+      'pipelines.d',
+      `${runId}.json`,
+    );
+    if (existsSync(regPath)) {
+      try {
+        const reg = JSON.parse(readFileSync(regPath, 'utf8'));
+        if (reg.worktree_path) {
+          const wtWorcaDir = join(reg.worktree_path, '.worca');
+          return {
+            worcaDir: wtWorcaDir,
+            runDir: join(wtWorcaDir, 'runs', runId),
+          };
+        }
+      } catch {
+        /* ignore */
+      }
+    }
+    return null;
   }
 
   /**
@@ -90,10 +130,17 @@ export class ProcessManager {
    * @returns {{ pid: number } | null}
    */
   getRunningPid(runId) {
-    // Build candidate PID paths: per-run first, then project-level fallback
+    // Build candidate PID paths: per-run first (with worktree overlay),
+    // then project-level fallback. Worktree runs live under
+    // <worktree_path>/.worca/runs/<id>/ and are routed via pipelines.d/.
     const candidates = [];
     if (runId) {
-      candidates.push(join(this.worcaDir, 'runs', runId, 'pipeline.pid'));
+      const ctx = this.resolveRunContext(runId);
+      if (ctx) {
+        candidates.push(join(ctx.runDir, 'pipeline.pid'));
+      } else {
+        candidates.push(join(this.worcaDir, 'runs', runId, 'pipeline.pid'));
+      }
     }
     candidates.push(join(this.worcaDir, 'pipeline.pid'));
 
@@ -125,7 +172,7 @@ export class ProcessManager {
 
   /**
    * Reconcile stale "running" status when the pipeline process is dead.
-   * Scans all runs with per-run PID files + the active_run pointer.
+   * Scans all runs with per-run PID files.
    * If pipeline_status is "running" but no process is alive, transitions
    * to "failed" with stop_reason="stale".
    * Preserves any existing stop_reason (e.g. "signal" set by Layer 1).
@@ -136,7 +183,7 @@ export class ProcessManager {
     let fixed = false;
     const dispatches = [];
 
-    // Collect run IDs to check: scan runs/*/pipeline.pid + active_run fallback
+    // Collect run IDs to check: scan runs/*/pipeline.pid
     const runIds = new Set();
     const runsDir = join(this.worcaDir, 'runs');
     if (existsSync(runsDir)) {
@@ -154,17 +201,6 @@ export class ProcessManager {
       }
     }
 
-    // Backward compat: also check active_run pointer
-    const activeRunPath = join(this.worcaDir, 'active_run');
-    if (existsSync(activeRunPath)) {
-      try {
-        const activeId = readFileSync(activeRunPath, 'utf8').trim();
-        if (activeId) runIds.add(activeId);
-      } catch {
-        /* ignore */
-      }
-    }
-
     for (const runId of runIds) {
       // Check if this run's process is alive
       const alive = this.getRunningPid(runId);
@@ -259,12 +295,76 @@ export class ProcessManager {
           }
         }
       }
+
+      this.maybeAutoCleanup(runId);
     }
 
     await Promise.all(dispatches);
     return fixed;
   }
 
+  /**
+   * Post-completion cleanup hook (§5b).
+   * When cleanup_policy is 'on-success' and the run completed cleanly,
+   * removes the worktree via worktree-ops and emits a worktree.auto_cleanup
+   * event. 'never' (default) and 'manual-only' are both no-ops.
+   * @param {string} runId
+   * @returns {{ cleaned: boolean, runId?: string, path?: string, reason?: string }}
+   */
+  maybeAutoCleanup(runId) {
+    const ctx = this.resolveRunContext(runId);
+    const runDir = ctx ? ctx.runDir : join(this.worcaDir, 'runs', runId);
+    const statusPath = join(runDir, 'status.json');
+
+    if (!existsSync(statusPath)) return { cleaned: false };
+
+    let status;
+    try {
+      status = JSON.parse(readFileSync(statusPath, 'utf8'));
+    } catch {
+      return { cleaned: false };
+    }
+
+    const worktreePath = status.worktree_path;
+    if (!worktreePath) return { cleaned: false };
+
+    const exitOk = status.pipeline_status === 'completed';
+    if (!exitOk) return { cleaned: false };
+
+    let policy = 'never';
+    if (this.prefsDir) {
+      try {
+        const globalPrefs = readGlobalSettings(
+          join(this.prefsDir, 'settings.json'),
+        );
+        policy = globalPrefs?.worca?.parallel?.cleanup_policy ?? 'never';
+      } catch {
+        // Fall back to default 'never'
+      }
+    }
+
+    if (policy !== 'on-success') return { cleaned: false };
+
+    removeWorktree(this.worcaDir, runId);
+
+    try {
+      const eventsPath = join(runDir, 'events.jsonl');
+      const evt = {
+        schema_version: '1',
+        event_id: randomUUID(),
+        event_type: 'worktree.auto_cleanup',
+        timestamp: new Date().toISOString(),
+        run_id: status.run_id ?? runId,
+        payload: { runId, path: worktreePath, reason: 'on-success' },
+      };
+      appendFileSync(eventsPath, `${JSON.stringify(evt)}\n`, 'utf8');
+    } catch {
+      /* non-fatal */
+    }
+
+    return { cleaned: true, runId, path: worktreePath, reason: 'on-success' };
+  }
+
   /**
    * Start a new pipeline run.
    * @param {{ inputType?: string, inputValue?: string, msize?: number, mloops?: number, planFile?: string, resume?: boolean, projectRoot?: string }} opts
@@ -272,20 +372,47 @@ export class ProcessManager {
    */
   async startPipeline(opts = {}) {
     const cwd = opts.projectRoot || this.projectRoot;
-    const scriptPath = join(cwd, '.claude/worca/scripts/run_pipeline.py');
-    if (!existsSync(scriptPath)) {
-      const err = new Error(`Pipeline script not found at ${scriptPath}`);
-      err.code = 'script_not_found';
-      throw err;
+    const pipelineScriptRel = '.claude/worca/scripts/run_pipeline.py';
+    const worktreeScriptRel = '.claude/worca/scripts/run_worktree.py';
+
+    let scriptRel;
+    if (opts.resume) {
+      const pipelinePath = join(cwd, pipelineScriptRel);
+      if (!existsSync(pipelinePath)) {
+        const err = new Error(`Pipeline script not found at ${pipelinePath}`);
+        err.code = 'script_not_found';
+        throw err;
+      }
+      scriptRel = pipelineScriptRel;
+    } else {
+      const worktreePath = join(cwd, worktreeScriptRel);
+      if (existsSync(worktreePath)) {
+        scriptRel = worktreeScriptRel;
+      } else {
+        const pipelinePath = join(cwd, pipelineScriptRel);
+        if (!existsSync(pipelinePath)) {
+          const err = new Error(`Pipeline script not found at ${pipelinePath}`);
+          err.code = 'script_not_found';
+          throw err;
+        }
+        console.warn(
+          '[worca] run_worktree.py not found, falling back to run_pipeline.py',
+        );
+        scriptRel = pipelineScriptRel;
+      }
     }
 
-    const args = ['.claude/worca/scripts/run_pipeline.py'];
+    const args = [scriptRel];
     let promptFilePath = null; // track for cleanup on spawn failure
 
     if (opts.resume) {
       args.push('--resume');
       if (opts.runId) {
-        args.push('--status-dir', join(this.worcaDir, 'runs', opts.runId));
+        const ctx = this.resolveRunContext(opts.runId);
+        const statusDir = ctx
+          ? ctx.runDir
+          : join(this.worcaDir, 'runs', opts.runId);
+        args.push('--status-dir', statusDir);
       }
     } else if (opts.sourceType !== undefined) {
       // New format: separate source and prompt args
@@ -400,10 +527,13 @@ export class ProcessManager {
     let pid = null;
     let foundPidPath = null;
 
+    const ctx = runId ? this.resolveRunContext(runId) : null;
+    const effectiveWorcaDir = ctx ? ctx.worcaDir : this.worcaDir;
+
     // Check per-run PID file first, then project-level fallback
     const candidates = [];
     if (runId) {
-      candidates.push(join(this.worcaDir, 'runs', runId, 'pipeline.pid'));
+      candidates.push(join(effectiveWorcaDir, 'runs', runId, 'pipeline.pid'));
     }
     candidates.push(join(this.worcaDir, 'pipeline.pid'));
 
@@ -431,10 +561,10 @@ export class ProcessManager {
     }
 
     // Belt-and-suspenders: write control.json so the orchestrator gets a clean signal
-    const effectiveRunId = runId || this._readActiveRunId();
+    const effectiveRunId = runId;
     if (effectiveRunId) {
       try {
-        const controlDir = join(this.worcaDir, 'runs', effectiveRunId);
+        const controlDir = join(effectiveWorcaDir, 'runs', effectiveRunId);
         mkdirSync(controlDir, { recursive: true });
         writeFileSync(
           join(controlDir, 'control.json'),
@@ -471,14 +601,17 @@ export class ProcessManager {
     // 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 { settingsPath, prefsDir } = this;
     const watchdog = setTimeout(() => {
       try {
         process.kill(pid, 0); // check alive
         process.kill(pid, 'SIGKILL');
-        setTimeout(() => reconcileStatus(worcaDir, settingsPath), 500);
+        setTimeout(
+          () => reconcileStatus(worcaDir, settingsPath, prefsDir),
+          500,
+        );
       } catch {
-        reconcileStatus(worcaDir, settingsPath);
+        reconcileStatus(worcaDir, settingsPath, prefsDir);
       }
     }, 10000);
     watchdog.unref();
@@ -514,7 +647,9 @@ export class ProcessManager {
     }
     const { pid } = running;
 
-    const controlDir = join(this.worcaDir, 'runs', runId);
+    const ctx = this.resolveRunContext(runId);
+    const effectiveWorcaDir = ctx ? ctx.worcaDir : this.worcaDir;
+    const controlDir = join(effectiveWorcaDir, 'runs', runId);
     mkdirSync(controlDir, { recursive: true });
     writeFileSync(
       join(controlDir, 'control.json'),
@@ -569,21 +704,6 @@ export class ProcessManager {
     }
   }
 
-  /**
-   * Read the active_run file to get the current run ID.
-   * @returns {string|null}
-   */
-  _readActiveRunId() {
-    const activeRunPath = join(this.worcaDir, 'active_run');
-    if (!existsSync(activeRunPath)) return null;
-    try {
-      const id = readFileSync(activeRunPath, 'utf8').trim();
-      return id || null;
-    } catch {
-      return null;
-    }
-  }
-
   /**
    * Delete a run directory and clean up references.
    * Refuses if the pipeline is currently running.
@@ -600,8 +720,10 @@ export class ProcessManager {
       throw err;
     }
 
-    const runsParent = resolve(this.worcaDir, 'runs');
-    const runDir = resolve(runsParent, runId);
+    const ctx = this.resolveRunContext(runId);
+    const effectiveWorcaDir = ctx ? ctx.worcaDir : this.worcaDir;
+    const runsParent = resolve(effectiveWorcaDir, 'runs');
+    const runDir = ctx ? resolve(ctx.runDir) : resolve(runsParent, runId);
     if (!runDir.startsWith(runsParent)) {
       const err = new Error('Invalid runId');
       err.code = 'invalid_id';
@@ -615,17 +737,6 @@ export class ProcessManager {
 
     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 };
   }
 
@@ -635,7 +746,8 @@ export class ProcessManager {
    * @returns {{ runId: string, paused: boolean }}
    */
   pausePipeline(runId) {
-    const controlDir = join(this.worcaDir, 'runs', runId);
+    const ctx = this.resolveRunContext(runId);
+    const controlDir = ctx ? ctx.runDir : join(this.worcaDir, 'runs', runId);
     mkdirSync(controlDir, { recursive: true });
     writeFileSync(
       join(controlDir, 'control.json'),
@@ -655,19 +767,34 @@ export class ProcessManager {
 
   /**
    * Restart a failed stage by resetting it and spawning with --resume.
+   *
+   * Internal API — only called from worca-ui (project-routes.js). The signature
+   * changed in W-048 from (stageKey, opts) to (runId, stageKey, opts) because
+   * runs are now per-worktree and the manager can no longer infer "the active
+   * run". Callers must pass an explicit runId.
+   *
+   * @param {string} runId - Run identifier to restart
    * @param {string} stageKey - The stage key to restart
    * @param {{ projectRoot?: string }} opts
    * @returns {Promise<{ pid: number, stage: string }>}
    */
-  async restartStage(stageKey, opts = {}) {
-    const running = this.getRunningPid();
+  async restartStage(runId, stageKey, opts = {}) {
+    const running = this.getRunningPid(runId);
     if (running) {
       const err = new Error(`Pipeline already running (PID ${running.pid})`);
       err.code = 'already_running';
       throw err;
     }
 
-    const cwd = opts.projectRoot || this.projectRoot;
+    const ctx = this.resolveRunContext(runId);
+    const runDir = ctx ? ctx.runDir : join(this.worcaDir, 'runs', runId);
+    // For worktree runs derive projectRoot from worcaDir parent (.worca/..)
+    const cwd =
+      opts.projectRoot ||
+      (ctx && ctx.worcaDir !== this.worcaDir
+        ? join(ctx.worcaDir, '..')
+        : this.projectRoot);
+
     const scriptPath = join(cwd, '.claude/worca/scripts/run_pipeline.py');
     if (!existsSync(scriptPath)) {
       const err = new Error(`Pipeline script not found at ${scriptPath}`);
@@ -675,24 +802,8 @@ export class ProcessManager {
       throw err;
     }
 
-    // Find status.json — check active_run first, then legacy
-    let statusPath = null;
-    const activeRunPath = join(this.worcaDir, 'active_run');
-    if (existsSync(activeRunPath)) {
-      try {
-        const runId = readFileSync(activeRunPath, 'utf8').trim();
-        const candidate = join(this.worcaDir, 'runs', runId, 'status.json');
-        if (existsSync(candidate)) statusPath = candidate;
-      } catch {
-        /* ignore */
-      }
-    }
-    if (!statusPath) {
-      const legacy = join(this.worcaDir, 'status.json');
-      if (existsSync(legacy)) statusPath = legacy;
-    }
-
-    if (!statusPath) {
+    const statusPath = join(runDir, 'status.json');
+    if (!existsSync(statusPath)) {
       const err = new Error('No status.json found');
       err.code = 'no_status';
       throw err;
@@ -720,14 +831,19 @@ export class ProcessManager {
     delete status.stages[stageKey].completed_at;
     writeFileSync(statusPath, `${JSON.stringify(status, null, 2)}\n`, 'utf8');
 
-    // Spawn with --resume
+    // Spawn with --resume --status-dir so the pipeline finds the right run
     const env = { ...process.env };
     delete env.CLAUDECODE;
 
     return new Promise((resolve, reject) => {
       const child = spawn(
         'python3',
-        ['.claude/worca/scripts/run_pipeline.py', '--resume'],
+        [
+          '.claude/worca/scripts/run_pipeline.py',
+          '--resume',
+          '--status-dir',
+          runDir,
+        ],
         {
           detached: true,
           stdio: 'ignore',
@@ -784,9 +900,13 @@ export function getRunningPid(worcaDir, runId) {
   return new ProcessManager({ worcaDir }).getRunningPid(runId);
 }
 
-/** @param {string} worcaDir @param {string} [settingsPath] */
-export function reconcileStatus(worcaDir, settingsPath) {
-  return new ProcessManager({ worcaDir, settingsPath }).reconcileStatus();
+/** @param {string} worcaDir @param {string} [settingsPath] @param {string} [prefsDir] */
+export function reconcileStatus(worcaDir, settingsPath, prefsDir) {
+  return new ProcessManager({
+    worcaDir,
+    settingsPath,
+    prefsDir,
+  }).reconcileStatus();
 }
 
 /** @param {string} worcaDir @param {object} opts */
@@ -807,10 +927,10 @@ export function pausePipeline(worcaDir, runId) {
   return new ProcessManager({ worcaDir }).pausePipeline(runId);
 }
 
-/** @param {string} worcaDir @param {string} stageKey @param {object} opts */
-export async function restartStage(worcaDir, stageKey, opts = {}) {
+/** @param {string} worcaDir @param {string} runId @param {string} stageKey @param {object} opts */
+export async function restartStage(worcaDir, runId, stageKey, opts = {}) {
   return new ProcessManager({
     worcaDir,
     projectRoot: opts.projectRoot,
-  }).restartStage(stageKey, opts);
+  }).restartStage(runId, stageKey, opts);
 }

package/server/process-registry.js

@@ -0,0 +1,92 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { atomicWriteSync } from './atomic-write.js';
+
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    if (err.code === 'EPERM') return true;
+    return false;
+  }
+}
+
+function clearStalePid(statusPath, status) {
+  try {
+    const patched = {
+      ...status,
+      pipeline_status: 'error',
+      error: 'Stale PID: process no longer running',
+    };
+    atomicWriteSync(statusPath, `${JSON.stringify(patched, null, 2)}\n`);
+  } catch {
+    // best-effort
+  }
+}
+
+/**
+ * Count running pipelines across all registered projects.
+ * Walks ~/.worca/projects.d/, checks each project's .worca/runs/ for
+ * status.json entries with pipeline_status=running, and verifies PID liveness.
+ * Prunes stale PIDs (dead processes still marked as running).
+ */
+export function countRunningPipelinesAcrossProjects(prefsDir) {
+  const projectsDir = join(prefsDir, 'projects.d');
+  if (!existsSync(projectsDir)) return 0;
+
+  let entries;
+  try {
+    entries = readdirSync(projectsDir);
+  } catch {
+    return 0;
+  }
+
+  let count = 0;
+
+  for (const file of entries) {
+    if (!file.endsWith('.json')) continue;
+
+    let project;
+    try {
+      project = JSON.parse(readFileSync(join(projectsDir, file), 'utf-8'));
+    } catch {
+      continue;
+    }
+
+    if (!project || typeof project.path !== 'string') continue;
+
+    const runsDir = join(project.path, '.worca', 'runs');
+    if (!existsSync(runsDir)) continue;
+
+    let runEntries;
+    try {
+      runEntries = readdirSync(runsDir);
+    } catch {
+      continue;
+    }
+
+    for (const runEntry of runEntries) {
+      const statusPath = join(runsDir, runEntry, 'status.json');
+      if (!existsSync(statusPath)) continue;
+
+      let status;
+      try {
+        status = JSON.parse(readFileSync(statusPath, 'utf-8'));
+      } catch {
+        continue;
+      }
+
+      if (status.pipeline_status !== 'running') continue;
+      if (!status.pid) continue;
+
+      if (isPidAlive(status.pid)) {
+        count++;
+      } else {
+        clearStalePid(statusPath, status);
+      }
+    }
+  }
+
+  return count;
+}