@synap-core/workspace-templates 0.10.0 → 0.12.0

package/src/business-model.yaml

@@ -0,0 +1,351 @@
+# Business Model workspace template
+#
+# WHY THIS TEMPLATE EXISTS (read before adding another strategy pack):
+# The nine-component business-model interrogation (porteur, offer, market,
+# money, means, and the conventions binding them) maps almost entirely onto
+# vocabulary that ALREADY EXISTS in this corpus — `mission`/`vision`/`value`
+# (foundation), `audience`/`pain-point`/`positioning`/`offer` (foundation,
+# shared + pod-scoped), `client`/`partner`/`lead` (foundation shared roles),
+# and the whole IBIS apparatus of `question`/`hypothesis`/`decision`/`source`
+# (research-base + research-decision). Minting a parallel `business-model-*`
+# vocabulary would have been a vocabulary fork — the exact failure
+# `concept-guard.ts` was written to catch.
+#
+# So this pack adds only what is genuinely MISSING, which is three things:
+#   1. `convention`  — the binding external rule the model rests on (an
+#      eligibility threshold, a deontological duty, a contractual floor). Not
+#      a decision (nobody chose it) and not a finding (it is not evidence, it
+#      is a constraint). Nothing in the corpus expressed this.
+#   2. `projection`  — a quantified scenario with its assumptions attached, so
+#      a number can be challenged by challenging what it assumed.
+#   3. `rests_on` / `refutes` — the two edges that make a business model a
+#      GRAPH instead of a document. `rests_on` is deliberately NOT `depends_on`
+#      or `blocks`: those are acyclic scheduling edges, and a business model is
+#      legitimately circular (the offer rests on the means, the means rest on
+#      the money, the money rests on the offer). `rests_on` carries support and
+#      staleness, not sequencing, so a cycle is information rather than a bug.
+#
+# The porteur and funder ROLES it needs are declared in foundation.yaml, the
+# shared-role SSOT — see the note there.
+
+meta:
+  slug: business-model
+  domain: strategy
+  name: Business Model
+  description: Interrogate a venture as a model that rests on things — components supported by evidence, bound by real conventions, and quantified by projections whose assumptions stay visible.
+  icon: layout-grid
+  color: "#0EA5E9"
+  tags: [strategy, business-model, grp, ibis, viability]
+  isPublic: true
+
+workspace:
+  name: Foundation
+  description: Adds business-model interrogation to the strategic substrate — what the model rests on, which conventions bind it, and which numbers assume what.
+  subtype: foundation
+
+# ONE compose base only — `validate.ts` requires every compose dependency to
+# equal `workspace.subtype`, which is correct: an overlay is layered into one
+# workspace, and a thing cannot be layered into two. The business model belongs
+# in Foundation, because its components ARE the strategic DNA. The evidence
+# apparatus it borrows (hypothesis, source, finding) lives in the Research
+# workspace and is reached by RELATION, not by merging two lenses into one.
+dependencies:
+  - slug: foundation
+    relation: compose
+    reason: The model's components ARE the foundation vocabulary — mission, audience, pain-point, positioning, offer, and the client/partner/porteur/funder roles. This pack interrogates them; it does not restate them.
+
+profiles:
+  # ── Re-declared from dependencies, verbatim-compatible ─────────────────────
+  # Re-declaring a composed profile is how a pack states what it operates on;
+  # the apply layer resolves shared slugs to the ONE pod-wide row. Shapes here
+  # are strict subsets of the owner's shape, so no overlay conflict arises.
+  - slug: question
+    displayName: Question
+    icon: help-circle
+    profileKind: kind
+    properties:
+      - slug: questionStatus
+        label: Status
+        valueType: string
+        inputType: select
+        enumValues: [open, exploring, answered, abandoned]
+  - slug: decision
+    displayName: Decision
+    icon: gavel
+    profileKind: kind
+    properties:
+      - slug: decisionStatus
+        label: Status
+        valueType: string
+        inputType: select
+        enumValues: [proposed, accepted, superseded, rejected]
+
+  # ── What this pack actually adds ───────────────────────────────────────────
+  - slug: convention
+    displayName: Convention
+    icon: scale
+    color: rose
+    description: A binding rule the model must satisfy and did not choose — an eligibility threshold, a professional duty, a contractual floor, a platform policy. Distinct from a decision (nobody decided it) and from a finding (it constrains rather than informs).
+    profileKind: kind
+    properties:
+      - slug: rule
+        label: The Rule
+        valueType: string
+        inputType: textarea
+        description: State the constraint in the terms the issuer uses, not in a paraphrase. Paraphrase is where eligibility collisions hide.
+      - slug: issuer
+        label: Issued By
+        valueType: string
+        inputType: text
+        description: Who imposes it — a regulator, a funder, an ordre professionnel, a platform, a counterparty.
+      - slug: conventionType
+        label: Type
+        valueType: string
+        inputType: select
+        enumValues: [regulatory, deontological, eligibility, contractual, platform, fiscal, other]
+      - slug: bindingStatus
+        label: Binding Status
+        valueType: string
+        inputType: select
+        enumValues: [verified, assumed, contested, expired]
+        description: "`assumed` is the dangerous default — it means nobody has read the source text yet."
+      - slug: sourceReference
+        label: Source Reference
+        valueType: string
+        inputType: text
+        description: The cahier des charges, article, or guide this comes from. A convention with no reference is an assumption wearing a rule's clothes.
+      - slug: expiresAt
+        label: Expires / Review By
+        valueType: date
+        inputType: date
+      - slug: consequenceIfBreached
+        label: Consequence If Breached
+        valueType: string
+        inputType: textarea
+
+  - slug: projection
+    displayName: Projection
+    icon: trending-up
+    color: violet
+    description: A quantified scenario with its assumptions attached. The number is never the artifact — the assumptions are, because that is the only part anyone can argue with.
+    profileKind: kind
+    properties:
+      - slug: scenario
+        label: Scenario
+        valueType: string
+        inputType: select
+        enumValues: [pessimistic, base, optimistic]
+      - slug: horizon
+        label: Horizon
+        valueType: string
+        inputType: select
+        enumValues: [month, quarter, year, three-year]
+      - slug: assumptions
+        label: Assumptions
+        valueType: string
+        inputType: textarea
+        description: Every input this number needs to be true. When one changes, whatever rests on this projection goes stale.
+      - slug: revenueEstimate
+        label: Revenue Estimate
+        valueType: number
+        inputType: number
+      - slug: costEstimate
+        label: Cost Estimate
+        valueType: number
+        inputType: number
+      - slug: breakEvenUnits
+        label: Break-Even Units
+        valueType: number
+        inputType: number
+      - slug: confidence
+        label: Confidence
+        valueType: string
+        inputType: select
+        enumValues: [low, medium, high]
+
+# Relation TYPE vocabulary. Declared here (not as bare entityLinks) because
+# these two carry description + inverse labels that the entity-link path drops.
+relationDefs:
+  - slug: rests_on
+    displayName: Rests On
+    description: "The source depends on the target for its validity — not for its scheduling. Cycles are LEGAL and meaningful here: a business model is mutually supporting by nature, and forcing it into an acyclic dependency graph destroys the information. When the target changes, everything resting on it is stale until re-checked."
+    isDirectional: true
+    uiHints:
+      category: reference
+      inverseLabel: Supports
+  - slug: refutes
+    displayName: Refutes
+    description: The source is evidence that the target is false. Kept as a first-class edge so a refuted component stays in the graph with its refutation attached, instead of being quietly deleted — the reason a road was not taken is worth more than the road.
+    isDirectional: true
+    uiHints:
+      category: reference
+      inverseLabel: Refuted By
+
+entityLinks:
+  - sourceProfileSlug: offer
+    targetProfileSlug: convention
+    type: rests_on
+    label: Rests on
+  - sourceProfileSlug: offer
+    targetProfileSlug: audience
+    type: rests_on
+    label: Rests on
+  - sourceProfileSlug: projection
+    targetProfileSlug: offer
+    type: rests_on
+    label: Rests on
+  - sourceProfileSlug: decision
+    targetProfileSlug: convention
+    type: rests_on
+    label: Rests on
+  - sourceProfileSlug: decision
+    targetProfileSlug: projection
+    type: rests_on
+    label: Rests on
+  - sourceProfileSlug: convention
+    targetProfileSlug: offer
+    type: refutes
+    label: Refutes
+  - sourceProfileSlug: convention
+    targetProfileSlug: audience
+    type: refutes
+    label: Refutes
+  - sourceProfileSlug: convention
+    targetProfileSlug: question
+    type: rests_on
+    label: Rests on
+
+views:
+  - name: Conventions
+    slug: business-model-conventions
+    type: table
+    scopeProfileSlug: convention
+    description: Every rule the model must satisfy, who imposes it, and whether anyone has actually verified it.
+    defaultView: true
+    config:
+      columns: [title, conventionType, issuer, bindingStatus, expiresAt]
+  - name: Unverified Conventions
+    slug: business-model-assumed-conventions
+    type: list
+    scopeProfileSlug: convention
+    description: Conventions still marked assumed or contested — the model rests on these and nobody has read the source text.
+    config:
+      filters:
+        - field: bindingStatus
+          operator: in
+          value: [assumed, contested]
+  - name: Projections
+    slug: business-model-projections
+    type: table
+    scopeProfileSlug: projection
+    description: Scenarios with their assumptions in the open, so a number can be argued with.
+    config:
+      columns: [title, scenario, horizon, revenueEstimate, costEstimate, confidence]
+  - name: Open Interrogation
+    slug: business-model-open-questions
+    type: kanban
+    scopeProfileSlug: question
+    groupBy: questionStatus
+    description: The nine component questions and everything they spawned, by status.
+
+# ── Seeds: the interrogation, not fake data ────────────────────────────────
+# A strategy template that seeds example companies teaches nothing and gets
+# deleted. What is actually reusable is the QUESTION SET — the workspace should
+# arrive with the model's nine interrogations already open, so the first session
+# has somewhere to start and the kanban is not an empty box.
+seedEntities:
+  - profileSlug: question
+    title: Who is the porteur, and what does the model rest on them for?
+    properties:
+      questionStatus: open
+    content: Name the person, then name the specific competence, network, capital, or legitimacy the model cannot survive without. If the answer is generic, the model has no porteur — it has a job posting.
+  - profileSlug: question
+    title: What does the porteur's situation forbid?
+    properties:
+      questionStatus: open
+    content: Runway, hours available, geography, non-compete, dependants, health. Constraints discovered in month four were knowable in week one.
+  - profileSlug: question
+    title: What is the offer, stated as the problem it ends?
+    properties:
+      questionStatus: open
+    content: Not a description of what is built — a statement of the situation a buyer is in before, and after. If the offer can only be described by its features, the buyer has not been found yet.
+  - profileSlug: question
+    title: Who exactly buys it, and who merely benefits from it?
+    properties:
+      questionStatus: open
+    content: Link to `audience` entities. Payer, user, and beneficiary are frequently three different parties, and a model that conflates them forecasts revenue from people who never pay.
+  - profileSlug: question
+    title: Which conventions bind this model, and which are still assumed?
+    properties:
+      questionStatus: open
+    content: Eligibility thresholds, professional duties, platform policies, fiscal regimes. Every convention starts `assumed`; the work is reading the source text and moving it to `verified`. An eligibility collision — where the segment with the most pull sits outside the scheme that would fund it — only becomes visible once the numbers are pulled.
+  - profileSlug: question
+    title: What does one unit of delivery actually cost to produce?
+    properties:
+      questionStatus: open
+    content: Time, tooling, subcontracting, the unbilled parts. Link the answer to a `projection` so the assumptions stay attached to the number.
+  - profileSlug: question
+    title: Where does the money come from before revenue does?
+    properties:
+      questionStatus: open
+    content: Attach `funder` roles to the companies or schemes involved, with their eligibility conditions. Subsidy is a credential and a discount; it is rarely a pipeline.
+  - profileSlug: question
+    title: What means — people, tools, licences, premises — must exist first?
+    properties:
+      questionStatus: open
+    content: The means rest on the money and the money rests on the offer. That circularity is the model, not a planning error; record it with `rests_on` and stop trying to linearise it.
+  - profileSlug: question
+    title: What observation would refute this model, and by when?
+    properties:
+      questionStatus: open
+    content: Set the falsifiable test now, while it can still be set honestly. A model with no refuting observation is a belief with a spreadsheet attached.
+
+# The circularity, declared. These edges deliberately form cycles — that is the
+# point of `rests_on`, and the reason this pack does not use `depends_on`.
+suggestedRelations:
+  - sourceRef: What is the offer, stated as the problem it ends?
+    targetRef: Who exactly buys it, and who merely benefits from it?
+    type: rests_on
+  - sourceRef: What is the offer, stated as the problem it ends?
+    targetRef: What means — people, tools, licences, premises — must exist first?
+    type: rests_on
+  - sourceRef: What means — people, tools, licences, premises — must exist first?
+    targetRef: Where does the money come from before revenue does?
+    type: rests_on
+  - sourceRef: Where does the money come from before revenue does?
+    targetRef: What is the offer, stated as the problem it ends?
+    type: rests_on
+  - sourceRef: Where does the money come from before revenue does?
+    targetRef: Which conventions bind this model, and which are still assumed?
+    type: rests_on
+  - sourceRef: Who exactly buys it, and who merely benefits from it?
+    targetRef: Which conventions bind this model, and which are still assumed?
+    type: rests_on
+  - sourceRef: What does one unit of delivery actually cost to produce?
+    targetRef: What does the porteur's situation forbid?
+    type: rests_on
+  - sourceRef: What is the offer, stated as the problem it ends?
+    targetRef: Who is the porteur, and what does the model rest on them for?
+    type: rests_on
+
+playbooks:
+  - name: Business Model Interrogation
+    description: Walk the nine components as questions, resolve each into a decision backed by evidence, and record the conventions and projections the model rests on — including the cycles.
+    goalTemplate: "Interrogate the business model for {venture} and record what it rests on. Steps: (1) Walk each of the nine seeded `question` entities in this workspace; where one is already answered, mark it and move on. (2) Resolve each into a `decision`, keeping the options that lost attached via `refutes` rather than deleting them. Where the evidence itself needs gathering, do that in the Research workspace and link back — do not restate sources here. (3) Every external rule discovered becomes a `convention` with its `issuer` and `sourceReference`; leave `bindingStatus` at `assumed` until the source text has actually been read, then `verified`. (4) Every number becomes a `projection` with its `assumptions` filled in — never a bare figure. (5) Wire the graph with `rests_on` — offer on audience, projection on offer, decision on convention. Do NOT try to make the graph acyclic: if the offer rests on the means and the means rest on the money and the money rests on the offer, record all three. (6) Attach `porteur` and `funder` roles to the real people and organisations instead of creating new entities for them. (7) Close by listing which conventions are still `assumed` and which projections carry `low` confidence — that list is the actual state of the model."
+    icon: layout-grid
+
+actionPlacements:
+  - profileSlug: question
+    surface: entity-detail
+    kind: playbook
+    ref: Business Model Interrogation
+    label: Interrogate as model component
+  - profileSlug: convention
+    surface: entity-detail
+    kind: playbook
+    ref: Business Model Interrogation
+    label: Re-check what rests on this
+
+integrations:
+  - templateKey: research-methods
+  - templateKey: exa

