@synap-core/workspace-templates 0.12.0 → 0.23.0

package/src/business-model-catalog-description.test.ts

@@ -0,0 +1,47 @@
+/**
+ * The Business Model package is LISTED as what it is: a track template.
+ *
+ * GRP agent-XP diagnosis 2026-09-28: CP `market_search` served the package as
+ * "Foundation" / "Adds business-model interrogation to the strategic
+ * substrate…" — the overlay TARGET's workspace name and description — so an
+ * agent looking for "the business-model method" never learned it runs as a
+ * track on a project. The peer fix took displayName from `meta.name`; this
+ * pins the other half: the catalog description is the package's own
+ * `meta.description`, and it names the track template.
+ *
+ * Does NOT cover: what an already-published CP row says (needs a publish).
+ */
+import { describe, expect, it } from "vitest";
+import { getWorkspaceTemplate, toPackageDefinition } from "./index.js";
+import { toOfficialPublishBody } from "./publish-body.mjs";
+
+describe("business-model catalog text", () => {
+  const tpl = getWorkspaceTemplate("business-model")!;
+  const pd = toPackageDefinition("business-model");
+
+  it("meta.description names the track template the pack ships", () => {
+    const track = (tpl.playbooks ?? []).find(
+      (p) => (p as { scope?: string }).scope === "project"
+    );
+    expect(track?.name, "the pack ships a project-scoped playbook").toBeTruthy();
+    expect(tpl.meta.description).toContain(`${track!.name}:`);
+    expect(tpl.meta.description).toMatch(/track template you run on a project/);
+  });
+
+  it("the package definition carries meta.description beside the workspace's own", () => {
+    expect(pd._meta.description).toBe(tpl.meta.description);
+    // The install copy stays the workspace's description — only the listing changes.
+    expect(pd.description).toBe(tpl.workspace.description);
+    expect(pd._meta.description).not.toBe(pd.description);
+  });
+
+  it("the official publisher lists the package's description, not the overlay target's", () => {
+    // Behavioural: the REAL body builder publish-official.mjs calls (it used to
+    // be a source-regex over the script, which broke the moment the builder
+    // moved into src/publish-body.mjs).
+    const body = toOfficialPublishBody(pd, "vendor-x");
+    expect(body.description).toBe(tpl.meta.description);
+    expect(body.description).not.toBe(pd.description);
+    expect(body.displayName).toBe(tpl.meta.name);
+  });
+});

package/src/business-model-grp.template.test.ts

