@ryanfw/prompt-orchestration-pipeline 1.3.2 → 1.3.4

package/src/config/__tests__/pipeline-registry.test.ts

@@ -0,0 +1,767 @@
+import { describe, it, expect, afterEach, mock } from "bun:test";
+import { join, resolve } from "node:path";
+import {
+  mkdtempSync,
+  mkdirSync,
+  writeFileSync,
+  rmSync,
+  readdirSync,
+  existsSync,
+  readFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import {
+  REGISTRY_VERSION,
+  RegistryError,
+  registryFilePath,
+  readRegistrySync,
+  resolvePipelineEntry,
+  resolvePipelineSync,
+  resolveAllPipelinesSync,
+  resolveTaskRegistryPath,
+  writeRegistry,
+  registerPipeline,
+} from "../pipeline-registry";
+import type { PipelineRegistry } from "../pipeline-registry";
+
+let renameShouldFail = false;
+
+mock.module("node:fs/promises", () => {
+  const actual = require("node:fs/promises");
+  return {
+    ...actual,
+    rename: (...args: Parameters<typeof actual.rename>) => {
+      if (renameShouldFail) {
+        return Promise.reject(new Error("forced rename failure"));
+      }
+      return actual.rename(...args);
+    },
+  };
+});
+
+describe("REGISTRY_VERSION", () => {
+  it("equals 1", () => {
+    expect(REGISTRY_VERSION).toBe(1);
+  });
+});
+
+describe("RegistryError", () => {
+  it("is an instance of Error", () => {
+    expect(new RegistryError("boom")).toBeInstanceOf(Error);
+  });
+});
+
+describe("registryFilePath", () => {
+  it("returns join(root, 'pipeline-config', 'registry.json')", () => {
+    expect(registryFilePath("/data")).toBe("/data/pipeline-config/registry.json");
+  });
+
+  it("works with a nested root", () => {
+    expect(registryFilePath("/home/user/project")).toBe(
+      "/home/user/project/pipeline-config/registry.json",
+    );
+  });
+});
+
+describe("resolvePipelineEntry", () => {
+  const baseEntry = { name: "Content Gen", description: "Generates content" };
+
+  describe("defaults", () => {
+    it("defaults configDir to join(root, 'pipeline-config', slug) and tasksDir to join(configDir, 'tasks')", () => {
+      const { configDir, tasksDir } = resolvePipelineEntry(
+        "/work",
+        "content-gen",
+        baseEntry,
+      );
+      expect(configDir).toBe("/work/pipeline-config/content-gen");
+      expect(tasksDir).toBe("/work/pipeline-config/content-gen/tasks");
+    });
+
+    it("defaults tasksDir off an explicit absolute configDir", () => {
+      const { configDir, tasksDir } = resolvePipelineEntry("/work", "s", {
+        ...baseEntry,
+        configDir: "/abs/cfg",
+      });
+      expect(configDir).toBe("/abs/cfg");
+      expect(tasksDir).toBe("/abs/cfg/tasks");
+    });
+  });
+
+  describe("relative values resolve against root", () => {
+    it("joins relative configDir and tasksDir under root", () => {
+      const { configDir, tasksDir } = resolvePipelineEntry("/work", "s", {
+        ...baseEntry,
+        configDir: "custom/cfg",
+        tasksDir: "custom/tasks",
+      });
+      expect(configDir).toBe("/work/custom/cfg");
+      expect(tasksDir).toBe("/work/custom/tasks");
+    });
+  });
+
+  describe("absolute values pass through", () => {
+    it("leaves absolute configDir and tasksDir unchanged", () => {
+      const { configDir, tasksDir } = resolvePipelineEntry("/work", "s", {
+        ...baseEntry,
+        configDir: "/abs/cfg",
+        tasksDir: "/abs/tasks",
+      });
+      expect(configDir).toBe("/abs/cfg");
+      expect(tasksDir).toBe("/abs/tasks");
+    });
+  });
+
+  describe("mixed relative and absolute", () => {
+    it("resolves each field independently", () => {
+      const { configDir, tasksDir } = resolvePipelineEntry("/work", "s", {
+        ...baseEntry,
+        configDir: "rel/cfg",
+        tasksDir: "/abs/tasks",
+      });
+      expect(configDir).toBe("/work/rel/cfg");
+      expect(tasksDir).toBe("/abs/tasks");
+    });
+  });
+});
+
+describe("readRegistrySync", () => {
+  let tmp: string;
+
+  afterEach(() => {
+    if (tmp) rmSync(tmp, { recursive: true, force: true });
+  });
+
+  const setupTmp = (): string => {
+    tmp = mkdtempSync(join(tmpdir(), "pop-reg-"));
+    mkdirSync(join(tmp, "pipeline-config"), { recursive: true });
+    return tmp;
+  };
+
+  const writeRegistry = (root: string, contents: string): string => {
+    const filePath = registryFilePath(root);
+    writeFileSync(filePath, contents);
+    return filePath;
+  };
+
+  describe("absent file", () => {
+    it("returns a fresh v1 empty registry", () => {
+      tmp = mkdtempSync(join(tmpdir(), "pop-reg-"));
+      const result = readRegistrySync(tmp);
+      expect(result).toEqual({ version: 1, pipelines: {} });
+    });
+  });
+
+  describe("malformed JSON", () => {
+    it("throws RegistryError with the file path in the message", () => {
+      const root = setupTmp();
+      const filePath = writeRegistry(root, "{ not json");
+      expect(() => readRegistrySync(root)).toThrow(RegistryError);
+      expect(() => readRegistrySync(root)).toThrow(filePath);
+      expect(() => readRegistrySync(root)).toThrow("not valid JSON");
+    });
+  });
+
+  describe("empty file", () => {
+    it("throws RegistryError naming the path", () => {
+      const root = setupTmp();
+      const filePath = writeRegistry(root, "");
+      expect(() => readRegistrySync(root)).toThrow(RegistryError);
+      expect(() => readRegistrySync(root)).toThrow(filePath);
+      expect(() => readRegistrySync(root)).toThrow("registry file is empty");
+    });
+  });
+
+  describe("whitespace-only file", () => {
+    it("throws RegistryError naming the path", () => {
+      const root = setupTmp();
+      const filePath = writeRegistry(root, "   \n\t ");
+      expect(() => readRegistrySync(root)).toThrow(RegistryError);
+      expect(() => readRegistrySync(root)).toThrow(filePath);
+    });
+  });
+
+  describe("non-object JSON", () => {
+    it("rejects an array", () => {
+      const root = setupTmp();
+      writeRegistry(root, JSON.stringify([1, 2, 3]));
+      expect(() => readRegistrySync(root)).toThrow(RegistryError);
+      expect(() => readRegistrySync(root)).toThrow(
+        "registry must be a JSON object",
+      );
+    });
+
+    it("rejects a string", () => {
+      const root = setupTmp();
+      writeRegistry(root, JSON.stringify("hello"));
+      expect(() => readRegistrySync(root)).toThrow(
+        "registry must be a JSON object",
+      );
+    });
+
+    it("rejects a number", () => {
+      const root = setupTmp();
+      writeRegistry(root, JSON.stringify(42));
+      expect(() => readRegistrySync(root)).toThrow(
+        "registry must be a JSON object",
+      );
+    });
+
+    it("rejects null", () => {
+      const root = setupTmp();
+      writeRegistry(root, JSON.stringify(null));
+      expect(() => readRegistrySync(root)).toThrow(
+        "registry must be a JSON object",
+      );
+    });
+  });
+
+  describe("missing pipelines", () => {
+    it("rejects a document without the pipelines key", () => {
+      const root = setupTmp();
+      writeRegistry(root, JSON.stringify({ version: 1 }));
+      expect(() => readRegistrySync(root)).toThrow(
+        "missing 'pipelines' object",
+      );
+    });
+
+    it("rejects pipelines: null", () => {
+      const root = setupTmp();
+      writeRegistry(root, JSON.stringify({ version: 1, pipelines: null }));
+      expect(() => readRegistrySync(root)).toThrow(
+        "missing 'pipelines' object",
+      );
+    });
+
+  });
+
+  describe("legacy shapes", () => {
+    it("tolerates the legacy { slugs: [] } shape as an empty registry", () => {
+      const root = setupTmp();
+      writeRegistry(root, JSON.stringify({ slugs: [] }));
+      expect(readRegistrySync(root)).toEqual({ version: 1, pipelines: {} });
+    });
+
+    it("tolerates the legacy { defaultSlug, slugs } shape as an empty registry", () => {
+      const root = setupTmp();
+      writeRegistry(
+        root,
+        JSON.stringify({ defaultSlug: "x", slugs: { x: {} } }),
+      );
+      expect(readRegistrySync(root)).toEqual({ version: 1, pipelines: {} });
+    });
+  });
+
+  describe("entry validation", () => {
+    it("rejects an entry missing 'name', naming the slug", () => {
+      const root = setupTmp();
+      writeRegistry(
+        root,
+        JSON.stringify({ version: 1, pipelines: { foo: { description: "d" } } }),
+      );
+      expect(() => readRegistrySync(root)).toThrow(RegistryError);
+      expect(() => readRegistrySync(root)).toThrow(
+        "entry 'foo': 'name' must be a string",
+      );
+    });
+
+    it("rejects an entry missing 'description', naming the slug", () => {
+      const root = setupTmp();
+      writeRegistry(
+        root,
+        JSON.stringify({ version: 1, pipelines: { foo: { name: "n" } } }),
+      );
+      expect(() => readRegistrySync(root)).toThrow(
+        "entry 'foo': 'description' must be a string",
+      );
+    });
+
+    it("rejects a non-string configDir, naming the slug", () => {
+      const root = setupTmp();
+      writeRegistry(
+        root,
+        JSON.stringify({
+          version: 1,
+          pipelines: {
+            foo: { name: "n", description: "d", configDir: 7 },
+          },
+        }),
+      );
+      expect(() => readRegistrySync(root)).toThrow(
+        "entry 'foo': 'configDir' must be a string when present",
+      );
+    });
+
+    it("rejects a non-string tasksDir, naming the slug", () => {
+      const root = setupTmp();
+      writeRegistry(
+        root,
+        JSON.stringify({
+          version: 1,
+          pipelines: {
+            foo: { name: "n", description: "d", tasksDir: false },
+          },
+        }),
+      );
+      expect(() => readRegistrySync(root)).toThrow(
+        "entry 'foo': 'tasksDir' must be a string when present",
+      );
+    });
+  });
+
+  describe("entry must be an object", () => {
+    it("rejects a null entry, naming the slug", () => {
+      const root = setupTmp();
+      writeRegistry(
+        root,
+        JSON.stringify({ version: 1, pipelines: { foo: null } }),
+      );
+      expect(() => readRegistrySync(root)).toThrow(RegistryError);
+      expect(() => readRegistrySync(root)).toThrow(
+        "entry 'foo': must be an object",
+      );
+    });
+
+    it("rejects a number entry, naming the slug", () => {
+      const root = setupTmp();
+      writeRegistry(
+        root,
+        JSON.stringify({ version: 1, pipelines: { foo: 42 } }),
+      );
+      expect(() => readRegistrySync(root)).toThrow(RegistryError);
+      expect(() => readRegistrySync(root)).toThrow(
+        "entry 'foo': must be an object",
+      );
+    });
+
+    it("rejects an array entry, naming the slug", () => {
+      const root = setupTmp();
+      writeRegistry(
+        root,
+        JSON.stringify({ version: 1, pipelines: { foo: [] } }),
+      );
+      expect(() => readRegistrySync(root)).toThrow(RegistryError);
+      expect(() => readRegistrySync(root)).toThrow(
+        "entry 'foo': must be an object",
+      );
+    });
+  });
+
+  describe("version", () => {
+    it("rejects an unsupported numeric version", () => {
+      const root = setupTmp();
+      writeRegistry(root, JSON.stringify({ version: 2, pipelines: {} }));
+      expect(() => readRegistrySync(root)).toThrow(RegistryError);
+      expect(() => readRegistrySync(root)).toThrow(
+        "unsupported registry version 2 (expected 1)",
+      );
+    });
+
+    it("rejects a non-number version value", () => {
+      const root = setupTmp();
+      writeRegistry(root, JSON.stringify({ version: "1", pipelines: {} }));
+      expect(() => readRegistrySync(root)).toThrow(
+        'unsupported registry version "1" (expected 1)',
+      );
+    });
+
+    it("accepts a document missing top-level version as version 1", () => {
+      const root = setupTmp();
+      writeRegistry(
+        root,
+        JSON.stringify({
+          pipelines: { foo: { name: "n", description: "d" } },
+        }),
+      );
+      const result = readRegistrySync(root);
+      expect(result.version).toBe(1);
+      expect(result.pipelines.foo?.name).toBe("n");
+    });
+  });
+
+  describe("permissive valid surface", () => {
+    it("accepts an entry carrying unknown extra keys", () => {
+      const root = setupTmp();
+      writeRegistry(
+        root,
+        JSON.stringify({
+          version: 1,
+          pipelines: {
+            foo: {
+              name: "n",
+              description: "d",
+              extra: "ok",
+              nested: { a: 1 },
+            },
+          },
+        }),
+      );
+      const result = readRegistrySync(root);
+      expect(result.pipelines.foo?.name).toBe("n");
+    });
+
+    it("returns { version: 1, pipelines: {} } for an empty pipelines map", () => {
+      const root = setupTmp();
+      writeRegistry(root, JSON.stringify({ version: 1, pipelines: {} }));
+      expect(readRegistrySync(root)).toEqual({ version: 1, pipelines: {} });
+    });
+  });
+});
+
+describe("resolvePipelineSync", () => {
+  let tmp: string;
+
+  afterEach(() => {
+    if (tmp) rmSync(tmp, { recursive: true, force: true });
+  });
+
+  const setupTmp = (): string => {
+    tmp = mkdtempSync(join(tmpdir(), "pop-reg-"));
+    mkdirSync(join(tmp, "pipeline-config"), { recursive: true });
+    return tmp;
+  };
+
+  const writeRegistryFile = (root: string, registry: unknown): void => {
+    writeFileSync(registryFilePath(root), JSON.stringify(registry));
+  };
+
+  it("registered slug resolves to pipeline.json path and tasksDir (defaults)", () => {
+    const root = setupTmp();
+    writeRegistryFile(root, {
+      version: 1,
+      pipelines: { foo: { name: "Foo", description: "d" } },
+    });
+    const result = resolvePipelineSync(root, "foo");
+    expect(result.pipelineJsonPath).toBe(
+      join(root, "pipeline-config", "foo", "pipeline.json"),
+    );
+    expect(result.tasksDir).toBe(join(root, "pipeline-config", "foo", "tasks"));
+  });
+
+  it("registered slug with explicit absolute configDir derives tasksDir and pipelineJsonPath", () => {
+    const root = setupTmp();
+    const customCfg = join(root, "custom-cfg");
+    writeRegistryFile(root, {
+      version: 1,
+      pipelines: {
+        foo: { name: "Foo", description: "d", configDir: customCfg },
+      },
+    });
+    const result = resolvePipelineSync(root, "foo");
+    expect(result.pipelineJsonPath).toBe(join(customCfg, "pipeline.json"));
+    expect(result.tasksDir).toBe(join(customCfg, "tasks"));
+  });
+
+  it("registered slug with relative configDir/tasksDir resolves against root", () => {
+    const root = setupTmp();
+    writeRegistryFile(root, {
+      version: 1,
+      pipelines: {
+        foo: {
+          name: "Foo",
+          description: "d",
+          configDir: "rel-cfg",
+          tasksDir: "rel-tasks",
+        },
+      },
+    });
+    const result = resolvePipelineSync(root, "foo");
+    expect(result.pipelineJsonPath).toBe(
+      join(root, "rel-cfg", "pipeline.json"),
+    );
+    expect(result.tasksDir).toBe(join(root, "rel-tasks"));
+  });
+
+  it("unknown slug throws 'Pipeline '<slug>' not found in registry'", () => {
+    const root = setupTmp();
+    writeRegistryFile(root, { version: 1, pipelines: {} });
+    expect(() => resolvePipelineSync(root, "missing")).toThrow(
+      "Pipeline 'missing' not found in registry",
+    );
+  });
+
+  it("unknown slug throws the same message when the registry file is absent", () => {
+    tmp = mkdtempSync(join(tmpdir(), "pop-reg-"));
+    expect(() => resolvePipelineSync(tmp, "missing")).toThrow(
+      "Pipeline 'missing' not found in registry",
+    );
+  });
+});
+
+describe("resolveAllPipelinesSync", () => {
+  let tmp: string;
+
+  afterEach(() => {
+    if (tmp) rmSync(tmp, { recursive: true, force: true });
+  });
+
+  const setupTmp = (): string => {
+    tmp = mkdtempSync(join(tmpdir(), "pop-reg-"));
+    mkdirSync(join(tmp, "pipeline-config"), { recursive: true });
+    return tmp;
+  };
+
+  const writeRegistryFile = (root: string, registry: unknown): void => {
+    writeFileSync(registryFilePath(root), JSON.stringify(registry));
+  };
+
+  it("returns empty map when pipelines is empty", () => {
+    const root = setupTmp();
+    writeRegistryFile(root, { version: 1, pipelines: {} });
+    expect(resolveAllPipelinesSync(root)).toEqual({});
+  });
+
+  it("returns empty map when the registry file is absent", () => {
+    tmp = mkdtempSync(join(tmpdir(), "pop-reg-"));
+    expect(resolveAllPipelinesSync(tmp)).toEqual({});
+  });
+
+  it("multi-entry registry returns per-slug { configDir, tasksDir } matching resolvePipelineEntry", () => {
+    const root = setupTmp();
+    const alphaEntry = { name: "A", description: "d" };
+    const betaEntry = {
+      name: "B",
+      description: "d",
+      configDir: "custom/beta",
+    };
+    writeRegistryFile(root, {
+      version: 1,
+      pipelines: { alpha: alphaEntry, beta: betaEntry },
+    });
+
+    const result = resolveAllPipelinesSync(root);
+
+    expect(result.alpha).toEqual(
+      resolvePipelineEntry(root, "alpha", alphaEntry),
+    );
+    expect(result.beta).toEqual(resolvePipelineEntry(root, "beta", betaEntry));
+    expect(result.alpha?.configDir).toBe(
+      join(root, "pipeline-config", "alpha"),
+    );
+    expect(result.beta?.configDir).toBe(join(root, "custom", "beta"));
+  });
+
+  it("does NOT include pipelineJsonPath in the per-entry shape", () => {
+    const root = setupTmp();
+    writeRegistryFile(root, {
+      version: 1,
+      pipelines: { alpha: { name: "A", description: "d" } },
+    });
+    const result = resolveAllPipelinesSync(root);
+    expect(result.alpha).not.toHaveProperty("pipelineJsonPath");
+  });
+});
+
+describe("resolveTaskRegistryPath", () => {
+  let tmp: string;
+
+  afterEach(() => {
+    if (tmp) rmSync(tmp, { recursive: true, force: true });
+  });
+
+  const setupTmp = (): string => {
+    tmp = mkdtempSync(join(tmpdir(), "pop-task-"));
+    return tmp;
+  };
+
+  it("returns index.js path when only index.js exists", () => {
+    const tasksDir = setupTmp();
+    writeFileSync(join(tasksDir, "index.js"), "");
+    expect(resolveTaskRegistryPath(tasksDir)).toBe(join(tasksDir, "index.js"));
+  });
+
+  it("returns index.ts path when only index.ts exists", () => {
+    const tasksDir = setupTmp();
+    writeFileSync(join(tasksDir, "index.ts"), "");
+    expect(resolveTaskRegistryPath(tasksDir)).toBe(join(tasksDir, "index.ts"));
+  });
+
+  it("prefers index.js when both index.js and index.ts exist", () => {
+    const tasksDir = setupTmp();
+    writeFileSync(join(tasksDir, "index.js"), "");
+    writeFileSync(join(tasksDir, "index.ts"), "");
+    expect(resolveTaskRegistryPath(tasksDir)).toBe(join(tasksDir, "index.js"));
+  });
+
+  it("returns index.js path when neither exists", () => {
+    const tasksDir = setupTmp();
+    expect(resolveTaskRegistryPath(tasksDir)).toBe(join(tasksDir, "index.js"));
+  });
+});
+
+describe("writeRegistry + registerPipeline", () => {
+  let tmp: string;
+
+  afterEach(() => {
+    if (tmp) rmSync(tmp, { recursive: true, force: true });
+  });
+
+  const setupTmp = (): string => {
+    tmp = mkdtempSync(join(tmpdir(), "pop-reg-write-"));
+    mkdirSync(join(tmp, "pipeline-config"), { recursive: true });
+    return tmp;
+  };
+
+  it("registerPipeline round-trips the entry through readRegistrySync", async () => {
+    const root = setupTmp();
+    await registerPipeline(root, "foo", {
+      name: "Foo",
+      description: "makes the foos",
+    });
+
+    const result = readRegistrySync(root);
+
+    expect(result.version).toBe(REGISTRY_VERSION);
+    expect(result.pipelines.foo?.name).toBe("Foo");
+    expect(result.pipelines.foo?.description).toBe("makes the foos");
+  });
+
+  it("writes the file at registryFilePath(root) containing version: 1", async () => {
+    const root = setupTmp();
+    await registerPipeline(root, "foo", {
+      name: "Foo",
+      description: "d",
+    });
+
+    const filePath = registryFilePath(root);
+    expect(existsSync(filePath)).toBe(true);
+    expect(existsSync(join(root, "registry.json"))).toBe(false);
+
+    const text = readFileSync(filePath, "utf8");
+    expect(text).toContain('"version":1');
+    expect(text).toContain('"foo"');
+  });
+
+  it("registerPipeline preserves existing entries when adding a new one", async () => {
+    const root = setupTmp();
+    writeFileSync(
+      registryFilePath(root),
+      JSON.stringify({
+        version: 1,
+        pipelines: { a: { name: "Alpha", description: "first" } },
+      }),
+    );
+
+    await registerPipeline(root, "b", {
+      name: "Beta",
+      description: "second",
+    });
+
+    const result = readRegistrySync(root);
+    expect(Object.keys(result.pipelines).sort()).toEqual(["a", "b"]);
+    expect(result.pipelines.a?.name).toBe("Alpha");
+    expect(result.pipelines.b?.name).toBe("Beta");
+  });
+
+  it("forced pre-rename failure leaves the previous registry content unchanged and removes the temp file", async () => {
+    const root = setupTmp();
+    const original: PipelineRegistry = {
+      version: 1,
+      pipelines: {
+        existing: { name: "Existing", description: "preserve me" },
+      },
+    };
+    writeFileSync(registryFilePath(root), JSON.stringify(original));
+
+    renameShouldFail = true;
+    try {
+      await expect(
+        writeRegistry(root, {
+          version: 1,
+          pipelines: { other: { name: "Other", description: "x" } },
+        }),
+      ).rejects.toThrow("forced rename failure");
+    } finally {
+      renameShouldFail = false;
+    }
+
+    expect(readRegistrySync(root)).toEqual(original);
+
+    const lingeringTemps = readdirSync(join(tmp, "pipeline-config")).filter(
+      (f) => f.includes("registry.json.tmp"),
+    );
+    expect(lingeringTemps).toEqual([]);
+  });
+});
+
+describe("demo registry", () => {
+  const demoRoot = resolve(process.cwd(), "demo");
+
+  it("readRegistrySync accepts the demo registry as a v1 document", () => {
+    const reg = readRegistrySync(demoRoot);
+    expect(reg.version).toBe(1);
+    expect(reg.pipelines["content-generation"]?.name).toBe(
+      "Content Generation Pipeline",
+    );
+    expect(reg.pipelines["agent-harness-demo"]?.name).toBe(
+      "Agent Harness Demo Pipeline",
+    );
+    expect(reg.pipelines["agent-js-task-demo"]?.name).toBe(
+      "Agent JS Task Demo Pipeline",
+    );
+  });
+
+  it("resolvePipelineSync resolves content-generation to existing pipeline.json and tasks dir", () => {
+    const resolved = resolvePipelineSync(demoRoot, "content-generation");
+    expect(existsSync(resolved.pipelineJsonPath)).toBe(true);
+    expect(existsSync(resolved.tasksDir)).toBe(true);
+  });
+
+  it("resolvePipelineSync resolves agent-harness-demo via default resolution", () => {
+    const resolved = resolvePipelineSync(demoRoot, "agent-harness-demo");
+    expect(resolved.pipelineJsonPath).toBe(
+      join(demoRoot, "pipeline-config", "agent-harness-demo", "pipeline.json"),
+    );
+    expect(resolved.tasksDir).toBe(
+      join(demoRoot, "pipeline-config", "agent-harness-demo", "tasks"),
+    );
+    expect(existsSync(resolved.pipelineJsonPath)).toBe(true);
+    expect(existsSync(resolved.tasksDir)).toBe(true);
+  });
+
+  it("resolvePipelineSync resolves agent-js-task-demo via default resolution", () => {
+    const resolved = resolvePipelineSync(demoRoot, "agent-js-task-demo");
+    expect(resolved.pipelineJsonPath).toBe(
+      join(demoRoot, "pipeline-config", "agent-js-task-demo", "pipeline.json"),
+    );
+    expect(resolved.tasksDir).toBe(
+      join(demoRoot, "pipeline-config", "agent-js-task-demo", "tasks"),
+    );
+    expect(existsSync(resolved.pipelineJsonPath)).toBe(true);
+    expect(existsSync(resolved.tasksDir)).toBe(true);
+  });
+
+  it("content-generation entry carries explicit configDir and tasksDir in the file", () => {
+    const raw = readFileSync(registryFilePath(demoRoot), "utf8");
+    expect(raw).toContain('"configDir"');
+    expect(raw).toContain('"tasksDir"');
+
+    const parsed = JSON.parse(raw) as {
+      pipelines: Record<string, Record<string, unknown>>;
+    };
+    const entry = parsed.pipelines["content-generation"];
+    expect(entry?.["configDir"]).toBe("pipeline-config/content-generation");
+    expect(entry?.["tasksDir"]).toBe("pipeline-config/content-generation/tasks");
+  });
+
+  it("agent-harness-demo relies on default resolution (no configDir/tasksDir)", () => {
+    const raw = readFileSync(registryFilePath(demoRoot), "utf8");
+    const parsed = JSON.parse(raw) as {
+      pipelines: Record<string, Record<string, unknown>>;
+    };
+    const entry = parsed.pipelines["agent-harness-demo"];
+    expect(entry).toBeDefined();
+    expect(entry?.["configDir"]).toBeUndefined();
+    expect(entry?.["tasksDir"]).toBeUndefined();
+  });
+
+  it("agent-js-task-demo relies on default resolution (no configDir/tasksDir)", () => {
+    const raw = readFileSync(registryFilePath(demoRoot), "utf8");
+    const parsed = JSON.parse(raw) as {
+      pipelines: Record<string, Record<string, unknown>>;
+    };
+    const entry = parsed.pipelines["agent-js-task-demo"];
+    expect(entry).toBeDefined();
+    expect(entry?.["configDir"]).toBeUndefined();
+    expect(entry?.["tasksDir"]).toBeUndefined();
+  });
+});