@ryanfw/prompt-orchestration-pipeline 1.3.2 → 1.3.3

package/src/config/__tests__/statuses.test.ts

@@ -8,6 +8,7 @@ import {
   VALID_JOB_LOCATIONS,
   normalizeTaskState,
   normalizeJobStatus,
+  jobStateToStatus,
   deriveJobStatusFromTasks,
 } from "../statuses";
 
@@ -159,6 +160,10 @@ describe("normalizeJobStatus", () => {
     expect(normalizeJobStatus("completed")).toBe("complete");
   });
 
+  it("handles synonym: done → complete", () => {
+    expect(normalizeJobStatus("done")).toBe("complete");
+  });
+
   it("handles synonym: error → failed", () => {
     expect(normalizeJobStatus("error")).toBe("failed");
   });
@@ -193,6 +198,42 @@ describe("normalizeJobStatus", () => {
   });
 });
 
+describe("jobStateToStatus", () => {
+  it("returns canonical for each recognized JobState", () => {
+    expect(jobStateToStatus("pending")).toBe("pending");
+    expect(jobStateToStatus("running")).toBe("running");
+    expect(jobStateToStatus("waiting")).toBe("waiting");
+    expect(jobStateToStatus("failed")).toBe("failed");
+  });
+
+  it("maps done (persisted JobState) to complete (canonical JobStatusValue)", () => {
+    expect(jobStateToStatus("done")).toBe("complete");
+  });
+
+  it("is case-insensitive and trims whitespace", () => {
+    expect(jobStateToStatus("DONE")).toBe("complete");
+    expect(jobStateToStatus("  failed  ")).toBe("failed");
+    expect(jobStateToStatus("Waiting")).toBe("waiting");
+  });
+
+  it("returns null for non-string input", () => {
+    expect(jobStateToStatus(null)).toBeNull();
+    expect(jobStateToStatus(undefined)).toBeNull();
+    expect(jobStateToStatus(42)).toBeNull();
+    expect(jobStateToStatus({})).toBeNull();
+  });
+
+  it("returns null for unrecognized strings", () => {
+    expect(jobStateToStatus("bogus-state")).toBeNull();
+  });
+
+  it("does not accept JobStatus synonyms that are not JobState values", () => {
+    expect(jobStateToStatus("error")).toBeNull();
+    expect(jobStateToStatus("completed")).toBeNull();
+    expect(jobStateToStatus("complete")).toBeNull();
+  });
+});
+
 describe("deriveJobStatusFromTasks", () => {
   it("returns failed when any task is failed (failed priority)", () => {
     expect(deriveJobStatusFromTasks([{ state: "failed" }, { state: "done" }])).toBe("failed");

package/src/config/statuses.ts

@@ -53,8 +53,9 @@ const TASK_STATE_SYNONYMS: Readonly<Record<string, TaskStateValue>> = Object.fre
   succeeded: "done",
 });
 
-const JOB_STATUS_SYNONYMS: Readonly<Record<string, JobStatusValue>> = Object.freeze({
+export const JOB_STATUS_SYNONYMS: Readonly<Record<string, JobStatusValue>> = Object.freeze({
   completed: "complete",
+  done: "complete",
   error: "failed",
 });
 
@@ -93,6 +94,24 @@ export function normalizeJobStatus(status: unknown): JobStatusValue {
   return "pending";
 }
 
+export function jobStateToStatus(state: unknown): JobStatusValue | null {
+  if (typeof state !== "string") return null;
+  switch (state.toLowerCase().trim()) {
+    case "pending":
+      return "pending";
+    case "running":
+      return "running";
+    case "waiting":
+      return "waiting";
+    case "failed":
+      return "failed";
+    case "done":
+      return "complete";
+    default:
+      return null;
+  }
+}
+
 export function deriveJobStatusFromTasks(
   tasks: ReadonlyArray<{ state: unknown }>,
 ): JobStatusValue {

package/src/core/__tests__/config.test.ts

@@ -1,5 +1,5 @@
 import { describe, test, expect, afterEach } from "bun:test";
-import { defaultConfig, resetConfig, loadConfig, getConfig, getConfigValue, getPipelineConfig } from "../config";
+import { defaultConfig, resetConfig, loadConfig, getConfig, getConfigValue, getPipelineConfig, getOrchestratorConfig } from "../config";
 import type { AppConfig } from "../config";
 import { mkdtemp, writeFile, mkdir, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
@@ -194,6 +194,36 @@ describe("PO_MAX_RUNNING_JOBS env override", () => {
   });
 });
 
+describe("PO_STALE_RUNNING_GRACE_MS env override", () => {
+  afterEach(() => {
+    delete process.env.PO_STALE_RUNNING_GRACE_MS;
+    resetConfig();
+  });
+
+  test("getOrchestratorConfig defaults staleRunningGraceMs to 30000", () => {
+    resetConfig();
+    expect(getOrchestratorConfig().staleRunningGraceMs).toBe(30000);
+  });
+
+  test("getOrchestratorConfig reads PO_STALE_RUNNING_GRACE_MS into orchestrator.staleRunningGraceMs", () => {
+    process.env.PO_STALE_RUNNING_GRACE_MS = "60000";
+    resetConfig();
+    expect(getOrchestratorConfig().staleRunningGraceMs).toBe(60000);
+  });
+
+  test("getOrchestratorConfig rejects non-positive PO_STALE_RUNNING_GRACE_MS", () => {
+    process.env.PO_STALE_RUNNING_GRACE_MS = "-1";
+    resetConfig();
+    expect(() => getOrchestratorConfig()).toThrow("orchestrator.staleRunningGraceMs");
+  });
+
+  test("getOrchestratorConfig rejects non-integer PO_STALE_RUNNING_GRACE_MS", () => {
+    process.env.PO_STALE_RUNNING_GRACE_MS = "1.5";
+    resetConfig();
+    expect(() => getOrchestratorConfig()).toThrow("orchestrator.staleRunningGraceMs");
+  });
+});
+
 describe("getConfig", () => {
   afterEach(() => {
     resetConfig();

package/src/core/__tests__/job-concurrency.test.ts

@@ -9,9 +9,11 @@ import {
   getJobConcurrencyStatus,
   listQueuedSeeds,
   pruneStaleJobSlots,
+  readJobSlotLease,
   releaseJobSlot,
   tryAcquireJobSlot,
   updateJobSlotPid,
+  withRuntimeLock,
   type JobSlotLease,
 } from "../job-concurrency";
 import { readFile } from "node:fs/promises";
@@ -552,3 +554,61 @@ describe("getJobConcurrencyStatus", () => {
     }
   });
 });
+
+describe("readJobSlotLease", () => {
+  test("returns the lease written by tryAcquireJobSlot", async () => {
+    const dir = await setupJobsDir("read-lease-acquired-");
+    try {
+      await makeCurrent(dir, "job-a");
+      const acquired = await tryAcquireJobSlot({
+        dataDir: dir,
+        jobId: "job-a",
+        maxConcurrentJobs: 2,
+        source: "orchestrator",
+        pid: process.pid,
+      });
+      expect(acquired.ok).toBe(true);
+
+      const lease = await readJobSlotLease(dir, "job-a");
+      expect(lease).not.toBeNull();
+      expect(lease!.jobId).toBe("job-a");
+      expect(lease!.pid).toBe(process.pid);
+      expect(lease!.source).toBe("orchestrator");
+    } finally {
+      await rm(dir, { recursive: true });
+    }
+  });
+
+  test("returns null for an unknown job", async () => {
+    const dir = await setupJobsDir("read-lease-unknown-");
+    try {
+      expect(await readJobSlotLease(dir, "unknown")).toBeNull();
+    } finally {
+      await rm(dir, { recursive: true });
+    }
+  });
+});
+
+describe("withRuntimeLock", () => {
+  test("serializes two concurrent callers", async () => {
+    const dir = await setupJobsDir("runtime-lock-serialize-");
+    const markerPath = join(dir, "marker.txt");
+    const events: string[] = [];
+    try {
+      const a = withRuntimeLock(dir, 5000, async () => {
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        await writeFile(markerPath, "from-a");
+        events.push("a-wrote");
+      });
+      const b = withRuntimeLock(dir, 5000, async () => {
+        const observed = await readFile(markerPath, "utf-8");
+        events.push(`b-read:${observed}`);
+      });
+      await Promise.all([a, b]);
+
+      expect(events).toEqual(["a-wrote", "b-read:from-a"]);
+    } finally {
+      await rm(dir, { recursive: true });
+    }
+  });
+});