@synap-core/workspace-templates 0.11.0 → 0.23.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/);
+  });
+});

package/src/crm-messages-cadence.template.test.ts

@@ -0,0 +1,164 @@
+/**
+ * CRM messages and follow-up cadence (founder decisions of 2026-10-27, contract
+ * lanes/_briefs/crm-messages-cadence-2026-10-27.md, pod session ba6f39c8),
+ * pinned against the REAL YAML corpus. The CRM app shows the same words:
+ *
+ *   - CADENCE: 3 days after the first message, 7 days after each follow-up, at
+ *     most two follow-ups, never a third; ONE paragraph, word for word the same
+ *     in every process that sets the next follow-up after a send;
+ *   - DRAFT RULES (one send door, founder decisions d1/d5/d6 of 2026-11-02,
+ *     session d00cd2ac): a draft is a proposed message in the person's
+ *     channel, filed through the pod's `messaging.send` with `to` = their
+ *     entity id; never a tool's own send verb, never an outreach touch, never
+ *     synap_capture; ONE paragraph, word for word, in every drafter;
+ *   - the CADENCE counts the outbound messages in the lead's channels, and a
+ *     reply (an inbound message after our last outbound one) is read by
+ *     "Follow up on leads in outreach";
+ *   - "Read the reply to an outreach message" (the touches marked sent before
+ *     the channels) reads silence by the same dates and proposes nurturing
+ *     after the second follow-up;
+ *   - WHOSE MESSAGE (founder D3.1, wave 2 lane E2): a touch still belongs to
+ *     the lead it `relates_to` (REQUIRED link) until the touches are moved
+ *     into their channels; a proposed message belongs to the channel of the
+ *     person written to, so a drafter's output writes no edge.
+ *
+ * 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";
+
+const corpus = readYamlTemplates().map((t) => t.data as WorkspaceYaml);
+const crm = corpus.find((x) => x.meta.slug === "crm")!;
+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 flat = (s: string | undefined) => (s ?? "").replace(/\s+/g, " ");
+const goalOf = (name: string) => flat(playbookOf(name).goalTemplate);
+const stageOf = (name: string, key: string) => {
+  const st = playbookOf(name).stages?.find((s) => s.key === key);
+  if (!st) throw new Error(`stage "${key}" not in "${name}"`);
+  return st;
+};
+
+const CADENCE =
+  'CADENCE: when a message is sent (a person approved its proposed message, so it is an outbound message in the channel), set its lead\'s lastContactedAt to the sent day, count the messages sent to the lead (the outbound messages in its channels, read with synap_get_channel mode person: for a company lead, the channels of the person written to there), and set the lead\'s next action: after the first message, nextAction "Follow up with <name> if no reply" and nextActionAt the sent day + 3 days; after the first follow-up, nextAction "Follow up with <name> a last time if no reply" and nextActionAt the sent day + 7 days; after the second follow-up, nextAction "No reply after two follow-ups: nurture or drop <name>" and nextActionAt the sent day + 7 days, and when that date passes with no reply, "Follow up on leads in outreach" proposes nurturing. Never a third follow-up. Propose moving a lead at new or researching to outreach through the status door, with its expected status. A reply stops the cadence: a reply is an inbound message after our last outbound one in the channel, and "Follow up on leads in outreach" reads it and proposes the next step.';
+
+const DRAFT_RULES =
+  "DRAFT RULES: each draft is one proposed message in the channel of the person it is written to, filed through the pod's send door: run messaging.send with to = that person's entity id (for a company lead, its decider: when that person is not in the pod, create them through the entity door with only their own fields, such as name, role and LinkedIn URL, never the company's website, domain or email), text = the message, and provider linkedin or email. Read their channel first (synap_get_channel, mode person) for what was already said. The pod files it for a person to review in that channel; it goes out only once they approve it. Never call a tool's own send verb (Unipile, Gmail), never create an outreach touch, a note or a task holding the message, and never use synap_capture for it. Never send.";
+
+/** What a drafter yields: a `messaging.external.send` proposal (target type `messaging`). */
+const PROPOSED_MESSAGE = "messaging";
+const outputsOf = (p: NonNullable<WorkspaceYaml["playbooks"]>[number]) => [
+  ...(p.expectedOutputs ?? []),
+  ...(p.stages ?? []).flatMap((st) => st.expectedOutputs ?? []),
+];
+
+const SENDERS = ["Draft a first message", "Follow up on leads in outreach", "Personalized Outreach"];
+const DRAFTERS = ["Draft a first message", "Follow up on leads in outreach", "Personalized Outreach"];
+
+describe("CRM messages and cadence — catalog contract", () => {
+  it("one CADENCE paragraph, word for word, in every process that sets the follow-up after a send", () => {
+    for (const name of SENDERS) expect(goalOf(name), name).toContain(CADENCE);
+    // Only these: a fourth copy would be a second wording to keep in step.
+    const holders = (crm.playbooks ?? []).filter((p) => flat(p.goalTemplate).includes("CADENCE:")).map((p) => p.name);
+    expect(holders.sort()).toEqual([...SENDERS].sort());
+  });
+
+  it("no CRM process keeps the old weekly cadence or the 14-day silence default", () => {
+    const texts = (crm.playbooks ?? []).flatMap((p) => [
+      [p.name, flat(p.goalTemplate)],
+      ...(p.stages ?? []).flatMap((s) => [[`${p.name} › ${s.key}`, flat(s.goal)], ...(s.criteria ?? []).map((c) => [`${p.name} › ${c.key}`, flat(c.statement)])]),
+    ]);
+    const stale = texts.filter(([, t]) => /a week later|a week forward|14 days when it has none|polite last message/i.test(t!));
+    expect(stale.map(([w]) => w)).toEqual([]);
+  });
+
+  it("one DRAFT RULES paragraph in every drafter: messaging.send to the person, never a tool's send verb, an outreach touch or synap_capture", () => {
+    for (const name of DRAFTERS) expect(goalOf(name), name).toContain(DRAFT_RULES);
+    // Every process that drafts a proposed message is a drafter, and holds it.
+    const drafting = (crm.playbooks ?? []).filter((p) => outputsOf(p).some((o) => o.kind === PROPOSED_MESSAGE)).map((p) => p.name);
+    expect(drafting.sort()).toEqual([...DRAFTERS].sort());
+    const holders = (crm.playbooks ?? []).filter((p) => flat(p.goalTemplate).includes("DRAFT RULES:")).map((p) => p.name);
+    expect(holders.sort()).toEqual([...DRAFTERS].sort());
+    for (const part of [
+      "filed through the pod's send door: run messaging.send with to = that person's entity id",
+      "it goes out only once they approve it",
+      "Never call a tool's own send verb",
+      "never create an outreach touch",
+      "never use synap_capture",
+      "never the company's website, domain or email",
+    ])
+      expect(DRAFT_RULES).toContain(part);
+  });
+
+  it("'Draft a first message': send it to <name> today, then follow up 3 days after the send", () => {
+    const name = "Draft a first message";
+    expect(goalOf(name)).toContain('"Send the first message to <name> on LinkedIn"');
+    expect(flat(stageOf(name, "draft").goal)).toMatch(/as a proposed message in their channel through messaging\.send \(to = their entity id, never a tool's own send verb, never an outreach touch or synap_capture\)/);
+    const criteria = (stageOf(name, "draft").criteria ?? []).map((c) => [c.key, flat(c.statement)] as const);
+    expect(criteria.length).toBeLessThanOrEqual(5);
+    expect(Object.fromEntries(criteria)["first-message-one-draft"]).toMatch(/filed through messaging\.send to the person written to .* waits for review in that person's channel/);
+    expect(Object.fromEntries(criteria)["first-message-no-capture"]).toMatch(/send verb.*outreach touch.*synap_capture.*never the company's website, domain or email/);
+    expect(Object.fromEntries(criteria)["first-message-next-action"]).toContain('"Send the first message to <name>"');
+    expect(flat(stageOf(name, "send").goal)).toContain('nextAction "Follow up with <name> if no reply" and nextActionAt the sent day + 3 days');
+  });
+
+  it("'Follow up on leads in outreach': at most two follow-ups, 7 days after each, never a third", () => {
+    const name = "Follow up on leads in outreach";
+    expect(goalOf(name)).toContain("Draft at most two follow-ups per lead: a lead already sent two follow-ups gets no draft, never a third follow-up");
+    expect(flat(stageOf(name, "draft").goal)).toMatch(/or was already sent two follow-ups, gets none/);
+    const criteria = Object.fromEntries((stageOf(name, "draft").criteria ?? []).map((c) => [c.key, flat(c.statement)]));
+    expect(Object.keys(criteria).length).toBeLessThanOrEqual(5);
+    expect(criteria["followup-no-draft-after-reply"]).toMatch(/nor a third follow-up/);
+    expect(criteria["followup-draft-rules"]).toMatch(/proposed message filed through messaging\.send to the person written to .*no tool's own send verb .*outreach touch.*synap_capture/);
+    const send = flat(stageOf(name, "send").goal);
+    expect(send).toContain('after the first follow-up, nextAction "Follow up with <name> a last time if no reply" and nextActionAt the sent day + 7 days');
+    expect(send).toContain('after the second follow-up, nextAction "No reply after two follow-ups: nurture or drop <name>" and nextActionAt the sent day + 7 days');
+  });
+
+  it("CADENCE counts a lead's messages in its channels, never in outreach touches", () => {
+    expect(CADENCE).toContain("count the messages sent to the lead (the outbound messages in its channels");
+    expect(CADENCE).toContain("a reply is an inbound message after our last outbound one in the channel");
+    // The old rules (touches with a sent date; sent to the lead or its decider; a
+    // person marking a message sent) are gone from every CRM text.
+    const texts = (crm.playbooks ?? []).flatMap((p) => [flat(p.goalTemplate), ...(p.stages ?? []).map((s) => flat(s.goal))]);
+    expect(texts.length).toBeGreaterThan(20);
+    expect(texts.filter((t) => /sent to it or its decider|outreach touches with a sent date|person marks a message sent/.test(t))).toEqual([]);
+  });
+
+  it("the touch kind declares relates_to a lead (person or company) as its REQUIRED link, and only that", () => {
+    const links = crm.entityLinks ?? [];
+    const touchLinks = links.filter((l) => l.sourceProfileSlug === "outreach-touch");
+    // Non-vacuity: the touch's other links (sent_to, part_of) are seen too.
+    expect(touchLinks.map((l) => l.type).sort()).toEqual(["part_of", "relates_to", "relates_to", "sent_to"]);
+    const required = links.filter((l) => l.required === true).map((l) => `${l.sourceProfileSlug} -${l.type}-> ${l.targetProfileSlug}`);
+    expect(required.sort()).toEqual(["outreach-touch -relates_to-> company", "outreach-touch -relates_to-> person"]);
+    // The lead role is worn by a person or a company: the rule's targets are both.
+    for (const l of touchLinks.filter((x) => x.type === "relates_to")) expect(l.required).toBe(true);
+  });
+
+  it("every drafter yields proposed messages, which write no edge, and none yields an outreach touch", () => {
+    for (const name of DRAFTERS) {
+      const outputs = outputsOf(playbookOf(name));
+      expect(outputs.length, name).toBeGreaterThan(0);
+      // The channel is bound to the person already: a proposed message relates to nothing else.
+      for (const o of outputs) expect([o.kind, o.relationToSubject], `${name} › ${o.label}`).toEqual([PROPOSED_MESSAGE, "none"]);
+    }
+    // Decision d5: no CRM process drafts an outreach touch any more.
+    const touchMakers = (crm.playbooks ?? []).filter((p) => outputsOf(p).some((o) => o.kind === "outreach-touch")).map((p) => p.name);
+    expect(touchMakers).toEqual([]);
+  });
+
+  it("'Read the reply to an outreach message': silence is read by the cadence's dates, and nurturing follows the second follow-up", () => {
+    const name = "Read the reply to an outreach message";
+    const goal = goalOf(name);
+    expect(goal).toContain("the sent day + 3 days after the first message, the sent day + 7 days after each follow-up");
+    expect(goal).toMatch(/When this message is the second follow-up .* mark it no response and propose moving the lead to nurturing/);
+    expect(goal).not.toMatch(/14 days/);
+    expect(flat(stageOf(name, "no-response").goal)).toMatch(/after the second follow-up propose moving the lead to nurturing/);
+  });
+});