npm - @ryanfw/prompt-orchestration-pipeline - Versions diffs - 1.3.1 → 1.3.2 - Mend

@ryanfw/prompt-orchestration-pipeline 1.3.1 → 1.3.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (31) hide show

package/docs/pop-task-guide.md +1 -0
package/package.json +1 -2
package/src/core/__tests__/agent-step.test.ts +322 -3
package/src/core/__tests__/task-runner.test.ts +57 -1
package/src/core/agent-step.ts +231 -14
package/src/core/agent-types.ts +3 -0
package/src/core/file-io.ts +8 -74
package/src/core/pipeline-runner.ts +54 -3
package/src/core/status-writer.ts +44 -26
package/src/core/task-runner.ts +27 -3
package/src/harness/__tests__/discovery.test.ts +60 -8
package/src/harness/discovery.ts +16 -6
package/src/ui/client/hooks/useJobListWithUpdates.ts +16 -1
package/src/ui/dist/assets/{index-CbS3OsW7.js → index--RH3sAt3.js} +14 -1
package/src/ui/dist/assets/{index-CbS3OsW7.js.map → index--RH3sAt3.js.map} +1 -1
package/src/ui/dist/assets/style-CSSKuMOe.css +2 -0
package/src/ui/dist/index.html +2 -2
package/src/ui/embedded-assets.js +6 -6
package/src/ui/server/__tests__/gate-endpoints.test.ts +90 -0
package/src/ui/server/__tests__/job-control-endpoints.test.ts +188 -0
package/src/ui/server/__tests__/path-containment.test.ts +54 -0
package/src/ui/server/__tests__/status-corruption.test.ts +55 -0
package/src/ui/server/config-bridge.ts +1 -0
package/src/ui/server/endpoints/__tests__/upload-endpoints.test.ts +77 -0
package/src/ui/server/endpoints/gate-endpoints.ts +17 -1
package/src/ui/server/endpoints/job-control-endpoints.ts +36 -2
package/src/ui/server/endpoints/upload-endpoints.ts +13 -3
package/src/ui/server/utils/http-utils.ts +6 -1
package/src/ui/server/utils/path-containment.ts +18 -0
package/src/ui/server/utils/status-corruption.ts +27 -0
package/src/ui/dist/assets/style-BUFg3Sth.css +0 -2

package/src/ui/dist/index.html CHANGED Viewed

@@ -11,8 +11,8 @@
     />
     <title>Prompt Pipeline Dashboard</title>
     <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
-    <script type="module" crossorigin src="/assets/index-CbS3OsW7.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/style-BUFg3Sth.css">
+    <script type="module" crossorigin src="/assets/index--RH3sAt3.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/style-CSSKuMOe.css">
   </head>
   <body>
     <div id="root"></div>

package/src/ui/embedded-assets.js CHANGED Viewed

@@ -1,12 +1,12 @@
 // Auto-generated by scripts/generate-embedded-assets.js — do not edit
 import _asset0 from "./dist/index.html" with { type: "file" };
-import _asset1 from "./dist/assets/index-CbS3OsW7.js.map" with { type: "file" };
-import _asset2 from "./dist/assets/style-BUFg3Sth.css" with { type: "file" };
-import _asset3 from "./dist/assets/index-CbS3OsW7.js" with { type: "file" };
+import _asset1 from "./dist/assets/style-CSSKuMOe.css" with { type: "file" };
+import _asset2 from "./dist/assets/index--RH3sAt3.js" with { type: "file" };
+import _asset3 from "./dist/assets/index--RH3sAt3.js.map" with { type: "file" };
 export const embeddedAssets = {
   "/index.html": { path: _asset0, mime: "text/html" },
-  "/assets/index-CbS3OsW7.js.map": { path: _asset1, mime: "application/json" },
-  "/assets/style-BUFg3Sth.css": { path: _asset2, mime: "text/css" },
-  "/assets/index-CbS3OsW7.js": { path: _asset3, mime: "application/javascript" }
+  "/assets/style-CSSKuMOe.css": { path: _asset1, mime: "text/css" },
+  "/assets/index--RH3sAt3.js": { path: _asset2, mime: "application/javascript" },
+  "/assets/index--RH3sAt3.js.map": { path: _asset3, mime: "application/json" }
 };

