@ryanfw/prompt-orchestration-pipeline 1.3.2 → 1.3.4

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

@@ -5,7 +5,7 @@ import path from "node:path";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
 
 import { resetConfig } from "../../../core/config";
-import { handleJobDetail } from "../endpoints/job-endpoints";
+import { handleJobDetail, handleJobList } from "../endpoints/job-endpoints";
 import { initPATHS, resetPATHS } from "../config-bridge-node";
 
 const tempRoots: string[] = [];
@@ -25,7 +25,12 @@ async function writePipelineRegistry(root: string): Promise<void> {
   await mkdir(tasksDir, { recursive: true });
   await writeFile(
     path.join(root, "pipeline-config", "registry.json"),
-    JSON.stringify({ pipelines: { demo: { configDir, tasksDir } } }),
+    JSON.stringify({
+      version: 1,
+      pipelines: {
+        demo: { name: "Demo", description: "demo pipeline", configDir, tasksDir },
+      },
+    }),
   );
   await writeFile(
     path.join(configDir, "pipeline.json"),
@@ -121,4 +126,155 @@ describe("job endpoints pipeline config loading", () => {
     expect(body.data.pipelineConfig?.["marker"]).toBe("shared");
     expect(body.data.pipelineConfig?.["tasks"]).toEqual([{ name: "shared-task" }]);
   });
+
+  it("preserves per-task costs in job detail responses", async () => {
+    const root = await makeTempRoot();
+    process.env["PO_ROOT"] = root;
+    resetConfig();
+    initPATHS(root);
+    await writePipelineRegistry(root);
+    const jobDir = await writeJob(root, "current", "job-costs");
+    await writeFile(
+      path.join(jobDir, "tasks-status.json"),
+      JSON.stringify({
+        id: "job-costs",
+        name: "job-costs",
+        pipeline: "demo",
+        createdAt: "2026-06-12T12:00:00.000Z",
+        state: "done",
+        tasks: {
+          build: {
+            state: "done",
+            tokenUsage: [["openai:gpt-4o", 10, 5, 0.25, "estimated", false, true]],
+          },
+        },
+      }),
+    );
+
+    const res = await handleJobDetail("job-costs");
+    const body = await res.json() as {
+      data: { costs?: Record<string, Record<string, unknown>> };
+    };
+
+    expect(res.status).toBe(200);
+    expect(body.data.costs?.["build"]).toMatchObject({
+      source: "estimated",
+      totalCost: 0.25,
+      costEstimated: true,
+    });
+  });
+});
+
+describe("handleJobDetail corrupt status", () => {
+  it("returns 409 STATUS_CORRUPT with the corrupt tasks-status.json path", async () => {
+    const root = await makeTempRoot();
+    process.env["PO_ROOT"] = root;
+    resetConfig();
+    initPATHS(root);
+    await writePipelineRegistry(root);
+    const jobDir = await writeJob(root, "current", "job-corrupt");
+    await writeFile(path.join(jobDir, "tasks-status.json"), "{ not valid json");
+
+    const res = await handleJobDetail("job-corrupt");
+    const body = (await res.json()) as { code: string; path?: string };
+
+    expect(res.status).toBe(409);
+    expect(body.code).toBe("STATUS_CORRUPT");
+    expect(body.path).toBe(path.join(jobDir, "tasks-status.json"));
+  });
+});
+
+describe("canonical status in HTTP responses", () => {
+  it("handleJobDetail returns canonical status:'failed' for a failed-state fixture", async () => {
+    const root = await makeTempRoot();
+    process.env["PO_ROOT"] = root;
+    resetConfig();
+    initPATHS(root);
+    await writePipelineRegistry(root);
+    const jobDir = await writeJob(root, "current", "job-failed");
+    await writeFile(
+      path.join(jobDir, "tasks-status.json"),
+      JSON.stringify({
+        id: "job-failed",
+        name: "job-failed",
+        pipeline: "demo",
+        createdAt: "2026-06-12T12:00:00.000Z",
+        state: "failed",
+        tasks: { a: { state: "failed" } },
+      }),
+    );
+
+    const res = await handleJobDetail("job-failed");
+    const body = (await res.json()) as { data: { status: string } };
+
+    expect(res.status).toBe(200);
+    expect(body.data.status).toBe("failed");
+  });
+
+  it("handleJobDetail returns canonical status:'complete' for a complete-state fixture", async () => {
+    const root = await makeTempRoot();
+    process.env["PO_ROOT"] = root;
+    resetConfig();
+    initPATHS(root);
+    await writePipelineRegistry(root);
+    const jobDir = await writeJob(root, "current", "job-complete");
+    await writeFile(
+      path.join(jobDir, "tasks-status.json"),
+      JSON.stringify({
+        id: "job-complete",
+        name: "job-complete",
+        pipeline: "demo",
+        createdAt: "2026-06-12T12:00:00.000Z",
+        state: "done",
+        tasks: { a: { state: "done" } },
+      }),
+    );
+
+    const res = await handleJobDetail("job-complete");
+    const body = (await res.json()) as { data: { status: string } };
+
+    expect(res.status).toBe(200);
+    expect(body.data.status).toBe("complete");
+  });
+
+  it("handleJobList returns canonical status for every job in the listing", async () => {
+    const root = await makeTempRoot();
+    process.env["PO_ROOT"] = root;
+    resetConfig();
+    initPATHS(root);
+    await writePipelineRegistry(root);
+    const failedDir = await writeJob(root, "current", "job-list-failed");
+    await writeFile(
+      path.join(failedDir, "tasks-status.json"),
+      JSON.stringify({
+        id: "job-list-failed",
+        name: "job-list-failed",
+        pipeline: "demo",
+        createdAt: "2026-06-12T12:00:00.000Z",
+        state: "failed",
+        tasks: { a: { state: "failed" } },
+      }),
+    );
+    const completeDir = await writeJob(root, "complete", "job-list-complete");
+    await writeFile(
+      path.join(completeDir, "tasks-status.json"),
+      JSON.stringify({
+        id: "job-list-complete",
+        name: "job-list-complete",
+        pipeline: "demo",
+        createdAt: "2026-06-12T12:00:00.000Z",
+        state: "done",
+        tasks: { a: { state: "done" } },
+      }),
+    );
+
+    const res = await handleJobList();
+    const body = (await res.json()) as { data: Array<{ jobId: string; status: string }> };
+
+    expect(res.status).toBe(200);
+    expect(body.data).toHaveLength(2);
+    const byId = new Map(body.data.map((job) => [job.jobId, job.status]));
+    expect(byId.get("job-list-failed")).toBe("failed");
+    expect(byId.get("job-list-complete")).toBe("complete");
+  });
 });