@@ -0,0 +1,214 @@
+/**
+ * business-model.yaml IS the canonical GRP (concept consolidation W4a;
+ * seed set switched by founder decision A, 2026-09-28).
+ *
+ * GRP = Génération · Rémunération · Partage. The nine seeded questions are the
+ * founder's LIVE pod-level set (workspaceId NULL, tags grp/method-question),
+ * read from the pod on 2026-09-28 and pinned below — NOT the later "GRP #1 … #9"
+ * set W4a first copied. That list is the evidence, not a convenience: the seed
+ * dedupe key is `${kind}:${title}` (services/definition-seeds.ts, target
+ * workspace OR the user's pod-wide rows), so a reworded title seeds a SECOND set
+ * beside the live one instead of adopting it. If the founder renames a live
+ * question, this list and the YAML move together.
+ */
+
+import { describe, expect, it } from "vitest";
+import { WORKSPACE_TEMPLATES } from "./templates.js";
+import type { TemplatePlaybook } from "./types.js";
+
+const bm = WORKSPACE_TEMPLATES["business-model"]!;
+
+const P = "Porteur — what does the founder bring that cannot be hired, and what does the venture require of them personally?";
+const VP = "Value proposition — for whom is this indispensable, and what do they stop doing once they have it?";
+const VF = "Value fabrication — what is the chain that actually produces the value, and which link do we own?";
+const RS = "Revenue sources — who pays, for which unit, and why that unit rather than another?";
+const VAP = "Volume and pricing — what volume at what price clears the cost base, and is that volume reachable in this market?";
+const PF = "Performance — which number tells us the model works, and what observation would falsify it?";
+const ST = "Stakeholders — who must say yes for this to exist, and what does each of them need in return?";
+const CV = "Conventions — which rules bind us, who enforces them, and which are mandatory rather than advisory?";
+const EC = "Ecosystem — what does the venture give back, and what breaks if we extract without returning?";
+
+/** Live title → its pillar (the live tag) and the method step that answers it. */
+const LIVE_GRP: Array<[title: string, pillar: string, step: string]> = [
+  [P, "generation", "porteur"],
+  [VP, "generation", "offer_buyer"],
+  [VF, "generation", "offer_buyer"],
+  [RS, "remuneration", "money_means"],
+  [VAP, "remuneration", "money_means"],
+  [PF, "remuneration", "refutation"],
+  [ST, "sharing", "conventions_cost"],
+  [CV, "sharing", "conventions_cost"],
+  [EC, "sharing", "conventions_cost"],
+];
+const LIVE_GRP_TITLES = LIVE_GRP.map(([t]) => t);
+const PILLAR_RANK: Record<string, number> = { generation: 0, remuneration: 1, sharing: 2 };
+/** The three cycles the live questions' own descriptions name ("Circular: …"). */
+const NAMED_BACK_EDGES = [
+  [VP, CV],
+  [P, ST],
+  [VAP, PF],
+];
+const PILLARS = ["generation", "remuneration", "sharing"];
+const pillarOf = (tags: unknown): string => {
+  const hit = (tags as string[]).filter((t) => PILLARS.includes(t));
+  expect(hit, `exactly one pillar tag in ${JSON.stringify(tags)}`).toHaveLength(1);
+  return hit[0]!;
+};
+
+const playbook = (name: string): TemplatePlaybook => {
+  const pb = (bm.playbooks ?? []).find((p) => p.name === name);
+  expect(pb, `playbook "${name}"`).toBeDefined();
+  return pb!;
+};
+const profile = (slug: string) => {
+  const p = bm.profiles.find((x) => x.slug === slug);
+  expect(p, `profile "${slug}"`).toBeDefined();
+  return p!;
+};
+
+describe("business-model = the canonical GRP", () => {
+  it("seeds exactly the nine live G·R·P questions, verbatim, with unique dedupe keys", () => {
+    const seeds = bm.seedEntities ?? [];
+    expect(seeds.map((s) => s.title)).toEqual(LIVE_GRP_TITLES);
+    expect(seeds.every((s) => s.profileSlug === "question")).toBe(true);
+    const keys = seeds.map((s) => `${s.profileSlug}:${s.title}`);
+    expect(new Set(keys).size).toBe(keys.length);
+    for (const s of seeds) {
+      const p = s.properties ?? {};
+      // The question text IS the title on the live rows.
+      expect(p.title, s.title).toBe(s.title);
+      // Every live row carries a 190–405 char description.
+      expect(String(p.description ?? "").length, s.title).toBeGreaterThan(150);
+      expect(p.tags, s.title).toEqual(expect.arrayContaining(["business-model", "grp", "method-question"]));
+      expect(p.questionStatus, s.title).toBe("open");
+      // Nothing the live set does not carry (wedge-stage left with the "GRP #" set).
+      expect(Object.keys(p).sort(), s.title).toEqual(["description", "questionStatus", "tags", "title"]);
+    }
+    expect(seeds.some((s) => /^GRP #/.test(s.title))).toBe(false);
+  });
+
+  it("each seed's pillar is its live tag, three per pillar", () => {
+    const seeds = bm.seedEntities ?? [];
+    expect(seeds.map((s) => [s.title, pillarOf(s.properties?.tags)])).toEqual(
+      LIVE_GRP.map(([t, pillar]) => [t, pillar])
+    );
+  });
+
+  it("each question is named by exactly the step that answers it (suggestedTasks)", () => {
+    const m = playbook("Business Model (GRP)");
+    for (const [title, , step] of LIVE_GRP) {
+      const naming = (m.stages ?? []).filter((s) => s.suggestedTasks?.includes(title)).map((s) => s.key);
+      expect(naming, title).toEqual([step]);
+    }
+  });
+
+  it("rests_on follows Génération → Rémunération → Partage, plus only the named cycles", () => {
+    const pillar = new Map(LIVE_GRP.map(([t, p]) => [t, p]));
+    const rels = bm.suggestedRelations ?? [];
+    expect(rels.every((r) => r.type === "rests_on")).toBe(true);
+    const has = (src: string, tgt: string) =>
+      rels.some((r) => r.sourceRef === src && r.targetRef === tgt);
+    // The ONLY cycles are the three the live descriptions name (as 2-cycles).
+    const cycleEdges = rels
+      .filter((r) => has(r.targetRef, r.sourceRef))
+      .map((r) => [r.sourceRef, r.targetRef].sort().join("|"));
+    expect([...new Set(cycleEdges)].sort()).toEqual(
+      NAMED_BACK_EDGES.map((e) => [...e].sort().join("|")).sort()
+    );
+    // Outside those cycles, an edge never rests on a LATER pillar.
+    for (const r of rels) {
+      if (has(r.targetRef, r.sourceRef)) continue;
+      expect(
+        PILLAR_RANK[pillar.get(r.sourceRef)!]! >= PILLAR_RANK[pillar.get(r.targetRef)!]!,
+        `${r.sourceRef} -> ${r.targetRef}`
+      ).toBe(true);
+    }
+    // Every pillar step is wired: R rests on G, P rests on R (or G).
+    const crosses = (from: string, to: string) =>
+      rels.some((r) => pillar.get(r.sourceRef) === from && pillar.get(r.targetRef) === to);
+    expect(crosses("remuneration", "generation")).toBe(true);
+    expect(crosses("sharing", "remuneration")).toBe(true);
+    const keys = rels.map((r) => `${r.sourceRef}|${r.targetRef}`);
+    expect(new Set(keys).size).toBe(keys.length);
+  });
+
+  it("every suggested relation joins two seeded questions", () => {
+    const titles = new Set((bm.seedEntities ?? []).map((s) => s.title));
+    const rels = bm.suggestedRelations ?? [];
+    expect(rels.length).toBeGreaterThan(0);
+    for (const r of rels) {
+      expect(titles.has(r.sourceRef), r.sourceRef).toBe(true);
+      expect(titles.has(r.targetRef), r.targetRef).toBe(true);
+    }
+  });
+
+  it("ships the method as a 6-step TRACK template with one domain per step", () => {
+    const m = playbook("Business Model (GRP)");
+    expect(m.scope).toBe("project");
+    expect(m.stages?.map((s) => [s.key, s.domain])).toEqual([
+      ["porteur", "foundation"],
+      ["offer_buyer", "foundation"],
+      ["conventions_cost", "foundation"],
+      ["money_means", "finance"],
+      ["refutation", "research-base"],
+      ["maintain", "foundation"],
+    ]);
+    expect(m.stages?.filter((s) => s.indefinite).map((s) => s.key)).toEqual(["maintain"]);
+    for (const s of m.stages ?? []) {
+      expect(s.category, s.key).toBe("started");
+      expect(s.goal, s.key).toBeTruthy();
+      expect(s.suggestedTasks?.length, s.key).toBeGreaterThan(0);
+    }
+  });
+
+  it("the session template it replaced is gone; the Deprecation Check joined (D4)", () => {
+    const names = (bm.playbooks ?? []).map((p) => p.name);
+    expect(names).not.toContain("Business Model Interrogation");
+    const dc = playbook("GRP Deprecation Check");
+    expect(dc.scope).toBeUndefined(); // a work template
+    expect(dc.stages?.map((s) => s.key)).toEqual([
+      "detect_impact",
+      "notify_owners",
+      "plan_update",
+      "verify",
+    ]);
+  });
+
+  it("grp-interrogation role joins (D4) and says GRP = Génération · Rémunération · Partage; wedge-stage left", () => {
+    const role = profile("grp-interrogation");
+    expect(role.profileKind).toBe("role");
+    expect(role.applicableKinds).toEqual(["question"]);
+    expect(role.properties.map((p) => p.slug).sort()).toEqual([
+      "evidence_quality",
+      "grp_domain",
+      "interrogation_number",
+    ]);
+    expect(role.description).toContain("GRP = Génération · Rémunération · Partage");
+    expect(role.description).not.toMatch(/Growth|Research Positioning/);
+    expect(profile("question").properties.map((p) => p.slug)).not.toContain("wedge-stage");
+  });
+
+  it("convention + projection are pod-wide kinds", () => {
+    for (const slug of ["convention", "projection"]) {
+      const p = profile(slug);
+      expect(p.scope, slug).toBe("shared");
+      expect(p.entityScope, slug).toBe("pod");
+    }
+  });
+
+  it("D3: no shortcut on question; the convention shortcut opens the method", () => {
+    const aps = bm.actionPlacements ?? [];
+    expect(aps.filter((a) => a.profileSlug === "question")).toEqual([]);
+    const names = new Set((bm.playbooks ?? []).map((p) => p.name));
+    for (const a of aps) expect(names.has(a.ref), a.ref).toBe(true);
+    expect(aps.find((a) => a.profileSlug === "convention")?.ref).toBe("Business Model (GRP)");
+  });
+
+  it("the packs carry it (D8: workspace templates only)", () => {
+    for (const pack of ["enterprise-os"]) {
+      const deps = (WORKSPACE_TEMPLATES[pack]?.dependencies ?? []).map((d) => d.slug);
+      expect(deps, pack).toContain("business-model");
+      expect(deps, pack).not.toContain("enterprise-os");
+    }
+  });
+});