@synap-core/workspace-templates 0.12.0 → 0.24.0

package/src/content-studio-retired.template.test.ts

@@ -0,0 +1,82 @@
+/**
+ * Static asset edit loop, W5 (build plan pod document ab3e0a5a §4, founder D0-D1, 2 Nov 2026).
+ * Pinned against the REAL YAML corpus and the real tombstone registry:
+ *
+ *   1. `content-studio` is no longer live, and `retired.yaml` points it at `content-os`, which
+ *      declares every kind it held (content-composition, content-asset, render-job, the
+ *      brand-template grant). No live template depends on it, and no standard targets it.
+ *   2. `brand-template`'s Format gains `layered` and `open-design` (the words content-os
+ *      `render-engine` uses), additively, in Brand Library and in Content OS's mirror.
+ *
+ * Does NOT cover: the pod side (the resolver refuses a retired install and leaves an
+ * installed space alone, synap-backend resolve-workspace-template.ts), nor the CP row,
+ * which changes only when the catalog is published.
+ */
+
+import { existsSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { describe, expect, it } from "vitest";
+import { readYamlTemplates } from "./generate.mjs";
+import type { WorkspaceYaml } from "./types.js";
+import { loadRetired } from "../scripts/catalog-lib.mjs";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const corpus = readYamlTemplates().map((t) => t.data as WorkspaceYaml);
+const template = (slug: string) => corpus.find((t) => t.meta.slug === slug);
+const prop = (tpl: WorkspaceYaml | undefined, profile: string, slug: string) =>
+  tpl?.profiles.find((p) => p.slug === profile)?.properties.find((d) => d.slug === slug) as
+    | { enumValues?: string[] }
+    | undefined;
+
+const FORMATS_BEFORE = ["tldraw", "html", "json", "markdown", "image", "mixed", "hyperframes"];
+
+describe("content-studio is retired into content-os", () => {
+  it("non-vacuity: the corpus is read and content-os is live", () => {
+    expect(corpus.length).toBeGreaterThanOrEqual(25);
+    expect(template("content-os")).toBeDefined();
+  });
+
+  it("is no longer live, and retired.yaml points it at content-os", async () => {
+    expect(corpus.map((t) => t.meta.slug)).not.toContain("content-studio");
+    const { retired, problems } = await loadRetired();
+    expect(problems).toEqual([]);
+    expect(retired.find((t) => t.slug === "content-studio")).toMatchObject({
+      kind: "workspace",
+      replacedBy: "content-os",
+      since: "2026-11-03",
+    });
+  });
+
+  it("content-os declares every kind content-studio held", () => {
+    const slugs = (template("content-os")?.profiles ?? []).map((p) => p.slug);
+    for (const kind of ["content-composition", "content-asset", "render-job", "brand-template"]) {
+      expect(slugs, `content-os must declare ${kind}`).toContain(kind);
+    }
+  });
+
+  it("nothing live depends on it, and no standard targets it", () => {
+    const dependents = corpus.filter((t) =>
+      ((t as { dependencies?: Array<{ slug: string }> }).dependencies ?? []).some((d) => d.slug === "content-studio")
+    );
+    expect(dependents.map((t) => t.meta.slug)).toEqual([]);
+    expect(existsSync(join(here, "../standards/content-studio.standard.yaml"))).toBe(false);
+  });
+});
+
+describe("brand-template gains the layered and open-design formats", () => {
+  it("uses the words content-os render-engine uses", () => {
+    const engines = prop(template("content-os"), "content-composition", "render-engine")?.enumValues ?? [];
+    expect(engines).toEqual(expect.arrayContaining(["layered", "open-design"]));
+  });
+
+  it("adds them without dropping a value, in Brand Library and Content OS's mirror", () => {
+    for (const slug of ["brand-library", "content-os"]) {
+      expect(prop(template(slug), "brand-template", "template-format")?.enumValues, slug).toEqual([
+        ...FORMATS_BEFORE,
+        "layered",
+        "open-design",
+      ]);
+    }
+  });
+});

package/src/corpus-flow-validity.test.ts

@@ -85,10 +85,9 @@ test("corpus: every shipped automation flow passes validateFlowDefinition", () =
 // These seeds ship automations verbatim into user pods, so they are held to the
 // same contract. Skips when the CP checkout is absent, like the drift guards.
 const HERE = dirname(fileURLToPath(import.meta.url));
-const CP_SEEDS = join(
-  HERE,
-  "../../../../synap-control-plane-api/src/seeds/capability-templates",
-);
+// The catalog's capability manifests (`spec` = the CP seed JSON; the CP keeps a
+// byte-checked mirror until its pin bump). Always present: no skip.
+const CP_SEEDS = join(HERE, "../capabilities");
 
 test("corpus: every CP capability seed's automation flow passes validateFlowDefinition", (t) => {
   if (!existsSync(CP_SEEDS)) {
@@ -99,7 +98,7 @@ test("corpus: every CP capability seed's automation flow passes validateFlowDefi
   let flowsChecked = 0;
 
   for (const file of readdirSync(CP_SEEDS).filter((f) => f.endsWith(".json"))) {
-    const seed = JSON.parse(readFileSync(join(CP_SEEDS, file), "utf8")) as {
+    const seed = (JSON.parse(readFileSync(join(CP_SEEDS, file), "utf8")) as { spec: unknown }).spec as {
       automations?: Array<{ key?: string; name?: string; flowDefinition?: unknown }>;
     };
     for (const automation of seed.automations ?? []) {

package/src/crm-absorbs-outreach.template.test.ts

@@ -0,0 +1,117 @@
+/**
+ * CRM absorbs Outreach & Comms (founder decision 2026-10-23: one space per
+ * domain; for a founder-led company outreach is part of the commercial job).
+ * Pinned against the REAL YAML corpus and the real tombstone registry:
+ *
+ *   1. `outreach-comms` is no longer live, and `retired.yaml` points it at `crm`;
+ *      no live template still depends on it.
+ *   2. CRM owns `outreach-touch` with the SAME slug and lifecycle keys the CRM
+ *      app reads, and `sent` is a person's move (the agent drafts, a person sends).
+ *   3. No twin: no template declares `outreach-campaign`; an outreach campaign is
+ *      CRM's `campaign` (campaign-type outreach) carrying the angle's offer
+ *      fields. Touch edges `sent_to` → person and `part_of` → campaign resolve.
+ *   4. No CRM process can send (no send grant, no send intent required) and none
+ *      opens a deal from a reply; the reply reader proposes the estimate or a
+ *      meeting and starts when a person marked the message sent (a touch from
+ *      before the channels; a channel's replies are read by the follow-up).
+ *
+ * Does NOT cover: what an agent does at run time (the goals are prose), nor the
+ * pod applying the fold (no pod had outreach-comms installed; nothing migrates).
+ */
+
+import { describe, expect, it } from "vitest";
+import { readYamlTemplates } from "./generate.mjs";
+import type { WorkspaceYaml } from "./types.js";
+import { loadRetired } from "../scripts/catalog-lib.mjs";
+
+const corpus = readYamlTemplates().map((t) => t.data as WorkspaceYaml);
+const crm = corpus.find((t) => t.meta.slug === "crm")!;
+const profileOf = (slug: string) => crm.profiles.find((p) => p.slug === slug);
+const playbookOf = (name: string) => {
+  const pb = crm.playbooks?.find((p) => p.name === name);
+  if (!pb) throw new Error(`playbook "${name}" not in crm`);
+  return pb;
+};
+const outputsOf = (pb: ReturnType<typeof playbookOf>) => [
+  ...(pb.expectedOutputs ?? []),
+  ...(pb.stages ?? []).flatMap((s) => s.expectedOutputs ?? []),
+];
+const SEND_GRANTS = ["unipile_send_message", "gmail_send", "linkedin_send_invite"];
+
+describe("CRM absorbs Outreach & Comms", () => {
+  it("non-vacuity: the corpus is read and CRM has processes", () => {
+    expect(corpus.length).toBeGreaterThanOrEqual(25);
+    expect(crm).toBeDefined();
+    expect((crm.playbooks ?? []).length).toBeGreaterThanOrEqual(5);
+  });
+
+  it("outreach-comms is retired to crm, and nothing live depends on it", async () => {
+    expect(corpus.map((t) => t.meta.slug)).not.toContain("outreach-comms");
+    const { retired, problems } = await loadRetired();
+    expect(problems).toEqual([]);
+    expect(retired.find((t) => t.slug === "outreach-comms")).toMatchObject({
+      kind: "workspace",
+      replacedBy: "crm",
+      since: "2026-10-23",
+    });
+    const dependents = corpus.filter((t) =>
+      ((t as { dependencies?: Array<{ slug: string }> }).dependencies ?? []).some((d) => d.slug === "outreach-comms")
+    );
+    expect(dependents.map((t) => t.meta.slug)).toEqual([]);
+  });
+
+  it("CRM owns outreach-touch with the same lifecycle keys, and sending is a person's move", () => {
+    const touch = profileOf("outreach-touch");
+    expect(touch?.lifecycle?.property).toBe("status");
+    expect(touch?.lifecycle?.options.map((o) => [o.key, o.category, o.humanOnly ?? false])).toEqual([
+      ["drafted", "open", false],
+      ["sent", "active", true],
+      ["opened", "active", false],
+      ["replied", "done", false],
+      ["bounced", "lost", false],
+      ["no_response", "lost", false],
+    ]);
+    expect(crm.meta.intent?.produces?.map((p) => p.profile)).toContain("outreach-touch");
+  });
+
+  it("no outreach-campaign twin: the angle is CRM's campaign, and the touch edges resolve", () => {
+    for (const t of corpus) expect(t.profiles.map((p) => p.slug), t.meta.slug).not.toContain("outreach-campaign");
+    const campaign = profileOf("campaign");
+    const props = (campaign?.properties ?? []).map((p) => p.slug);
+    expect(props).toEqual(expect.arrayContaining(["campaign-value-prop", "campaign-call-to-action"]));
+    expect(campaign?.properties.find((p) => p.slug === "campaign-type")?.enumValues).toContain("outreach");
+    const touchLinks = (crm.entityLinks ?? []).filter((l) => l.sourceProfileSlug === "outreach-touch");
+    expect(touchLinks.map((l) => [l.type, l.targetProfileSlug])).toEqual([
+      ["sent_to", "person"],
+      ["part_of", "campaign"],
+      // Whose message it is: the lead, a person or a company (required, lane E2).
+      ["relates_to", "person"],
+      ["relates_to", "company"],
+    ]);
+    // A campaign reaches people through member_of, not a second `targets` edge.
+    expect((crm.entityLinks ?? []).filter((l) => l.sourceProfileSlug === "campaign")).toEqual([]);
+  });
+
+  it("no CRM process sends, and none opens a deal from a reply", () => {
+    for (const pb of crm.playbooks ?? []) {
+      const grants = (pb as { grants?: string[] }).grants ?? [];
+      expect(grants.filter((g) => SEND_GRANTS.includes(g)), pb.name).toEqual([]);
+      expect(pb.requiredIntents ?? [], pb.name).not.toContain("send_message");
+    }
+    const reply = playbookOf("Read the reply to an outreach message");
+    expect(reply.subjectProfile?.profileSlug).toBe("outreach-touch");
+    expect(reply.activators).toEqual([{ on: "enters_status", status: "sent", mode: "run" }]);
+    expect(outputsOf(reply).map((o) => o.kind)).not.toContain("deal");
+    expect(reply.goalTemplate).toMatch(/estimate/);
+    expect(reply.goalTemplate).toMatch(/meeting/);
+    expect(reply.goalTemplate).not.toMatch(/(?<!never )open a deal/i);
+    // The run starts at `sent`: no stage may move the message back to drafted or sent.
+    expect((reply.stages ?? []).map((s) => s.subjectStatus).filter(Boolean)).toEqual(["replied", "bounced", "no_response"]);
+
+    const outreach = playbookOf("Personalized Outreach");
+    expect(outreach.subjectProfile).toMatchObject({ profileSlug: "campaign", statusProperty: "campaign-status" });
+    expect(outputsOf(outreach)).toEqual([
+      { kind: "messaging", label: "Proposed first messages", relationToSubject: "none" },
+    ]);
+  });
+});

package/src/crm-build-plan.template.test.ts

@@ -0,0 +1,128 @@
+/**
+ * The CRM build plan's catalog changes (pod document a684720a, section 3A,
+ * founder-approved 2026-10-22), pinned against the REAL YAML corpus and the
+ * real validator:
+ *
+ *   A1  the lead role's leadSource names warm-network, research, import, inbound-form;
+ *   A2  the deal's first stages read "Meeting booked" / "Proposal sent", and every
+ *       stage still open is stuck after 14 days;
+ *   A3  the deal carries the booked meeting's date;
+ *   A5  "Build a prospect list from our foundation": ONE review per batch, and the
+ *       next batch reads back the candidates a person dropped;
+ *   A6  "Follow up on leads in outreach" is the one follow-up process and drafts
+ *       proposed messages through the pod's send door (2026-11-02; outreach
+ *       touches before); no outreach process opens a deal (Outreach & Comms'
+ *       "Send an outreach message" is CRM's "Read the reply to an outreach
+ *       message" since the fold of 2026-10-23, pinned in
+ *       crm-absorbs-outreach.template.test.ts);
+ *   A7  "Prepare a pre-sale estimate": the owner approves, then a SENT step records
+ *       date and channel on the lead;
+ *   A8  a lead's segment is a `targets` edge to an audience.
+ * A4 ("Qualify a lead" opens no deal) is pinned in decisions-wave.template.test.ts.
+ *
+ * Does NOT cover: what an agent does at run time (the goals are prose), and A9
+ * (CRM referencing `contact`), which waits on the pod granting a system role.
+ */
+
+import { describe, expect, it } from "vitest";
+import { readYamlTemplates } from "./generate.mjs";
+import type { WorkspaceYaml } from "./types.js";
+import { validateTemplate } from "./validate.js";
+
+const corpus = readYamlTemplates().map((t) => t.data as WorkspaceYaml);
+const tpl = (slug: string) => {
+  const t = corpus.find((x) => x.meta.slug === slug);
+  if (!t) throw new Error(`template ${slug} not in the corpus`);
+  return t;
+};
+const profileOf = (t: WorkspaceYaml, slug: string) => t.profiles.find((p) => p.slug === slug);
+const propOf = (t: WorkspaceYaml, profile: string, prop: string) =>
+  profileOf(t, profile)?.properties.find((p) => p.slug === prop);
+const playbookOf = (t: WorkspaceYaml, name: string) => {
+  const pb = t.playbooks?.find((p) => p.name === name);
+  if (!pb) throw new Error(`playbook "${name}" not in ${t.meta.slug}`);
+  return pb;
+};
+const outputsOf = (pb: ReturnType<typeof playbookOf>) => [
+  ...(pb.expectedOutputs ?? []),
+  ...(pb.stages ?? []).flatMap((s) => s.expectedOutputs ?? []),
+];
+
+const crm = tpl("crm");
+
+describe("CRM build plan — catalog changes", () => {
+  it("crm validates against the corpus", () => {
+    expect(validateTemplate(crm, { corpus }).errors).toEqual([]);
+  });
+
+  it("A1: the lead role's leadSource names the four new sources", () => {
+    const values = propOf(crm, "lead", "leadSource")?.enumValues ?? [];
+    for (const v of ["warm-network", "research", "import", "inbound-form"]) expect(values).toContain(v);
+  });
+
+  it("A2: deal stages read Meeting booked / Proposal sent, and every unfinished stage is stuck after 14 days", () => {
+    const options = profileOf(crm, "deal")?.lifecycle?.options ?? [];
+    expect(options.map((o) => [o.key, o.label, o.stuckAfterDays])).toEqual([
+      ["draft", "Meeting booked", 14],
+      ["proposed", "Proposal sent", 14],
+      ["negotiating", undefined, 14],
+      ["won", undefined, undefined],
+      ["lost", undefined, undefined],
+    ]);
+  });
+
+  it("A3: the deal records the booked meeting's date", () => {
+    expect(propOf(crm, "deal", "meetingDate")).toMatchObject({ valueType: "date", inputType: "date" });
+  });
+
+  it("A5: the prospect list is one review per batch, reads back dropped candidates, and creates leads only there", () => {
+    const pb = playbookOf(crm, "Build a prospect list from our foundation");
+    expect(pb.subjectProfile?.profileSlug).toBe("audience");
+    // No stage gate asks the person a second time: the batch's proposal is the review.
+    expect((pb.stages ?? []).filter((s) => s.gate)).toEqual([]);
+    expect(pb.goalTemplate).toMatch(/ONE proposal/);
+    expect(pb.goalTemplate).toMatch(/dropped/);
+    expect(pb.goalTemplate).toMatch(/lead source\s+research/);
+    expect(outputsOf(pb)).toEqual([{ kind: "company", label: "Prospect accounts", relationToSubject: "targets" }]);
+  });
+
+  it("A6: one follow-up process drafts proposed messages on weekdays; no outreach process opens a deal", () => {
+    const pb = playbookOf(crm, "Follow up on leads in outreach");
+    expect(pb.subjectProfile).toMatchObject({ profileSlug: "lead", statusProperty: "leadStage" });
+    expect(pb.activators).toContainEqual({ on: "schedule", cron: "0 7 * * 1-5", status: "outreach", mode: "propose" });
+    expect(outputsOf(pb).map((o) => o.kind)).toEqual(["messaging"]);
+    expect(pb.stages?.at(-1)).toMatchObject({ key: "send", gate: { kind: "human" } });
+
+    const followUps = corpus.flatMap((t) => (t.playbooks ?? []).filter((p) => /follow.?up/i.test(p.name)));
+    expect(followUps.map((p) => p.name)).toEqual(["Follow up on leads in outreach"]);
+
+    const reply = playbookOf(crm, "Read the reply to an outreach message");
+    expect(outputsOf(reply).map((o) => o.kind)).not.toContain("deal");
+    expect(reply.goalTemplate).not.toMatch(/(?<!never )open a deal/i);
+  });
+
+  it("A7: the estimate is approved by the owner, then a SENT step records date and channel on the lead", () => {
+    const pb = playbookOf(crm, "Prepare a pre-sale estimate");
+    expect(pb.subjectProfile?.profileSlug).toBe("lead");
+    expect((pb.stages ?? []).map((s) => [s.key, s.gate?.kind])).toEqual([
+      ["research", undefined],
+      ["draft", undefined],
+      ["approve", "human"],
+      ["sent", "human"],
+    ]);
+    // A reader: an estimate never moves the lead's stage.
+    expect((pb.stages ?? []).filter((s) => s.subjectStatus)).toEqual([]);
+    expect(propOf(crm, "lead", "estimateSentAt")).toMatchObject({ valueType: "date" });
+    expect(propOf(crm, "lead", "estimateSentChannel")?.inputType).toBe("select");
+  });
+
+  it("A8: a lead's segment is a targets edge from the person or company to an audience", () => {
+    const links = (crm.entityLinks ?? []).filter((l) => l.targetProfileSlug === "audience");
+    expect(links.map((l) => [l.sourceProfileSlug, l.type])).toEqual([
+      ["person", "targets"],
+      ["company", "targets"],
+    ]);
+    // A reference to foundation's shared kind, so the CRM space is granted it.
+    expect(profileOf(crm, "audience")).toMatchObject({ scope: "shared", entityScope: "pod", properties: [] });
+  });
+});

package/src/crm-lists.template.test.ts

@@ -0,0 +1,96 @@
+/**
+ * CRM lists, signal-first scores, Claude Code drafts (contract of 2026-10-27,
+ * founder decisions in pod session ba6f39c8), pinned against the REAL YAML
+ * corpus and the real validator. The CRM app codes against these names:
+ *
+ *   - the lead role carries buyingSignal / buyingSignalSource / scoredAt, and
+ *     icpScore reads 1–5;
+ *   - an outreach touch can be a first_message;
+ *   - "Score a list" (subject audience) is the ONE home of the rubric;
+ *   - "Draft a first message" (subject lead) drafts one touch and never sends;
+ *   - "Build a prospect list from our foundation" takes pool public|network.
+ * "Qualify a lead" being manual only is pinned in decisions-wave.template.test.ts.
+ *
+ * Does NOT cover what an agent does at run time (the goals are prose).
+ */
+
+import { describe, expect, it } from "vitest";
+import { readYamlTemplates } from "./generate.mjs";
+import type { WorkspaceYaml } from "./types.js";
+import { validateTemplate } from "./validate.js";
+
+const corpus = readYamlTemplates().map((t) => t.data as WorkspaceYaml);
+const crm = corpus.find((x) => x.meta.slug === "crm")!;
+const profileOf = (slug: string) => crm.profiles.find((p) => p.slug === slug);
+const propOf = (profile: string, prop: string) => profileOf(profile)?.properties.find((p) => p.slug === prop);
+const playbookOf = (name: string) => {
+  const pb = crm.playbooks?.find((p) => p.name === name);
+  if (!pb) throw new Error(`playbook "${name}" not in crm`);
+  return pb;
+};
+const paramsOf = (name: string) =>
+  (playbookOf(name).params ?? []).map((p) => [p.name, p.type, p.required ?? false, (p as { defaultValue?: unknown }).defaultValue]);
+
+describe("CRM lists — catalog contract", () => {
+  it("crm validates against the corpus", () => {
+    expect(validateTemplate(crm, { corpus }).errors).toEqual([]);
+  });
+
+  it("the lead role carries the signal fields, and icpScore reads 1–5", () => {
+    expect(propOf("lead", "buyingSignal")).toMatchObject({ valueType: "string", inputType: "select", enumValues: ["hiring", "asking", "tooling", "none"] });
+    expect(propOf("lead", "buyingSignalSource")).toMatchObject({ valueType: "string", inputType: "url" });
+    expect(propOf("lead", "scoredAt")).toMatchObject({ valueType: "date", inputType: "date" });
+    expect(propOf("lead", "icpScore")?.label).toMatch(/1–5/);
+  });
+
+  it("an outreach touch can be a first message", () => {
+    expect(propOf("outreach-touch", "touchType")?.enumValues).toEqual(["first_message", "connection_request", "follow_up", "intro_email", "reply"]);
+  });
+
+  it("'Score a list' scores one audience's leads in one manual run and is the rubric's one home", () => {
+    const pb = playbookOf("Score a list");
+    expect(pb.subjectProfile).toEqual({ profileSlug: "audience" });
+    expect(pb.activators).toEqual([{ on: "manual", mode: "propose" }]);
+    expect(paramsOf("Score a list")).toEqual([
+      ["audience", "entity", true, undefined],
+      ["limit", "number", false, 50],
+      ["rescoreAfterDays", "number", false, 30],
+    ]);
+    // The audience has no lifecycle: no stage moves anything.
+    expect((pb.stages ?? []).filter((s) => s.subjectStatus || s.gate)).toEqual([]);
+    for (const part of [/SIGNAL, 0 to\s+2/, /FIT, 0\s+to 2/, /WARMTH, 0 or 1/, /within the last 90 days/])
+      expect(pb.goalTemplate).toMatch(part);
+    // ONE home: no other playbook restates the rubric.
+    const restating = corpus.flatMap((t) => (t.playbooks ?? []).filter((p) => p !== pb && /WARMTH, 0 or 1/.test(p.goalTemplate)));
+    expect(restating.map((p) => p.name)).toEqual([]);
+  });
+
+  it("'Draft a first message' drafts one proposed message through the send door for a person to approve, and reads the lead's lifecycle", () => {
+    const pb = playbookOf("Draft a first message");
+    expect(pb.subjectProfile).toEqual({ profileSlug: "lead" });
+    expect(pb.activators).toEqual([{ on: "manual", mode: "propose" }]);
+    expect(paramsOf("Draft a first message")).toEqual([
+      ["lead", "entity", true, undefined],
+      ["campaign", "entity", false, undefined],
+      ["channel", "choice", false, "linkedin"],
+    ]);
+    expect(pb.grants).toEqual(["entity.create"]);
+    expect((pb.stages ?? []).flatMap((s) => s.expectedOutputs ?? [])).toEqual([
+      { kind: "messaging", label: "Proposed first message", relationToSubject: "none" },
+    ]);
+    // A reader: no stage moves the lead; the person approves the send behind a human gate.
+    expect((pb.stages ?? []).filter((s) => s.subjectStatus)).toEqual([]);
+    expect(pb.stages?.at(-1)).toMatchObject({ key: "send", gate: { kind: "human" } });
+    expect(pb.goalTemplate).toMatch(/run messaging\.send with to = that person's entity id/);
+    expect(pb.goalTemplate).toMatch(/Never send\./);
+    expect(pb.goalTemplate).toMatch(/"Send the first message to\s+<name> on LinkedIn"/);
+  });
+
+  it("'Build a prospect list from our foundation' takes a pool, and the network pool makes warm-network leads", () => {
+    const pb = playbookOf("Build a prospect list from our foundation");
+    expect(pb.params?.find((p) => p.name === "pool")).toMatchObject({ type: "choice", options: ["public", "network"], defaultValue: "public" });
+    expect(pb.goalTemplate).toMatch(/\{pool\}/);
+    expect(pb.goalTemplate).toMatch(/lead source warm-network/);
+    expect(pb.goalTemplate).toMatch(/"Score\s+a list" process/);
+  });
+});