package/src/ui/server/__tests__/read-static-path-guard.test.ts

@@ -0,0 +1,94 @@
+// Source-scan guard (AC-8 / spec §7 Step 6).
+//
+// Asserts that none of the four read/static HTTP boundary files builds its final
+// filesystem read path via a bare `path.join`/`join` from URL-derived params
+// outside the containment helpers `resolveUnderRoot` / `resolveWithin`. The
+// current code is clean; this test exists so a future edit like
+// `const p = path.join(root, slug); await Bun.file(p).text()` fails CI.
+//
+// The scan is span-based, not line-based: each join call's full balanced-paren
+// argument span is evaluated as one unit, so a join split across multiple lines
+// (`path.join(\n  root,\n  slug,\n)`) is still checked. A join whose call site is
+// lexically enclosed by a `resolveUnderRoot(...)`/`resolveWithin(...)` argument
+// span is allowed — the param is being contained.
+//
+// Known lexical-guard limitation: a URL param first copied to a local variable
+// and then joined (`const s = slug; path.join(root, s)`) is not detected — that
+// needs dataflow, which is out of scope for a source scan.
+
+import { describe, expect, it } from "vitest";
+
+import path from "node:path";
+
+const BOUNDARY_FILES = [
+  "../endpoints/schema-file-endpoint.ts",
+  "../endpoints/file-endpoints.ts",
+  "../endpoints/task-analysis-endpoint.ts",
+  "../router.ts",
+];
+
+// Identifiers treated as URL-derived when they appear in a join argument span.
+// Documented exclusions: `type`/`params`/`jobId`/`location` are intentionally
+// omitted (see subspec 6-spec.md) — those inputs are out of this guard's scope
+// because they are not part of the encoded-path containment boundary.
+const URL_DERIVED = /\b(slug|filename|taskId|taskName|pathname|searchParams)\b/;
+// Matches `path.join(`, `path.posix.join(`, `path.win32.join(`, or a bare `join(`
+// not preceded by a word char, `$`, or `.` (the `.` exclusion skips array `.join(`).
+const JOIN_CALL = /(?:path(?:\.posix|\.win32)?\.join|(?<![\w$.])join)\s*\(/g;
+// Containment helpers whose argument span makes a join nested inside them safe.
+const CONTAINMENT_CALL = /(?:resolveUnderRoot|resolveWithin)\s*\(/g;
+
+type Span = { open: number; close: number };
+type Violation = { file: string; line: number; snippet: string };
+
+// Given the index of an opening `(`, return the index of its matching `)`.
+function matchingParen(src: string, openIndex: number): number {
+  let depth = 0;
+  for (let i = openIndex; i < src.length; i++) {
+    if (src[i] === "(") depth++;
+    else if (src[i] === ")") {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return src.length - 1;
+}
+
+// All call spans for a regex that matches up to and including the `(`.
+function callSpans(src: string, callRe: RegExp): Span[] {
+  const spans: Span[] = [];
+  callRe.lastIndex = 0;
+  for (let m = callRe.exec(src); m !== null; m = callRe.exec(src)) {
+    const open = m.index + m[0].length - 1; // index of the `(`
+    spans.push({ open, close: matchingParen(src, open) });
+  }
+  return spans;
+}
+
+async function scan(filePath: string): Promise<Violation[]> {
+  const src = await Bun.file(filePath).text();
+  const containment = callSpans(src, CONTAINMENT_CALL);
+  const violations: Violation[] = [];
+  for (const join of callSpans(src, JOIN_CALL)) {
+    const args = src.slice(join.open + 1, join.close);
+    if (!URL_DERIVED.test(args) && !args.includes("${")) continue;
+    // Allowed when the join call sits inside a containment call's argument span.
+    const contained = containment.some((c) => c.open < join.open && join.close <= c.close);
+    if (contained) continue;
+    const line = src.slice(0, join.open).split("\n").length;
+    violations.push({ file: path.basename(filePath), line, snippet: args.replace(/\s+/g, " ").trim() });
+  }
+  return violations;
+}
+
+describe("read/static path-building source guard (AC-8)", () => {
+  it("no boundary file builds a final read path via bare path.join(<root>, <url-param>)", async () => {
+    const base = import.meta.dirname;
+    const all: Violation[] = [];
+    for (const rel of BOUNDARY_FILES) {
+      const full = path.resolve(base, rel);
+      all.push(...(await scan(full)));
+    }
+    expect(all, all.map((v) => `${v.file}:${v.line} → ${v.snippet}`).join("\n")).toEqual([]);
+  });
+});

package/src/ui/server/__tests__/router-root-isolation.test.ts

@@ -0,0 +1,204 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+
+import { resetPATHS } from "../config-bridge-node";
+import { createRouter } from "../router";
+
+const ORIGINAL_PO_ROOT = process.env["PO_ROOT"];
+
+const tempRoots: string[] = [];
+
+async function makeTempRoot(prefix: string): Promise<string> {
+  const root = await Bun.$`mktemp -d ${path.join(os.tmpdir(), `${prefix}-XXXXXX`)}`.text();
+  const trimmed = root.trim();
+  tempRoots.push(trimmed);
+  return trimmed;
+}
+
+beforeEach(() => {
+  resetPATHS();
+});
+
+afterEach(async () => {
+  if (ORIGINAL_PO_ROOT === undefined) {
+    delete process.env["PO_ROOT"];
+  } else {
+    process.env["PO_ROOT"] = ORIGINAL_PO_ROOT;
+  }
+  resetPATHS();
+  await Promise.all(tempRoots.splice(0).map((root) => Bun.$`rm -rf ${root}`));
+});
+
+describe("router root isolation (AC-5)", () => {
+  it("handleTaskFile reads from the threaded root, ignoring PO_ROOT=/B", async () => {
+    const rootA = await makeTempRoot("router-iso-A");
+    const rootB = await makeTempRoot("router-iso-B");
+    process.env["PO_ROOT"] = rootB;
+
+    const jobDir = path.join(rootA, "pipeline-data", "current", "job-1");
+    await mkdir(path.join(jobDir, "files", "artifacts"), { recursive: true });
+    await writeFile(path.join(jobDir, "files", "artifacts", "out.json"), '{"source":"A"}\n');
+    await writeFile(
+      path.join(jobDir, "tasks-status.json"),
+      JSON.stringify({
+        id: "job-1",
+        tasks: {
+          research: {
+            files: { artifacts: ["out.json"], logs: [], tmp: [] },
+          },
+        },
+      }),
+    );
+
+    const router = createRouter({ dataDir: rootA });
+    const response = await router.handle(
+      new Request("http://localhost/api/jobs/job-1/tasks/research/file?type=artifacts&filename=out.json", {
+        headers: { Host: "localhost" },
+      }),
+    );
+
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toMatchObject({
+      ok: true,
+      data: '{"source":"A"}\n',
+      mime: "application/json",
+    });
+  });
+
+  it("handleTaskFileList reads from the threaded root, ignoring PO_ROOT=/B", async () => {
+    const rootA = await makeTempRoot("router-iso-A");
+    const rootB = await makeTempRoot("router-iso-B");
+    process.env["PO_ROOT"] = rootB;
+
+    const jobDir = path.join(rootA, "pipeline-data", "current", "job-1");
+    await mkdir(jobDir, { recursive: true });
+    await writeFile(
+      path.join(jobDir, "tasks-status.json"),
+      JSON.stringify({
+        id: "job-1",
+        tasks: {
+          research: {
+            files: { artifacts: ["listed.json"], logs: [], tmp: [] },
+          },
+        },
+      }),
+    );
+
+    const router = createRouter({ dataDir: rootA });
+    const response = await router.handle(
+      new Request("http://localhost/api/jobs/job-1/tasks/research/files?type=artifacts", {
+        headers: { Host: "localhost" },
+      }),
+    );
+
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toEqual({ ok: true, data: ["listed.json"] });
+  });
+
+  it("handleSchemaFile reads from the threaded root, ignoring PO_ROOT=/B", async () => {
+    const rootA = await makeTempRoot("router-iso-A");
+    const rootB = await makeTempRoot("router-iso-B");
+    process.env["PO_ROOT"] = rootB;
+
+    await mkdir(path.join(rootA, "pipeline-config", "slug-1", "schemas"), { recursive: true });
+    await writeFile(path.join(rootA, "pipeline-config", "slug-1", "schemas", "task.schema.json"), '{"$schema":"http://example"}\n');
+
+    const router = createRouter({ dataDir: rootA });
+    const response = await router.handle(
+      new Request("http://localhost/api/pipelines/slug-1/schemas/task.schema.json", {
+        headers: { Host: "localhost" },
+      }),
+    );
+
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toEqual({ ok: true, data: '{"$schema":"http://example"}\n' });
+  });
+
+  it("handleTaskAnalysis reads from the threaded root, ignoring PO_ROOT=/B", async () => {
+    const rootA = await makeTempRoot("router-iso-A");
+    const rootB = await makeTempRoot("router-iso-B");
+    process.env["PO_ROOT"] = rootB;
+
+    await mkdir(path.join(rootA, "pipeline-config", "slug-1", "tasks"), { recursive: true });
+    await writeFile(
+      path.join(rootA, "pipeline-config", "slug-1", "tasks", "research.analysis.json"),
+      JSON.stringify({ taskId: "research", steps: 3 }),
+    );
+
+    const router = createRouter({ dataDir: rootA });
+    const response = await router.handle(
+      new Request("http://localhost/api/pipelines/slug-1/tasks/research/analysis", {
+        headers: { Host: "localhost" },
+      }),
+    );
+
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toEqual({ ok: true, data: { taskId: "research", steps: 3 } });
+  });
+
+  it("handleCreatePipeline writes under the threaded root, ignoring PO_ROOT=/B", async () => {
+    const rootA = await makeTempRoot("router-iso-A");
+    const rootB = await makeTempRoot("router-iso-B");
+    process.env["PO_ROOT"] = rootB;
+
+    const router = createRouter({ dataDir: rootA });
+    const response = await router.handle(
+      new Request("http://localhost/api/pipelines", {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Host: "localhost" },
+        body: JSON.stringify({ name: "Isolation Test Pipeline", description: "x" }),
+      }),
+    );
+
+    expect(response.status).toBe(201);
+    const body = (await response.json()) as { ok: boolean; data: { slug: string; name: string } };
+    expect(body.ok).toBe(true);
+    const slug = body.data.slug;
+    expect(slug.length).toBeGreaterThan(0);
+
+    const pipelinePath = path.join(rootA, "pipeline-config", slug, "pipeline.json");
+    const pipelineText = await Bun.file(pipelinePath).text();
+    const pipeline = JSON.parse(pipelineText) as { name: string; slug: string };
+    expect(pipeline).toMatchObject({ name: "Isolation Test Pipeline", slug });
+
+    const registryPath = path.join(rootA, "pipeline-config", "registry.json");
+    const registry = JSON.parse(await Bun.file(registryPath).text()) as {
+      pipelines: Record<string, { name: string; description: string; configDir: string; tasksDir: string }>;
+    };
+    expect(registry.pipelines[slug]?.configDir).toBe(path.join("pipeline-config", slug));
+    expect(registry.pipelines[slug]?.tasksDir).toBe(path.join("pipeline-config", slug, "tasks"));
+    expect(registry.pipelines[slug]?.name).toBe("Isolation Test Pipeline");
+    expect(registry.pipelines[slug]?.description).toBe("x");
+
+    const bRootExists = await Bun.file(path.join(rootB, "pipeline-config", "registry.json")).exists();
+    expect(bRootExists).toBe(false);
+  });
+
+  it("handleTaskSave writes under the threaded root, ignoring PO_ROOT=/B", async () => {
+    const rootA = await makeTempRoot("router-iso-A");
+    const rootB = await makeTempRoot("router-iso-B");
+    process.env["PO_ROOT"] = rootB;
+
+    const router = createRouter({ dataDir: rootA });
+    const response = await router.handle(
+      new Request("http://localhost/api/tasks/create", {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Host: "localhost" },
+        body: JSON.stringify({ slug: "saved-slug", taskId: "research", content: "# research notes\n" }),
+      }),
+    );
+
+    expect(response.status).toBe(201);
+    await expect(response.json()).resolves.toEqual({ ok: true, data: { slug: "saved-slug", taskId: "research" } });
+
+    const savedPath = path.join(rootA, "pipeline-config", "saved-slug", "tasks", "research.md");
+    const savedText = await Bun.file(savedPath).text();
+    expect(savedText).toBe("# research notes\n");
+
+    const bRootExists = await Bun.file(path.join(rootB, "pipeline-config", "saved-slug", "tasks", "research.md")).exists();
+    expect(bRootExists).toBe(false);
+  });
+});

package/src/ui/server/__tests__/router-threading.test.ts

@@ -0,0 +1,148 @@
+import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
+
+// ─── Capture-args table: populated by mocked handlers so each test can assert
+//     the last argument the router passed.
+const capturedArgs: Record<string, unknown[] | undefined> = {};
+
+mock.module("../endpoints/file-endpoints", () => ({
+  handleTaskFile: mock((...args: unknown[]) => {
+    capturedArgs.handleTaskFile = args;
+    return Promise.resolve(new Response("{}", { headers: { "Content-Type": "application/json" } }));
+  }),
+  handleTaskFileList: mock((...args: unknown[]) => {
+    capturedArgs.handleTaskFileList = args;
+    return Promise.resolve(new Response("{}", { headers: { "Content-Type": "application/json" } }));
+  }),
+}));
+
+mock.module("../endpoints/schema-file-endpoint", () => ({
+  handleSchemaFile: mock((...args: unknown[]) => {
+    capturedArgs.handleSchemaFile = args;
+    return Promise.resolve(new Response("{}", { headers: { "Content-Type": "application/json" } }));
+  }),
+}));
+
+mock.module("../endpoints/task-analysis-endpoint", () => ({
+  handleTaskAnalysis: mock((...args: unknown[]) => {
+    capturedArgs.handleTaskAnalysis = args;
+    return Promise.resolve(new Response("{}", { headers: { "Content-Type": "application/json" } }));
+  }),
+}));
+
+mock.module("../endpoints/pipeline-analysis-endpoint", () => ({
+  handlePipelineAnalysis: mock((...args: unknown[]) => {
+    capturedArgs.handlePipelineAnalysis = args;
+    return Promise.resolve(new Response("{}", { headers: { "Content-Type": "application/json" } }));
+  }),
+}));
+
+mock.module("../endpoints/create-pipeline-endpoint", () => ({
+  handleCreatePipeline: mock((...args: unknown[]) => {
+    capturedArgs.handleCreatePipeline = args;
+    return Promise.resolve(new Response("{}", { headers: { "Content-Type": "application/json" } }));
+  }),
+}));
+
+mock.module("../endpoints/task-save-endpoint", () => ({
+  handleTaskSave: mock((...args: unknown[]) => {
+    capturedArgs.handleTaskSave = args;
+    return Promise.resolve(new Response("{}", { headers: { "Content-Type": "application/json" } }));
+  }),
+}));
+
+// ─── Import the module under test (after mock.module calls) ───────────────────
+import { createRouter } from "../router";
+
+// ─── Env capture/restore per ~/.agents/rules/unit-testing.md §6 ───────────────
+const ORIGINAL_PO_ROOT = process.env["PO_ROOT"];
+
+beforeEach(() => {
+  process.env["PO_ROOT"] = "/B";
+  for (const key of Object.keys(capturedArgs)) delete capturedArgs[key];
+});
+
+afterEach(() => {
+  if (ORIGINAL_PO_ROOT === undefined) {
+    delete process.env["PO_ROOT"];
+  } else {
+    process.env["PO_ROOT"] = ORIGINAL_PO_ROOT;
+  }
+});
+
+describe("router threads resolved root to six handlers (AC-5)", () => {
+  it("passes options.dataDir as the last argument to handleTaskFile", async () => {
+    const router = createRouter({ dataDir: "/A" });
+    await router.handle(
+      new Request("http://localhost/api/jobs/job-1/tasks/task-1/file?type=artifacts&filename=out.txt", {
+        headers: { Host: "localhost" },
+      }),
+    );
+    expect(capturedArgs.handleTaskFile?.at(-1)).toBe("/A");
+  });
+
+  it("passes options.dataDir as the last argument to handleTaskFileList", async () => {
+    const router = createRouter({ dataDir: "/A" });
+    await router.handle(
+      new Request("http://localhost/api/jobs/job-1/tasks/task-1/files?type=artifacts", {
+        headers: { Host: "localhost" },
+      }),
+    );
+    expect(capturedArgs.handleTaskFileList?.at(-1)).toBe("/A");
+  });
+
+  it("passes options.dataDir as the last argument to handleSchemaFile", async () => {
+    const router = createRouter({ dataDir: "/A" });
+    await router.handle(
+      new Request("http://localhost/api/pipelines/slug-1/schemas/task.schema.json", {
+        headers: { Host: "localhost" },
+      }),
+    );
+    expect(capturedArgs.handleSchemaFile?.at(-1)).toBe("/A");
+  });
+
+  it("passes options.dataDir as the last argument to handleTaskAnalysis", async () => {
+    const router = createRouter({ dataDir: "/A" });
+    await router.handle(
+      new Request("http://localhost/api/pipelines/slug-1/tasks/task-1/analysis", {
+        headers: { Host: "localhost" },
+      }),
+    );
+    expect(capturedArgs.handleTaskAnalysis?.at(-1)).toBe("/A");
+  });
+
+  it("passes options.dataDir as the last argument to handlePipelineAnalysis", async () => {
+    const router = createRouter({ dataDir: "/A" });
+    await router.handle(
+      new Request("http://localhost/api/pipelines/slug-1/analyze", {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Host: "localhost" },
+        body: "{}",
+      }),
+    );
+    expect(capturedArgs.handlePipelineAnalysis?.at(-1)).toBe("/A");
+  });
+
+  it("passes options.dataDir as the last argument to handleCreatePipeline", async () => {
+    const router = createRouter({ dataDir: "/A" });
+    await router.handle(
+      new Request("http://localhost/api/pipelines", {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Host: "localhost" },
+        body: "{}",
+      }),
+    );
+    expect(capturedArgs.handleCreatePipeline?.at(-1)).toBe("/A");
+  });
+
+  it("passes options.dataDir as the last argument to handleTaskSave", async () => {
+    const router = createRouter({ dataDir: "/A" });
+    await router.handle(
+      new Request("http://localhost/api/tasks/create", {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Host: "localhost" },
+        body: "{}",
+      }),
+    );
+    expect(capturedArgs.handleTaskSave?.at(-1)).toBe("/A");
+  });
+});