@synap-core/workspace-templates 0.12.0 → 0.24.0

package/src/catalog-safety.test.ts

@@ -0,0 +1,198 @@
+/**
+ * W0 catalog safety — checks that SPAN SOURCES (before this file, no guard
+ * spanned sources). Read-only over sibling repos; a sibling that is absent (this
+ * package checked out alone, e.g. in synap-app CI) SKIPS its half honestly,
+ * with the reason logged, instead of passing vacuously.
+ *
+ * (a) ONE SOURCE PER PLAYBOOK NAME. The pod reuses playbooks by name (one live
+ *     row per lower(name) per workspace, migration 0227), so the same name
+ *     declared by two sources — a workspace YAML and a CP capability, or two
+ *     capabilities — contend for ONE row, and whichever applies first silently
+ *     wins. Every name may be declared by exactly one source file; the known
+ *     exceptions are listed with their reason and must match EXACTLY, so a new
+ *     duplicate AND a resolved one both turn this red.
+ *
+ * (b) EVERY SKILL REFERENCE RESOLVES. `dependencies[]` of kind `skill`, every
+ *     `skills:` link, and every `system/<pkg>/<stem>` named in template or
+ *     capability prose must name a skill package in this corpus
+ *     (`skills/*.skill.json` or `skills/<slug>/*.skill.json`) or a system skill on disk under
+ *     `synap-backend/skills/<pkg>/<stem>.md` (the pod's `ensureSystemSkills`
+ *     derives `system/<pkg>/<file-stem>` from exactly that layout).
+ *     Not covered: whether the corpus skill package is PUBLISHED.
+ *
+ * (c) The catalog's content directories ship in the npm bundle (`files` +
+ *     the `exports` subpaths, in both `exports` and `publishConfig.exports`),
+ *     and the build reads none of them (it compiles `src/*.yaml` only).
+ *
+ * The capability half reads the CATALOG's `capabilities/*.capability.json`
+ * (manifests; the CapabilityDefinition is `spec`) — the catalog is the source;
+ * the CP's `src/seeds/capability-templates/` is a transition mirror held
+ * identical by the CP's `catalog-mirror.tripwire.test.ts`.
+ */
+
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { readYamlTemplates } from "./generate.mjs";
+import type { WorkspaceYaml } from "./types.js";
+// One duplicate detector, shared with validateCatalog (duplicate-playbook-name).
+import { duplicateNames } from "../scripts/catalog-lib.mjs";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const PKG = join(HERE, "..");
+const MONO = join(HERE, "../../../..");
+const CATALOG_CAPS = join(PKG, "capabilities");
+const BACKEND_SKILLS = join(MONO, "synap-backend/skills");
+const CORPUS_SKILLS = join(PKG, "skills");
+
+const yamls = readYamlTemplates() as Array<{ file: string; slug: string; data: WorkspaceYaml }>;
+const hasBackend = existsSync(BACKEND_SKILLS);
+if (!hasBackend) console.warn(`[catalog-safety] SKIP the system-skill half: ${BACKEND_SKILLS} is absent`);
+
+const capFiles = readdirSync(CATALOG_CAPS)
+  .filter((f) => f.endsWith(".capability.json"))
+  .map((f) => ({ file: f, text: readFileSync(join(CATALOG_CAPS, f), "utf8") }));
+
+// ── (a) one source per playbook name ────────────────────────────────────────
+
+type Declared = { name: string; source: string };
+
+const declared: Declared[] = [
+  ...yamls.flatMap((t) =>
+    (t.data.playbooks ?? []).map((p) => ({ name: p.name, source: `yaml:${t.file}` }))
+  ),
+  ...capFiles.flatMap((c) =>
+    ((JSON.parse(c.text).spec?.playbooks ?? []) as Array<{ name: string }>).map((p) => ({
+      name: p.name,
+      source: `cap:${c.file}`,
+    }))
+  ),
+];
+
+/**
+ * Known duplicates, each with its reason. Both are CP-internal (out of this
+ * package's lane); giving each one home is wave W4.
+ */
+const KNOWN_DUPLICATES: Record<string, string[]> = {
+  "client onboarding": ["cap:agency-skills.capability.json", "cap:discord-bot.capability.json"],
+  "lead outreach": ["cap:agency-skills.capability.json", "cap:discord-bot.capability.json"],
+};
+
+describe("(a) one source per playbook name", () => {
+  it("non-vacuity: the scan sees the YAML playbooks (and the capability ones when present)", () => {
+    expect(declared.filter((d) => d.source.startsWith("yaml:")).length).toBeGreaterThanOrEqual(15);
+    expect(capFiles.length).toBeGreaterThanOrEqual(30);
+    expect(declared.filter((d) => d.source.startsWith("cap:")).length).toBeGreaterThanOrEqual(5);
+  });
+
+  it("self-check: a name declared by two sources, in any case, is reported", () => {
+    expect(
+      duplicateNames([
+        { name: "Produce Content", source: "yaml:a.yaml" },
+        { name: "produce content ", source: "cap:b.json" },
+        { name: "Solo", source: "yaml:a.yaml" },
+      ])
+    ).toEqual({ "produce content": ["cap:b.json", "yaml:a.yaml"] });
+  });
+
+  it("no playbook name has two sources beyond the listed exceptions (exact)", () => {
+    expect(duplicateNames(declared)).toEqual(KNOWN_DUPLICATES);
+  });
+});
+
+// ── (b) every skill reference resolves ──────────────────────────────────────
+
+/** `skills/*.skill.json` and `skills/<slug>/*.skill.json` (one level, as the catalog lib reads them). */
+const corpusSkillFiles = readdirSync(CORPUS_SKILLS, { withFileTypes: true }).flatMap((d) =>
+  d.isDirectory()
+    ? readdirSync(join(CORPUS_SKILLS, d.name))
+        .filter((f) => f.endsWith(".skill.json"))
+        .map((f) => join(CORPUS_SKILLS, d.name, f))
+    : d.name.endsWith(".skill.json")
+      ? [join(CORPUS_SKILLS, d.name)]
+      : []
+);
+const corpusSkillSlugs = new Set(corpusSkillFiles.map((f) => JSON.parse(readFileSync(f, "utf8")).meta.slug as string));
+
+/** `system/<pkg>/<stem>` → is there a `synap-backend/skills/<pkg>/<stem>.md` (stem case-insensitive)? */
+function systemSkillExists(ref: string): boolean {
+  const [, pkg, stem] = ref.split("/");
+  const dir = join(BACKEND_SKILLS, pkg ?? "");
+  if (!pkg || !stem || !existsSync(dir)) return false;
+  return readdirSync(dir).some((f) => f.toLowerCase() === `${stem.toLowerCase()}.md`);
+}
+
+const SYSTEM_REF = /(?<![A-Za-z0-9_/-])system\/[a-z0-9_-]+\/[a-z0-9_-]+/g;
+
+const structuredRefs = yamls.flatMap((t) => [
+  ...(t.data.dependencies ?? [])
+    .filter((d) => d.kind === "skill")
+    .map((d) => ({ where: `${t.file} dependencies`, slug: d.slug })),
+  ...(t.data.skills ?? []).map((s) => ({ where: `${t.file} skills:`, slug: s.slug })),
+]);
+
+const proseRefs = [
+  ...yamls.flatMap((t) =>
+    [...readFileSync(join(HERE, t.file), "utf8").matchAll(SYSTEM_REF)].map((m) => ({
+      where: t.file,
+      slug: m[0],
+    }))
+  ),
+  ...capFiles.flatMap((c) =>
+    [...c.text.matchAll(SYSTEM_REF)].map((m) => ({ where: c.file, slug: m[0] }))
+  ),
+];
+
+describe("(b) every skill reference resolves", () => {
+  it("non-vacuity: structured refs exist, and the resolvers see a literal sample", () => {
+    expect(structuredRefs.length).toBeGreaterThanOrEqual(2);
+    expect(corpusSkillSlugs.has("creative-director")).toBe(true);
+    // The prose matcher catches a system ref and ignores a path that merely ends in one.
+    expect("load system/synap/concepts now".match(SYSTEM_REF)).toEqual(["system/synap/concepts"]);
+    expect("ecosystem/operations/crm".match(SYSTEM_REF)).toBeNull();
+  });
+
+  it("every skill dependency and skills: link names a corpus or system skill", () => {
+    const dangling = structuredRefs.filter((r) =>
+      r.slug.startsWith("system/")
+        ? hasBackend && !systemSkillExists(r.slug)
+        : !corpusSkillSlugs.has(r.slug)
+    );
+    expect(dangling.map((r) => `${r.where}: ${r.slug}`)).toEqual([]);
+  });
+
+  it.skipIf(!hasBackend)("every system/<pkg>/<stem> named in prose exists under synap-backend/skills", () => {
+    expect(systemSkillExists("system/synap/concepts")).toBe(true); // literal sample
+    expect(systemSkillExists("system/synap/creative-director")).toBe(false); // the stale ref
+    const dangling = proseRefs.filter((r) => !systemSkillExists(r.slug));
+    expect(dangling.map((r) => `${r.where}: ${r.slug}`)).toEqual([]);
+  });
+});
+
+// ── (c) the content directories ship, the build reads none of them ─────────
+
+const CONTENT_DIRS = ["capabilities", "skills", "automations", "views"];
+
+describe("(c) catalog content ships in the npm bundle; the build reads only src/*.yaml", () => {
+  const pkg = JSON.parse(readFileSync(join(PKG, "package.json"), "utf8"));
+
+  it("non-vacuity: every content directory exists and holds files", () => {
+    for (const d of CONTENT_DIRS) expect(readdirSync(join(PKG, d)).length, d).toBeGreaterThan(0);
+  });
+
+  it("`files` carries every content directory, and both export maps expose it", () => {
+    for (const d of CONTENT_DIRS) {
+      expect(pkg.files, d).toContain(d);
+      expect(pkg.exports[`./${d}/*`], d).toBe(`./${d}/*`);
+      expect(pkg.publishConfig.exports[`./${d}/*`], d).toBe(`./${d}/*`);
+    }
+    expect(pkg.files).toEqual(expect.arrayContaining(["dist", "src"]));
+  });
+
+  it("build.mjs compiles src/*.yaml only", () => {
+    expect(yamls.every((t) => t.file.endsWith(".yaml") && !t.file.includes("/"))).toBe(true);
+    const build = readFileSync(join(PKG, "build.mjs"), "utf8");
+    for (const d of CONTENT_DIRS) expect(build, d).not.toMatch(new RegExp(`["'\`/]${d}/`));
+  });
+});