package/src/ui/server/__tests__/gate-endpoints.test.ts CHANGED Viewed

@@ -74,6 +74,32 @@ function gateRequest(jobId: string, body: unknown): Request {
   });
 }
+function corruptStatusOnTextRead(
+  statusPath: string,
+  readNumber: number,
+  corruptContent = "{ invalid json }",
+): void {
+  const realFile = Bun.file.bind(Bun);
+  let textReads = 0;
+  vi.spyOn(Bun, "file").mockImplementation(((filePath: Parameters<typeof Bun.file>[0], options?: Parameters<typeof Bun.file>[1]) => {
+    const file = realFile(filePath, options);
+    if (String(filePath) !== statusPath) return file;
+    return {
+      exists: () => file.exists(),
+      text: async () => {
+        textReads += 1;
+        if (textReads === readNumber) {
+          await Bun.write(statusPath, corruptContent);
+          return corruptContent;
+        }
+        return file.text();
+      },
+    } as ReturnType<typeof Bun.file>;
+  }) as typeof Bun.file);
+}
 afterEach(async () => {
   vi.restoreAllMocks();
   resetPATHS();
@@ -196,6 +222,70 @@ describe("handleGateDecision", () => {
     expect(body["code"]).toBe("JOB_NOT_FOUND");
   });
+  it("approve returns 409 STATUS_CORRUPT when current tasks-status.json is corrupt", async () => {
+    const root = await makeTempRoot();
+    initPATHS(root);
+    const jobDir = path.join(root, "pipeline-data", "current", "corrupt-approve");
+    await mkdir(jobDir, { recursive: true });
+    const corruptContent = "{ invalid json }";
+    await writeFile(path.join(jobDir, "tasks-status.json"), corruptContent);
+    const res = await handleGateDecision("corrupt-approve", gateRequest("corrupt-approve", { action: "approve" }), root);
+    const body = await res.json() as Record<string, unknown>;
+    expect(res.status).toBe(409);
+    expect(body["code"]).toBe("STATUS_CORRUPT");
+    const fileContent = await readFile(path.join(jobDir, "tasks-status.json"), "utf8");
+    expect(fileContent).toBe(corruptContent);
+  });
+  it("reject returns 409 STATUS_CORRUPT when current tasks-status.json is corrupt", async () => {
+    const root = await makeTempRoot();
+    initPATHS(root);
+    const jobDir = path.join(root, "pipeline-data", "current", "corrupt-reject");
+    await mkdir(jobDir, { recursive: true });
+    const corruptContent = "{ invalid json }";
+    await writeFile(path.join(jobDir, "tasks-status.json"), corruptContent);
+    const res = await handleGateDecision("corrupt-reject", gateRequest("corrupt-reject", { action: "reject" }), root);
+    const body = await res.json() as Record<string, unknown>;
+    expect(res.status).toBe(409);
+    expect(body["code"]).toBe("STATUS_CORRUPT");
+    const fileContent = await readFile(path.join(jobDir, "tasks-status.json"), "utf8");
+    expect(fileContent).toBe(corruptContent);
+  });
+  it("releases the gate slot when the status write detects corruption", async () => {
+    const root = await makeTempRoot();
+    initPATHS(root);
+    const jobDir = await setupJob(root, "write-corrupt-gate", makeSnapshot());
+    const statusPath = path.join(jobDir, "tasks-status.json");
+    corruptStatusOnTextRead(statusPath, 3);
+    const res = await handleGateDecision(
+      "write-corrupt-gate",
+      gateRequest("write-corrupt-gate", { action: "reject" }),
+      root,
+    );
+    const body = await res.json() as Record<string, unknown>;
+    expect(res.status).toBe(409);
+    expect(body["code"]).toBe("STATUS_CORRUPT");
+    expect(body["path"]).toBe(statusPath);
+    expect(await readFile(statusPath, "utf8")).toBe("{ invalid json }");
+    const reacquired = await tryAcquireJobSlot({
+      dataDir: path.join(root, "pipeline-data"),
+      jobId: "write-corrupt-gate",
+      maxConcurrentJobs: 1,
+      source: "gate",
+    });
+    expect(reacquired.ok).toBe(true);
+  });
   it("returns 400 for a bad action", async () => {
     const root = await makeTempRoot();
     initPATHS(root);

package/src/ui/server/__tests__/job-control-endpoints.test.ts CHANGED Viewed

@@ -92,6 +92,32 @@ function spawnSleeper(): Subprocess {
   return proc;
 }
+function corruptStatusOnTextRead(
+  statusPath: string,
+  readNumber: number,
+  corruptContent = "{ invalid json }",
+): void {
+  const realFile = Bun.file.bind(Bun);
+  let textReads = 0;
+  vi.spyOn(Bun, "file").mockImplementation(((filePath: Parameters<typeof Bun.file>[0], options?: Parameters<typeof Bun.file>[1]) => {
+    const file = realFile(filePath, options);
+    if (String(filePath) !== statusPath) return file;
+    return {
+      exists: () => file.exists(),
+      text: async () => {
+        textReads += 1;
+        if (textReads === readNumber) {
+          await Bun.write(statusPath, corruptContent);
+          return corruptContent;
+        }
+        return file.text();
+      },
+    } as ReturnType<typeof Bun.file>;
+  }) as typeof Bun.file);
+}
 afterEach(async () => {
   vi.restoreAllMocks();
   resetPATHS();
@@ -1672,3 +1698,165 @@ describe("concurrency enforcement", () => {
     expect(lease.jobId).toBe("lease-pid");
   });
 });
+describe("corrupt status handling", () => {
+  async function setupCorruptJob(
+    root: string,
+    jobId: string,
+    location: "current" | "complete" = "current",
+    pid?: number,
+  ): Promise<string> {
+    const jobDir = path.join(root, "pipeline-data", location, jobId);
+    await mkdir(jobDir, { recursive: true });
+    await writeFile(path.join(jobDir, "tasks-status.json"), "not-valid-json{{{");
+    if (pid !== undefined) {
+      await writeFile(path.join(jobDir, "runner.pid"), String(pid));
+    }
+    return jobDir;
+  }
+  it("corrupt current status makes handleJobStop return 409 STATUS_CORRUPT", async () => {
+    const root = await makeTempRoot();
+    const jobDir = await setupCorruptJob(root, "corrupt-stop", "current");
+    const req = new Request("http://localhost/api/jobs/corrupt-stop/stop", { method: "POST" });
+    const res = await handleJobStop(req, "corrupt-stop", root);
+    expect(res.status).toBe(409);
+    const body = await res.json() as Record<string, unknown>;
+    expect(body["code"]).toBe("STATUS_CORRUPT");
+    expect(body["path"]).toContain("corrupt-stop");
+    const raw = await readFile(path.join(jobDir, "tasks-status.json"), "utf-8");
+    expect(raw).toBe("not-valid-json{{{");
+  });
+  it("kills a live runner before returning STATUS_CORRUPT for corrupt current status", async () => {
+    const root = await makeTempRoot();
+    const proc = spawnSleeper();
+    const jobDir = await setupCorruptJob(root, "corrupt-stop-live", "current", proc.pid);
+    const req = new Request("http://localhost/api/jobs/corrupt-stop-live/stop", { method: "POST" });
+    const res = await handleJobStop(req, "corrupt-stop-live", root);
+    expect(res.status).toBe(409);
+    const body = await res.json() as Record<string, unknown>;
+    expect(body["code"]).toBe("STATUS_CORRUPT");
+    expect(body["path"]).toContain("corrupt-stop-live");
+    const raw = await readFile(path.join(jobDir, "tasks-status.json"), "utf-8");
+    expect(raw).toBe("not-valid-json{{{");
+    expect(await Bun.file(path.join(jobDir, "runner.pid")).exists()).toBe(false);
+    const exited = await Promise.race([
+      proc.exited.then(() => true),
+      new Promise<boolean>((resolve) => setTimeout(() => resolve(false), 1000)),
+    ]);
+    expect(exited).toBe(true);
+  });
+  it("corrupt current status makes handleJobRestart return 409 STATUS_CORRUPT", async () => {
+    const root = await makeTempRoot();
+    const jobDir = await setupCorruptJob(root, "corrupt-restart", "current");
+    const req = new Request("http://localhost/api/jobs/corrupt-restart/restart", { method: "POST" });
+    const res = await handleJobRestart(req, "corrupt-restart", root);
+    expect(res.status).toBe(409);
+    const body = await res.json() as Record<string, unknown>;
+    expect(body["code"]).toBe("STATUS_CORRUPT");
+    const raw = await readFile(path.join(jobDir, "tasks-status.json"), "utf-8");
+    expect(raw).toBe("not-valid-json{{{");
+  });
+  it("corrupt current status makes handleTaskStart return 409 STATUS_CORRUPT", async () => {
+    const root = await makeTempRoot();
+    const jobDir = await setupCorruptJob(root, "corrupt-task-start", "current");
+    const req = new Request("http://localhost/api/jobs/corrupt-task-start/tasks/research/start", { method: "POST" });
+    const res = await handleTaskStart(req, "corrupt-task-start", "research", root);
+    expect(res.status).toBe(409);
+    const body = await res.json() as Record<string, unknown>;
+    expect(body["code"]).toBe("STATUS_CORRUPT");
+    const raw = await readFile(path.join(jobDir, "tasks-status.json"), "utf-8");
+    expect(raw).toBe("not-valid-json{{{");
+  });
+  it("corrupt complete status makes handleJobRestart return 409 STATUS_CORRUPT", async () => {
+    const root = await makeTempRoot();
+    const jobDir = await setupCorruptJob(root, "corrupt-complete-restart", "complete");
+    const req = new Request("http://localhost/api/jobs/corrupt-complete-restart/restart", { method: "POST" });
+    const res = await handleJobRestart(req, "corrupt-complete-restart", root);
+    expect(res.status).toBe(409);
+    const body = await res.json() as Record<string, unknown>;
+    expect(body["code"]).toBe("STATUS_CORRUPT");
+    const raw = await readFile(path.join(jobDir, "tasks-status.json"), "utf-8");
+    expect(raw).toBe("not-valid-json{{{");
+  });
+  it("releases the restart slot when the status write detects corruption", async () => {
+    const root = await makeTempRoot();
+    const jobDir = await setupJob(root, "write-corrupt-restart", {
+      id: "write-corrupt-restart",
+      state: "pending",
+      current: null,
+      currentStage: null,
+      lastUpdated: "2026-04-01T10:00:00.000Z",
+      tasks: { research: { state: "pending" } },
+      files: { artifacts: [], logs: [], tmp: [] },
+    });
+    const statusPath = path.join(jobDir, "tasks-status.json");
+    corruptStatusOnTextRead(statusPath, 3);
+    const req = new Request("http://localhost/api/jobs/write-corrupt-restart/restart", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ fromTask: "research" }),
+    });
+    const res = await handleJobRestart(req, "write-corrupt-restart", root);
+    const body = await res.json() as Record<string, unknown>;
+    expect(res.status).toBe(409);
+    expect(body["code"]).toBe("STATUS_CORRUPT");
+    expect(body["path"]).toBe(statusPath);
+    expect(await readFile(statusPath, "utf8")).toBe("{ invalid json }");
+    const reacquired = await tryAcquireJobSlot({
+      dataDir: path.join(root, "pipeline-data"),
+      jobId: "write-corrupt-restart",
+      maxConcurrentJobs: 1,
+      source: "restart",
+    });
+    expect(reacquired.ok).toBe(true);
+  });
+  it("maps handleJobStop write-time StatusCorruptError to 409 STATUS_CORRUPT", async () => {
+    const root = await makeTempRoot();
+    const jobDir = await setupJob(root, "write-corrupt-stop", {
+      id: "write-corrupt-stop",
+      state: "running",
+      current: "research",
+      currentStage: null,
+      lastUpdated: "2026-04-01T10:00:00.000Z",
+      tasks: { research: { state: "running" } },
+      files: { artifacts: [], logs: [], tmp: [] },
+    });
+    const statusPath = path.join(jobDir, "tasks-status.json");
+    corruptStatusOnTextRead(statusPath, 2);
+    const req = new Request("http://localhost/api/jobs/write-corrupt-stop/stop", { method: "POST" });
+    const res = await handleJobStop(req, "write-corrupt-stop", root);
+    const body = await res.json() as Record<string, unknown>;
+    expect(res.status).toBe(409);
+    expect(body["code"]).toBe("STATUS_CORRUPT");
+    expect(body["path"]).toBe(statusPath);
+    expect(await readFile(statusPath, "utf8")).toBe("{ invalid json }");
+  });
+});

package/src/ui/server/__tests__/path-containment.test.ts ADDED Viewed

@@ -0,0 +1,54 @@
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { resolveWithin } from "../utils/path-containment";
+describe("resolveWithin", () => {
+  const rootDir = "/app/staging";
+  it("rejects relative path with parent dir escape", () => {
+    expect(resolveWithin(rootDir, "../x")).toBeNull();
+  });
+  it("rejects deeply nested parent dir escape", () => {
+    expect(resolveWithin(rootDir, "../../../../tmp/PWNED.txt")).toBeNull();
+  });
+  it("rejects normalized parent dir escape", () => {
+    expect(resolveWithin(rootDir, "a/../../b")).toBeNull();
+  });
+  it("rejects absolute path", () => {
+    expect(resolveWithin(rootDir, "/etc/passwd")).toBeNull();
+  });
+  it("rejects empty string", () => {
+    expect(resolveWithin(rootDir, "")).toBeNull();
+  });
+  it("rejects non-string input", () => {
+    expect(resolveWithin(rootDir, 42)).toBeNull();
+  });
+  it("rejects string containing NUL byte", () => {
+    expect(resolveWithin(rootDir, "safe\0/../escape")).toBeNull();
+  });
+  it("rejects current-directory root target", () => {
+    expect(resolveWithin(rootDir, ".")).toBeNull();
+  });
+  it("rejects nested path that normalizes to root", () => {
+    expect(resolveWithin(rootDir, "dir/..")).toBeNull();
+  });
+  it("resolves a plain filename within root", () => {
+    const result = resolveWithin(rootDir, "out.json");
+    expect(result).toBe(path.resolve(rootDir, "out.json"));
+  });
+  it("resolves a nested relative path within root", () => {
+    const result = resolveWithin(rootDir, "data/foo.json");
+    expect(result).toBe(path.resolve(rootDir, "data/foo.json"));
+  });
+});

package/src/ui/server/__tests__/status-corruption.test.ts ADDED Viewed

@@ -0,0 +1,55 @@
+import { mkdtempSync } from "node:fs";
+import { mkdir, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { afterEach, describe, expect, it } from "vitest";
+import { StatusCorruptError } from "../../../core/status-writer";
+import { assertKnownJobStatusesParseable, assertStatusParseable, statusCorruptResponse } from "../utils/status-corruption";
+const tempRoots: string[] = [];
+function makeTempRoot(): string {
+  const dir = mkdtempSync(join(tmpdir(), "status-corruption-"));
+  tempRoots.push(dir);
+  return dir;
+}
+afterEach(async () => {
+  await Promise.all(tempRoots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+});
+describe("assertStatusParseable", () => {
+  it("throws StatusCorruptError for corrupt JSON", async () => {
+    const dir = makeTempRoot();
+    const statusPath = join(dir, "tasks-status.json");
+    await Bun.write(statusPath, "{ not valid json }");
+    await expect(assertStatusParseable(statusPath)).rejects.toThrow(StatusCorruptError);
+  });
+  it("resolves for missing file", async () => {
+    await expect(assertStatusParseable("/tmp/nonexistent-path/tasks-status.json")).resolves.toBeUndefined();
+  });
+});
+describe("assertKnownJobStatusesParseable", () => {
+  it("throws StatusCorruptError for a known corrupt complete status", async () => {
+    const root = makeTempRoot();
+    const jobDir = join(root, "pipeline-data", "complete", "job-corrupt");
+    await mkdir(jobDir, { recursive: true });
+    await Bun.write(join(jobDir, "tasks-status.json"), "{ not valid json }");
+    await expect(assertKnownJobStatusesParseable(root, "job-corrupt")).rejects.toThrow(StatusCorruptError);
+  });
+});
+describe("statusCorruptResponse", () => {
+  it("returns 409 with STATUS_CORRUPT code and path", async () => {
+    const err = new StatusCorruptError("/some/path");
+    const response = statusCorruptResponse(err);
+    const body = await response.json() as Record<string, unknown>;
+    expect(response.status).toBe(409);
+    expect(body.code).toBe("STATUS_CORRUPT");
+    expect(body.path).toBe("/some/path");
+  });
+});

package/src/ui/server/config-bridge.ts CHANGED Viewed

@@ -26,6 +26,7 @@ export const Constants = {
     FS_ERROR: "FS_ERROR",
     JOB_NOT_FOUND: "JOB_NOT_FOUND",
     BAD_REQUEST: "BAD_REQUEST",
+    STATUS_CORRUPT: "STATUS_CORRUPT",
   }),
 } as const;

package/src/ui/server/endpoints/__tests__/upload-endpoints.test.ts CHANGED Viewed

@@ -99,4 +99,81 @@ describe("handleSeedUploadDirect", () => {
       await rm(dataDir, { recursive: true, force: true });
     }
   });