package/src/catalog.ts

@@ -33,6 +33,20 @@ import type { WorkspaceYaml } from "./types.js";
 // Inputs
 // ============================================================================
 
+/**
+ * A lightweight, QUERY-TIME summary of one sub-object a package carries (a cell
+ * today; the shape generalizes to views/automations without change). Rides the
+ * catalog LIST projection so a surface can match/surface a sub-item WITHOUT the
+ * full `definition` — it carries `key + name` only, never the sub-object's code.
+ * `kind` is DERIVED (in the CP SELECT, from which sub-array the row came from),
+ * never a stored taxonomy.
+ */
+export interface PackageItemSummary {
+  kind: string;
+  key: string;
+  name: string;
+}
+
 /**
  * A bundled template — the canonical `WorkspaceYaml` this package ships. Callers
  * pass `listPublicTemplates()` (18) or `listWorkspaceTemplates()` (21); the door
@@ -69,6 +83,20 @@ 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
+   * `definition`. `undefined` on sources that don't compute it (bundled) — treated
+   * as "no known sub-items". See `PackageItemSummary`.
+   */
+  items?: PackageItemSummary[];
   /**
    * The CP `definition` jsonb — opaque install payload. The door reads only
    * `definition.sourcePackage.version` (the winner signal). Absent on browse rows
@@ -128,6 +156,13 @@ 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.
+   */
+  items?: PackageItemSummary[];
 }
 
 /**
@@ -154,6 +189,8 @@ 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.
   };
@@ -175,6 +212,18 @@ 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
+   * cells → `[]` (honest); a remote row carries its CP-computed `items`.
+   */
+  items: PackageItemSummary[];
 }
 
 /** A catalog entry backed by a bundled template. Install via `toWorkspaceDefinition()` / `toPackageDefinition()` on `template`. */