package/src/catalog.template-items.test.ts

@@ -0,0 +1,75 @@
+/**
+ * Bundled catalog entries carry DERIVED playbook sub-items — `track-template`
+ * for `scope: project`, `work-template` otherwise — the same rule the control
+ * plane computes in SQL for remote rows (`packageItemsSql`). A bundle usually
+ * WINS the merge for an official template, so without this the marketplace's
+ * "Track templates" lens could never see the templates this repo ships.
+ *
+ * Driven from the REAL bundled corpus through the REAL `mergeCatalog` door, not
+ * a hand-built entry.
+ */
+import { test } from "vitest";
+import assert from "node:assert/strict";
+import { mergeCatalog, TRACK_TEMPLATE_ITEM_KIND, WORK_TEMPLATE_ITEM_KIND } from "./catalog.js";
+import { listWorkspaceTemplates } from "./index.js";
+
+test("a bundled template with a project-scope playbook reads as shipping a track template", () => {
+  const bundled = listWorkspaceTemplates();
+  const withMethod = bundled.filter((t) =>
+    (t.playbooks ?? []).some((p) => p.scope === "project")
+  );
+  // Non-vacuity: the corpus really ships at least one track template.
+  assert.ok(withMethod.length >= 1, "no bundled template ships a scope:project playbook");
+
+  const { entries } = mergeCatalog({ bundled, remote: [], bundleVersion: "0.0.0", remoteStatus: "ok" });
+  for (const tpl of withMethod) {
+    const entry = entries.find((e) => e.slug === tpl.meta.slug);
+    assert.ok(entry, `bundled ${tpl.meta.slug} missing from the merge`);
+    const tracks = entry.items.filter((i) => i.kind === TRACK_TEMPLATE_ITEM_KIND);
+    const expected = (tpl.playbooks ?? []).filter((p) => p.scope === "project").map((p) => p.name);
+    assert.deepEqual(tracks.map((i) => i.name), expected);
+  }
+});
+
+test("a session / unscoped playbook is a work template, never a track template", () => {
+  const tpl = listWorkspaceTemplates()[0];
+  const synthetic = {
+    ...tpl,
+    meta: { ...tpl.meta, slug: "zz-synthetic" },
+    playbooks: [
+      { name: "Digest", goalTemplate: "g", scope: "session" as const },
+      { name: "Enrich", goalTemplate: "g" },
+    ],
+  };
+  const { entries } = mergeCatalog({ bundled: [synthetic], remote: [], bundleVersion: "0.0.0", remoteStatus: "ok" });
+  assert.deepEqual(
+    entries[0].items
+      .filter((i) => i.kind === WORK_TEMPLATE_ITEM_KIND || i.kind === TRACK_TEMPLATE_ITEM_KIND)
+      .map((i) => i.kind),
+    [WORK_TEMPLATE_ITEM_KIND, WORK_TEMPLATE_ITEM_KIND]
+  );
+});
+
+// G1 (2026-09-27): what a package brings BESIDE its templates — kinds, roles,
+// views — rides the same derived items, so a card can say "+ 4 kinds, 4 views"
+// without the definition. Same rule as the CP `packageItemsSql`.
+test("a bundled template's profiles and views derive kind / role / view items", () => {
+  const bundled = listWorkspaceTemplates();
+  const { entries } = mergeCatalog({ bundled, remote: [], bundleVersion: "0.0.0", remoteStatus: "ok" });
+  const grp = bundled.find((t) => t.meta.slug === "business-model");
+  assert.ok(grp, "business-model is no longer bundled");
+  const entry = entries.find((e) => e.slug === "business-model")!;
+  const count = (k: string) => entry.items.filter((i) => i.kind === k).length;
+  const kinds = grp.profiles.filter((p) => p.profileKind !== "role").length;
+  const roles = grp.profiles.filter((p) => p.profileKind === "role").length;
+  assert.ok(kinds > 0 && (grp.views ?? []).length > 0, "non-vacuity: GRP ships kinds and views");
+  assert.equal(count("kind"), kinds);
+  assert.equal(count("role"), roles);
+  assert.equal(count("view"), (grp.views ?? []).length);
+  // A role-profile reads as a role, never a kind.
+  const withRole = bundled.find((t) => t.profiles.some((p) => p.profileKind === "role"));
+  assert.ok(withRole, "non-vacuity: some bundled template declares a role");
+  const roleEntry = entries.find((e) => e.slug === withRole.meta.slug)!;
+  const roleSlug = withRole.profiles.find((p) => p.profileKind === "role")!.slug;
+  assert.equal(roleEntry.items.find((i) => i.key === roleSlug)?.kind, "role");
+});

