@ryanfw/prompt-orchestration-pipeline 1.3.2 → 1.3.4

package/src/api/__tests__/index.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
 import { mkdtemp, rm, mkdir, readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
@@ -29,8 +29,11 @@ async function scaffoldWorkspace(tmpDir: string): Promise<void> {
   await Bun.write(
     join(tmpDir, "pipeline-config", "registry.json"),
     JSON.stringify({
+      version: 1,
       pipelines: {
         "test-pipeline": {
+          name: "Test Pipeline",
+          description: "test pipeline",
           configDir: join(tmpDir, "pipeline-config", "test-pipeline"),
           tasksDir: join(tmpDir, "pipeline-config", "test-pipeline", "tasks"),
         },
@@ -60,7 +63,7 @@ describe("submitJobWithValidation", () => {
 
   it("writes seed file to pending and returns success", async () => {
     const result = await submitJobWithValidation({
-      dataDir: tmpDir,
+      root: tmpDir,
       seedObject: { pipeline: "test-pipeline" },
     });
 
@@ -79,7 +82,7 @@ describe("submitJobWithValidation", () => {
 
   it("returns seed name as jobName when provided", async () => {
     const result = await submitJobWithValidation({
-      dataDir: tmpDir,
+      root: tmpDir,
       seedObject: { pipeline: "test-pipeline", name: "my-job" },
     });
 
@@ -87,74 +90,88 @@ describe("submitJobWithValidation", () => {
     expect((result as SubmitSuccessResult).jobName).toBe("my-job");
   });
 
-  it("rejects non-object seed with message containing 'JSON object'", async () => {
+  it("rejects non-object seed with exact message", async () => {
     const result = await submitJobWithValidation({
-      dataDir: tmpDir,
+      root: tmpDir,
       seedObject: "not an object",
     });
 
     expect(result.success).toBe(false);
-    expect((result as SubmitFailureResult).message).toContain("JSON object");
+    expect((result as SubmitFailureResult).message).toBe("seed must be a JSON object");
   });
 
-  it("rejects array seed with message containing 'JSON object'", async () => {
+  it("rejects array seed with exact message", async () => {
     const result = await submitJobWithValidation({
-      dataDir: tmpDir,
+      root: tmpDir,
       seedObject: [1, 2, 3],
     });
 
     expect(result.success).toBe(false);
-    expect((result as SubmitFailureResult).message).toContain("JSON object");
+    expect((result as SubmitFailureResult).message).toBe("seed must be a JSON object");
   });
 
-  it("rejects null seed with message containing 'JSON object'", async () => {
+  it("rejects null seed with exact message", async () => {
     const result = await submitJobWithValidation({
-      dataDir: tmpDir,
+      root: tmpDir,
       seedObject: null,
     });
 
     expect(result.success).toBe(false);
-    expect((result as SubmitFailureResult).message).toContain("JSON object");
+    expect((result as SubmitFailureResult).message).toBe("seed must be a JSON object");
   });
 
-  it("rejects seed missing pipeline field with message containing 'pipeline'", async () => {
+  it("rejects seed missing pipeline field with exact message", async () => {
     const result = await submitJobWithValidation({
-      dataDir: tmpDir,
+      root: tmpDir,
       seedObject: { name: "my-job" },
     });
 
     expect(result.success).toBe(false);
-    expect((result as SubmitFailureResult).message).toContain("pipeline");
+    expect((result as SubmitFailureResult).message).toBe("seed.pipeline must be a non-empty string");
   });
 
   it("rejects seed with empty pipeline string", async () => {
     const result = await submitJobWithValidation({
-      dataDir: tmpDir,
+      root: tmpDir,
       seedObject: { pipeline: "" },
     });
 
     expect(result.success).toBe(false);
-    expect((result as SubmitFailureResult).message).toContain("pipeline");
+    expect((result as SubmitFailureResult).message).toBe("seed.pipeline must be a non-empty string");
   });
 
-  it("rejects non-existent pipeline slug with message containing 'not found'", async () => {
+  it("rejects non-string pipeline value", async () => {
     const result = await submitJobWithValidation({
-      dataDir: tmpDir,
+      root: tmpDir,
+      seedObject: { pipeline: 123 },
+    });
+
+    expect(result.success).toBe(false);
+    expect((result as SubmitFailureResult).message).toBe("seed.pipeline must be a non-empty string");
+  });
+
+  it("rejects non-existent pipeline slug with exact message", async () => {
+    const result = await submitJobWithValidation({
+      root: tmpDir,
       seedObject: { pipeline: "does-not-exist" },
     });
 
     expect(result.success).toBe(false);
-    expect((result as SubmitFailureResult).message).toContain("not found");
+    expect((result as SubmitFailureResult).message).toBe(
+      "Pipeline 'does-not-exist' not found in registry",
+    );
   });
 
   it("rejects seed with empty name string", async () => {
     const result = await submitJobWithValidation({
-      dataDir: tmpDir,
+      root: tmpDir,
       seedObject: { pipeline: "test-pipeline", name: "" },
     });
 
     expect(result.success).toBe(false);
-    expect((result as SubmitFailureResult).message).toContain("name");
+    expect((result as SubmitFailureResult).message).toBe(
+      "seed.name must be a non-empty string if provided",
+    );
   });
 });
 
@@ -196,7 +213,7 @@ describe("PipelineOrchestrator.getStatus", () => {
       }),
     );
 
-    const orch = new PipelineOrchestrator({ autoStart: false });
+    const orch = new PipelineOrchestrator({ autoStart: false, root: tmpDir });
     const record = await orch.getStatus(jobId);
 
     expect(record.jobId).toBe(jobId);
@@ -214,17 +231,18 @@ describe("PipelineOrchestrator.getStatus", () => {
         id: jobId,
         name: "done-job",
         pipeline: "test-pipeline",
-        state: "complete",
+        state: "done",
         createdAt: "2026-01-01T00:00:00.000Z",
         tasks: {},
       }),
     );
 
-    const orch = new PipelineOrchestrator({ autoStart: false });
+    const orch = new PipelineOrchestrator({ autoStart: false, root: tmpDir });
     const record = await orch.getStatus(jobId);
 
     expect(record.jobId).toBe(jobId);
     expect(record.jobName).toBe("done-job");
+    expect(record.state).toBe("complete");
   });
 
   it("finds job by name scan fallback", async () => {
@@ -243,7 +261,7 @@ describe("PipelineOrchestrator.getStatus", () => {
       }),
     );
 
-    const orch = new PipelineOrchestrator({ autoStart: false });
+    const orch = new PipelineOrchestrator({ autoStart: false, root: tmpDir });
     const record = await orch.getStatus("named-job");
 
     expect(record.jobId).toBe(jobId);
@@ -257,7 +275,7 @@ describe("PipelineOrchestrator.getStatus", () => {
       JSON.stringify({ pipeline: "test-pipeline", name: "pending-job" }),
     );
 
-    const orch = new PipelineOrchestrator({ autoStart: false });
+    const orch = new PipelineOrchestrator({ autoStart: false, root: tmpDir });
     const record = await orch.getStatus(jobId);
 
     expect(record.jobId).toBe(jobId);
@@ -267,11 +285,78 @@ describe("PipelineOrchestrator.getStatus", () => {
     expect(record.createdAt).toBeTruthy();
   });
 
+  it("returns pending record for non-UUID seed filename parsed by parseSeedFilename", async () => {
+    const jobId = "my-job";
+    await Bun.write(
+      join(tmpDir, "pipeline-data", "pending", `${jobId}-seed.json`),
+      JSON.stringify({ pipeline: "test-pipeline", name: "my-job" }),
+    );
+
+    const orch = new PipelineOrchestrator({ autoStart: false, root: tmpDir });
+    const record = await orch.getStatus(jobId);
+
+    expect(record.jobId).toBe(jobId);
+    expect(record.jobName).toBe("my-job");
+    expect(record.state).toBe("pending");
+    expect(record.pipeline).toBe("test-pipeline");
+  });
+
   it("throws for nonexistent job with message containing 'not found'", async () => {
-    const orch = new PipelineOrchestrator({ autoStart: false });
+    const orch = new PipelineOrchestrator({ autoStart: false, root: tmpDir });
 
     await expect(orch.getStatus("nonexistent-id")).rejects.toThrow("not found");
   });
+
+  it("returns unreadable placeholder for corrupt current job instead of throwing", async () => {
+    const jobId = "33333333-4444-5555-6666-777777777777";
+    const jobDir = join(tmpDir, "pipeline-data", "current", jobId);
+    await mkdir(jobDir, { recursive: true });
+    await Bun.write(join(jobDir, "tasks-status.json"), "{{{not valid json");
+
+    const orch = new PipelineOrchestrator({ autoStart: false, root: tmpDir });
+    const record = await orch.getStatus(jobId);
+
+    expect(record.jobId).toBe(jobId);
+    expect(record.state).toBe("failed");
+    expect(record.readable).toBe(false);
+    expect(record.error).toBeDefined();
+    const error = record.error as { code: string; message: string; path: string };
+    expect(error.code).toBe("STATUS_CORRUPT");
+    expect(error.path).toBe(join(jobDir, "tasks-status.json"));
+    expect(error.message).toContain("Repair or delete");
+    expect(error.message).toContain(jobId);
+  });
+
+  it("skips unexpected current read errors and falls back to complete lookup", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const jobId = "33333333-4444-5555-6666-888888888888";
+    const currentDir = join(tmpDir, "pipeline-data", "current", jobId);
+    await mkdir(currentDir, { recursive: true });
+    await mkdir(join(currentDir, "tasks-status.json"));
+
+    const completeDir = join(tmpDir, "pipeline-data", "complete", jobId);
+    await mkdir(completeDir, { recursive: true });
+    await Bun.write(
+      join(completeDir, "tasks-status.json"),
+      JSON.stringify({
+        id: jobId,
+        name: "complete-fallback",
+        pipeline: "test-pipeline",
+        state: "done",
+        createdAt: "2026-01-01T00:00:00.000Z",
+        tasks: {},
+      }),
+    );
+
+    const orch = new PipelineOrchestrator({ autoStart: false, root: tmpDir });
+    const record = await orch.getStatus(jobId);
+
+    expect(record.jobId).toBe(jobId);
+    expect(record.jobName).toBe("complete-fallback");
+    expect(record.state).toBe("complete");
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining(jobId));
+    warn.mockRestore();
+  });
 });
 
 // ─── PipelineOrchestrator.listJobs ───────────────────────────────────────────
@@ -330,13 +415,13 @@ describe("PipelineOrchestrator.listJobs", () => {
         id: completeId,
         name: "complete-one",
         pipeline: "test-pipeline",
-        state: "complete",
+        state: "done",
         createdAt: "2026-01-01T00:00:00.000Z",
         tasks: {},
       }),
     );
 
-    const orch = new PipelineOrchestrator({ autoStart: false });
+    const orch = new PipelineOrchestrator({ autoStart: false, root: tmpDir });
     const jobs = await orch.listJobs();
 
     expect(jobs.length).toBe(3);
@@ -354,7 +439,7 @@ describe("PipelineOrchestrator.listJobs", () => {
   });
 
   it("returns empty array when all directories are empty", async () => {
-    const orch = new PipelineOrchestrator({ autoStart: false });
+    const orch = new PipelineOrchestrator({ autoStart: false, root: tmpDir });
     const jobs = await orch.listJobs();
 
     expect(jobs).toEqual([]);
@@ -364,9 +449,335 @@ describe("PipelineOrchestrator.listJobs", () => {
     // Remove all pipeline-data directories
     await rm(join(tmpDir, "pipeline-data"), { recursive: true, force: true });
 
-    const orch = new PipelineOrchestrator({ autoStart: false });
+    const orch = new PipelineOrchestrator({ autoStart: false, root: tmpDir });
+    const jobs = await orch.listJobs();
+
+    expect(jobs).toEqual([]);
+  });
+
+  it("surfaces corrupt current job as unreadable placeholder alongside valid and pending jobs", async () => {
+    const pendingId = "bbbb-1111-2222-3333-0001";
+    await Bun.write(
+      join(tmpDir, "pipeline-data", "pending", `${pendingId}-seed.json`),
+      JSON.stringify({ pipeline: "test-pipeline", name: "pending-one" }),
+    );
+
+    const validCurrentId = "bbbb-1111-2222-3333-0002";
+    const validCurrentDir = join(tmpDir, "pipeline-data", "current", validCurrentId);
+    await mkdir(validCurrentDir, { recursive: true });
+    await Bun.write(
+      join(validCurrentDir, "tasks-status.json"),
+      JSON.stringify({
+        id: validCurrentId,
+        name: "valid-current",
+        pipeline: "test-pipeline",
+        state: "running",
+        createdAt: "2026-01-01T00:00:00.000Z",
+        tasks: {},
+      }),
+    );
+
+    const corruptCurrentId = "bbbb-1111-2222-3333-0003";
+    const corruptCurrentDir = join(tmpDir, "pipeline-data", "current", corruptCurrentId);
+    await mkdir(corruptCurrentDir, { recursive: true });
+    await Bun.write(join(corruptCurrentDir, "tasks-status.json"), "{{{not valid json");
+
+    const completeId = "bbbb-1111-2222-3333-0004";
+    const completeDir = join(tmpDir, "pipeline-data", "complete", completeId);
+    await mkdir(completeDir, { recursive: true });
+    await Bun.write(
+      join(completeDir, "tasks-status.json"),
+      JSON.stringify({
+        id: completeId,
+        name: "complete-one",
+        pipeline: "test-pipeline",
+        state: "done",
+        createdAt: "2026-01-01T00:00:00.000Z",
+        tasks: {},
+      }),
+    );
+
+    const orch = new PipelineOrchestrator({ autoStart: false, root: tmpDir });
+    const jobs = await orch.listJobs();
+
+    expect(jobs.length).toBe(4);
+
+    const ids = jobs.map((j) => j.jobId);
+    expect(ids).toContain(pendingId);
+    expect(ids).toContain(validCurrentId);
+    expect(ids).toContain(corruptCurrentId);
+    expect(ids).toContain(completeId);
+
+    const corrupt = jobs.find((j) => j.jobId === corruptCurrentId)!;
+    expect(corrupt.state).toBe("failed");
+    expect(corrupt.readable).toBe(false);
+    const corruptError = corrupt.error as { code: string; message: string; path: string };
+    expect(corruptError.code).toBe("STATUS_CORRUPT");
+    expect(corruptError.path).toBe(join(corruptCurrentDir, "tasks-status.json"));
+    expect(corruptError.message).toContain("Repair or delete");
+    expect(corruptError.message).toContain(corruptCurrentId);
+
+    const valid = jobs.find((j) => j.jobId === validCurrentId)!;
+    expect(valid.readable).toBeUndefined();
+    expect(valid.error).toBeUndefined();
+    expect(valid.jobName).toBe("valid-current");
+
+    const pending = jobs.find((j) => j.jobId === pendingId)!;
+    expect(pending.state).toBe("pending");
+    expect(pending.readable).toBeUndefined();
+  });
+
+  it("skips current job whose status file is missing", async () => {
+    const missingId = "cccc-1111-2222-3333-0001";
+    const missingDir = join(tmpDir, "pipeline-data", "current", missingId);
+    await mkdir(missingDir, { recursive: true });
+
+    const validId = "cccc-1111-2222-3333-0002";
+    const validDir = join(tmpDir, "pipeline-data", "current", validId);
+    await mkdir(validDir, { recursive: true });
+    await Bun.write(
+      join(validDir, "tasks-status.json"),
+      JSON.stringify({
+        id: validId,
+        name: "valid-current",
+        pipeline: "test-pipeline",
+        state: "running",
+        createdAt: "2026-01-01T00:00:00.000Z",
+        tasks: {},
+      }),
+    );
+
+    const orch = new PipelineOrchestrator({ autoStart: false, root: tmpDir });
+    const jobs = await orch.listJobs();
+
+    const ids = jobs.map((j) => j.jobId);
+    expect(ids).toContain(validId);
+    expect(ids).not.toContain(missingId);
+  });
+
+  it("skips current job with unexpected status read error without throwing", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const unreadableId = "dddd-1111-2222-3333-0001";
+    const unreadableDir = join(tmpDir, "pipeline-data", "current", unreadableId);
+    await mkdir(unreadableDir, { recursive: true });
+    await mkdir(join(unreadableDir, "tasks-status.json"));
+
+    const validId = "dddd-1111-2222-3333-0002";
+    const validDir = join(tmpDir, "pipeline-data", "current", validId);
+    await mkdir(validDir, { recursive: true });
+    await Bun.write(
+      join(validDir, "tasks-status.json"),
+      JSON.stringify({
+        id: validId,
+        name: "valid-current",
+        pipeline: "test-pipeline",
+        state: "running",
+        createdAt: "2026-01-01T00:00:00.000Z",
+        tasks: {},
+      }),
+    );
+
+    const orch = new PipelineOrchestrator({ autoStart: false, root: tmpDir });
+    const jobs = await orch.listJobs();
+
+    const ids = jobs.map((j) => j.jobId);
+    expect(ids).toContain(validId);
+    expect(ids).not.toContain(unreadableId);
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining(unreadableId));
+    warn.mockRestore();
+  });
+
+  it("getStatus and listJobs return identical state for the same fixture", async () => {
+    const jobId = "cccc-5555-6666-7777-0001";
+    const jobDir = join(tmpDir, "pipeline-data", "current", jobId);
+    await mkdir(jobDir, { recursive: true });
+    await Bun.write(
+      join(jobDir, "tasks-status.json"),
+      JSON.stringify({
+        id: jobId,
+        name: "cross-surface",
+        pipeline: "test-pipeline",
+        state: "running",
+        createdAt: "2026-01-01T00:00:00.000Z",
+        tasks: {
+          a: { state: "running" },
+          b: { state: "pending" },
+        },
+      }),
+    );
+
+    const orch = new PipelineOrchestrator({ autoStart: false, root: tmpDir });
+    const getStatusRecord = await orch.getStatus(jobId);
+    const listJobsRecords = await orch.listJobs();
+    const listJobsRecord = listJobsRecords.find((j) => j.jobId === jobId)!;
+
+    expect(getStatusRecord.state).toBe("running");
+    expect(listJobsRecord.state).toBe("running");
+    expect(getStatusRecord.state).toBe(listJobsRecord.state);
+  });
+
+  it("getStatus returns canonical 'complete' for persisted 'done' state", async () => {
+    const jobId = "cccc-5555-6666-7777-0002";
+    const jobDir = join(tmpDir, "pipeline-data", "complete", jobId);
+    await mkdir(jobDir, { recursive: true });
+    await Bun.write(
+      join(jobDir, "tasks-status.json"),
+      JSON.stringify({
+        id: jobId,
+        name: "done-canonical",
+        pipeline: "test-pipeline",
+        state: "done",
+        createdAt: "2026-01-01T00:00:00.000Z",
+        tasks: { a: { state: "done" } },
+      }),
+    );
+
+    const orch = new PipelineOrchestrator({ autoStart: false, root: tmpDir });
+    const record = await orch.getStatus(jobId);
+
+    expect(record.state).toBe("complete");
+  });
+
+  it("listJobs returns canonical 'complete' for persisted 'done' state without force", async () => {
+    const jobId = "cccc-5555-6666-7777-0003";
+    const jobDir = join(tmpDir, "pipeline-data", "complete", jobId);
+    await mkdir(jobDir, { recursive: true });
+    await Bun.write(
+      join(jobDir, "tasks-status.json"),
+      JSON.stringify({
+        id: jobId,
+        name: "done-list",
+        pipeline: "test-pipeline",
+        state: "done",
+        createdAt: "2026-01-01T00:00:00.000Z",
+        tasks: { a: { state: "done" } },
+      }),
+    );
+
+    const orch = new PipelineOrchestrator({ autoStart: false, root: tmpDir });
     const jobs = await orch.listJobs();
+    const record = jobs.find((j) => j.jobId === jobId)!;
+
+    expect(record.state).toBe("complete");
+  });
+
+  it("getStatus maps persisted 'error' legacy status to canonical 'failed'", async () => {
+    const jobId = "cccc-5555-6666-7777-0004";
+    const jobDir = join(tmpDir, "pipeline-data", "current", jobId);
+    await mkdir(jobDir, { recursive: true });
+    await Bun.write(
+      join(jobDir, "tasks-status.json"),
+      JSON.stringify({
+        id: jobId,
+        name: "legacy-error",
+        pipeline: "test-pipeline",
+        state: "unknown-state",
+        status: "error",
+        createdAt: "2026-01-01T00:00:00.000Z",
+        tasks: { a: { state: "failed" } },
+      }),
+    );
+
+    const orch = new PipelineOrchestrator({ autoStart: false, root: tmpDir });
+    const record = await orch.getStatus(jobId);
+
+    expect(record.state).toBe("failed");
+  });
 
+  it("listJobs preserves JobView extras (costs)", async () => {
+    const jobId = "cccc-5555-6666-7777-0005";
+    const jobDir = join(tmpDir, "pipeline-data", "current", jobId);
+    await mkdir(jobDir, { recursive: true });
+    await Bun.write(
+      join(jobDir, "tasks-status.json"),
+      JSON.stringify({
+        id: jobId,
+        name: "with-extras",
+        pipeline: "test-pipeline",
+        state: "running",
+        progress: 42,
+        createdAt: "2026-01-01T00:00:00.000Z",
+        costs: { usd: 1.23 },
+        tasks: { a: { state: "running" } },
+      }),
+    );
+
+    const orch = new PipelineOrchestrator({ autoStart: false, root: tmpDir });
+    const jobs = await orch.listJobs();
+    const record = jobs.find((j) => j.jobId === jobId)!;
+
+    expect(record.state).toBe("running");
+    expect(record.progress).toBe(0);
+    expect(record.costs).toEqual({ usd: 1.23 });
+  });
+});
+
+// ─── AC-4: API strict root resolution ─────────────────────────────────────────
+
+describe("API strict root resolution (AC-4)", () => {
+  let tmpDir: string;
+  let savedPoRoot: string | undefined;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), "pop-api-strict-test-"));
+    await scaffoldWorkspace(tmpDir);
+    savedPoRoot = process.env["PO_ROOT"];
+    delete process.env["PO_ROOT"];
+  });
+
+  afterEach(async () => {
+    if (savedPoRoot === undefined) {
+      delete process.env["PO_ROOT"];
+    } else {
+      process.env["PO_ROOT"] = savedPoRoot;
+    }
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("PipelineOrchestrator throws when neither root nor PO_ROOT is set", () => {
+    expect(() => new PipelineOrchestrator({ autoStart: false })).toThrow(
+      "Workspace root is required",
+    );
+  });
+
+  it("PipelineOrchestrator succeeds when root is set explicitly", async () => {
+    const orch = new PipelineOrchestrator({ autoStart: false, root: tmpDir });
+    const jobs = await orch.listJobs();
+    expect(jobs).toEqual([]);
+  });
+
+  it("PipelineOrchestrator succeeds when PO_ROOT is set and root is absent", async () => {
+    process.env["PO_ROOT"] = tmpDir;
+    const orch = new PipelineOrchestrator({ autoStart: false });
+    const jobs = await orch.listJobs();
     expect(jobs).toEqual([]);
   });
+
+  it("submitJobWithValidation throws when neither root nor PO_ROOT is set", async () => {
+    await expect(
+      submitJobWithValidation({ seedObject: { pipeline: "test-pipeline" } }),
+    ).rejects.toThrow("Workspace root is required");
+  });
+
+  it("submitJobWithValidation succeeds when root is set explicitly", async () => {
+    const result = await submitJobWithValidation({
+      root: tmpDir,
+      seedObject: { pipeline: "test-pipeline" },
+    });
+    expect(result.success).toBe(true);
+    const pendingFiles = await readdir(join(tmpDir, "pipeline-data", "pending"));
+    const seedFile = pendingFiles.find((f) => f.endsWith("-seed.json"));
+    expect(seedFile).toBeDefined();
+  });
+
+  it("submitJobWithValidation succeeds when PO_ROOT is set and root is absent", async () => {
+    process.env["PO_ROOT"] = tmpDir;
+    const result = await submitJobWithValidation({
+      seedObject: { pipeline: "test-pipeline" },
+    });
+    expect(result.success).toBe(true);
+    const pendingFiles = await readdir(join(tmpDir, "pipeline-data", "pending"));
+    const seedFile = pendingFiles.find((f) => f.endsWith("-seed.json"));
+    expect(seedFile).toBeDefined();
+  });
 });