@synap-core/workspace-templates 0.11.0 → 0.12.0

package/package.json

@@ -1,13 +1,11 @@
 {
   "name": "@synap-core/workspace-templates",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "type": "module",
-  "packageManager": "pnpm@9.15.4",
   "description": "Canonical workspace definitions — YAML source + typed exports for browser, backend, CLI, and marketplace",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "node": "./dist/index.js",
       "default": "./dist/index.js"
     }
   },
@@ -15,16 +13,6 @@
     "dist",
     "src"
   ],
-  "scripts": {
-    "type-check": "tsc --noEmit",
-    "build:yaml": "node --experimental-strip-types build.mjs",
-    "check:converters": "node scripts/check-converters.mjs",
-    "check:concepts": "node scripts/check-concepts.mjs",
-    "build": "node --experimental-strip-types build.mjs && tsup && node scripts/check-converters.mjs && node scripts/check-concepts.mjs",
-    "provision": "node scripts/provision.mjs",
-    "eval": "node scripts/eval-standard.mjs",
-    "prepublishOnly": "node --experimental-strip-types build.mjs && tsup && node scripts/check-converters.mjs && node scripts/check-concepts.mjs"
-  },
   "dependencies": {
     "zod": "^3.0.0",
     "js-yaml": "^4.1.0"
@@ -37,15 +25,18 @@
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
-    "access": "public",
-    "main": "./dist/index.js",
-    "module": "./dist/index.js",
-    "types": "./dist/index.d.ts",
-    "exports": {
-      ".": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      }
-    }
-  }
-}
+    "access": "public"
+  },
+  "scripts": {
+    "type-check": "tsc --noEmit",
+    "build:yaml": "node --experimental-strip-types build.mjs",
+    "check:converters": "node scripts/check-converters.mjs",
+    "check:concepts": "node scripts/check-concepts.mjs",
+    "build": "node --experimental-strip-types build.mjs && tsup && node scripts/check-converters.mjs && node scripts/check-concepts.mjs",
+    "provision": "node scripts/provision.mjs",
+    "eval": "node scripts/eval-standard.mjs"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts"
+}

package/src/base.template.test.ts

@@ -8,14 +8,14 @@
  * seeders be deleted (Wave 4) without silently changing what every workspace
  * gets.
  *
- * FIDELITY MECHANISM. The report prompts are the product — a single altered
- * character is a regression. Importing `REPORT_AUTOMATION_FLOW` from
- * `@synap/database` into this frontend package would be an upward layering
- * violation, so instead the byte-for-byte guardrail is a COMMITTED, GENERATED
- * fixture (`__fixtures__/report-automation-flow.json`) snapshotted from the
- * backend const at authoring time, never hand-typed. The chain the test proves:
- *     compiled base flow  ===  fixture  (=== REPORT_AUTOMATION_FLOW at capture).
- * Same for the 23-ish relation defs via `__fixtures__/default-relation-defs.json`.
+ * FIDELITY MECHANISM. base.yaml is now the SINGLE source of the report flow —
+ * the backend `REPORT_AUTOMATION_FLOW` const it was once snapshotted against was
+ * retired, and with it the `__fixtures__/report-automation-flow.json` copy-pin
+ * (a copy pinned to a copy caught no upstream drift). The report flow is guarded
+ * here directly instead: the prompt-fragment smoke check below proves the product
+ * content survived, and `templates-freshness.test.ts` pins templates.ts == the
+ * YAML source. The 23-ish relation defs KEEP their byte-for-byte fixture
+ * guardrail (`__fixtures__/default-relation-defs.json`).
  */
 
 import { readFileSync } from "fs";