package/src/catalog.ts

@@ -47,6 +47,68 @@ export interface PackageItemSummary {
   name: string;
 }
 
+/**
+ * The DERIVED template kinds a playbook sub-item carries. A playbook's own
+ * `scope` decides it — `"project"` is a method a project runs as a track, any
+ * other value (the schema default `session`) is one sitting of work. The author
+ * never declares it. The control plane derives the SAME rule in SQL for remote
+ * rows (`packageItemsSql`, synap-control-plane-api `routes/packages.ts`); the
+ * user-facing noun is `resolveTemplateNoun(scope)` (`@synap-core/types/vocabulary`).
+ */
+export const TRACK_TEMPLATE_ITEM_KIND = "track-template";
+export const WORK_TEMPLATE_ITEM_KIND = "work-template";
+
+/** Playbooks → `{kind,key,name}` sub-items. `key` = name (playbooks carry no key). */
+export function derivePlaybookItems(
+  playbooks:
+    | ReadonlyArray<{ name?: unknown; scope?: unknown } | null | undefined>
+    | null
+    | undefined
+): PackageItemSummary[] {
+  const out: PackageItemSummary[] = [];
+  for (const pb of playbooks ?? []) {
+    if (!pb || typeof pb.name !== "string" || !pb.name) continue;
+    out.push({
+      kind: pb.scope === "project" ? TRACK_TEMPLATE_ITEM_KIND : WORK_TEMPLATE_ITEM_KIND,
+      key: pb.name,
+      name: pb.name,
+    });
+  }
+  return out;
+}
+
+/**
+ * Schema sub-items: what a package brings BESIDE its templates — each profile as
+ * `kind` (or `role` when `profileKind: role`), each view as `view`. The CP derives
+ * the SAME rule in SQL (`packageItemsSql`). A card reads them only to say, in a
+ * secondary line, what else comes with the package ("+ 4 kinds, 4 views").
+ */
+export function deriveSchemaItems(tpl: {
+  profiles?: ReadonlyArray<{ slug?: unknown; displayName?: unknown; profileKind?: unknown } | null | undefined> | null;
+  views?: ReadonlyArray<{ name?: unknown; displayName?: unknown; slug?: unknown } | null | undefined> | null;
+}): PackageItemSummary[] {
+  const out: PackageItemSummary[] = [];
+  for (const p of tpl.profiles ?? []) {
+    if (!p || typeof p.slug !== "string" || !p.slug) continue;
+    out.push({
+      kind: p.profileKind === "role" ? "role" : "kind",
+      key: p.slug,
+      name: typeof p.displayName === "string" && p.displayName ? p.displayName : p.slug,
+    });
+  }
+  for (const v of tpl.views ?? []) {
+    const name =
+      v && typeof v.name === "string" && v.name
+        ? v.name
+        : v && typeof v.displayName === "string" && v.displayName
+          ? v.displayName
+          : null;
+    if (!v || !name) continue;
+    out.push({ kind: "view", key: typeof v.slug === "string" && v.slug ? v.slug : name, name });
+  }
+  return out;
+}
+
 /**
  * A bundled template — the canonical `WorkspaceYaml` this package ships. Callers
  * pass `listPublicTemplates()` (18) or `listWorkspaceTemplates()` (21); the door
@@ -307,8 +369,10 @@ function bundledToEntry(tpl: WorkspaceYaml): BundledCatalogEntry {
     isPrivate: tpl.meta.isPublic === false,
     // Bundled templates ship in-client and are never tier-gated.
     requiredTier: null,
-    // Bundled workspace templates carry no cells — be honest, not `undefined`.
-    items: [],
+    // Bundled workspace templates carry no cells; their playbooks are summarized
+    // with the same derived kind the CP computes for a remote row, so a bundle
+    // that wins the merge still reads as shipping a track template.
+    items: [...derivePlaybookItems(tpl.playbooks), ...deriveSchemaItems(tpl)],
     template: tpl,
   };
 }

package/src/concept-guard.test.ts

@@ -45,18 +45,19 @@ describe("concept guard — shipped corpus", () => {
 
   it("needs NO declared divergence — the CRM fork was resolved, not allowlisted", () => {
     // The allowlist was born carrying `crm-lead|lead` + `client|crm-client`.
-    // business-developer.yaml now re-declares the SHARED `lead`/`client` roles
-    // and carries its business-development fields as workspace-overlay
-    // properties, so there is no fork left to declare. Rule 3 (stale-allowlist)
+    // crm.yaml re-declares the SHARED `lead`/`client` roles and carries the
+    // qualification/handoff fields (folded in from business-developer,
+    // 2026-10-12) as workspace-overlay properties, so there is no fork left to
+    // declare. Rule 3 (stale-allowlist)
     // is what forces this to stay true: a leftover entry fails CI.
     expect(Object.keys(DECLARED_DIVERGENCES)).toEqual([]);
 
-    const bd = WORKSPACE_TEMPLATES["business-developer"]?.profiles ?? [];
-    expect(bd.map((p) => p.slug)).not.toContain("crm-lead");
-    expect(bd.map((p) => p.slug)).not.toContain("crm-client");
+    const crm = WORKSPACE_TEMPLATES["crm"]?.profiles ?? [];
+    expect(crm.map((p) => p.slug)).not.toContain("crm-lead");
+    expect(crm.map((p) => p.slug)).not.toContain("crm-client");
     for (const slug of ["lead", "client"]) {
-      const reused = bd.find((p) => p.slug === slug);
-      expect(reused, `business-developer must reuse shared '${slug}'`).toBeDefined();
+      const reused = crm.find((p) => p.slug === slug);
+      expect(reused, `crm must reuse shared '${slug}'`).toBeDefined();
       expect(reused?.scope).toBe("shared");
       expect(reused?.profileKind).toBe("role");
       // No alias: the shared slug IS the concept identity.
@@ -190,3 +191,22 @@ describe("concept guard — stays green on legitimate patterns", () => {
     expect(violations).toEqual([]);
   });
 });
+
+// "Pipeline" is a VIEW, never a stored kind (work model L3, 2026-10-11): the
+// pipeline is computed from a kind or role + its lifecycle. A stored kind named
+// pipeline (content-studio's old `content-pipeline`) makes "open the pipeline"
+// ambiguous. Scans every profile slug and semanticSlug in the shipped corpus.
+// Does NOT scan property slugs (builder's agent-run `pipeline_phase` is a run
+// phase, a different word) nor view names ("Lead Pipeline" IS the view).
+describe("no stored kind is named pipeline", () => {
+  it("the corpus declares no profile whose slug or semanticSlug says pipeline", () => {
+    const all = Object.values(WORKSPACE_TEMPLATES).flatMap((t) =>
+      (t.profiles ?? []).map((p) => ({ tpl: t.meta?.slug, p }))
+    );
+    expect(all.length).toBeGreaterThan(100); // non-vacuity
+    const hits = all
+      .filter(({ p }) => /pipeline/i.test(p.slug) || /pipeline/i.test(p.semanticSlug ?? ""))
+      .map(({ tpl, p }) => `${tpl}:${p.slug}`);
+    expect(hits).toEqual([]);
+  });
+});

package/src/concept-guard.ts

@@ -51,8 +51,8 @@ export interface ConceptViolation {
  *
  * Currently EMPTY, and that is the healthy state. The two entries this list was
  * born for — `crm-lead|lead` and `client|crm-client` — were RESOLVED rather
- * than kept: business-developer.yaml now re-declares the shared `lead`/`client`
- * roles and carries its business-development fields as workspace-overlay
+ * than kept: crm.yaml (business-developer folded into it, 2026-10-12)
+ * re-declares the shared `lead`/`client` roles and carries its business-development fields as workspace-overlay
  * PROPERTIES. One concept, one slug, workspace-specific fields. Rule 3 below
  * would have failed CI had the entries been left behind.
  */

