@synap-core/workspace-templates 0.11.0 → 0.23.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", "packs", "automations"];
+
+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
@@ -83,6 +145,13 @@ export interface RemoteEntry {
    * never "unknown-so-hide".
    */
   isPrivate?: boolean;
+  /**
+   * The minimum subscription tier required to INSTALL this package (`solo` | `pro`
+   * | `team` | `enterprise`); `null`/absent ⇒ ungated. DISPLAY only here — the real
+   * install floor is the pod's `assertPackageTierAccess`. Kept a bare `string` so
+   * this pure/shared door stays enum-agnostic (like `category`).
+   */
+  requiredTier?: string | null;
   /**
    * Lightweight computed summary of the row's sub-objects (cells), carried on the
    * LIST projection so a surface can surface a matching sub-item without the full
@@ -149,6 +218,8 @@ export interface CpPackageRow {
   icon?: string | null;
   /** Present only on `/mine` rows. `false` ⇒ private. Browse rows omit it. */
   isPublic?: boolean;
+  /** The package's `required_tier` gate (`solo`|`pro`|…); `null`/absent ⇒ ungated. */
+  requiredTier?: string | null;
   /**
    * Computed sub-object summary from `GET /api/packages` / `/mine` (query-time,
    * not a stored column). Carries `key + name` per cell; never the cell code.
@@ -180,6 +251,7 @@ export function rowToRemoteEntry(
     tags: row.tags ?? [],
     icon: row.icon ?? null,
     isPrivate,
+    requiredTier: row.requiredTier ?? null,
     items: row.items,
     // Both list routes strip `definition`; absence ⇒ bundle wins a slug conflict,
     // and the install path fetches the full definition per-slug when needed.
@@ -202,6 +274,12 @@ interface CatalogEntryBase {
   icon?: string | null;
   /** `true` ⇒ not publicly listed (internal bundled template, or private CP row). */
   isPrivate: boolean;
+  /**
+   * Minimum install tier (`solo`|`pro`|…); `null` ⇒ ungated. Bundled templates are
+   * always `null` (they ship in-client, never gated). DISPLAY only — a surface
+   * shows a "requires <tier>" badge; the real floor is the pod's install check.
+   */
+  requiredTier?: string | null;
   /**
    * The entry's sub-object summary (cells). Always present (defaults to `[]`) so a
    * consumer can match sub-items uniformly. Bundled workspace templates carry no
@@ -289,8 +367,12 @@ function bundledToEntry(tpl: WorkspaceYaml): BundledCatalogEntry {
     tags: tpl.meta.tags ?? [],
     icon: tpl.meta.icon,
     isPrivate: tpl.meta.isPublic === false,
-    // Bundled workspace templates carry no cells — be honest, not `undefined`.
-    items: [],
+    // Bundled templates ship in-client and are never tier-gated.
+    requiredTier: null,
+    // 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,
   };
 }
@@ -306,6 +388,7 @@ function remoteToEntry(row: RemoteEntry): RemoteCatalogEntry {
     tags: row.tags ?? [],
     icon: row.icon ?? null,
     isPrivate: row.isPrivate ?? false,
+    requiredTier: row.requiredTier ?? null,
     items: row.items ?? [],
     remote: row,
   };

package/src/civic-france.yaml

@@ -0,0 +1,102 @@
+# France civic open-data research overlay — STUB (enhance later)
+#
+# Thin overlay that composes onto research-base for investigating French public
+# data (open data / Licence Ouverte). NOT a government product, NOT a marketplace
+# civic-tech app. Private workspace template only.
+#
+# Data access: consume official APIs only — data.gouv.fr, api.gouv.fr, PISTE.
+# Never scrape HTML. Do not invent a public pod host or resource_shares.
+# No automations that fetch the web in this stub.
+
+meta:
+  slug: civic-france
+  domain: knowledge
+  name: France Civic Research
+  description: Overlay for investigating French public data (open data / Licence Ouverte). Composes onto Research. Not a government product — a private research stub.
+  icon: landmark
+  color: "#1D4ED8"
+  tags: [research, civic, france, open-data, licence-ouverte]
+  isPublic: false
+
+workspace:
+  name: Research
+  description: Adds a French civic open-data lens onto the Research substrate — track public datasets consulted during investigations.
+  subtype: research-base
+
+# Layer additively onto the research-base workspace (no second workspace).
+# Visibility and capabilities OMITTED so the base Research workspace keeps its own.
+dependencies:
+  - slug: research-base
+    relation: compose
+    reason: France civic research is a research method — it needs the Research substrate (question / research / source) to work over.
+
+profiles:
+  # Slugs this overlay reuses from research-base — declared for the per-file
+  # validator (base owns their full schema; the applier skips already-existing
+  # properties). Mirror research-decision's reuse pattern.
+  - slug: question
+    displayName: Question
+    icon: help-circle
+    color: blue
+    description: An open question driving a civic-data investigation.
+    properties:
+      - slug: questionStatus
+        label: Status
+        valueType: string
+        inputType: select
+        enumValues: [open, exploring, answered, abandoned]
+        constraints: { defaultValue: open }
+
+  - slug: research
+    displayName: Research
+    icon: microscope
+    color: violet
+    description: An investigation into French public data — sources, findings, conclusion.
+    properties:
+      - slug: researchStatus
+        label: Status
+        valueType: string
+        inputType: select
+        enumValues: [ongoing, concluded, abandoned]
+        constraints: { defaultValue: ongoing }
+
+  - slug: source
+    displayName: Source
+    icon: file-text
+    color: cyan
+    description: Anything consulted — API payload, dataset page, decree, report.
+    properties:
+      - slug: url
+        label: URL
+        valueType: string
+        inputType: url
+
+  # Workspace-owned catalog entry for a French public dataset (thin stub).
+  - slug: public_dataset
+    displayName: Public dataset
+    icon: database
+    color: blue
+    description: A French public dataset consulted via official open-data APIs (data.gouv.fr / api.gouv.fr / PISTE) — never scraped HTML.
+    scope: WORKSPACE
+    properties:
+      - slug: sourceUrl
+        label: Source URL
+        valueType: string
+        inputType: url
+      - slug: license
+        label: License
+        valueType: string
+        inputType: text
+      - slug: publisher
+        label: Publisher
+        valueType: string
+        inputType: text
+
+views:
+  - name: Public datasets
+    slug: civic-france-public-datasets
+    type: table
+    scopeProfileSlug: public_dataset
+    description: French public datasets tracked in this research workspace.
+    config:
+      columns: [title, publisher, license, sourceUrl]

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
+    );
+  });
+});