@synap-core/workspace-templates 0.11.0 → 0.23.0

package/src/research-decision.yaml

@@ -58,6 +58,15 @@ profiles:
     icon: git-branch
     color: violet
     description: A candidate option under consideration — argued for and against by sources.
+    # The ONE lifecycle (work model L1): every option's category.
+    lifecycle:
+      property: stance
+      options:
+        - { key: proposed, category: open }
+        - { key: supported, category: done }
+        - { key: contested, category: active }
+        - { key: refuted, category: lost }
+        - { key: superseded, category: lost }
     properties:
       - slug: stance
         label: Stance
@@ -131,9 +140,10 @@ playbooks:
       sources with a reason — never drop the counter-evidence). (4) Weigh the
       options against explicit, named criteria (cost, reversibility, risk, time,
       evidence strength). (5) Record the recommendation as a `decision` entity
-      that `resolves` the question — its rationale explains why it won, and its
-      `alternatives` field preserves the options that lost and WHY. (6) Note what
-      evidence would change the decision. Every write is proposal-gated.
+      at the proposed status that `resolves` the question — its rationale
+      explains why it won, and its `alternatives` field preserves the options
+      that lost and WHY. (6) Note what evidence would change the decision.
+      Accepting the decision is a person's call. Every write is proposal-gated.
     subjectProfile:
       profileSlug: question
     params:
@@ -145,6 +155,44 @@ playbooks:
       - exa_search
       - entity.create
     status: active
+    expectedOutputs:
+      - { kind: decision, label: Recommended decision, relationToSubject: resolves }
+
+  - name: Decide
+    description: Put a proposed decision in front of a person with its options and evidence, and record what they chose.
+    goalTemplate: >-
+      Bring this decision ({decision}) to a person. Summarise the question it
+      resolves, the options that were considered, the evidence for and
+      against each, and the recommendation, in one screen. A person accepts or
+      rejects it. When a later decision replaces it, the person marks it
+      superseded.
+    subjectProfile:
+      profileSlug: decision
+      statusProperty: decisionStatus
+    humanOnlyStatuses: [superseded, rejected]
+    activators:
+      - { on: created, mode: propose }
+    params:
+      - { name: decision, type: entity, label: Decision, required: true }
+    executor: is-agent
+    status: active
+    stages:
+      - key: prepare
+        name: Prepare
+        category: started
+        subjectStatus: proposed
+        goal: Summarise the question, the options, the evidence and the recommendation in one screen.
+        criteria:
+          - key: decision-options-listed
+            statement: The decision lists every option considered and why each lost or won.
+            check: { kind: judge }
+      - key: accept
+        name: Accept
+        category: completed
+        subjectStatus: accepted
+        goal: A person accepts the decision.
+        gate: { kind: human }
+        onFail: { toStage: prepare }
 
 actionPlacements:
   - profileSlug: question
@@ -156,3 +204,12 @@ actionPlacements:
 integrations:
   - templateKey: research-methods
   - templateKey: exa
+
+# ── taskIntents — WHAT THIS WORKSPACE NEEDS TO FUNCTION ───────────────────
+# Closed vocabulary: `@synap-core/types/capability-intents` (pod migrations
+# 0283/0284). DERIVED from the declared intents of this template's own
+# `integrations` capability packs — not hand-guessed. Checked at authoring
+# time by `validateTemplate` (`task-intent-unknown`) and by
+# `src/task-intents.test.ts`.
+taskIntents:
+  - search_external

package/src/reserved-profile-slugs.test.ts