package/src/content-creation.template.test.ts

@@ -0,0 +1,52 @@
+/**
+ * Contract tests for the Content Creation suite.
+ *
+ * Reads the generated `templates.ts` corpus (same as every installer).
+ */
+import { describe, expect, it } from "vitest";
+import { getWorkspaceTemplate } from "./templates.js";
+
+const template = (() => {
+  const resolved = getWorkspaceTemplate("content-creation");
+  if (!resolved) throw new Error("content-creation template is not registered");
+  return resolved;
+})();
+
+describe("Content Creation suite", () => {
+  it("is a public suite tagged for content creation", () => {
+    expect(template.meta.slug).toBe("content-creation");
+    expect(template.meta.isPublic).toBe(true);
+    expect(template.meta.domain).toBe("content");
+    expect(template.meta.tags).toEqual(
+      expect.arrayContaining(["suite", "content", "creation"])
+    );
+  });
+
+  it("requires content-os and brand-library because content-os consumes brand; never the retired content-studio", () => {
+    const required = (template.dependencies ?? []).map((d) => ({
+      slug: d.slug,
+      relation: d.relation ?? "require",
+    }));
+    expect(required).toEqual(
+      expect.arrayContaining([
+        { slug: "content-os", relation: "require" },
+        { slug: "brand-library", relation: "require" },
+      ])
+    );
+    // content-studio is retired into content-os (retired.yaml, 2026-11-03).
+    expect(required.map((d) => d.slug)).not.toContain("content-studio");
+    expect(required.every((d) => d.relation === "require")).toBe(true);
+    // Foundation is NOT a direct dep: content-os already requires it, and
+    // neither constituent's sourceRoles consume `strategy`.
+    expect(required.map((d) => d.slug)).not.toContain("foundation");
+  });
+
+  it("does not silently skip the brand spine its constituents consume", () => {
+    expect(template.workspace.sourceRoles?.brand).toBe("consumer");
+    const contentOs = getWorkspaceTemplate("content-os");
+    expect(contentOs?.workspace.sourceRoles?.brand).toBe("consumer");
+    expect((template.dependencies ?? []).some((d) => d.slug === "brand-library")).toBe(
+      true
+    );
+  });
+});