@@ -55,18 +55,13 @@ describe("Task A — report automation, byte-faithful", () => {
     expect(automation?.description).toMatch(/Gather this workspace's state/);
   });
 
-  it("flow BYTE-MATCHES the REPORT_AUTOMATION_FLOW snapshot", () => {
-    const fixture = readFixture("report-automation-flow.json");
-    // deep-equal: the compiled template's flow is JSON.stringify(parsed YAML), so
-    // a deep-equal against the JSON snapshot of the source const proves the
-    // transcription is lossless (nodes, edges, and every prompt string).
-    expect(automation?.flow).toEqual(fixture);
-  });
-
   it("preserves the load-bearing hardened prompt fragments (v13)", () => {
-    // A coarse smoke check that the specific product content survived — the
-    // deep-equal above is authoritative, but these named fragments make a
-    // regression legible if the fixture is ever regenerated wrongly.
+    // The primary guardrail that the report flow's product content survived in
+    // base.yaml. (A byte-for-byte fixture pin used to sit above this, snapshotting
+    // the retired backend `REPORT_AUTOMATION_FLOW` const; with that const gone
+    // base.yaml is the single source, so a copy-pinned-to-a-copy proved nothing
+    // and was dropped. `templates-freshness.test.ts` pins templates.ts == the
+    // YAML source.)
     const flowStr = JSON.stringify(automation?.flow);
     for (const marker of [
       "COUNTS — the exact number of records gathered",
@@ -77,6 +72,17 @@ describe("Task A — report automation, byte-faithful", () => {
       expect(flowStr).toContain(marker);
     }
   });
+
+  it("carries the v15 retry policy on all four AI rounds (regression guard)", () => {
+    // v15's fix for the 2026-08-03 finishReason=length incident: each of the four
+    // ai.generate rounds (analyze/relate/assemble/summarize) gets ONE retry with a
+    // 5s delay. This field dropped SILENTLY once — the 700→2000 fix ported maxTokens
+    // into base.yaml but not the retry policy, so it went missing on the reconcile-
+    // winning path. Assert it here (base.yaml is the SSOT now) so it can't drift again.
+    const flowStr = JSON.stringify(automation?.flow);
+    expect((flowStr.match(/"retryDelay":5000/g) ?? []).length).toBe(4);
+    expect((flowStr.match(/"maxRetries":1(?=[,}])/g) ?? []).length).toBe(4);
+  });
 });
 
 describe("Task B — relation defs, full coverage", () => {

package/src/base.yaml

@@ -458,6 +458,8 @@ automations:
               maxTokens: "2000"
             errorHandling:
               continueOnError: true
+              maxRetries: 1
+              retryDelay: 5000
         - id: relate
           type: capability
           position:
@@ -540,6 +542,8 @@ automations:
               maxTokens: "2000"
             errorHandling:
               continueOnError: true
+              maxRetries: 1
+              retryDelay: 5000
         - id: assemble
           type: capability
           position:
@@ -724,6 +728,9 @@ automations:
                 RELATE ROUND MATERIAL:
                 {{steps.relate.output}}
               maxTokens: "2000"
+            errorHandling:
+              maxRetries: 1
+              retryDelay: 5000
         - id: summarize
           type: capability
           position:
@@ -742,6 +749,9 @@ automations:
                 Material to summarize (may be an error object if the round failed):
                 {{steps.analyze.output}}
               maxTokens: "500"
+            errorHandling:
+              maxRetries: 1
+              retryDelay: 5000
         - id: guard-assembled
           type: guard
           position:

package/src/builder.yaml

@@ -1,6 +1,17 @@
 # Builder workspace template
 # Developer + agent intelligence layer.
-# Generated from synap-app/apps/devplane/lib/builderWorkspaceDefinition.ts (source of truth).
+#
+# ✅ SINGLE SOURCE OF TRUTH for the Builder workspace, on every door.
+# Both doors now derive from this file:
+#   • apps/devplane/lib/builderWorkspaceDefinition.ts → the devplane onboarding
+#     path (trpc.workspaces.createFromDefinition) — since 2026-09-05 that module
+#     is a five-line `toWorkspaceDefinition("builder-workspace")` derivation
+#   • the registry / marketplace install path — same seam
+# Until 2026-09-05 the TS file held a ~1,150-line hand-typed PEER copy of this
+# workspace and nothing compared the two, which produced five real divergences
+# (four capabilities, a dead-Coolify seed pair, defaultApp/primarySurface, an
+# unprefixed calendar dateField, and this file's playbooks/onboarding). Edit the
+# schema HERE; there is no second copy to keep in sync.
 
 meta:
   slug: builder-workspace
@@ -23,6 +34,13 @@ workspace:
     - builder.deployments
     - builder.agents
     - builder.packages
+    # Tier-1 signal for `resolveWorkspaceForScope` — must match the DevPlane app
+    # manifest's `defaultScope.capability` (browser/…/apps/manifest.ts) and the
+    # `workspaceCapabilities` list the devplane door derives from this block.
+    # Without it a workspace created through THIS door fails all four resolver tiers
+    # (no capability · subtype "builder" ≠ kind "devplane" · name "Builder" ≠ "DevPlane")
+    # and the workspace press falls silently to a setup card.
+    - devplane.workspace
 
 profiles:
   - slug: devplane_app

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

@@ -83,6 +83,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 +156,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 +189,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 +212,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,6 +305,8 @@ 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,
@@ -306,6 +324,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,
   };