@owlmeans/viable-common 0.0.33 → 0.0.35

package/src/intent/schemas.ts

@@ -0,0 +1,27 @@
+import type { JSONSchemaType } from 'ajv'
+import { INTENT_PROMPT_MAX, INTENT_REF_LENGTH, INTENT_REF_PATTERN } from './consts.js'
+import type { IntentPickupBody, IntentStashBody } from './types.js'
+
+/**
+ * The stash body. `consent` is a constant `true`, not a boolean: the data-processing confirmation is
+ * a precondition of the request existing, so the wire refuses its absence instead of the handler
+ * having to remember to look.
+ */
+export const IntentStashBodySchema: JSONSchemaType<IntentStashBody> = {
+  type: 'object',
+  properties: {
+    prompt: { type: 'string', minLength: 1, maxLength: INTENT_PROMPT_MAX },
+    consent: { type: 'boolean', const: true },
+  },
+  required: ['prompt', 'consent'],
+  additionalProperties: false,
+}
+
+export const IntentPickupBodySchema: JSONSchemaType<IntentPickupBody> = {
+  type: 'object',
+  properties: {
+    ref: { type: 'string', minLength: INTENT_REF_LENGTH, maxLength: INTENT_REF_LENGTH, pattern: INTENT_REF_PATTERN },
+  },
+  required: ['ref'],
+  additionalProperties: false,
+}

package/src/intent/types.ts

@@ -0,0 +1,45 @@
+import type { ResourceRecord } from '@owlmeans/resource'
+
+/** What the public site sends: the prompt and the person's confirmation of its processing. */
+export interface IntentStashBody {
+  prompt: string
+  /** Always `true` — the site's checkbox; a request without it is refused by the schema. */
+  consent: true
+}
+
+/** The reference the platform answers with, and the moment its record expires. */
+export interface IntentStashResult {
+  ref: string
+  /** Epoch milliseconds. */
+  expiresAt: number
+}
+
+export interface IntentPickupBody {
+  ref: string
+}
+
+export interface IntentPickupResult {
+  prompt: string
+}
+
+/**
+ * The prompt as it waits in the visitor's browser between pickup and the decision on the home
+ * screen. `expiresAt` is checked on read — browser storage has no TTL of its own.
+ */
+export interface IntentDraft extends ResourceRecord {
+  id: string
+  /** The reference it was picked up with; a reload of the landing reuses the draft of that ref. */
+  ref: string
+  prompt: string
+  expiresAt: number
+}
+
+/**
+ * Options of {@link makeIntentProtocols}.
+ */
+export interface IntentProtocolOptions {
+  /** Path prefix of the guest API; defaults to `/public/intent`. */
+  path?: string
+  /** Path of the landing screen; defaults to `/start`. */
+  landing?: string
+}

package/src/scaffold/consts.ts

@@ -1,4 +1,4 @@
-import type { BentoFragmentKind } from './types.js'
+import type { BentoFragmentKind, LandingGateFieldKind } from './types.js'
 
 /**
  * The shapes a drawn widget can take.
@@ -34,3 +34,16 @@ export const AREA_SECTION_CAP = 6
  * value nothing can draw is a tile with an empty bottom.
  */
 export const BENTO_FRAGMENT_KINDS: BentoFragmentKind[] = ['list', 'note', 'people', 'steps']
+
+/**
+ * The controls a landing-gate field can be — the simplest native inputs, and no picker of any
+ * kind. A closed set for the same reason as {@link BENTO_FRAGMENT_KINDS}: each value is one plain
+ * element the seed's gate knows how to draw.
+ */
+export const LANDING_GATE_FIELD_KINDS: LandingGateFieldKind[] = ['text', 'select', 'number', 'date']
+
+/** The most fields a landing gate carries. A form longer than this is a screen, not an entry. */
+export const LANDING_GATE_MAX_FIELDS = 3
+
+/** The options a `select` field carries: fewer is no choice, more is a list to browse. */
+export const LANDING_GATE_OPTIONS = { min: 2, max: 6 } as const

package/src/scaffold/schemas.ts

@@ -1,9 +1,9 @@
 import type { JSONSchemaType } from 'ajv'
 
 import { ProjectArea } from '../areas/consts.js'