package/src/content-creation.yaml

@@ -0,0 +1,192 @@
+# Content Creation — the public editorial + production suite
+# ==========================================================
+# A SUITE template: it stands up a content operation in one install by REQUIRING
+# its constituent workspaces (deps-first), then adds a thin "program tower" home
+# of its own — a place to track the editorial programs that cut across the
+# lenses it just installed.
+#
+# What it composes (all public, all bundled):
+#   • brand-library  — brand identity spine (both constituents consume `brand`)
+#   • content-os     — the editorial engine (pillars, posts, platforms, newsletters)
+#                      AND the video / visual pipeline (compositions, assets,
+#                      renders); transitively requires foundation + marketing-campaign
+#
+# content-studio was retired into content-os (retired.yaml, 2026-11-03): one
+# space per domain, and content-os.yaml said never to install it beside
+# content-os. This suite no longer requires it.
+#
+# Brand is required because content-os declares `sourceRoles.brand: consumer`
+# — skipping it would silently drop the spine it consumes. Foundation is NOT a direct dep: content-os already
+# requires it (and marketing-campaign) via its own `dependencies[]`; sourceRoles
+# do not consume `strategy`.
+#
+# It uses `require` (not `compose`): each constituent is a REAL workspace, not an
+# overlay. Installing Content Creation a second time is idempotent — the resolver
+# reuses existing constituent workspaces by slug.
+
+meta:
+  slug: content-creation
+  domain: content
+  name: Content Creation
+  description: Stand up a content operation in one install — brand, editorial engine, and video pipeline — plus a program tower to track what you are making across them.
+  icon: pen-tool
+  color: "#6366F1"
+  tags: [suite, content, creation, editorial, video, studio]
+  isPublic: true
+
+# Deps-first: brand-library is the brand-vocabulary provider content-os
+# consumes, so it must resolve before content-os reuses it. `require` (not
+# `compose`): each is a standalone workspace, not an additive overlay.
+dependencies:
+  - slug: brand-library
+    kind: workspace
+    relation: require
+    reason: "Brand identity spine — Content OS consumes `brand`; skipping it would drop the provider that sourceRole requires."
+  - slug: content-os
+    kind: workspace
+    relation: require
+    reason: "The editorial engine and the video / visual pipeline — pillars, posts, platforms, newsletters, compositions and renders. Transitively brings foundation (strategy spine) and marketing-campaign."
+
+workspace:
+  name: Content Creation
+  description: The program tower for the content operation — track the editorial programs that cut across the brand, editorial, and production lenses this suite installs.
+  subtype: content-creation
+  visibility: pod_visible
+  sourceRoles:
+    brand: consumer
+    content: provider
+
+profiles:
+  # The one native profile the program tower owns: a content program the
+  # operation is driving across the lenses this suite installs. Deliberately
+  # light — the depth lives in the constituent workspaces; this is the
+  # cross-cutting scoreboard that ties them together.
+  - slug: content-program
+    displayName: Content Program
+    icon: target
+    color: "#6366F1"
+    description: A content program the operation is driving — the cross-cutting outcome the editorial and production lenses serve.
+    # The ONE lifecycle (work model L1): every option's category.
+    lifecycle:
+      property: status
+      options:
+        - { key: on-track, category: active }
+        - { key: at-risk, category: active }
+        - { key: off-track, category: active }
+        - { key: shipped, category: done }
+    properties:
+      - slug: outcome
+        label: Outcome
+        valueType: string
+        inputType: textarea
+      - slug: status
+        label: Status
+        valueType: string
+        inputType: select
+        enumValues: [on-track, at-risk, off-track, shipped]
+        constraints: { defaultValue: on-track }
+      - slug: horizon
+        label: Horizon
+        valueType: string
+        inputType: select
+        enumValues: [now, next, later]
+        constraints: { defaultValue: now }
+      - slug: owner
+        label: Owner
+        valueType: string
+        inputType: text
+      - slug: targetDate
+        label: Target Date
+        valueType: date
+        inputType: date
+
+views:
+  - name: Programs
+    slug: programs
+    type: table
+    scopeProfileSlug: content-program
+    description: The content programs across editorial and production, by horizon and status.
+    defaultView: true
+    config:
+      columns: [title, status, horizon, owner, targetDate]
+  - name: Program Board
+    slug: program-board
+    type: kanban
+    scopeProfileSlug: content-program
+    description: Programs grouped by status — a running scoreboard for the content operation.
+    config:
+      groupBy: status
+
+onboarding:
+  goal: >
+    Stand up the content operation and name the handful of programs it is
+    driving — so brand, editorial, and production are all in place and pointed
+    at the same outcomes from day one.
+  framing: |
+    THE EDITORIAL PRODUCER: Act as a sharp producer standing up the content OS.
+    Brand and Content OS are already installed — your job is
+    to name the 3-5 programs that cut across them, so the operation has a
+    scoreboard, not just structure.
+  expertise:
+    starters:
+      - >
+        Name few, real programs. A content operation with 20 programs has
+        none; force the 3-5 that actually decide this quarter, each with an
+        owner and a horizon (now / next / later).
+      - >
+        Tie each program to a lens. A good program names where it lives —
+        a series (editorial), a production pipeline (video and visual
+        posts), or a brand system
+        (library) — so the scoreboard maps to the structure underneath it.
+    blindSpots:
+      - >
+        Programs with no owner and no date are wishes. Every one needs a
+        single owner and a target date, or it will not move.
+      - >
+        "Make more content" is not a program — it is a category. Push for
+        the specific outcome that would make this quarter a win.
+    bar: >
+      A short, honest scoreboard: 3-5 programs, each owned, dated, placed on a
+      horizon, and tied to the lens that serves it — sitting on top of a fully
+      installed content operation.
+  collect:
+    - profileSlug: content-program
+      what: The 3-5 content programs the operation is driving this horizon.
+      cardinality: few
+      keyFields: [status, horizon, owner]
+  openingQuestions:
+    - "What are the 3-5 content programs that will decide this quarter?"
+    - "Who owns each one, and is it a now, next, or later horizon?"
+  doneWhen: A few programs captured, each with an owner and a horizon.
+
+app:
+  kind: stored
+  cellKey: entity-detail
+
+layout:
+  defaultView: Programs
+  defaultApp: null
+  pinnedApps: [dashboard, data]
+  sidebarItems:
+    - kind: view
+      viewName: Programs
+      label: Programs
+      icon: target
+    - kind: view
+      viewName: Program Board
+      label: Board
+      icon: kanban-square
+    - kind: app
+      appId: data
+      label: Data
+      icon: database
+
+bento:
+  viewName: Programs
+  blocks:
+    - kind: view
+      viewName: Programs
+      pos: { x: 0, y: 0, w: 8, h: 4 }
+    - kind: view
+      viewName: Program Board
+      pos: { x: 8, y: 0, w: 4, h: 4 }