+  it("AC-12: unsafe artifact path returns 400 and does not create the escape target", async () => {
+    const dataDir = await mkdtemp(path.join(tmpdir(), "upload-unsafe-"));
+    try {
+      const seedObject = { name: "demo", pipeline: "x" };
+      const response = await handleSeedUploadDirect(seedObject, dataDir, [
+        { filename: "../../../../tmp/PWNED.txt", content: new TextEncoder().encode("pwned") },
+      ]);
+      expect(response.status).toBe(400);
+      const escapeTarget = "/tmp/PWNED.txt";
+      expect(await pathExists(escapeTarget)).toBe(false);
+    } finally {
+      await rm(dataDir, { recursive: true, force: true });
+    }
+  });
+  it("AC-13: mixed safe and unsafe paths return 400 with no partial writes", async () => {
+    const dataDir = await mkdtemp(path.join(tmpdir(), "upload-mixed-"));
+    try {
+      const seedObject = { name: "demo", pipeline: "x" };
+      const artifacts = [
+        { filename: "safe.md", content: new TextEncoder().encode("safe") },
+        { filename: "../../tmp/escape.txt", content: new TextEncoder().encode("escape") },
+      ];
+      const response = await handleSeedUploadDirect(seedObject, dataDir, artifacts);
+      expect(response.status).toBe(400);
+      const stagingRoot = path.join(dataDir, "pipeline-data", "staging");
+      expect(await pathExists(stagingRoot)).toBe(false);
+    } finally {
+      await rm(dataDir, { recursive: true, force: true });
+    }
+  });
+  it("rejects root-normalizing artifact paths without partial writes", async () => {
+    const dataDir = await mkdtemp(path.join(tmpdir(), "upload-root-target-"));
+    try {
+      const seedObject = { name: "demo", pipeline: "x" };
+      const artifacts = [
+        { filename: "safe.md", content: new TextEncoder().encode("safe") },
+        { filename: "dir/..", content: new TextEncoder().encode("root") },
+      ];
+      const response = await handleSeedUploadDirect(seedObject, dataDir, artifacts);
+      expect(response.status).toBe(400);
+      const stagingRoot = path.join(dataDir, "pipeline-data", "staging");
+      expect(await pathExists(stagingRoot)).toBe(false);
+    } finally {
+      await rm(dataDir, { recursive: true, force: true });
+    }
+  });
+  it("AC-14: all-safe artifact paths with nesting return 201 and files present", async () => {
+    const dataDir = await mkdtemp(path.join(tmpdir(), "upload-safe-"));
+    try {
+      const seedObject = { name: "demo", pipeline: "x" };
+      const artifacts = [
+        { filename: "out.json", content: new TextEncoder().encode("{}") },
+        { filename: "data/foo.json", content: new TextEncoder().encode('{"a":1}') },
+      ];
+      const response = await handleSeedUploadDirect(seedObject, dataDir, artifacts);
+      expect(response.status).toBe(201);
+      const body = (await response.json()) as { data: { jobId: string } };
+      const jobId = body.data.jobId;
+      const stagingJobDir = path.join(dataDir, "pipeline-data", "staging", jobId);
+      expect(await pathExists(path.join(stagingJobDir, "out.json"))).toBe(true);
+      expect(await pathExists(path.join(stagingJobDir, "data/foo.json"))).toBe(true);
+    } finally {
+      await rm(dataDir, { recursive: true, force: true });
+    }
+  });
 });

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