@@ -256,6 +305,10 @@ function bundledToEntry(tpl: WorkspaceYaml): BundledCatalogEntry {
     tags: tpl.meta.tags ?? [],
     icon: tpl.meta.icon,
     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: [],
     template: tpl,
   };
 }
@@ -271,6 +324,8 @@ 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/dist-freshness.test.ts

@@ -0,0 +1,97 @@
+/**
+ * FRESHNESS GATE for the BUILT `dist/` artifact.
+ *
+ * WHY (read before deleting):
+ * `templates-freshness.test.ts` (sibling file) proves `src/templates.ts`
+ * matches `src/*.yaml`. That is necessary but not sufficient: `dist/` — built
+ * by `tsup` from `src/templates.ts` — is what `synap-backend` and every other
+ * consumer actually imports as the published `@synap-core/workspace-templates`
+ * npm dependency (see this package's `exports` field: `dist/index.js`).
+ * Nothing regenerates `dist/` automatically, and it is committed independently
+ * of `src/templates.ts`. A YAML edit can reach `src/templates.ts` (green on
+ * the sibling test) and NOT reach `dist/` — the sibling test stays green while
+ * the backend keeps reading stale data, because it never looks at `dist/` at
+ * all. That gap is exactly what happened on 2026-09-05.
+ *
+ * This test closes it by importing the BUILT `dist/index.js` module (not
+ * re-parsing its text — a bundled/minified file has no byte-for-byte
+ * relationship to `src/templates.ts`) and asserting its exported
+ * `WORKSPACE_TEMPLATES` deep-equals what `src/*.yaml` renders to right now.
+ * That is the same non-vacuous shape as the sibling test: it re-derives the
+ * expected value from the YAML source on every run rather than trusting any
+ * stored marker, and it asserts the corpus is non-empty so a broken import
+ * can't silently compare `{}` to `{}`.
+ */
+
+import { describe, expect, it } from "vitest";
+import { readYamlTemplates } from "./generate.mjs";
+
+const FIX_COMMAND =
+  "cd synap-app/packages/workspace-templates && pnpm build";
+
+describe("dist/ freshness", () => {
+  it("dist/index.js's WORKSPACE_TEMPLATES matches what src/*.yaml renders to", async () => {
+    const expectedEntries = readYamlTemplates().map((t) => [t.slug, t.data]);
+    const expected = Object.fromEntries(expectedEntries);
+
+    // Guard against a vacuous pass: if the YAML corpus itself came back empty
+    // (a broken readdir, an emptied src/ directory), an empty-vs-empty
+    // comparison below would prove nothing. Fail loudly instead.
+    if (expectedEntries.length === 0) {
+      throw new Error(
+        "readYamlTemplates() returned zero templates — src/*.yaml did not " +
+          "parse. This test cannot verify dist/ freshness against an empty " +
+          "expected corpus; fix the YAML read before trusting this gate.",
+      );
+    }
+
+    let dist: { WORKSPACE_TEMPLATES?: Record<string, unknown> };
+    try {
+      // dist/index.js is the BUILT artifact — import it live so we're
+      // comparing against exactly what a consumer (synap-backend, the CLI)
+      // resolves via this package's `exports` field, not a re-parse of its
+      // source text.
+      dist = await import("../dist/index.js");
+    } catch (err) {
+      throw new Error(
+        [
+          "",
+          "❌ dist/index.js could not be imported — it is missing or fails to load.",
+          "",
+          `   FIX — build it:`,
+          `     ${FIX_COMMAND}`,
+          "",
+          `   (original error: ${(err as Error).message})`,
+          "",
+        ].join("\n"),
+      );
+    }
+
+    const actual = dist.WORKSPACE_TEMPLATES;
+    if (!actual || Object.keys(actual).length === 0) {
+      throw new Error(
+        "dist/index.js loaded but exported no WORKSPACE_TEMPLATES (or an " +
+          `empty object) — it is stale or broken.\n\n   FIX:\n     ${FIX_COMMAND}\n`,
+      );
+    }
+
+    if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+      throw new Error(
+        [
+          "",
+          "❌ dist/index.js is STALE — its WORKSPACE_TEMPLATES no longer matches",
+          "   what src/*.yaml renders to. synap-backend and every other consumer",
+          "   resolve this package to dist/, not src/, so a stale dist/ means the",
+          "   backend is reading templates that no longer exist on disk — even",
+          "   though src/templates.ts (and templates-freshness.test.ts) are fresh.",
+          "",
+          "   FIX — rebuild and commit the result:",
+          `     ${FIX_COMMAND}`,
+          "",
+        ].join("\n"),
+      );
+    }
+
+    expect(actual).toEqual(expected);
+  });
+});