@ryanfw/prompt-orchestration-pipeline 1.3.2 → 1.3.4

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

@@ -3,6 +3,7 @@ import path from "node:path";
 import { readJob } from "../job-reader";
 import { sendJson } from "../utils/http-utils";
 import { getMimeType, isTextMime } from "../utils/mime-types";
+import { resolveWithin } from "../../../utils/path-containment";
 
 export function validateFileName(filename: string): boolean {
   return Boolean(
@@ -20,8 +21,7 @@ type TaskFiles = {
   tmp: string[];
 };
 
-function getJobFilesBase(location: string, jobId: string): string {
-  const root = process.env["PO_ROOT"] ?? process.cwd();
+function getJobFilesBase(location: string, jobId: string, root: string): string {
   return path.join(root, "pipeline-data", location, jobId, "files");
 }
 
@@ -49,25 +49,27 @@ function getTaskFiles(data: Record<string, unknown>, taskId: string): TaskFiles
   };
 }
 
-export async function handleTaskFileList(req: Request, jobId: string, taskId: string): Promise<Response> {
+export async function handleTaskFileList(req: Request, jobId: string, taskId: string, root: string): Promise<Response> {
   const type = new URL(req.url).searchParams.get("type") ?? "artifacts";
   if (!validateFileName(type)) return sendJson(400, { ok: false, code: "BAD_REQUEST", message: "invalid file type" });
-  const job = await readJob(jobId);
+  const job = await readJob(jobId, root);
   if (!job.ok) return sendJson(404, job);
 
   const files = getTaskFiles(job.data, taskId);
   return sendJson(200, { ok: true, data: files[type as keyof TaskFiles] ?? [] });
 }
 
-export async function handleTaskFile(req: Request, jobId: string, taskId: string): Promise<Response> {
+export async function handleTaskFile(req: Request, jobId: string, taskId: string, root: string): Promise<Response> {
   const url = new URL(req.url);
   const type = url.searchParams.get("type") ?? "artifacts";
   const filename = url.searchParams.get("filename") ?? "";
-  if (!validateFileName(type) || !validateFileName(filename)) {
+  const job = await readJob(jobId, root);
+  if (!job.ok) return sendJson(404, job);
+
+  const filePath = resolveWithin(getJobFilesBase(job.location, jobId, root), path.join(type, filename));
+  if (filePath === null) {
     return sendJson(400, { ok: false, code: "BAD_REQUEST", message: "invalid filename" });
   }
-  const job = await readJob(jobId);
-  if (!job.ok) return sendJson(404, job);
 
   const taskFiles = getTaskFiles(job.data, taskId);
   const allowedFiles = taskFiles[type as keyof TaskFiles] ?? [];
@@ -75,9 +77,12 @@ export async function handleTaskFile(req: Request, jobId: string, taskId: string
     return sendJson(404, { ok: false, code: "NOT_FOUND", message: `file not found for task: ${type}/${filename}` });
   }
 
-  const filePath = path.join(getJobFilesBase(job.location, jobId), type, filename);
+  const file = Bun.file(filePath);
+  if (!(await file.exists())) {
+    return sendJson(404, { ok: false, code: "NOT_FOUND", message: `file not found for task: ${type}/${filename}` });
+  }
   const mime = getMimeType(filename);
-  const buffer = new Uint8Array(await Bun.file(filePath).arrayBuffer());
+  const buffer = new Uint8Array(await file.arrayBuffer());
   return sendJson(200, {
     ok: true,
     data: isTextMime(mime) ? new TextDecoder().decode(buffer) : Buffer.from(buffer).toString("base64"),

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

@@ -9,12 +9,8 @@ import { releaseJobSlot } from "../../../core/job-concurrency";
 import { appendRunEvent } from "../../../core/run-events";
 import { readJobStatus, writeJobStatus, StatusCorruptError } from "../../../core/status-writer";
 import { assertStatusParseable, statusCorruptResponse } from "../utils/status-corruption";
-import {
-  acquireConcurrencySlot,
-  isProcessAlive,
-  readRunnerPid,
-  spawnWithSlot,
-} from "./job-control-endpoints";
+import { acquireConcurrencySlot, spawnWithSlot } from "./job-control-endpoints";
+import { isProcessAlive, readRunnerPid } from "../../../core/runner-liveness";
 
 type GateAction = "approve" | "reject";
 

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

@@ -5,7 +5,6 @@ import { createErrorResponse } from "../config-bridge";
 import { Constants } from "../config-bridge-node";
 import { sendJson } from "../utils/http-utils";
 import { getJobDirectoryPath, getPipelineDataDir } from "../../../config/paths";
-import { deriveJobStatusFromTasks } from "../../../config/statuses";
 import { getOrchestratorConfig, getPipelineConfig } from "../../../core/config";
 import {
   releaseJobSlot,
@@ -13,6 +12,11 @@ import {
   updateJobSlotPid,
   type JobSlotLease,
 } from "../../../core/job-concurrency";
+import {
+  classifyStaleRunningStatus,
+  isProcessAlive,
+  readRunnerPid,
+} from "../../../core/runner-liveness";
 import {
   readJobStatus,
   resetJobFromTask,
@@ -22,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,
@@ -29,29 +37,21 @@ import {
 import { readFileWithRetry } from "../file-reader";
 
 const RUNNER_PATH = path.resolve(import.meta.dir, "../../../core/pipeline-runner.ts");
-const STALE_RUNNING_GRACE_MS = 30_000;
-
-interface StaleRunningInput {
-  status: StatusSnapshot;
-  pid: number | null;
-  pidAlive: boolean;
-  nowMs: number;
-  staleAfterMs: number;
-}
-
-type StaleRunningDecision =
-  | { stale: false; reason: "not_running" | "live_pid" | "fresh_status" | "missing_last_updated" }
-  | { stale: true; runningTaskId: string | null; ageMs: number };
 
 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,
   };
 }
 
@@ -111,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") {
@@ -174,25 +175,6 @@ export async function spawnWithSlot(
   }
 }
 
-export async function readRunnerPid(jobDir: string): Promise<number | null> {
-  try {
-    const content = await Bun.file(path.join(jobDir, "runner.pid")).text();
-    const pid = parseInt(content.trim(), 10);
-    return Number.isNaN(pid) ? null : pid;
-  } catch {
-    return null;
-  }
-}
-
-export function isProcessAlive(pid: number): boolean {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 const KILL_GRACE_MS = 1500;
 const KILL_POLL_MS = 100;
 
@@ -204,43 +186,6 @@ function isNonTerminalTaskState(state: unknown): boolean {
   return state === "pending" || state === "running";
 }
 
-function isDependencySatisfied(state: unknown): boolean {
-  return state === "done";
-}
-
-function getTaskDerivedStatus(snapshot: StatusSnapshot): string {
-  return deriveJobStatusFromTasks(
-    Object.values(snapshot.tasks).map((task) => ({ state: task.state })),
-  );
-}
-
-function findRunningTaskId(snapshot: StatusSnapshot): string | null {
-  if (snapshot.current && snapshot.tasks[snapshot.current]?.state === "running") {
-    return snapshot.current;
-  }
-  return Object.keys(snapshot.tasks).find((taskId) => snapshot.tasks[taskId]?.state === "running") ?? null;
-}
-
-export function classifyStaleRunningStatus(input: StaleRunningInput): StaleRunningDecision {
-  if (getTaskDerivedStatus(input.status) !== "running") {
-    return { stale: false, reason: "not_running" };
-  }
-  if (input.pid !== null && input.pidAlive) {
-    return { stale: false, reason: "live_pid" };
-  }
-  const updatedMs = Date.parse(input.status.lastUpdated);
-  if (!Number.isFinite(updatedMs)) {
-    // No live PID and no parseable timestamp: the runner crashed before writing a
-    // valid lastUpdated. There is no evidence of liveness, so treat as stale.
-    return { stale: true, runningTaskId: findRunningTaskId(input.status), ageMs: 0 };
-  }
-  const ageMs = input.nowMs - updatedMs;
-  if (ageMs < input.staleAfterMs) {
-    return { stale: false, reason: "fresh_status" };
-  }
-  return { stale: true, runningTaskId: findRunningTaskId(input.status), ageMs };
-}
-
 function isTaskLikelyInProgress(task: Record<string, unknown>): boolean {
   const state = task["state"];
   const nonTerminal = isNonTerminalTaskState(state);
@@ -552,7 +497,7 @@ export async function handleJobRestart(
         pid,
         pidAlive,
         nowMs: Date.now(),
-        staleAfterMs: STALE_RUNNING_GRACE_MS,
+        staleAfterMs: getOrchestratorConfig().staleRunningGraceMs,
       });
       // Note: "live_pid" can never be returned here because pidAlive is guaranteed false
       // by the early-return guard above; only "not_running", "fresh_status", or stale=true
@@ -562,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;
 
@@ -631,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);
   }
@@ -764,7 +746,7 @@ export async function handleTaskStart(
       pid,
       pidAlive,
       nowMs: Date.now(),
-      staleAfterMs: STALE_RUNNING_GRACE_MS,
+      staleAfterMs: getOrchestratorConfig().staleRunningGraceMs,
     });
     if (!staleDecision.stale && staleDecision.reason !== "not_running") {
       return sendJson(409, createErrorResponse("job_running", "Job is currently running (task-level running)"));
@@ -789,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

@@ -60,6 +60,12 @@ export async function handleJobDetail(jobId: string): Promise<Response> {
 
   const result = await readJob(jobId);
   if (!result.ok) {
+    if (result.code === Constants.ERROR_CODES.INVALID_JSON) {
+      return sendJson(
+        409,
+        createErrorResponse(Constants.ERROR_CODES.STATUS_CORRUPT, result.message, result.path),
+      );
+    }
     const status = result.code === Constants.ERROR_CODES.JOB_NOT_FOUND ? 404 : 400;
     return sendJson(status, result);
   }
@@ -74,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/meta-endpoint.ts

@@ -1,7 +1,7 @@
 import { sendJson } from "../utils/http-utils";
 import pkg from "../../../../package.json";
 
-export const PROTOCOL_VERSION = 1;
+export const PROTOCOL_VERSION = 2;
 
 export function handleMeta(): Response {
   return sendJson(200, {

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" });
   }