@@ -7,7 +7,8 @@ import { getJobDirectoryPath, getPipelineDataDir } from "../../../config/paths";
 import { getOrchestratorConfig } from "../../../core/config";
 import { releaseJobSlot } from "../../../core/job-concurrency";
 import { appendRunEvent } from "../../../core/run-events";
-import { readJobStatus, writeJobStatus } from "../../../core/status-writer";
+import { readJobStatus, writeJobStatus, StatusCorruptError } from "../../../core/status-writer";
+import { assertStatusParseable, statusCorruptResponse } from "../utils/status-corruption";
 import {
   acquireConcurrencySlot,
   isProcessAlive,
@@ -58,6 +59,13 @@ export async function handleGateDecision(
     return sendJson(404, createErrorResponse(Constants.ERROR_CODES.JOB_NOT_FOUND, `job "${jobId}" was not found`));
   }
+  try {
+    await assertStatusParseable(statusPath);
+  } catch (err) {
+    if (err instanceof StatusCorruptError) return statusCorruptResponse(err);
+    throw err;
+  }
   const snapshot = await readJobStatus(jobDir);
   if (!snapshot) {
     return sendJson(500, createErrorResponse("status_unavailable", `job "${jobId}" status could not be read`));
@@ -108,6 +116,14 @@ export async function handleGateDecision(
       slotAcquired = false;
     }
   } catch (error) {
+    if (error instanceof StatusCorruptError) {
+      if (slotAcquired) {
+        const orchestrator = getOrchestratorConfig();
+        await releaseJobSlot(getPipelineDataDir(dataDir), jobId, orchestrator.lockFileTimeout);
+        slotAcquired = false;
+      }
+      return statusCorruptResponse(error);
+    }
     if (slotAcquired) {
       const orchestrator = getOrchestratorConfig();
       await releaseJobSlot(getPipelineDataDir(dataDir), jobId, orchestrator.lockFileTimeout);

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

@@ -19,8 +19,10 @@ import {
   resetJobToCleanSlate,
   resetSingleTask,
   writeJobStatus,
+  StatusCorruptError,
   type StatusSnapshot,
 } from "../../../core/status-writer";
+import { assertKnownJobStatusesParseable, statusCorruptResponse } from "../utils/status-corruption";
 import {
   materializeNormalizedPipelineDefinition,
 } from "../../../core/pipeline-definition";
@@ -454,6 +456,18 @@ export async function resolveJobLifecycle(
   return null;
 }
+async function resolveJobLifecycleByStatusPresence(
+  dataDir: string,
+  jobId: string,
+): Promise<"current" | "complete" | null> {
+  for (const location of READ_LOCATIONS) {
+    const statusPath = path.join(dataDir, "pipeline-data", location, jobId, "tasks-status.json");
+    if (await Bun.file(statusPath).exists()) return location;
+  }
+  return null;
+}
 export function isRestartInProgress(jobId: string): boolean {
   return restartingJobs.has(jobId);
 }
@@ -500,6 +514,9 @@ export async function handleJobRestart(
   }
   try {
+    try { await assertKnownJobStatusesParseable(dataDir, jobId); }
+    catch (err) { if (err instanceof StatusCorruptError) return statusCorruptResponse(err); throw err; }
     // Parse optional request body
     let fromTask: string | undefined;
     let singleTask: boolean | undefined;
@@ -579,6 +596,12 @@ export async function handleJobRestart(
       });
       spawned = true;
     } catch (err) {
+      if (err instanceof StatusCorruptError) {
+        if (!spawned) {
+          await releaseJobSlot(getPipelineDataDir(dataDir), jobId, getOrchestratorRuntimeConfig().lockFileTimeout);
+        }
+        return statusCorruptResponse(err);
+      }
       if (!spawned) {
         await releaseJobSlot(getPipelineDataDir(dataDir), jobId, getOrchestratorRuntimeConfig().lockFileTimeout);
       }
@@ -601,7 +624,7 @@ export async function handleJobStop(
   }
   try {
-    const lifecycle = await resolveJobLifecycle(dataDir, jobId);
+    const lifecycle = await resolveJobLifecycleByStatusPresence(dataDir, jobId);
     if (!lifecycle) {
       return sendJson(404, createErrorResponse(Constants.ERROR_CODES.JOB_NOT_FOUND, `job "${jobId}" was not found`));
     }
@@ -624,10 +647,14 @@ export async function handleJobStop(
       await cleanupRunnerPid(jobDir);
     }
+    try { await assertKnownJobStatusesParseable(dataDir, jobId); }
+    catch (err) { if (err instanceof StatusCorruptError) return statusCorruptResponse(err); throw err; }
     let resetTask: string | null = null;
     // Reset running task and clear root-level fields in a single atomic write.
-    await writeJobStatus(jobDir, (snapshot) => {
+    try {
+      await writeJobStatus(jobDir, (snapshot) => {
       if (snapshot.current && snapshot.tasks[snapshot.current]?.state === "running") {
         resetTask = snapshot.current;
       } else {
@@ -667,6 +694,10 @@ export async function handleJobStop(
       snapshot.currentStage = null;
       snapshot.progress = getProgressPercent(snapshot);
     });
+    } catch (err) {
+      if (err instanceof StatusCorruptError) return statusCorruptResponse(err);
+      throw err;
+    }
     return sendJson(202, {
       ok: true,
@@ -703,6 +734,9 @@ export async function handleTaskStart(
   }
   try {
+    try { await assertKnownJobStatusesParseable(dataDir, jobId); }
+    catch (err) { if (err instanceof StatusCorruptError) return statusCorruptResponse(err); throw err; }
     const lifecycle = await resolveJobLifecycle(dataDir, jobId);
     if (!lifecycle) {
       return sendJson(404, createErrorResponse(Constants.ERROR_CODES.JOB_NOT_FOUND, `job "${jobId}" was not found`));