@@ -0,0 +1,83 @@
+/**
+ * A template may never declare a profile on a slug the pod reserves.
+ *
+ * `project` was declared by builder, life-os and project-management (and the
+ * project-management pack) long after migration 0151 moved projects to their
+ * own table — every such declaration is refused by `ProfileRepository.create`
+ * on install, so it was dead schema at best. `validateTemplate` now refuses it
+ * at authoring time (`profile-slug-reserved`), and the catalog validator runs
+ * `validateTemplate` for every workspace and pack.
+ *
+ * The mirror check reads the pod's own reservation module from the sibling
+ * synap-backend checkout and skips, with the reason logged, when it is absent.
+ */
+
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { RESERVED_PROFILE_SLUGS, validateTemplate } from "./validate.js";
+import { readYamlTemplates } from "./generate.mjs";
+import type { WorkspaceYaml } from "./types.js";
+
+const PKG = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const BACKEND_RESERVED = resolve(
+  PKG,
+  "../../../synap-backend/packages/database/src/utils/reserved-profile-slugs.ts"
+);
+
+const template = (profiles: WorkspaceYaml["profiles"]): WorkspaceYaml =>
+  ({
+    meta: { slug: "reserved-probe", name: "Probe", description: "d", icon: "x", color: "violet" },
+    workspace: { name: "Probe", description: "d" },
+    profiles,
+  }) as unknown as WorkspaceYaml;
+
+const reservedErrors = (tpl: WorkspaceYaml) =>
+  validateTemplate(tpl).errors.filter((e) => e.rule === "profile-slug-reserved");
+
+describe("profile-slug-reserved", () => {
+  it("refuses a declared `project` profile, case- and whitespace-insensitively", () => {
+    for (const slug of ["project", "Projects", " project "]) {
+      const errors = reservedErrors(
+        template([{ slug, displayName: "Project", properties: [] }] as unknown as WorkspaceYaml["profiles"])
+      );
+      expect(errors, slug).toHaveLength(1);
+      expect(errors[0].message).toContain("projects table");
+    }
+  });
+
+  it("leaves a free slug that merely contains the word alone", () => {
+    const errors = reservedErrors(
+      template([{ slug: "grant-project", displayName: "Grant project", properties: [] }] as unknown as WorkspaceYaml["profiles"])
+    );
+    expect(errors).toEqual([]);
+  });
+
+  it("no shipped template or pack declares a reserved slug", () => {
+    const yamls = readYamlTemplates().map((t) => ({ file: `src/${t.file}`, data: t.data }));
+    const packs = readdirSync(join(PKG, "packs"))
+      .filter((f) => f.endsWith(".json"))
+      .map((f) => ({ file: `packs/${f}`, data: JSON.parse(readFileSync(join(PKG, "packs", f), "utf8")) }));
+    // Non-vacuity: the scan sees the corpus, and the corpus declares profiles.
+    expect(yamls.length).toBeGreaterThan(20);
+    expect(packs.length).toBeGreaterThan(2);
+    const declared = [...yamls, ...packs].flatMap((t) => (t.data?.profiles ?? []).map((p: { slug: string }) => p.slug));
+    expect(declared.length).toBeGreaterThan(100);
+
+    const offenders = [...yamls, ...packs].flatMap((t) =>
+      reservedErrors(t.data as WorkspaceYaml).map((e) => `${t.file}: ${e.path}`)
+    );
+    expect(offenders).toEqual([]);
+  });
+});
+
+describe.skipIf(!existsSync(BACKEND_RESERVED))("RESERVED_PROFILE_SLUGS mirrors the pod's reservation", () => {
+  if (!existsSync(BACKEND_RESERVED))
+    console.warn(`[reserved-profile-slugs] SKIP: no synap-backend checkout at ${BACKEND_RESERVED}`);
+
+  it("is the same set as @synap/database reservedProfileSlugs()", async () => {
+    const mod = (await import(BACKEND_RESERVED)) as { reservedProfileSlugs: () => readonly string[] };
+    expect([...RESERVED_PROFILE_SLUGS].sort()).toEqual([...mod.reservedProfileSlugs()].sort());
+  });
+});

package/src/retired-goal-kinds.test.ts

