@ryanfw/prompt-orchestration-pipeline 1.3.3 → 1.3.4

package/src/ui/server/endpoints/job-control-endpoints.ts

@@ -26,6 +26,10 @@ import {
   StatusCorruptError,
   type StatusSnapshot,
 } from "../../../core/status-writer";
+import {
+  areDependenciesSatisfied,
+  firstUnsatisfiedDependency,
+} from "../../../core/lifecycle-policy";
 import { assertKnownJobStatusesParseable, statusCorruptResponse } from "../utils/status-corruption";
 import {
   materializeNormalizedPipelineDefinition,
@@ -38,11 +42,16 @@ const restartingJobs = new Set<string>();
 const stoppingJobs = new Set<string>();
 const startingJobs = new Set<string>();
 
-function getOrchestratorRuntimeConfig(): { maxConcurrentJobs: number; lockFileTimeout: number } {
+function getOrchestratorRuntimeConfig(): {
+  maxConcurrentJobs: number;
+  lockFileTimeout: number;
+  staleLeaseTimeoutMs: number;
+} {
   const orchestrator = getOrchestratorConfig();
   return {
     maxConcurrentJobs: orchestrator.maxConcurrentJobs,
     lockFileTimeout: orchestrator.lockFileTimeout,
+    staleLeaseTimeoutMs: orchestrator.staleLeaseTimeoutMs,
   };
 }
 
@@ -102,13 +111,14 @@ export async function acquireConcurrencySlot(
   jobId: string,
   source: JobSlotLease["source"],
 ): Promise<{ ok: true } | { ok: false; response: Response }> {
-  const { maxConcurrentJobs, lockFileTimeout } = getOrchestratorRuntimeConfig();
+  const { maxConcurrentJobs, lockFileTimeout, staleLeaseTimeoutMs } = getOrchestratorRuntimeConfig();
   const result = await tryAcquireJobSlot({
     dataDir: getPipelineDataDir(dataDir),
     jobId,
     maxConcurrentJobs,
     source,
     lockTimeoutMs: lockFileTimeout,
+    staleLeaseTimeoutMs,
   });
   if (result.ok) return { ok: true };
   if (result.reason === "already_held") {
@@ -176,10 +186,6 @@ function isNonTerminalTaskState(state: unknown): boolean {
   return state === "pending" || state === "running";
 }
 
-function isDependencySatisfied(state: unknown): boolean {
-  return state === "done";
-}
-
 function isTaskLikelyInProgress(task: Record<string, unknown>): boolean {
   const state = task["state"];
   const nonTerminal = isNonTerminalTaskState(state);
@@ -501,6 +507,31 @@ export async function handleJobRestart(
       }
     }
 
+    if (fromTask) {
+      if (!status) {
+        return sendJson(500, createErrorResponse("status_unavailable", `job "${jobId}" status could not be read`));
+      }
+      const pipelineTaskOrder = await loadPipelineTaskOrder(dataDir, jobDir, status);
+      if (!pipelineTaskOrder) {
+        return sendJson(500, createErrorResponse("status_unavailable", `pipeline task order for job "${jobId}" could not be read`));
+      }
+      const taskIndex = pipelineTaskOrder.indexOf(fromTask);
+      if (taskIndex === -1) {
+        return sendJson(404, createErrorResponse("task_not_found", `task "${fromTask}" was not found in the pipeline definition`));
+      }
+      const predecessors = pipelineTaskOrder.slice(0, taskIndex).map((name) => ({
+        name,
+        state: status.tasks[name]?.state ?? "pending",
+      }));
+      if (!areDependenciesSatisfied(predecessors.map((p) => p.state))) {
+        const blocker = firstUnsatisfiedDependency(predecessors)!;
+        return sendJson(412, createErrorResponse(
+          "dependencies_not_satisfied",
+          `task "${blocker.name}" must be done or skipped before "${fromTask}" (state: "${blocker.state}")`,
+        ));
+      }
+    }
+
     const slot = await acquireConcurrencySlot(dataDir, jobId, "restart");
     if (!slot.ok) return slot.response;
 
@@ -570,81 +601,93 @@ export async function handleJobStop(
 
     const jobDir = getJobDirectoryPath(dataDir, jobId, lifecycle as "current" | "complete");
 
-    // Kill the runner process via PID file
-    let pidFound = false;
-    let usedSignal: string | null = null;
-
-    const pid = await readRunnerPid(jobDir);
-    if (pid !== null) {
-      pidFound = true;
-      try {
-        const result = await killProcess(pid);
-        usedSignal = result.signal;
-      } catch (err) {
-        console.error(`[handleJobStop] Error killing pid ${pid} for job ${jobId}:`, err);
+    try {
+      // Kill the runner process via PID file
+      let pidFound = false;
+      let usedSignal: string | null = null;
+
+      const pid = await readRunnerPid(jobDir);
+      if (pid !== null) {
+        pidFound = true;
+        try {
+          const result = await killProcess(pid);
+          usedSignal = result.signal;
+        } catch (err) {
+          console.error(`[handleJobStop] Error killing pid ${pid} for job ${jobId}:`, err);
+        }
+        await cleanupRunnerPid(jobDir);
       }
-      await cleanupRunnerPid(jobDir);
-    }
 
-    try { await assertKnownJobStatusesParseable(dataDir, jobId); }
-    catch (err) { if (err instanceof StatusCorruptError) return statusCorruptResponse(err); throw err; }
+      try { await assertKnownJobStatusesParseable(dataDir, jobId); }
+      catch (err) { if (err instanceof StatusCorruptError) return statusCorruptResponse(err); throw err; }
 
-    let resetTask: string | null = null;
+      let resetTask: string | null = null;
 
-    // Reset running task and clear root-level fields in a single atomic write.
-    try {
-      await writeJobStatus(jobDir, (snapshot) => {
-      if (snapshot.current && snapshot.tasks[snapshot.current]?.state === "running") {
-        resetTask = snapshot.current;
-      } else {
-        for (const taskId of Object.keys(snapshot.tasks)) {
-          if (snapshot.tasks[taskId]!.state === "running") {
-            resetTask = taskId;
-            break;
+      // Reset running task and clear root-level fields in a single atomic write.
+      try {
+        await writeJobStatus(jobDir, (snapshot) => {
+        if (snapshot.current && snapshot.tasks[snapshot.current]?.state === "running") {
+          resetTask = snapshot.current;
+        } else {
+          for (const taskId of Object.keys(snapshot.tasks)) {
+            if (snapshot.tasks[taskId]!.state === "running") {
+              resetTask = taskId;
+              break;
+            }
           }
         }
-      }
 
-      if (!resetTask) {
-        resetTask = findRecoveryTask(snapshot);
-      }
+        if (!resetTask) {
+          resetTask = findRecoveryTask(snapshot);
+        }
 
-      if (resetTask) {
-        const task = snapshot.tasks[resetTask];
-        if (task) {
-          task.state = "pending";
-          task.currentStage = null;
-          delete task.endedAt;
-          delete task.startedAt;
-          delete task.failedStage;
-          delete task.error;
-          task.attempts = 0;
-          task.restartCount = 0;
-          task.refinementAttempts = 0;
-          task.tokenUsage = [];
+        if (resetTask) {
+          const task = snapshot.tasks[resetTask];
+          if (task) {
+            task.state = "pending";
+            task.currentStage = null;
+            delete task.endedAt;
+            delete task.startedAt;
+            delete task.failedStage;
+            delete task.error;
+            task.attempts = 0;
+            task.restartCount = 0;
+            task.refinementAttempts = 0;
+            task.tokenUsage = [];
+          }
+        } else if (snapshot.current === null && snapshot.state === "pending" && Object.keys(snapshot.tasks).length > 0) {
+          const taskIds = Object.keys(snapshot.tasks);
+          snapshot.current = taskIds[0] ?? null;
         }
-      } else if (snapshot.current === null && snapshot.state === "pending" && Object.keys(snapshot.tasks).length > 0) {
-        const taskIds = Object.keys(snapshot.tasks);
-        snapshot.current = taskIds[0] ?? null;
+
+        snapshot.state = "pending";
+        snapshot.current = resetTask ?? snapshot.current;
+        snapshot.currentStage = null;
+        snapshot.progress = getProgressPercent(snapshot);
+      });
+      } catch (err) {
+        if (err instanceof StatusCorruptError) return statusCorruptResponse(err);
+        throw err;
       }
 
-      snapshot.state = "pending";
-      snapshot.current = resetTask ?? snapshot.current;
-      snapshot.currentStage = null;
-      snapshot.progress = getProgressPercent(snapshot);
-    });
-    } catch (err) {
-      if (err instanceof StatusCorruptError) return statusCorruptResponse(err);
-      throw err;
+      return sendJson(202, {
+        ok: true,
+        jobId,
+        stopped: pidFound,
+        resetTask,
+        signal: usedSignal,
+      });
+    } finally {
+      try {
+        await releaseJobSlot(
+          getPipelineDataDir(dataDir),
+          jobId,
+          getOrchestratorRuntimeConfig().lockFileTimeout,
+        );
+      } catch (releaseErr) {
+        console.error(`[handleJobStop] Failed to release slot for job ${jobId}:`, releaseErr);
+      }
     }
-
-    return sendJson(202, {
-      ok: true,
-      jobId,
-      stopped: pidFound,
-      resetTask,
-      signal: usedSignal,
-    });
   } finally {
     endStop(jobId);
   }
@@ -728,10 +771,16 @@ export async function handleTaskStart(
       return sendJson(404, createErrorResponse("task_not_found", `task "${taskId}" was not found in the pipeline definition`));
     }
 
-    for (const priorTaskId of pipelineTaskOrder.slice(0, taskIndex)) {
-      if (!isDependencySatisfied(snapshot.tasks[priorTaskId]?.state)) {
-        return sendJson(412, createErrorResponse("dependencies_not_satisfied", `task "${priorTaskId}" must be done before "${taskId}"`));
-      }
+    const predecessors = pipelineTaskOrder.slice(0, taskIndex).map((name) => ({
+      name,
+      state: snapshot.tasks[name]?.state ?? "pending",
+    }));
+    if (!areDependenciesSatisfied(predecessors.map((p) => p.state))) {
+      const blocker = firstUnsatisfiedDependency(predecessors)!;
+      return sendJson(412, createErrorResponse(
+        "dependencies_not_satisfied",
+        `task "${blocker.name}" must be done or skipped before "${taskId}" (state: "${blocker.state}")`,
+      ));
     }
 
     const slot = await acquireConcurrencySlot(dataDir, jobId, "task-start");

package/src/ui/server/endpoints/job-endpoints.ts

@@ -80,5 +80,6 @@ export async function handleJobDetail(jobId: string): Promise<Response> {
   }
 
   const [apiJob] = transformJobListForAPI([job], { includePipelineMetadata: true });
+  if (apiJob) apiJob.costs = job.costs;
   return sendJson(200, { ok: true, data: apiJob });
 }

package/src/ui/server/endpoints/pipeline-analysis-endpoint.ts

@@ -1,15 +1,51 @@
+import { dirname, resolve } from "node:path";
+
+import { resolvePipelineSync, resolveTaskRegistryPath } from "../../../config/pipeline-registry";
+import { loadFreshModule } from "../../../core/module-loader";
+import { analyzeTask } from "../../../task-analysis/analyzer";
+import { TaskAnalysisRepository } from "../../../task-analysis/repository";
+import type { PersistedTaskAnalysis, TaskAnalysis } from "../../../task-analysis/types";
 import { acquireLock, releaseLock } from "../../state/analysis-lock";
 
-export async function handlePipelineAnalysis(_req: Request, slug: string): Promise<Response> {
+/** Doc-shaped placeholder persisted when per-task analysis throws unexpectedly. */
+function emptyAnalysis(): TaskAnalysis {
+  return {
+    summary: "",
+    stages: [],
+    artifacts: { reads: [], writes: [] },
+    models: [],
+  };
+}
+
+/** Loads the task-name -> module-path map (default export of the task registry module). */
+async function loadTaskRegistryMap(registryPath: string): Promise<Record<string, string>> {
+  const mod = await loadFreshModule(registryPath);
+  return (mod["default"] ?? {}) as Record<string, string>;
+}
+
+export async function handlePipelineAnalysis(_req: Request, slug: string, root: string): Promise<Response> {
   const lock = acquireLock(slug);
   if (!lock.acquired) {
-    return new Response(JSON.stringify({ ok: false, code: "BAD_REQUEST", message: `analysis lock held by ${lock.heldBy}` }), {
-      status: 409,
-      headers: { "Content-Type": "application/json" },
-    });
+    return new Response(
+      JSON.stringify({ ok: false, code: "BAD_REQUEST", message: `analysis lock held by ${lock.heldBy}` }),
+      {
+        status: 409,
+        headers: { "Content-Type": "application/json" },
+      },
+    );
   }
 
   const encoder = new TextEncoder();
+  // Shared across start()'s finally and cancel() so the lock is released exactly
+  // once regardless of which path runs first (client disconnect vs. completion).
+  let released = false;
+  const releaseOnce = (): void => {
+    if (!released) {
+      released = true;
+      releaseLock(slug);
+    }
+  };
+
   const response = new Response(
     new ReadableStream<Uint8Array>({
       start(controller) {
@@ -17,19 +53,71 @@ export async function handlePipelineAnalysis(_req: Request, slug: string): Promi
           controller.enqueue(encoder.encode(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`));
         };
 
-        queueMicrotask(() => {
+        void (async () => {
           try {
-            send("started", { slug });
+            // Resolution failures (unknown slug, unloadable registry) must not abort the
+            // run: emit an error and still reach `complete`.
+            let registryDir = "";
+            let taskMap: Record<string, string> = {};
+            try {
+              const { tasksDir } = resolvePipelineSync(root, slug);
+              const registryPath = resolveTaskRegistryPath(tasksDir);
+              registryDir = dirname(registryPath);
+              taskMap = await loadTaskRegistryMap(registryPath);
+            } catch (err) {
+              send("error", { message: err instanceof Error ? err.message : String(err) });
+            }
+
+            const taskNames = Object.keys(taskMap);
+            send("started", { slug, totalTasks: taskNames.length });
+
+            for (const taskName of taskNames) {
+              send("task:start", { task: taskName });
+              try {
+                const sourcePath = resolve(registryDir, taskMap[taskName]!);
+                const source = await Bun.file(sourcePath).text();
+                const result = await analyzeTask(source);
+                const persisted: PersistedTaskAnalysis = {
+                  summary: result.summary,
+                  stages: result.stages,
+                  artifacts: result.artifacts,
+                  models: result.models,
+                  analyzedAt: new Date().toISOString(),
+                  analysisStatus: result.analysisStatus,
+                  ...(result.analysisError !== undefined ? { analysisError: result.analysisError } : {}),
+                };
+                await TaskAnalysisRepository.write(root, slug, taskName, persisted);
+              } catch (err) {
+                // Any unexpected throw (source read, persist) persists an `error`
+                // placeholder and reports it, without aborting the run.
+                const message = err instanceof Error ? err.message : String(err);
+                const placeholder: PersistedTaskAnalysis = {
+                  ...emptyAnalysis(),
+                  analyzedAt: new Date().toISOString(),
+                  analysisStatus: "error",
+                  analysisError: message,
+                };
+                try {
+                  await TaskAnalysisRepository.write(root, slug, taskName, placeholder);
+                } catch {}
+                send("error", { task: taskName, message });
+              }
+              send("task:complete", { task: taskName });
+            }
+
+            send("complete", { slug });
+          } catch (err) {
+            send("error", { message: err instanceof Error ? err.message : String(err) });
             send("complete", { slug });
-            controller.close();
           } finally {
-            releaseLock(slug);
+            controller.close();
+            releaseOnce();
           }
-        });
+        })();
       },
       cancel() {
         try {
-          releaseLock(slug);
+          releaseOnce();
         } catch {}
       },
     }),

package/src/ui/server/endpoints/schema-file-endpoint.ts

@@ -1,10 +1,18 @@
 import path from "node:path";
 
+import { resolveUnderRoot } from "../../../utils/path-containment";
 import { sendJson } from "../utils/http-utils";
 
-export async function handleSchemaFile(_req: Request, slug: string, filename: string): Promise<Response> {
-  const root = process.env["PO_ROOT"] ?? process.cwd();
-  const filePath = path.join(root, "pipeline-config", slug, "schemas", filename);
+export async function handleSchemaFile(
+  _req: Request,
+  slug: string,
+  filename: string,
+  root: string,
+): Promise<Response> {
+  const filePath = resolveUnderRoot(path.join(root, "pipeline-config"), slug, "schemas", filename);
+  if (filePath === null) {
+    return sendJson(400, { ok: false, code: "BAD_REQUEST", message: "invalid path" });
+  }
   if (!(await Bun.file(filePath).exists())) {
     return sendJson(404, { ok: false, code: "NOT_FOUND", message: "schema file not found" });
   }

package/src/ui/server/endpoints/task-analysis-endpoint.ts

@@ -1,12 +1,28 @@
 import path from "node:path";
 
+import { TaskAnalysisRepository } from "../../../task-analysis/repository";
+import { resolveUnderRoot } from "../../../utils/path-containment";
 import { sendJson } from "../utils/http-utils";
 
-export async function handleTaskAnalysis(_req: Request, slug: string, taskId: string): Promise<Response> {
-  const root = process.env["PO_ROOT"] ?? process.cwd();
-  const filePath = path.join(root, "pipeline-config", slug, "tasks", `${taskId}.analysis.json`);
-  if (!(await Bun.file(filePath).exists())) {
+export async function handleTaskAnalysis(
+  _req: Request,
+  slug: string,
+  taskId: string,
+  root: string,
+): Promise<Response> {
+  const validatedPath = resolveUnderRoot(
+    path.join(root, "pipeline-config"),
+    slug,
+    "tasks",
+    `${taskId}.analysis.json`,
+  );
+  if (validatedPath === null) {
+    return sendJson(400, { ok: false, code: "BAD_PATH", message: "invalid task-analysis path" });
+  }
+
+  const analysis = await TaskAnalysisRepository.readFromPath(validatedPath);
+  if (analysis === null) {
     return sendJson(404, { ok: false, code: "NOT_FOUND", message: "analysis file not found" });
   }
-  return sendJson(200, { ok: true, data: JSON.parse(await Bun.file(filePath).text()) });
+  return sendJson(200, { ok: true, data: analysis });
 }

package/src/ui/server/endpoints/task-save-endpoint.ts

@@ -3,12 +3,11 @@ import path from "node:path";
 
 import { sendJson } from "../utils/http-utils";
 
-export async function handleTaskSave(req: Request): Promise<Response> {
+export async function handleTaskSave(req: Request, root: string): Promise<Response> {
   const body = (await req.json()) as Record<string, unknown>;
   const slug = typeof body["slug"] === "string" ? body["slug"] : "";
   const taskId = typeof body["taskId"] === "string" ? body["taskId"] : "";
   const content = typeof body["content"] === "string" ? body["content"] : "";
-  const root = process.env["PO_ROOT"] ?? process.cwd();
   const taskPath = path.join(root, "pipeline-config", slug, "tasks", `${taskId}.md`);
   await mkdir(path.dirname(taskPath), { recursive: true });
   await Bun.write(taskPath, content);

package/src/ui/server/endpoints/upload-endpoints.ts

@@ -1,21 +1,14 @@
-import { mkdir } from "node:fs/promises";
-import path from "node:path";
-
 import { parseMultipartFormData, sendJson } from "../utils/http-utils";
 import { extractSeedZip } from "../zip-utils";
 import { createErrorResponse } from "../config-bridge";
 import { Constants } from "../config-bridge-node";
-import { resolveWithin } from "../utils/path-containment";
+import { submitUploadedSeed } from "../../../core/job-submission.ts";
 
 export interface SeedUploadResult {
   seedObject: Record<string, unknown>;
   artifacts?: Array<{ filename: string; content: Uint8Array }>;
 }
 
-function nextJobId(): string {
-  return `job-${Date.now()}`;
-}
-
 export async function normalizeSeedUpload(req: Request): Promise<SeedUploadResult> {
   const contentType = req.headers.get("content-type") ?? "";
   if (contentType.includes("application/json")) {
@@ -34,39 +27,11 @@ export async function handleSeedUploadDirect(
   dataDir: string,
   artifacts: Array<{ filename: string; content: Uint8Array }> = [],
 ): Promise<Response> {
-  const jobId = nextJobId();
-  const pipelineData = path.join(dataDir, "pipeline-data");
-  const pendingDir = path.join(pipelineData, "pending");
-
-  // Stage artifacts under staging/{jobId}/ (before the trigger file).
-  // The orchestrator owns current/{jobId}/ and moves staged artifacts into
-  // current/{jobId}/files/artifacts/ during promotion.
-  if (artifacts.length > 0) {
-    const stagingJobDir = path.join(pipelineData, "staging", jobId);
-
-    for (const artifact of artifacts) {
-      if (resolveWithin(stagingJobDir, artifact.filename) === null) {
-        return sendJson(400, createErrorResponse(Constants.ERROR_CODES.BAD_REQUEST, `unsafe artifact path: ${artifact.filename}`));
-      }
-    }
-
-    for (const artifact of artifacts) {
-      const resolved = resolveWithin(stagingJobDir, artifact.filename)!;
-      await mkdir(path.dirname(resolved), { recursive: true });
-      await Bun.write(resolved, artifact.content);
-    }
+  const result = await submitUploadedSeed({ root: dataDir, seedObject, artifacts });
+  if (!result.success) {
+    return sendJson(400, createErrorResponse(Constants.ERROR_CODES.BAD_REQUEST, result.message));
   }
-
-  // Write the seed to pending/ as the trigger file for the orchestrator.
-  // The orchestrator watches pending/*.json and handles the full lifecycle:
-  // move to current/, write tasks-status.json, and spawn the pipeline runner.
-  await mkdir(pendingDir, { recursive: true });
-  await Bun.write(
-    path.join(pendingDir, `${jobId}-seed.json`),
-    JSON.stringify(seedObject, null, 2),
-  );
-
-  return sendJson(201, { ok: true, data: { jobId } });
+  return sendJson(201, { ok: true, data: { jobId: result.jobId } });
 }
 
 export async function handleSeedUpload(req: Request, dataDir: string): Promise<Response> {

package/src/ui/server/index.ts

@@ -1,7 +1,8 @@
 import path from "node:path";
 
-import { getPipelineDataDir } from "../../config/paths";
-import { getOrchestratorConfig } from "../../core/config";
+import { emitSseEvent, type SseEvent } from "../../config/sse-events.ts";
+import { getPipelineDataDir, resolveWorkspaceRoot } from "../../config/paths";
+import { getConfig, getOrchestratorConfig } from "../../core/config";
 import { loadEnvironment } from "../../core/environment";
 import { getConcurrencyRuntimePaths } from "../../core/job-concurrency";
 import { createLogger } from "../../core/logger";
@@ -19,7 +20,8 @@ import { sseRegistry } from "./sse-registry";
 const logger = createLogger("ui-server");
 
 export interface ServerOptions {
-  dataDir: string;
+  /** Workspace root (not the `pipeline-data` subdir); omitted values fall back to `PO_ROOT` at boot. */
+  dataDir?: string;
   port?: number;
 }
 
@@ -62,8 +64,8 @@ export async function initializeWatcher(dataDir: string): Promise<void> {
   );
 }
 
-export function createServer(dataDir?: string): { fetch: (req: Request) => Promise<Response> } {
-  const resolvedDataDir = dataDir ?? process.env["PO_ROOT"] ?? process.cwd();
+export function createServer(dataDir: string): { fetch: (req: Request) => Promise<Response> } {
+  const resolvedDataDir = dataDir;
   const rawOrigins = process.env["PO_CORS_ORIGINS"];
   const allowNull = process.env["PO_CORS_ALLOW_NULL_ORIGIN"];
   const cors = parseCorsConfig(rawOrigins, allowNull === "1" || allowNull === "true");
@@ -72,18 +74,21 @@ export function createServer(dataDir?: string): { fetch: (req: Request) => Promi
 }
 
 export async function startServer(options: ServerOptions): Promise<ServerHandle> {
-  if (process.env["NODE_ENV"] !== "test" && !process.env["PO_ROOT"]) {
-    throw new Error("PO_ROOT is required in non-test environments");
-  }
+  const root = resolveWorkspaceRoot(options.dataDir);
 
-  await loadEnvironment({ rootDir: options.dataDir });
-  initPATHS(options.dataDir);
+  await loadEnvironment({ rootDir: root });
+  getConfig();
+  initPATHS(root);
 
   const port = options.port ?? 4000;
-  const app = createServer(options.dataDir);
+  const app = createServer(root);
 
   let heartbeat: ReturnType<typeof setInterval> | null = setInterval(() => {
-    sseRegistry.broadcast("heartbeat", { ok: true, timestamp: new Date().toISOString() });
+    const event: SseEvent = {
+      type: "heartbeat",
+      data: { ok: true, timestamp: new Date().toISOString() },
+    };
+    emitSseEvent(sseRegistry, event);
   }, 30_000);
 
   let server: Bun.Server<undefined> | null = null;
@@ -112,7 +117,7 @@ export async function startServer(options: ServerOptions): Promise<ServerHandle>
   ]);
   await startup;
   try {
-    await initializeWatcher(options.dataDir);
+    await initializeWatcher(root);
   } catch (error) {
     if (heartbeat) clearInterval(heartbeat);
     heartbeat = null;
@@ -164,7 +169,7 @@ if (
   process.argv[1] !== process.execPath &&
   import.meta.url === Bun.pathToFileURL(process.argv[1]).href
 ) {
-  const dataDir = process.env["PO_ROOT"] ?? process.cwd();
+  const dataDir = process.env["PO_ROOT"];
   startServer({ dataDir }).catch((err) => {
     console.error("Failed to start server:", err);
     process.exit(1);

package/src/ui/server/job-reader.ts

@@ -1,9 +1,12 @@
+import { join } from "node:path";
+
 import type { ErrorEnvelope } from "./config-bridge";
 import {
   Constants,
   createErrorResponse,
   getTasksStatusPath,
   isLocked,
+  resolvePipelinePaths,
   validateJobId,
 } from "./config-bridge-node";
 import { getFileReadingStats, readFileWithRetry } from "./file-reader";
@@ -30,13 +33,22 @@ export interface JobReadingStats {
 
 const READ_LOCATIONS = ["current", "complete"] as const;
 
-export async function readJob(jobId: string): Promise<JobReadResult> {
+function getTasksStatusPathForRoot(
+  jobId: string,
+  location: (typeof READ_LOCATIONS)[number],
+  root?: string,
+): string {
+  if (root === undefined) return getTasksStatusPath(jobId, location);
+  return join(resolvePipelinePaths(root)[location], jobId, "tasks-status.json");
+}
+
+export async function readJob(jobId: string, root?: string): Promise<JobReadResult> {
   if (!validateJobId(jobId)) {
     return { ...createErrorResponse(Constants.ERROR_CODES.BAD_REQUEST, "invalid job id"), jobId, location: "" };
   }
 
   for (const location of READ_LOCATIONS) {
-    const path = getTasksStatusPath(jobId, location);
+    const path = getTasksStatusPathForRoot(jobId, location, root);
     const result = await readFileWithRetry(path);
     if (!result.ok) {
       if (result.code === Constants.ERROR_CODES.NOT_FOUND) continue;