@ryanfw/prompt-orchestration-pipeline 1.2.4 → 1.2.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryanfw/prompt-orchestration-pipeline",
-  "version": "1.2.4",
+  "version": "1.2.5",
   "description": "A Prompt-orchestration pipeline (POP) is a framework for building, running, and experimenting with complex chains of LLM tasks.",
   "type": "module",
   "main": "src/ui/server/index.ts",

package/src/core/__tests__/task-runner.test.ts

@@ -4,6 +4,7 @@ import os from "node:os";
 import path from "node:path";
 
 import { runPipeline } from "../task-runner";
+import type { StatusSnapshot } from "../status-writer";
 
 const tempRoots: string[] = [];
 
@@ -57,3 +58,157 @@ describe("runPipeline log tracking", () => {
     ]);
   });
 });
+
+describe("task-runner does not write job-level status fields", () => {
+  it("does not set snapshot.state, snapshot.current, snapshot.currentStage, or snapshot.progress on success", async () => {
+    const root = await makeTempRoot();
+    const workDir = path.join(root, "job-1");
+    await mkdir(workDir, { recursive: true });
+    await writeFile(path.join(workDir, "seed.json"), JSON.stringify({ topic: "x" }));
+    await writeFile(
+      path.join(workDir, "tasks-status.json"),
+      JSON.stringify({ id: "job-1", state: "pending", current: null, currentStage: null, tasks: {} }),
+    );
+
+    const modulePath = path.join(root, "task-module.mjs");
+    await writeFile(
+      modulePath,
+      "export const ingestion = async ({ flags }) => ({ output: { ok: true }, flags });",
+    );
+
+    const result = await runPipeline(modulePath, {
+      workDir,
+      taskName: "research",
+      statusPath: path.join(workDir, "tasks-status.json"),
+      jobId: "job-1",
+      envLoaded: true,
+      seed: { data: { topic: "x" } },
+      pipelineTasks: ["research"],
+      llm: {} as never,
+    });
+
+    expect(result.ok).toBe(true);
+
+    const status = JSON.parse(await readFile(path.join(workDir, "tasks-status.json"), "utf8")) as StatusSnapshot;
+
+    // Job-level fields must remain untouched by task-runner
+    expect(status.state).toBe("pending");
+    expect(status.current).toBeNull();
+    expect(status.currentStage).toBeNull();
+    expect(status.progress).toBeUndefined();
+  });
+
+  it("does not set snapshot.state on task failure", async () => {
+    const root = await makeTempRoot();
+    const workDir = path.join(root, "job-1");
+    await mkdir(workDir, { recursive: true });
+    await writeFile(path.join(workDir, "seed.json"), JSON.stringify({ topic: "x" }));
+    await writeFile(
+      path.join(workDir, "tasks-status.json"),
+      JSON.stringify({ id: "job-1", state: "pending", current: null, currentStage: null, tasks: {} }),
+    );
+
+    const modulePath = path.join(root, "task-module.mjs");
+    await writeFile(
+      modulePath,
+      'export const ingestion = async () => { throw new Error("boom"); };',
+    );
+
+    const result = await runPipeline(modulePath, {
+      workDir,
+      taskName: "research",
+      statusPath: path.join(workDir, "tasks-status.json"),
+      jobId: "job-1",
+      envLoaded: true,
+      seed: { data: { topic: "x" } },
+      pipelineTasks: ["research"],
+      llm: {} as never,
+    });
+
+    expect(result.ok).toBe(false);
+
+    const status = JSON.parse(await readFile(path.join(workDir, "tasks-status.json"), "utf8")) as StatusSnapshot;
+
+    // Job-level state must remain "pending" -- task-runner does not own it
+    expect(status.state).toBe("pending");
+    expect(status.current).toBeNull();
+    expect(status.currentStage).toBeNull();
+  });
+});
+
+describe("task-runner writes correct task-level state transitions", () => {
+  it("transitions task through running -> done on success", async () => {
+    const root = await makeTempRoot();
+    const workDir = path.join(root, "job-1");
+    await mkdir(workDir, { recursive: true });
+    await writeFile(path.join(workDir, "seed.json"), JSON.stringify({ topic: "x" }));
+    await writeFile(
+      path.join(workDir, "tasks-status.json"),
+      JSON.stringify({ id: "job-1", state: "pending", current: null, currentStage: null, tasks: {} }),
+    );
+
+    const modulePath = path.join(root, "task-module.mjs");
+    await writeFile(
+      modulePath,
+      "export const ingestion = async ({ flags }) => ({ output: { ok: true }, flags });",
+    );
+
+    const result = await runPipeline(modulePath, {
+      workDir,
+      taskName: "research",
+      statusPath: path.join(workDir, "tasks-status.json"),
+      jobId: "job-1",
+      envLoaded: true,
+      seed: { data: { topic: "x" } },
+      pipelineTasks: ["research"],
+      llm: {} as never,
+    });
+
+    expect(result.ok).toBe(true);
+
+    const status = JSON.parse(await readFile(path.join(workDir, "tasks-status.json"), "utf8")) as StatusSnapshot;
+    const task = status.tasks["research"];
+
+    expect(task).toBeDefined();
+    expect(task!.state).toBe("done");
+    expect(task!.currentStage).toBeNull();
+  });
+
+  it("transitions task to failed with error details on stage failure", async () => {
+    const root = await makeTempRoot();
+    const workDir = path.join(root, "job-1");
+    await mkdir(workDir, { recursive: true });
+    await writeFile(path.join(workDir, "seed.json"), JSON.stringify({ topic: "x" }));
+    await writeFile(
+      path.join(workDir, "tasks-status.json"),
+      JSON.stringify({ id: "job-1", state: "pending", current: null, currentStage: null, tasks: {} }),
+    );
+
+    const modulePath = path.join(root, "task-module.mjs");
+    await writeFile(
+      modulePath,
+      'export const ingestion = async () => { throw new Error("stage exploded"); };',
+    );
+
+    const result = await runPipeline(modulePath, {
+      workDir,
+      taskName: "research",
+      statusPath: path.join(workDir, "tasks-status.json"),
+      jobId: "job-1",
+      envLoaded: true,
+      seed: { data: { topic: "x" } },
+      pipelineTasks: ["research"],
+      llm: {} as never,
+    });
+
+    expect(result.ok).toBe(false);
+
+    const status = JSON.parse(await readFile(path.join(workDir, "tasks-status.json"), "utf8")) as StatusSnapshot;
+    const task = status.tasks["research"];
+
+    expect(task).toBeDefined();
+    expect(task!.state).toBe("failed");
+    expect(task!.failedStage).toBe("ingestion");
+    expect(task!.error).toBe("stage exploded");
+  });
+});