@@ -0,0 +1,58 @@
+/**
+ * No catalog template declares a goal-like kind (decision D2, 2026-10-23).
+ *
+ * "Goal" is the user's word for a track (`project_tracks`). The catalog used to
+ * ship three entity kinds that read as goals: Life OS `goal`, Enterprise OS
+ * `objective`, Project Management `okr`. A pod that installed two of them
+ * showed two "Goals". New installs no longer create them; a pod that already
+ * has them keeps its entities (profiles are never removed from an installed
+ * pod) until the "Make it a goal" conversion is offered.
+ *
+ * `retired.yaml` tombstones whole templates, not a kind inside a live template,
+ * so this list is the kind-level record. A template that needs the idea of a
+ * goal links to the pod's goals (tracks); it never re-declares the kind.
+ */
+
+import { readdirSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { readYamlTemplates } from "./generate.mjs";
+
+const PKG = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+
+const RETIRED_GOAL_KINDS = ["goal", "objective", "okr"] as const;
+
+type Declared = { slug?: string };
+type Corpus = { file: string; data: { profiles?: Declared[] } };
+
+/** `file: slug` for every declared profile whose slug is a retired goal kind. */
+const retiredKindsDeclared = (corpus: Corpus[]): string[] =>
+  corpus.flatMap((t) =>
+    (t.data?.profiles ?? [])
+      .filter((p) => (RETIRED_GOAL_KINDS as readonly string[]).includes(String(p.slug).trim().toLowerCase()))
+      .map((p) => `${t.file}: ${p.slug}`)
+  );
+
+describe("retired goal-like kinds", () => {
+  it("the scan catches a template that declares one (so the guard is not vacuous)", () => {
+    const probe: Corpus[] = [
+      { file: "probe.yaml", data: { profiles: [{ slug: "task" }, { slug: " OKR " }] } },
+      { file: "probe2.yaml", data: { profiles: [{ slug: "goal" }, { slug: "objective" }] } },
+    ];
+    expect(retiredKindsDeclared(probe)).toEqual(["probe.yaml:  OKR ", "probe2.yaml: goal", "probe2.yaml: objective"]);
+  });
+
+  it("no shipped workspace template or pack declares one", () => {
+    const yamls: Corpus[] = readYamlTemplates().map((t) => ({ file: `src/${t.file}`, data: t.data }));
+    const packs: Corpus[] = readdirSync(join(PKG, "packs"))
+      .filter((f) => f.endsWith(".json"))
+      .map((f) => ({ file: `packs/${f}`, data: JSON.parse(readFileSync(join(PKG, "packs", f), "utf8")) }));
+    // Non-vacuity: the scan reads the corpus, and the corpus declares profiles.
+    expect(yamls.length).toBeGreaterThan(20);
+    const declared = [...yamls, ...packs].flatMap((t) => t.data?.profiles ?? []);
+    expect(declared.length).toBeGreaterThan(100);
+
+    expect(retiredKindsDeclared([...yamls, ...packs])).toEqual([]);
+  });
+});

package/src/role-reference-and-step-domain.test.ts

@@ -0,0 +1,192 @@
+/**
+ * W4a (concept consolidation) validator rules — each driven with a template
+ * built to BREAK it, plus the real corpus passing it.
+ *
+ *   shared-role-reference-no-foundation  a template re-declaring/referencing a
+ *       foundation shared role must reach foundation through its dependencies.
+ *   shared-role-reference-unknown        a reference (no applicableKinds) must
+ *       name a role foundation actually defines.
+ *   stage-domain-shape / -unknown / -not-a-domain  a step's `domain` is a slug
+ *       of a workspace template that OWNS a workspace.
+ *   pack-requires-pack                   D8: a pack lists workspace templates.
+ *
+ * NOT covered: that the pod honours a reference (resolves it to the pod-wide
+ * row, grants access) — that is the backend apply door, not this package.
+ */
+
+import { describe, expect, it } from "vitest";
+import { validateTemplate } from "./validate.js";
+import { WORKSPACE_TEMPLATES } from "./templates.js";
+import type { WorkspaceYaml } from "./types.js";
+
+const corpus: WorkspaceYaml[] = Object.values(WORKSPACE_TEMPLATES);
+
+const tpl = (over: Record<string, unknown>): WorkspaceYaml =>
+  ({
+    meta: {
+      slug: "acme",
+      name: "Acme",
+      description: "d",
+      icon: "x",
+      color: "#000000",
+    },
+    workspace: { name: "Acme", description: "d" },
+    profiles: [{ slug: "gadget", displayName: "Gadget", properties: [] }],
+    ...over,
+  }) as unknown as WorkspaceYaml;
+
+const rules = (t: WorkspaceYaml, prefix: string) =>
+  validateTemplate(t, { corpus })
+    .errors.filter((e) => e.rule.startsWith(prefix))
+    .map((e) => e.rule);
+
+const leadReference = {
+  slug: "lead",
+  displayName: "Lead",
+  scope: "shared",
+  profileKind: "role",
+  properties: [],
+};
+
+describe("shared-role references need foundation in the dependency chain", () => {
+  it("non-vacuity: foundation defines the shared roles the rule reads", () => {
+    const roles = (WORKSPACE_TEMPLATES["foundation"]?.profiles ?? []).filter(
+      (p) => p.scope === "shared" && p.profileKind === "role"
+    );
+    expect(roles.map((p) => p.slug)).toEqual(
+      expect.arrayContaining(["client", "partner", "lead"])
+    );
+  });
+
+  it("a reference with NO foundation in its chain is refused", () => {
+    expect(rules(tpl({ profiles: [leadReference] }), "shared-role-reference")).toEqual([
+      "shared-role-reference-no-foundation",
+    ]);
+  });
+
+  it("a FULL re-declaration of a foundation role without foundation is refused too", () => {
+    const full = { ...leadReference, applicableKinds: ["company", "person"] };
+    expect(rules(tpl({ profiles: [full] }), "shared-role-reference")).toEqual([
+      "shared-role-reference-no-foundation",
+    ]);
+  });
+
+  it("foundation reached TRANSITIVELY (via crm) satisfies it", () => {
+    const t = tpl({
+      profiles: [leadReference],
+      dependencies: [{ slug: "crm", kind: "workspace", relation: "require" }],
+    });
+    expect(rules(t, "shared-role-reference")).toEqual([]);
+  });
+
+  it("a reference to a role foundation does not define is refused", () => {
+    const t = tpl({
+      profiles: [{ ...leadReference, slug: "investor", displayName: "Investor" }],
+      dependencies: [{ slug: "foundation", kind: "workspace", relation: "require" }],
+    });
+    expect(rules(t, "shared-role-reference")).toEqual(["shared-role-reference-unknown"]);
+  });
+
+  it("a shared role the template OWNS (full body, not foundation's) is left alone", () => {
+    const own = {
+      slug: "competitor",
+      displayName: "Competitor",
+      scope: "shared",
+      profileKind: "role",
+      applicableKinds: ["company"],
+      properties: [],
+    };
+    expect(rules(tpl({ profiles: [own] }), "shared-role-reference")).toEqual([]);
+  });
+
+  it("crm and ecosystem now carry references, not bodies", () => {
+    for (const slug of ["crm", "ecosystem"]) {
+      const roles = (WORKSPACE_TEMPLATES[slug]?.profiles ?? []).filter(
+        (p) =>
+          p.scope === "shared" &&
+          p.profileKind === "role" &&
+          ["client", "partner", "lead"].includes(p.slug)
+      );
+      expect(roles.length, `${slug} references no foundation role`).toBeGreaterThan(0);
+      for (const r of roles) {
+        expect(r.applicableKinds, `${slug}.${r.slug} restates applicableKinds`).toBeUndefined();
+        expect(r.description, `${slug}.${r.slug} restates description`).toBeUndefined();
+        expect(r.icon, `${slug}.${r.slug} restates icon`).toBeUndefined();
+      }
+    }
+  });
+});
+
+const withStep = (domain: unknown) =>
+  tpl({
+    playbooks: [
+      {
+        name: "M",
+        goalTemplate: "g",
+        scope: "project",
+        stages: [{ key: "s", name: "S", category: "started", domain }],
+      },
+    ],
+  });
+
+describe("step domains name a workspace template that owns a workspace", () => {
+  it("a real domain template passes", () => {
+    expect(rules(withStep("finance"), "stage-domain")).toEqual([]);
+  });
+  it("a workspace id is refused", () => {
+    expect(rules(withStep("8f894661-db21-4f6d-ba30-5334f7b67bef"), "stage-domain")).toEqual([
+      "stage-domain-shape",
+    ]);
+  });
+  it("a display name is refused", () => {
+    expect(rules(withStep("Foundation"), "stage-domain")).toEqual(["stage-domain-shape"]);
+  });
+  it("a slug no template carries is refused", () => {
+    expect(rules(withStep("no-such-domain"), "stage-domain")).toEqual(["stage-domain-unknown"]);
+  });
+  it("an overlay's slug is refused (it never owns a workspace)", () => {
+    expect(rules(withStep("business-model"), "stage-domain")).toEqual([
+      "stage-domain-not-a-domain",
+    ]);
+  });
+  it("a pack's slug is refused", () => {
+    expect(rules(withStep("enterprise-os"), "stage-domain")).toEqual([
+      "stage-domain-not-a-domain",
+    ]);
+  });
+});
+
+describe("D8: a pack lists workspace templates, never a pack", () => {
+  const pack = (deps: unknown[]) =>
+    tpl({ meta: { slug: "p", name: "P", description: "d", icon: "x", color: "#000000", tags: ["suite"] }, dependencies: deps });
+  it("pack → pack is refused", () => {
+    expect(
+      rules(pack([{ slug: "enterprise-os", kind: "workspace", relation: "require" }]), "pack-")
+    ).toEqual(["pack-requires-pack"]);
+  });
+  it("pack → workspace templates passes", () => {
+    expect(
+      rules(pack([{ slug: "foundation", kind: "workspace", relation: "require" }]), "pack-")
+    ).toEqual([]);
+  });
+});
+
+describe("the real corpus passes every W4a rule", () => {
+  it("no template trips a W4a rule", () => {
+    expect(corpus.length).toBeGreaterThan(20);
+    const hits = corpus.flatMap((t) =>
+      validateTemplate(t, { corpus })
+        .errors.filter((e) =>
+          /^(shared-role-reference|stage-domain|pack-requires-pack)/.test(e.rule)
+        )
+        .map((e) => `${t.meta?.slug}: ${e.rule} ${e.path}`)
+    );
+    expect(hits).toEqual([]);
+  });
+  it("non-vacuity: the corpus HAS step domains and role references to check", () => {
+    const domains = corpus.flatMap((t) =>
+      (t.playbooks ?? []).flatMap((p) => (p.stages ?? []).map((s) => s.domain))
+    ).filter(Boolean);
+    expect(domains.length).toBeGreaterThanOrEqual(12); // business-model 6 + grants 6
+  });
+});

package/src/seed-obligation.test.ts

@@ -0,0 +1,176 @@
+/**
+ * Seed-obligation guard.
+ *
+ * THE BUG THIS EXISTS TO STOP, stated plainly: the applier has supported
+ * `seedEntities` and `suggestedRelations` since
+ * `create-workspace-from-definition.ts` learned to read them, and for 31 of 31
+ * shipped templates that support was exercised exactly zero times. The
+ * observable result is a workspace that installs 15 views over 0 entities —
+ * every board empty, every chart blank, and the user left to guess what the
+ * pack was for. Two real workspaces in the field reproduced this identically,
+ * which is the signature of a template defect rather than user behaviour.
+ *
+ * The rule: a template that ships VIEWS over profiles it OWNS must also ship
+ * at least one seed entity, so the workspace opens with something in it.
+ *
+ * The escape hatch is deliberate and narrow. `SEEDLESS_BY_DESIGN` lists the
+ * templates that predate this guard, each with the reason it is still empty.
+ * Adding a line there is legal; adding one silently is not, because the list is
+ * asserted to be exact — a template that gains seeds must leave the list in the
+ * same commit. That is what turns this from a lint into a shrinking backlog.
+ *
+ * What a seed is NOT: filler. Seeding three fake companies teaches nothing and
+ * gets deleted in the first minute. Seed the QUESTIONS, the stages, the
+ * checklist — the reusable part of the method. See `business-model.yaml`, which
+ * seeds the nine interrogations rather than an example business.
+ */
+
+import { describe, expect, it } from "vitest";
+import { WORKSPACE_TEMPLATES } from "./templates.js";
+import type { WorkspaceYaml } from "./types.js";
+
+/**
+ * Templates that ship views over their own profiles and NO seed entities.
+ *
+ * Every entry is a workspace that currently installs empty. Keep the reason
+ * honest — "not done yet" is a valid reason and a useful one, because it reads
+ * as debt instead of as a decision.
+ */
+const SEEDLESS_BY_DESIGN: Record<string, string> = {
+  base: "Pod substrate, not a workspace a user opens. Seeds would land in every workspace.",
+  "blockchain-ecosystem": "Pre-dates this guard; needs a seed pass.",
+  "brand-library": "Pre-dates this guard; brand assets are inherently per-company.",
+  "builder-workspace": "Pre-dates this guard; needs a seed pass.",
+  "civic-france": "Pre-dates this guard; needs a seed pass.",
+  communication: "Pre-dates this guard; needs a seed pass.",
+  "content-os": "Pre-dates this guard; needs a seed pass.",
+  "content-creation": "Suite command tower; seeds belong on the constituent workspaces (content-os), same as enterprise-os.",
+  crm: "Pre-dates this guard; needs a seed pass.",
+  ecosystem: "Pre-dates this guard; needs a seed pass.",
+  "enterprise-os": "Pre-dates this guard; needs a seed pass.",
+  finance:
+    "Pre-dates this guard. Confirmed empty in the field: 15 views, 6 profiles, 0 entities. First candidate for a seed pass — a chart of accounts and a metric set are genuinely reusable.",
+  foundation:
+    "Pre-dates this guard. Strategic DNA is company-specific, but the INTERROGATION is not — see business-model.yaml, which seeds it as an overlay.",
+  grants: "Pre-dates this guard; needs a seed pass.",
+  hr: "Pre-dates this guard; needs a seed pass.",
+  "internal-runbook": "Pre-dates this guard; needs a seed pass.",
+  legal: "Pre-dates this guard; needs a seed pass.",
+  "life-os": "Pre-dates this guard; needs a seed pass.",
+  "marketing-campaign": "Pre-dates this guard; needs a seed pass.",
+  "meetings-knowledge": "Pre-dates this guard; needs a seed pass.",
+  networking: "Pre-dates this guard; needs a seed pass.",
+  operations: "Pre-dates this guard; needs a seed pass.",
+  "project-management": "Pre-dates this guard; needs a seed pass.",
+  "research-base":
+    "Pre-dates this guard. Radar reproduced the empty-workspace pathology on top of this substrate; seed pass wanted.",
+  "research-decision": "Overlay on research-base; the method is a playbook, not entities.",
+  social: "Pre-dates this guard; needs a seed pass.",
+};
+
+/** Slugs of profiles this template declares itself (owned or re-declared). */
+function declaredProfileSlugs(tpl: WorkspaceYaml): Set<string> {
+  const profiles = (tpl as { profiles?: Array<{ slug?: string }> }).profiles ?? [];
+  return new Set(profiles.map((p) => p.slug).filter((s): s is string => Boolean(s)));
+}
+
+/** Views whose scope is a profile the template declares. */
+function viewsOverOwnProfiles(tpl: WorkspaceYaml): number {
+  const declared = declaredProfileSlugs(tpl);
+  const views =
+    (tpl as { views?: Array<{ scopeProfileSlug?: string; scopeProfileSlugs?: string[] }> })
+      .views ?? [];
+  return views.filter((v) => {
+    const scoped = [v.scopeProfileSlug, ...(v.scopeProfileSlugs ?? [])].filter(Boolean);
+    return scoped.some((s) => declared.has(s as string));
+  }).length;
+}
+
+function seedCount(tpl: WorkspaceYaml): number {
+  const t = tpl as {
+    seedEntities?: unknown[];
+    suggestedEntities?: unknown[];
+  };
+  return (t.seedEntities?.length ?? 0) + (t.suggestedEntities?.length ?? 0);
+}
+
+const slugOf = (slug: string, tpl: WorkspaceYaml) =>
+  (tpl as { meta?: { slug?: string } }).meta?.slug ?? slug;
+
+describe("workspace-templates — seed obligation (corpus)", () => {
+  it("every template with views over its own profiles ships seeds, or is declared seedless", () => {
+    const undeclared: string[] = [];
+
+    for (const [key, tpl] of Object.entries(WORKSPACE_TEMPLATES)) {
+      const slug = slugOf(key, tpl);
+      if (viewsOverOwnProfiles(tpl) === 0) continue;
+      if (seedCount(tpl) > 0) continue;
+      if (slug in SEEDLESS_BY_DESIGN) continue;
+      undeclared.push(
+        `${slug}: ships ${viewsOverOwnProfiles(tpl)} view(s) over its own profiles and 0 seed entities. ` +
+          `Add seedEntities (seed the METHOD, not fake data), or add "${slug}" to SEEDLESS_BY_DESIGN with a reason.`
+      );
+    }
+
+    expect(
+      undeclared,
+      `Templates would install a workspace of empty views:\n  - ${undeclared.join("\n  - ")}`
+    ).toEqual([]);
+  });
+
+  it("the seedless allowlist is exact — a template that gains seeds must leave it", () => {
+    const stale: string[] = [];
+
+    for (const [key, tpl] of Object.entries(WORKSPACE_TEMPLATES)) {
+      const slug = slugOf(key, tpl);
+      if (!(slug in SEEDLESS_BY_DESIGN)) continue;
+      if (seedCount(tpl) > 0) {
+        stale.push(`${slug}: now seeds ${seedCount(tpl)} entity(ies) — remove it from SEEDLESS_BY_DESIGN`);
+      }
+    }
+
+    const corpusSlugs = new Set(
+      Object.entries(WORKSPACE_TEMPLATES).map(([key, tpl]) => slugOf(key, tpl))
+    );
+    for (const slug of Object.keys(SEEDLESS_BY_DESIGN)) {
+      if (!corpusSlugs.has(slug)) {
+        stale.push(`${slug}: listed in SEEDLESS_BY_DESIGN but no such template exists`);
+      }
+    }
+
+    expect(stale, `Stale seedless allowlist:\n  - ${stale.join("\n  - ")}`).toEqual([]);
+  });
+
+  it("every seeded relation names entities seeded in the same template", () => {
+    // A suggested relation whose ref matches no seeded title fails SILENTLY at
+    // apply time — the workspace installs, the edge does not, and nothing says
+    // so. Catch the typo here instead of in a user's pod.
+    const dangling: string[] = [];
+
+    for (const [key, tpl] of Object.entries(WORKSPACE_TEMPLATES)) {
+      const slug = slugOf(key, tpl);
+      const t = tpl as {
+        seedEntities?: Array<{ title?: string }>;
+        suggestedEntities?: Array<{ title?: string }>;
+        suggestedRelations?: Array<{ sourceRef?: string; targetRef?: string; type?: string }>;
+      };
+      const rels = t.suggestedRelations ?? [];
+      if (rels.length === 0) continue;
+
+      const titles = new Set(
+        [...(t.seedEntities ?? []), ...(t.suggestedEntities ?? [])]
+          .map((e) => e.title)
+          .filter((x): x is string => Boolean(x))
+      );
+
+      for (const rel of rels) {
+        for (const ref of [rel.sourceRef, rel.targetRef]) {
+          if (!ref || titles.has(ref)) continue;
+          dangling.push(`${slug}: relation "${rel.type}" references unseeded entity "${ref}"`);
+        }
+      }
+    }
+
+    expect(dangling, `Dangling seeded relations:\n  - ${dangling.join("\n  - ")}`).toEqual([]);
+  });
+});