-import { BENTO_FRAGMENT_KINDS, WidgetKind } from './consts.js'
+import { BENTO_FRAGMENT_KINDS, LANDING_GATE_FIELD_KINDS, WidgetKind } from './consts.js'
 import type {
-  BentoFragment, GuestHomePlan, LandingGatePlan, ProductIdentity,
+  BentoFragment, GuestHomePlan, LandingGateAnswer, LandingGateField, LandingGatePlan, ProductIdentity,
   ScaffoldAreaPlan, ScaffoldPlan, ScaffoldStoryPlan, SketchContent,
 } from './types.js'
 
@@ -83,7 +83,8 @@ const ScaffoldStoryPlanSchema: JSONSchemaType<ScaffoldStoryPlan> = {
     screen: {
       type: 'string',
       description: 'The main screen this story will need, named "{section}/{purpose}" -'
-        + ' e.g. "Requests/Submit a request". The section part must equal the section above'
+        + ' e.g. "Requests/Submit request". The purpose is one or two words, never a sentence.'
+        + ' The section part must equal the section above'
     },
     widget: {
       type: 'object',
@@ -225,99 +226,129 @@ const BentoFragmentSchema: JSONSchemaType<BentoFragment> = {
   additionalProperties: false,
 }
 
-const LandingGatePlanSchema: JSONSchemaType<LandingGatePlan> = {
+const LandingGateFieldSchema: JSONSchemaType<LandingGateField> = {
   type: 'object',
-  title: 'LandingGatePlan',
-  description: 'The working entry into the key end-user workflow, drawn in the hero instead of the'
-    + ' call-to-action buttons: a guest makes a few picks, sees sample results ranked against them,'
-    + ' and signs in to continue with the picks carried over. Every text is in the end user\'s words',
+  title: 'LandingGateField',
+  description: 'One simple, non-sensitive field of the landing gate',
   properties: {
-    story: {
+    name: {
       type: 'string',
-      description: 'The code of the landing story, copied EXACTLY as given to you. Never shown'
+      description: 'The camelCase key its value travels under, one word - e.g. "dish"'
     },
-    target: {
-      type: 'string', nullable: true,
-      description: 'Leave it out - the platform fills it'
-    },
-    question: {
+    label: {
       type: 'string',
-      description: 'The question the gate asks, 3-6 words, in the end user\'s words - e.g. "What\'s'
-        + ' in your pantry?"'
+      description: 'The visible label in the end user\'s words, 2-5 words - e.g. "What are you baking?"'
     },
-    hint: { type: 'string', description: 'A short reassurance beside it, e.g. "No account needed"' },
-    label: {
+    kind: {
       type: 'string',
-      description: 'The accessible name of the group of choices, 2-3 words - e.g. "Your pantry"'
+      enum: LANDING_GATE_FIELD_KINDS,
+      description: 'text (a short line, the default), select (ONE choice out of 2-6 plain options),'
+        + ' number, or date. Nothing else exists: no chips, no toggles, no multiple choice'
     },
-    inputs: {
-      type: 'array',
-      items: { type: 'string' },
-      description: '5 to 8 things a guest can pick, 1-3 words each, from the story\'s own domain.'
-        + ' Nothing personal, nothing sensitive, nothing that needs an account'
+    placeholder: {
+      type: 'string', nullable: true,
+      description: 'text or number only: an example value, e.g. "Rye sourdough". Never personal'
     },
-    selected: {
-      type: 'array',
+    options: {
+      type: 'array', nullable: true,
       items: { type: 'string' },
-      description: '4 or 5 of the inputs above, copied exactly, pre-selected so the first view'
-        + ' already shows results'
+      description: 'select only: 2 to 6 plain options, 1-3 words each'
     },
+  },
+  required: ['name', 'label', 'kind'],
+  additionalProperties: false,
+}
+
+/** What the gate's texts tell the planning model — one place, shared by the answer and stored schemas. */
+const GATE_TEXT = {
+  description: 'The working entry into the key end-user workflow, drawn in the hero instead of the'
+    + ' call-to-action buttons: ONE SMALL FORM - a heading, one to three simple non-sensitive'
+    + ' fields, one button. A guest fills it in, signs in, and continues with what they entered.'
+    + ' No choices to browse, no sample results, no counts, no previews. Every text is in the end'
+    + ' user\'s words',
+  story: 'The code of the landing story, copied EXACTLY as given to you. Never shown',
+  target: 'Leave it out - the platform fills it',
+  question: 'The heading of the form, 3-6 words, in the end user\'s words - e.g. "What are you'
+    + ' baking?"',
+  fields: 'The fields, AS FEW AS POSSIBLE: one whenever one is enough, never more than three. They'
+    + ' are the first things the story\'s own screen asks for, in the same words',
+  cta: 'The button label, a verb first, 2-3 words and an arrow - e.g. "Start my post →"',
+  note: 'One short muted line under the form: no account is needed yet and what was entered comes'
+    + ' along - e.g. "No account needed. What you enter comes with you."',
+}
+
+/** The pre-form keys of a stored gate: optional, described as history, never offered to the model. */
+const LEGACY_GATE_NOTE = 'Pre-form shape, never written'
+
+/**
+ * What the planning MODEL answers for the gate: the form and nothing older. The stored schema below
+ * adds the pre-form keys as optional, so a plan written before the gate became a form still
+ * validates; the model is never offered them.
+ */
+const LandingGateAnswerSchema: JSONSchemaType<LandingGateAnswer> = {
+  type: 'object',
+  title: 'LandingGatePlan',
+  description: GATE_TEXT.description,
+  properties: {
+    story: { type: 'string', description: GATE_TEXT.story },
+    target: { type: 'string', nullable: true, description: GATE_TEXT.target },
+    question: { type: 'string', description: GATE_TEXT.question },
+    fields: { type: 'array', items: LandingGateFieldSchema, description: GATE_TEXT.fields },
+    cta: { type: 'string', description: GATE_TEXT.cta },
+    note: { type: 'string', description: GATE_TEXT.note },
+  },
+  required: ['story', 'question', 'fields', 'cta', 'note'],
+  additionalProperties: false,
+}
+
+/**
+ * The gate as a plan may STORE it: the form, plus the pre-form keys (chips, sample records, a live
+ * count) as optional. A schema that validates a stored document only ever grows optional.
+ */
+const LandingGatePlanSchema: JSONSchemaType<LandingGatePlan> = {
+  type: 'object',
+  title: 'LandingGatePlan',
+  description: GATE_TEXT.description,
+  properties: {
+    story: { type: 'string', description: GATE_TEXT.story },
+    target: { type: 'string', nullable: true, description: GATE_TEXT.target },
+    question: { type: 'string', description: GATE_TEXT.question },
+    fields: { type: 'array', nullable: true, items: LandingGateFieldSchema, description: GATE_TEXT.fields },
+    cta: { type: 'string', description: GATE_TEXT.cta },
+    note: { type: 'string', description: GATE_TEXT.note },
+    hint: { type: 'string', nullable: true, description: LEGACY_GATE_NOTE },
+    label: { type: 'string', nullable: true, description: LEGACY_GATE_NOTE },
+    inputs: { type: 'array', nullable: true, items: { type: 'string' }, description: LEGACY_GATE_NOTE },
+    selected: { type: 'array', nullable: true, items: { type: 'string' }, description: LEGACY_GATE_NOTE },
     results: {
-      type: 'array',
+      type: 'array', nullable: true,
       items: {
         type: 'object',
         properties: {
-          title: { type: 'string', description: 'A realistic record title, 2-4 words' },
-          meta: {
-            type: 'string',
-            description: 'One short line: how well it fits and one fact, e.g. "Uses all 3 · 3 h 20 min"'
-          },
-          needs: {
-            type: 'array',
-            items: { type: 'string' },
-            description: '2-4 of the inputs above, copied exactly, that this record uses'
-          },
+          title: { type: 'string' },
+          meta: { type: 'string' },
+          needs: { type: 'array', items: { type: 'string' } },
         },
         required: ['title', 'meta', 'needs'],
         additionalProperties: false,
       },
-      description: '3 or 4 sample records the picks are ranked against - illustrative, never real data'
+      description: LEGACY_GATE_NOTE
     },
     count: {
-      type: 'object',
+      type: 'object', nullable: true,
       properties: {
-        one: { type: 'string', description: 'The count for one match, with {n}: "{n} bake matches"' },
-        many: { type: 'string', description: 'The count for several, with {n}: "{n} bakes match"' },
-        none: { type: 'string', description: 'The count for none, e.g. "No matches yet"' },
+        one: { type: 'string' },
+        many: { type: 'string' },
+        none: { type: 'string' },
       },
       required: ['one', 'many', 'none'],
       additionalProperties: false,
-      description: 'The live count label; write the literal token {n} where the number goes'
-    },
-    empty: {
-      type: 'string',
-      description: 'One line shown when nothing matches, saying what to pick - e.g. "Pick two or more'
-        + ' ingredients to see what you can bake."'
-    },
-    note: {
-      type: 'string',
-      description: 'One short line beside the button: signing in is by email and the picks come'
-        + ' along - e.g. "Sign in with your email. Your picks come with you."'
-    },
-    cta: {
-      type: 'string',
-      description: 'The button label, a verb first, 2-3 words and an arrow - e.g. "Open recipes →"'
-    },
-    lock: {
-      type: 'string',
-      description: 'What unlocks after sign-in, as the accessible name of a lock icon - e.g. "Full'
-        + ' method after sign-in"'
+      description: LEGACY_GATE_NOTE
     },
+    empty: { type: 'string', nullable: true, description: LEGACY_GATE_NOTE },
+    lock: { type: 'string', nullable: true, description: LEGACY_GATE_NOTE },
   },
-  required: [
-    'story', 'question', 'hint', 'label', 'inputs', 'selected', 'results', 'count', 'empty',
-    'note', 'cta', 'lock',
-  ],
+  required: ['story', 'question', 'cta', 'note'],
   additionalProperties: false,
 }
 
@@ -535,3 +566,28 @@ export const ScaffoldPlanSchema: JSONSchemaType<ScaffoldPlan> = {
   required: ['identity', 'guestHome', 'areas', 'stories', 'motifs'],
   additionalProperties: false,
 }
+
+/**
+ * The plan as the planning MODEL answers it — {@link ScaffoldPlanSchema} with the gate held to the
+ * form. The stored schema keeps the pre-form gate keys optional so an old plan still validates;
+ * offering them to the model would let it write a chip picker again. Typed as the stored plan
+ * because every answer is one: the answer's gate is a subset of the stored gate.
+ */
+export const ScaffoldPlanAnswerSchema = {
+  ...ScaffoldPlanSchema,
+  properties: {
+    ...ScaffoldPlanSchema.properties,
+    guestHome: {
+      ...GuestHomePlanSchema,
+      properties: {
+        ...GuestHomePlanSchema.properties,
+        gate: {
+          ...LandingGateAnswerSchema,
+          nullable: true,
+          description: 'ONLY when you were given a landing story; omit it otherwise. '
+            + LandingGateAnswerSchema.description,
+        },
+      },
+    },
+  },
+} as unknown as JSONSchemaType<ScaffoldPlan>

package/src/scaffold/types.ts

@@ -119,42 +119,83 @@ export interface BentoFragment {
   rows: { label: string, value?: string }[]
 }
 
+/**
+ * What kind of control a landing-gate field is. A CLOSED set of the simplest native inputs: each
+ * value is one plain element, so there is nothing here a visitor has to learn, and nothing that
+ * can grow into a picker, a chip group or a preview.
+ */
+export type LandingGateFieldKind = 'text' | 'select' | 'number' | 'date'
+
+/** One simple, non-sensitive field of the landing gate. */
+export interface LandingGateField {
+  /** The camelCase key the entered value travels under in the landing handoff: "dish". */
+  name: string
+  /** The visible label, in the end user's words: "What are you baking?". */
+  label: string
+  kind: LandingGateFieldKind
+  /** An example value shown inside an empty text or number field — never a personal one. */
+  placeholder?: string
+  /** `select` only: 2–6 plain options. */
+  options?: string[]
+}
+
 /**
  * The landing gate — the working entry into the product's key END-USER workflow, drawn in the
  * hero where the call-to-action pills would otherwise be.
  *
- * A guest makes a few non-sensitive choices on the landing page, sees sample results ranked
- * against them, and signs in to continue on the story's full-scale screen with those choices
- * carried over. Every field is copy or sample data in the end user's own words; nothing here is
- * an address the model invented — `target` is filled by code.
+ * A guest fills in one to three simple non-sensitive fields on the landing page and signs in to
+ * continue on the story's full-scale screen with what they entered already in place. It is a small
+ * form and nothing more: no choices to browse, no sample results, no counts. Every text is copy in
+ * the end user's own words; nothing here is an address the model invented — `target` is filled by
+ * code.
+ *
+ * The keys after `note` are the shape a plan had before the gate became a form (chips, sample
+ * records, a live count). They stay so a plan STORED under the old shape still validates and
+ * still reads; nothing writes them and nothing draws from them, and a gate that carries no
+ * `fields` is drawn as no gate at all.
  */
 export interface LandingGatePlan {
   /** The key end-user story's code — never rendered. */
   story: string
   /** Entrypoint ALIAS of the story's full-scale screen in the user area (filled by code, not the model). */
   target?: string
-  /** The question the gate asks, in the end user's words: "What's in your pantry?". */
+  /** The heading of the form, in the end user's words: "What are you baking?". */
   question: string
-  /** The reassurance beside it: "No account needed". */
-  hint: string
-  /** The accessible name of the chip group: "Your pantry". */
-  label: string
-  /** 5–8 chip labels the guest picks from. */
-  inputs: string[]
-  /** 4–5 of `inputs`, pre-selected so the first view already shows results. */
-  selected: string[]
-  /** 3–4 sample records; `needs` is the subset of `inputs` each one uses. */
-  results: { title: string, meta: string, needs: string[] }[]
-  /** The live count label; `{n}` is replaced by the number ("{n} bakes match"). */
-  count: { one: string, many: string, none: string }
-  /** The line shown when nothing matches the picks. */
-  empty: string
-  /** The line beside the CTA: "Sign in with your email. Your picks come with you.". */
+  /** The fields, one to three — one whenever one is enough. Absent only on a plan stored under the old shape. */
+  fields?: LandingGateField[]
+  /** The one button's label: "Start my post →". */
+  cta: string
+  /** The muted line under the form: "No account needed. What you enter comes with you.". */
   note: string
-  /** The CTA label: "Open recipes →". */
+  /** @deprecated Pre-form shape, kept for stored plans only. */
+  hint?: string
+  /** @deprecated Pre-form shape, kept for stored plans only. */
+  label?: string
+  /** @deprecated Pre-form shape, kept for stored plans only. */
+  inputs?: string[]
+  /** @deprecated Pre-form shape, kept for stored plans only. */
+  selected?: string[]
+  /** @deprecated Pre-form shape, kept for stored plans only. */
+  results?: { title: string, meta: string, needs: string[] }[]
+  /** @deprecated Pre-form shape, kept for stored plans only. */
+  count?: { one: string, many: string, none: string }
+  /** @deprecated Pre-form shape, kept for stored plans only. */
+  empty?: string
+  /** @deprecated Pre-form shape, kept for stored plans only. */
+  lock?: string
+}
+
+/**
+ * The gate as the planning MODEL answers it: the form, and none of the pre-form keys. Assignable
+ * to {@link LandingGatePlan}, which is what a plan stores.
+ */
+export interface LandingGateAnswer {
+  story: string
+  target?: string
+  question: string
+  fields: LandingGateField[]
   cta: string
-  /** The accessible name of a result row's lock icon: "Full method after sign-in". */
-  lock: string
+  note: string
 }
 
 /** The guest area's landing page — the product's public face. */

package/src/skills/consts.ts

@@ -85,115 +85,3 @@ export enum ViableSkill {
   LibrariesAi = 'libraries-ai',
   LibrariesGame = 'libraries-game',
 }
-
-/**
- * Sort weights. Skills render in this order inside the cached block, so the sequence is
- * part of the cache key — reordering them invalidates every prefix at once. Grouped in
- * tens to leave room for a consumer's own skills between them.
- */
-export const SKILL_ORDER: Record<ViableSkill, number> = {
-  [ViableSkill.OutputSourceOnly]: 10,
-  [ViableSkill.OutputTextOnly]: 10,
-  [ViableSkill.ScopeDiscipline]: 15,
-  [ViableSkill.MainFlowFocus]: 12,
-  [ViableSkill.NonTypescriptOutput]: 18,
-  [ViableSkill.TsStyle]: 20,
-  [ViableSkill.TsImports]: 30,
-  [ViableSkill.ReactComponents]: 40,
-  [ViableSkill.OwlMeansEntrypoints]: 41,
-  [ViableSkill.OwlMeansNav]: 42,
-  [ViableSkill.PermissionModel]: 43,
-  [ViableSkill.ShadcnUi]: 44,
-  [ViableSkill.OwlmeansState]: 50,
-  [ViableSkill.FormFeedback]: 51,
-  [ViableSkill.StoreAccess]: 52,
-  [ViableSkill.ViewModelNaming]: 55,
-  // After the frontend rules it builds on (entrypoints, nav, shadcn, form feedback, the store), and
-  // before the backend block — it is only ever carried by analysis and frontend personas.
-  [ViableSkill.LandingGate]: 56,
-  // Analysis and frontend read it the same way LandingGate is read — after the frontend rules it
-  // references (nav, shadcn) — and a backend coder reads it as a server-side check, so it sits
-  // just ahead of the backend block for either audience.
-  [ViableSkill.MarketingConsent]: 57,
-  [ViableSkill.ResourceLayer]: 60,
-  [ViableSkill.ResourceResults]: 62,
-  [ViableSkill.ResourceMigrations]: 64,
-  [ViableSkill.OwlMeansServer]: 70,
-  [ViableSkill.OwlmeansContext]: 65,
-  [ViableSkill.OwlMeansServices]: 66,
-  [ViableSkill.FixerHeuristics]: 75,
-  [ViableSkill.ProjectLayout]: 5,
-  [ViableSkill.AgentTooling]: 8,
-  [ViableSkill.QueueDiscipline]: 67,
-  [ViableSkill.WorkerJobs]: 68,
-  [ViableSkill.TargetAgents]: 69,
-  [ViableSkill.AgenticChoice]: 71,
-  [ViableSkill.TargetLlm]: 72,
-  [ViableSkill.TargetAgentTools]: 73,
-  [ViableSkill.GameDesign]: 45,
-  [ViableSkill.GameScene]: 46,
-  [ViableSkill.GameUi]: 47,
-  [ViableSkill.GameNetworking]: 48,
-  [ViableSkill.LayoutDefinition]: 80,
-  [ViableSkill.ScreenDefinition]: 82,
-  [ViableSkill.LibrariesCommon]: 90,
-  [ViableSkill.LibrariesUiState]: 90,
-  [ViableSkill.LibrariesUi]: 90,
-  [ViableSkill.LibrariesBackend]: 90,
-  [ViableSkill.LibrariesAi]: 90,
-  [ViableSkill.LibrariesGame]: 90,
-}
-
-/**
- * The catalogue entries whose subject a PUBLISHED `@owlmeans` package already documents.
- *
- * The catalogue and `agent-meta/skills/*` state the same contract twice — the P1 duplication —
- * and the duplication is not symmetric: a package skill is versioned with the package and reaches
- * a prompt through `owlmeansPackagesPlugin` whenever the request names that package, while a
- * catalogue entry is a constant here that has to be edited by hand every time the framework moves.
- *
- * Naming the overlap is what makes it a DATA decision instead of a code one. A blueprint lists
- * which of these its prompts carry, and a persona's skills are filtered against that list — so
- * dropping one is a line in a blueprint, and restoring it is the same line. Everything NOT in this
- * set is viable's own (output discipline, scope, the view-model convention, the fixer heuristics,
- * where files live) and always loads, because no published package documents it.
- *
- * The default blueprint currently lists every one of them: the reduction is a real change to what
- * a coder is told, and it is measured against a green end-to-end baseline rather than guessed.
- */
-export const FRAMEWORK_OWNED_SKILLS: ViableSkill[] = [
-  ViableSkill.ResourceLayer,
-  ViableSkill.ResourceResults,
-  ViableSkill.ResourceMigrations,
-  ViableSkill.OwlmeansContext,
-  ViableSkill.OwlMeansServices,
-  ViableSkill.OwlMeansServer,
-  ViableSkill.OwlMeansEntrypoints,
-  ViableSkill.OwlMeansNav,
-  ViableSkill.PermissionModel,
-  ViableSkill.OwlmeansState,
-  ViableSkill.StoreAccess,
-  ViableSkill.ShadcnUi,
-  ViableSkill.ReactComponents,
-  ViableSkill.FormFeedback,
-]
-
-const FRAMEWORK_OWNED = new Set<ViableSkill>(FRAMEWORK_OWNED_SKILLS)
-
-/**
- * Filter a persona's skills against what a blueprint asks for.
- *
- * A skill nobody owns always survives. A framework-owned one survives only while the blueprint
- * lists it — so a blueprint built on another persistence layer stops teaching the Postgres
- * resource contract without anybody editing a persona, and a blueprint that lists nothing at all
- * (the shape a test builds) is read as "everything", because an empty allow-list almost always
- * means "not stated" rather than "none".
- */
-export const skillsForBlueprint = (
-  skills: ViableSkill[], allowed?: ViableSkill[]
-): ViableSkill[] => {
-  if (allowed == null || allowed.length === 0) return skills
-  const permitted = new Set(allowed)
-
-  return skills.filter(skill => !FRAMEWORK_OWNED.has(skill) || permitted.has(skill))
-}

package/src/skills/index.ts

@@ -1,4 +1,3 @@
 
 export * from './consts.js'
-export * from './catalogue.js'
 export * from './roles.js'