package/src/core/orchestrator.ts

@@ -102,6 +102,8 @@ import { createTaskFileIO, generateLogName } from "./file-io";
 import { LogEvent, LogFileExtension } from "../config/log-events";
 import { getConfig, getPipelineConfig } from "./config";
 import { buildReexecArgs } from "../cli/self-reexec";
+import { writeJobStatus } from "./status-writer";
+import { initializeStatusFromArtifacts } from "./status-initializer";
 
 /**
  * Normalize any path that may already include `pipeline-data` (or subdirs
@@ -291,11 +293,10 @@ export async function handleSeedAdd(
     JSON.stringify(status, null, 2)
   );
 
+  const normalizedPipelineTasks = pipelineTasks.map((name) => ({ id: name }));
   try {
-    const mod = await import("./status-initializer");
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
-    const fn = (mod as unknown as { initializeStatusFromArtifacts: (jobDir: string, status: JobStatusInit) => Promise<void> }).initializeStatusFromArtifacts;
-    await fn(jobDir, status);
+    const applyArtifacts = await initializeStatusFromArtifacts({ jobDir, pipeline: { tasks: normalizedPipelineTasks } });
+    await writeJobStatus(jobDir, applyArtifacts);
   } catch {
     logger.warn(`status-initializer unavailable or failed for job ${jobId}; proceeding with base status`);
   }

package/src/core/pipeline-runner.ts

@@ -346,7 +346,9 @@ export async function runPipelineJob(jobId: string): Promise<void> {
 
     // Update status to RUNNING
     await writeJobStatus(config.workDir, (snapshot) => {
+      snapshot.state = "running";
       snapshot.current = taskName;
+      snapshot.currentStage = null;
       const taskEntry = snapshot.tasks[taskName] ?? {};
       taskEntry.state = "running";
       taskEntry.startedAt = new Date().toISOString();
@@ -452,6 +454,8 @@ export async function runPipelineJob(jobId: string): Promise<void> {
 
       // Update status to FAILED
       await writeJobStatus(config.workDir, (snapshot) => {
+        snapshot.state = "failed";
+        snapshot.current = taskName;
         const raw = (snapshot.tasks[taskName] ?? {}) as Record<string, unknown>;
         raw["state"] = TaskState.FAILED;
         raw["endedAt"] = new Date().toISOString();
@@ -471,6 +475,11 @@ export async function runPipelineJob(jobId: string): Promise<void> {
 
   // On full pipeline completion (not single-task mode), finalize the job
   if (!runSingleTask) {
+    await writeJobStatus(config.workDir, (snapshot) => {
+      snapshot.state = "done";
+      snapshot.current = null;
+      snapshot.currentStage = null;
+    });
     const finalStatusText = await Bun.file(config.statusPath).text();
     const finalStatus = JSON.parse(finalStatusText) as JobStatus;
     await completeJob(config, finalStatus, pipelineArtifacts);

package/src/core/task-runner.ts

@@ -4,7 +4,7 @@
 import { mkdir } from "node:fs/promises";
 import { dirname, isAbsolute, join } from "node:path";
 import { pathToFileURL } from "node:url";
-import { KNOWN_STAGES, computeDeterministicProgress } from "./progress";
+import { KNOWN_STAGES } from "./progress";
 import type { StageName } from "./progress";
 import { createTaskFileIO, generateLogName, trackFile } from "./file-io";
 import type { TaskFileIO } from "./file-io";
@@ -629,9 +629,6 @@ export async function runPipeline(
       // Write stage-start status (swallow errors)
       try {
         await writeJobStatus(jobDir, (snapshot: StatusSnapshot) => {
-          snapshot.state = TaskState.RUNNING;
-          snapshot.current = taskName;
-          snapshot.currentStage = stageName;
           if (!snapshot.tasks[taskName]) snapshot.tasks[taskName] = {};
           snapshot.tasks[taskName]!.state = TaskState.RUNNING;
           snapshot.tasks[taskName]!.currentStage = stageName;
@@ -705,15 +702,9 @@ export async function runPipeline(
       context.logs.push(auditEntry);
       returnedLogs.push(auditEntry);
 
-      // Write stage-completion status with progress (swallow errors)
+      // Write stage-completion status (swallow errors)
       try {
-        const progress = computeDeterministicProgress(
-          pipelineTasks ?? [taskName],
-          taskName,
-          stageName,
-        );
         await writeJobStatus(jobDir, (snapshot: StatusSnapshot) => {
-          snapshot.progress = progress;
           if (!snapshot.tasks[taskName]) snapshot.tasks[taskName] = {};
           snapshot.tasks[taskName]!.currentStage = stageName;
         });
@@ -769,7 +760,6 @@ export async function runPipeline(
       // Write failure status (swallow errors)
       try {
         await writeJobStatus(jobDir, (snapshot: StatusSnapshot) => {
-          snapshot.state = TaskState.FAILED;
           if (!snapshot.tasks[taskName]) snapshot.tasks[taskName] = {};
           snapshot.tasks[taskName]!.state = TaskState.FAILED;
           snapshot.tasks[taskName]!.failedStage = stageName;
@@ -806,10 +796,6 @@ export async function runPipeline(
   // Write done status (best-effort)
   try {
     await writeJobStatus(jobDir, (snapshot: StatusSnapshot) => {
-      snapshot.state = TaskState.DONE;
-      snapshot.progress = 100;
-      snapshot.current = null;
-      snapshot.currentStage = null;
       if (!snapshot.tasks[taskName]) snapshot.tasks[taskName] = {};
       snapshot.tasks[taskName]!.state = TaskState.DONE;
       snapshot.tasks[taskName]!.currentStage = null;

package/src/providers/base.ts

@@ -13,7 +13,8 @@ const RETRYABLE_ERROR_CODES = new Set([
   "ETIMEDOUT",
   "ECONNREFUSED",
 ]);
-const RETRYABLE_MESSAGE_PATTERN = /network|timeout|connection|socket|protocol|read ECONNRESET|fetch failed/i;
+const RETRYABLE_MESSAGE_PATTERN =
+  /network|timeout|connection|socket|protocol|read ECONNRESET|fetch failed/i;
 
 /**
  * Splits a messages array into system, user, and assistant parts.

package/src/ui/components/UploadSeed.tsx

@@ -19,7 +19,8 @@ export default function UploadSeed({
 }) {
   const inputRef = useRef<HTMLInputElement | null>(null);
   const [error, setError] = useState<string | null>(null);
-  const [isUploading, setIsUploading] = useState(false);
+  const [pendingUploads, setPendingUploads] = useState(0);
+  const isUploading = pendingUploads > 0;
   const [isDragging, setIsDragging] = useState(false);
 
   const hint = useMemo(() => (isDragging ? "Drop seed file" : "Upload JSON or ZIP seed"), [isDragging]);
@@ -33,7 +34,7 @@ export default function UploadSeed({
     const formData = new FormData();
     formData.append("file", file);
 
-    setIsUploading(true);
+    setPendingUploads((n) => n + 1);
     setError(null);
     try {
       const response = await fetch("/api/upload/seed", {
@@ -49,7 +50,7 @@ export default function UploadSeed({
     } catch (uploadError) {
       setError(normalizeUploadError(uploadError));
     } finally {
-      setIsUploading(false);
+      setPendingUploads((n) => n - 1);
     }
   };
 
@@ -68,8 +69,8 @@ export default function UploadSeed({
         onDrop={(event) => {
           event.preventDefault();
           setIsDragging(false);
-          const file = event.dataTransfer.files[0];
-          if (file) void uploadFile(file);
+          const files = Array.from(event.dataTransfer.files);
+          for (const file of files) void uploadFile(file);
         }}
       >
         <p>{hint}</p>
@@ -80,10 +81,11 @@ export default function UploadSeed({
           ref={inputRef}
           type="file"
           hidden
+          multiple
           accept=".json,.zip,application/json,application/zip"
           onChange={(event) => {
-            const file = event.target.files?.[0];
-            if (file) void uploadFile(file);
+            const files = Array.from(event.target.files ?? []);
+            for (const file of files) void uploadFile(file);
           }}
         />
       </div>

package/src/ui/components/__tests__/UploadSeed.test.tsx

@@ -45,6 +45,74 @@ test("UploadSeed posts dropped files and reports success", async () => {
   expect(onUploadSuccess).toHaveBeenCalledWith({ jobName: "test-job" });
 });
 
+test("UploadSeed uploads all dropped files independently", async () => {
+  let callCount = 0;
+  fetchMock.mockImplementation((_input, _init) => {
+    callCount++;
+    const jobName = `job-${callCount}`;
+    return Promise.resolve(
+      new Response(
+        JSON.stringify({ ok: true, data: { jobName } }),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      ),
+    );
+  });
+
+  const onUploadSuccess = mock((_result: { jobName: string }) => {});
+  const view = render(<UploadSeed onUploadSuccess={onUploadSuccess} />);
+  const fileA = new File(['{"a":1}'], "a.json", { type: "application/json" });
+  const fileB = new File(['{"b":2}'], "b.json", { type: "application/json" });
+  const fileC = new File([new ArrayBuffer(8)], "c.zip", { type: "application/zip" });
+  const dropZone = view.getByText("Upload JSON or ZIP seed").parentElement as Element;
+
+  await act(async () => {
+    fireEvent.drop(dropZone, {
+      dataTransfer: { files: [fileA, fileB, fileC] },
+    });
+  });
+
+  expect(fetchMock).toHaveBeenCalledTimes(3);
+  expect(onUploadSuccess).toHaveBeenCalledTimes(3);
+});
+
+test("UploadSeed one failed file does not block other uploads", async () => {
+  let callCount = 0;
+  fetchMock.mockImplementation((_input, _init) => {
+    callCount++;
+    if (callCount === 2) {
+      return Promise.resolve(
+        new Response(
+          JSON.stringify({ ok: false, message: "bad file" }),
+          { status: 400, headers: { "Content-Type": "application/json" } },
+        ),
+      );
+    }
+    return Promise.resolve(
+      new Response(
+        JSON.stringify({ ok: true, data: { jobName: `job-${callCount}` } }),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      ),
+    );
+  });
+
+  const onUploadSuccess = mock((_result: { jobName: string }) => {});
+  const view = render(<UploadSeed onUploadSuccess={onUploadSuccess} />);
+  const fileA = new File(['{"a":1}'], "a.json", { type: "application/json" });
+  const fileB = new File(['{"b":2}'], "b.json", { type: "application/json" });
+  const fileC = new File(['{"c":3}'], "c.json", { type: "application/json" });
+  const dropZone = view.getByText("Upload JSON or ZIP seed").parentElement as Element;
+
+  await act(async () => {
+    fireEvent.drop(dropZone, {
+      dataTransfer: { files: [fileA, fileB, fileC] },
+    });
+  });
+
+  expect(fetchMock).toHaveBeenCalledTimes(3);
+  expect(onUploadSuccess).toHaveBeenCalledTimes(2);
+  expect(view.getByText("bad file")).toBeTruthy();
+});
+
 test("UploadSeed shows inline errors", async () => {
   fetchMock.mockImplementationOnce((_input, _init) =>
     Promise.resolve(

package/src/ui/dist/assets/{index-CItKJVeE.js → index-Dgzc8e-G.js}

@@ -20606,7 +20606,8 @@ function UploadSeed({
 }) {
   const inputRef = reactExports.useRef(null);
   const [error, setError] = reactExports.useState(null);
-  const [isUploading, setIsUploading] = reactExports.useState(false);
+  const [pendingUploads, setPendingUploads] = reactExports.useState(0);
+  const isUploading = pendingUploads > 0;
   const [isDragging, setIsDragging] = reactExports.useState(false);
   const hint = reactExports.useMemo(() => isDragging ? "Drop seed file" : "Upload JSON or ZIP seed", [isDragging]);
   const uploadFile = async (file) => {
@@ -20616,7 +20617,7 @@ function UploadSeed({
     }
     const formData = new FormData();
     formData.append("file", file);
-    setIsUploading(true);
+    setPendingUploads((n) => n + 1);
     setError(null);
     try {
       const response = await fetch("/api/upload/seed", {
@@ -20631,7 +20632,7 @@ function UploadSeed({
     } catch (uploadError) {
       setError(normalizeUploadError(uploadError));
     } finally {
-      setIsUploading(false);
+      setPendingUploads((n) => n - 1);
     }
   };
   return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "space-y-3", children: [
@@ -20650,8 +20651,8 @@ function UploadSeed({
         onDrop: (event) => {
           event.preventDefault();
           setIsDragging(false);
-          const file = event.dataTransfer.files[0];
-          if (file) void uploadFile(file);
+          const files = Array.from(event.dataTransfer.files);
+          for (const file of files) void uploadFile(file);
         },
         children: [
           /* @__PURE__ */ jsxRuntimeExports.jsx("p", { children: hint }),
@@ -20662,10 +20663,11 @@ function UploadSeed({
               ref: inputRef,
               type: "file",
               hidden: true,
+              multiple: true,
               accept: ".json,.zip,application/json,application/zip",
               onChange: (event) => {
-                const file = event.target.files?.[0];
-                if (file) void uploadFile(file);
+                const files = Array.from(event.target.files ?? []);
+                for (const file of files) void uploadFile(file);
               }
             }
           )
@@ -22243,9 +22245,7 @@ function computeActiveIndex(items) {
   if (running >= 0) return running;
   const failed = items.findIndex((item) => item.status === "failed");
   if (failed >= 0) return failed;
-  const pending = items.findIndex((item) => item.status === "pending");
-  if (pending >= 0) return pending;
-  return Math.max(0, items.length - 1);
+  return -1;
 }
 function formatCurrency4(value) {
   if (!Number.isFinite(value) || value === 0) return "$0";