@owlmeans/viable-common 0.0.33 → 0.0.35

package/src/ba/schemas.ts

@@ -1,196 +0,0 @@
-
-import type { JSONSchemaType } from "ajv"
-import type { EntityList, StoryList, Entity, Attribute, MainStoryProbability, MainStoryCandidates, ConnectingStoryDraft, ConnectingStoryList } from "./types.js"
-import type { StoryDraft } from "../areas/types.js"
-import { ProjectArea } from "../areas/consts.js"
-import { ConnectingStoryKind } from "./consts.js"
-
-/**
- * The one rendering of the area field's description.
- *
- * Every schema that carries an area points at this. Two copies drift, and the drift is invisible:
- * both schemas keep validating, and the two prompts that read them start classifying differently.
- * It is the same reason `AREA_CLASSIFICATION` is spelled once in the BA helper.
- */
-const AREA_FIELD_DESCRIPTION = `
-      Which area of the application the acting user works in:
-- guest - the actor is NOT signed in (public visitors, prospects, anonymous readers)
-- user - the actor is a signed-in end user consuming the product's value (the front office)
-- operator - the actor is staff running the product's business process from the inside (the back office)
-- admin - the actor is the owner configuring or managing the application itself
-      `
-
-const STORY_BODY_DESCRIPTION =
-  "User story body in format: As a [role], I want to [make something] so that [I get the following results]"
-
-export const StoryDraftSchema: JSONSchemaType<StoryDraft> = {
-  type: "object",
-  title: "StoryDraft",
-  description: "One user story and the area of the application its actor works in",
-  properties: {
-    story: {
-      type: "string",
-      description: STORY_BODY_DESCRIPTION
-    },
-    area: {
-      type: "string",
-      enum: Object.values(ProjectArea),
-      description: AREA_FIELD_DESCRIPTION
-    },
-  },
-  required: ["story", "area"],
-  additionalProperties: false
-}
-
-export const ConnectingStoryDraftSchema: JSONSchemaType<ConnectingStoryDraft> = {
-  type: "object",
-  title: "ConnectingStoryDraft",
-  description: "One user story that connects the numbered steps of the main flow to each other",
-  properties: {
-    story: {
-      type: "string",
-      description: STORY_BODY_DESCRIPTION
-    },
-    area: {
-      type: "string",
-      enum: Object.values(ProjectArea),
-      description: AREA_FIELD_DESCRIPTION
-    },
-    kind: {
-      type: "string",
-      enum: Object.values(ConnectingStoryKind),
-      description: `
-      Which connecting screen this story is:
-- queue - the list of records waiting for THIS actor to perform their step on them
-- index - the directory of a kind of record, where the actor finds and opens the one they mean
-- record - the page of ONE record: everything that has happened to it, and the actions that start from it
-- tracker - the actor's own list of what they submitted, and what state each one has reached
-      `
-    },
-    after: {
-      type: "integer",
-      minimum: 1,
-      description: "The NUMBER of the flow user story whose result this story displays - this story belongs immediately after that one. Never 0, and never greater than the number of flow stories given"
-    },
-  },
-  required: ["story", "area", "kind", "after"],
-  additionalProperties: false
-}
-
-export const ConnectingStoryListSchema: JSONSchemaType<ConnectingStoryList> = {
-  type: "object",
-  title: "ConnectingStoryList",
-  description: "User stories that connect the numbered steps of the main flow to each other",
-  properties: {
-    stories: {
-      type: "array",
-      items: ConnectingStoryDraftSchema,
-      description: "The connecting stories, each anchored to the flow story it comes after"
-    },
-  },
-  required: ["stories"]
-}
-
-export const EntityListSchema: JSONSchemaType<EntityList> = {
-  type: "object",
-  title: "EntityList",
-  description: "Domain entities",
-  properties: {
-    entities: {
-      type: "array",
-      items: { 
-        type: "string",
-        description: "Domain entity name, only alphanumeric characters are allowed no more than 2 words"
-      },
-      description: "List of domain entities"
-    },
-  },
-  required: ["entities"]
-}
-
-export const StoryListSchema: JSONSchemaType<StoryList> = {
-  type: "object",
-  title: "StoryList",
-  description: "User stories",
-  properties: {
-    stories: {
-      type: "array",
-      items: StoryDraftSchema,
-      description: "List of user stories IN FLOW ORDER - the order of the numbered steps they were taken from"
-    },
-  },
-  required: ["stories"]
-}
-
-export const AttributeSchema: JSONSchemaType<Attribute> = {
-  type: "object",
-  title: "Attribute",
-  description: "Entity attribute",
-  properties: {
-    name: {
-      type: "string",
-      description: "Attribute name, should be descriptive and use camelCase"
-    },
-    description: {
-      type: "string",
-      description: "Detailed description of the attribute in the domain entity"
-    }
-  },
-  required: ["name", "description"],
-  additionalProperties: false,
-}
-
-export const EntitySchema: JSONSchemaType<Entity> = {
-  type: "object",
-  title: "Entity",
-  description: "Domain entity with attributes",
-  properties: {
-    name: {
-      type: "string",
-      description: "Entity name, should be descriptive and use PascalCase"
-    },
-    description: {
-      type: "string",
-      description: "Detailed description of the entity and its role in the domain"
-    },
-    attributes: {
-      type: "array",
-      items: AttributeSchema,
-      description: "List of entity attributes"
-    }
-  },
-  required: ["name", "description", "attributes"],
-  additionalProperties: false,
-}
-
-export const MainStoryProbabilitySchema: JSONSchemaType<MainStoryProbability> = {
-  type: "object",
-  title: "MainStoryProbability",
-  description: "Probability that the user story describes main action on the home screen",
-  properties: {
-    story: {
-      type: "string",
-      description: "Exact user story text copied from input"
-    },
-    probability: {
-      type: "number",
-      description: "Probability scroe — from 0 to 10 — that the user story describes main action on the home screen if we compare with other stories"
-    }
-  },
-  required: ["story", "probability"],
-  additionalProperties: false,
-}
-
-export const MainStoryCandidatesSchema: JSONSchemaType<MainStoryCandidates> = {
-  type: "object",
-  title: "MainStoryCandidates",
-  description: "List of main story candidates",
-  properties: {
-    candidates: {
-      type: "array",
-      items: MainStoryProbabilitySchema,
-    }
-  },
-  required: ["candidates"],
-  additionalProperties: false,
-}

package/src/blueprint/case.ts

@@ -1,320 +0,0 @@
-import { SubProject } from '../slot/consts.js'
-import { ViableSkill } from '../skills/consts.js'
-import { ViablePersona } from '../skills/roles.js'
-import { aiLibraryList, gameLibraryList } from '../skills/catalogue.js'
-import { LandingGatePreference } from './types.js'
-import type { BlueprintPatch } from './types.js'
-
-/**
- * WHICH KIND of product is being built on a blueprint.
- *
- * A blueprint says what the STACK is — the language, the framework, the topology, the seeds. A
- * case says what is being built ON it, and that is a different question with different consumers:
- * the analyst framing the brief, the architect deciding whether a story needs a queue, the coder
- * choosing which packages it may import.
- *
- * Deliberately NOT a second blueprint. Everything a case has to say is already a blueprint field,
- * so a case is a PATCH and the resolution order stays base → case → per-run overrides. That is
- * also why adding one is a data change: nothing reads `BlueprintCase` except the table below and
- * the prompt that classifies a project into it.
- */
-export enum BlueprintCase {
-  /** A web application whose every feature fits inside a request. No queue, no worker, no agents. */
-  Web = 'web',
-  /** A web application with work that genuinely belongs off the request path. */
-  Scalable = 'scalable',
-  /** The product's value comes from ordered, deterministic model-driven steps. */
-  AiPipeline = 'ai-pipeline',
-  /** The product's value comes from an agent that decides its own path through tools. */
-  AiAgent = 'ai-agent',
-  /** A browser game: a three.js scene with an ordinary React interface over it. */
-  Game = 'game',
-}
-
-/**
- * How a game is played, which decides who owns its state.
- *
- * Recorded beside the case rather than folded into it, because it changes nothing about the
- * dependencies and everything about where the logic goes. `OnlineTurn` is the default for
- * anything multiplayer unless the brief plainly asks for live play — it is the shape that
- * actually builds, and it needs no socket, no tick loop and no reconciliation.
- */
-export enum GameKind {
-  Casual = 'casual',
-  OnlineTurn = 'online-turn',
-  OnlineLive = 'online-live',
-}
-
-export interface BlueprintCaseDefinition {
-  id: BlueprintCase
-  title: string
-  /**
-   * What this case is FOR, as the classifier prompt reads it.
-   *
-   * A pure constant, like every skill body: it lands in a cached prompt region, and one
-   * interpolated byte invalidates the prefix for every project classified after it.
-   */
-  when: string
-  /** Applied between the base blueprint and the run's own overrides. A case is nothing else. */
-  patch: BlueprintPatch
-}
-
-/** What every AI case installs. The langchain peers are declared here, at ONE range. */
-const AI_DEPS = {
-  [SubProject.Backend]: {
-    '@owlmeans/llm': '^0.1.18-rc.37',
-    '@owlmeans/agent': '^0.1.18-rc.38',
-    '@langchain/core': '^1.2.9',
-    '@langchain/anthropic': '^1.5.8',
-    '@langchain/openai': '^1.5.10',
-    '@langchain/langgraph': '^1.4.13',
-    '@langchain/langgraph-checkpoint': '^1.1.5',
-  },
-}
-
-/** The library allow-list a backend persona gets once the AI packages are installed. */
-const AI_LIBRARIES = {
-  [SubProject.Backend]: aiLibraryList,
-  [SubProject.Api]: aiLibraryList,
-  [SubProject.Worker]: aiLibraryList,
-}
-
-/** Skills every AI case adds on top of the blueprint's own. */
-const AI_SKILLS = [
-  ViableSkill.AgenticChoice,
-  ViableSkill.TargetLlm,
-  ViableSkill.LibrariesAi,
-]
-
-/**
- * What the API side is told once a project may have a queue.
- *
- * The endpoint that starts slow work is the PRODUCER, and it is generated by a persona that
- * otherwise has no reason to know a broker exists. Its job alias is declared before it runs
- * (`runtime-declare`), so by the time this coder writes the handler there is something to enqueue
- * onto — and this is what tells it to, instead of doing the work inline behind a request the user
- * is waiting on.
- */
-const PRODUCER_PERSONA_SKILLS = {
-  [ViablePersona.ApiArchitect]: [ViableSkill.QueueDiscipline, ViableSkill.WorkerJobs],
-  [ViablePersona.ApiCoder]: [ViableSkill.WorkerJobs],
-}
-
-/**
- * What the analysis stage is told about a product whose value is a model.
- *
- * The pairing rule is the load-bearing one: an agent holds no permissions and owns no screen, so
- * a story that is the AGENT's work is invisible unless a human story starts it and watches it.
- */
-const AI_PERSONA_SKILLS = {
-  ...PRODUCER_PERSONA_SKILLS,
-  [ViablePersona.BusinessAnalyst]: [ViableSkill.AgenticChoice],
-  [ViablePersona.UxDesigner]: [ViableSkill.AgenticChoice],
-  [ViablePersona.RuntimeArchitect]: [ViableSkill.AgenticChoice, ViableSkill.TargetLlm],
-  [ViablePersona.WorkerCoder]: [
-    ViableSkill.AgenticChoice, ViableSkill.TargetLlm, ViableSkill.LibrariesAi,
-  ],
-}
-
-type PersonaSkills = Partial<Record<ViablePersona, ViableSkill[]>>
-
-/**
- * Join persona-skill maps, UNIONING a persona two maps both name.
- *
- * An object spread would keep only the last map's list for that persona — `BusinessAnalyst`
- * carries `AgenticChoice` in an AI case and `LandingGate` from the gate map, and a spread would
- * silently drop whichever came first.
- */
-const joinPersonaSkills = (...maps: PersonaSkills[]): PersonaSkills => {
-  const out: PersonaSkills = {}
-  for (const map of maps) {
-    for (const [persona, skills] of Object.entries(map)) {
-      const key = persona as ViablePersona
-      out[key] = [...new Set([...(out[key] ?? []), ...(skills ?? [])])]
-    }
-  }
-
-  return out
-}
-
-/**
- * Who has to know the landing-gate pattern in a case that encourages one.
- *
- * The analyst decides whether a story is gate-worthy and plans the gate's copy; the UX designer
- * shapes the full-scale screen that continues what the guest started; the frontend personas draw
- * the gate, write the handoff and read it back. Nobody else touches it.
- */
-const LANDING_GATE_PERSONA_SKILLS: PersonaSkills = {
-  [ViablePersona.BusinessAnalyst]: [ViableSkill.LandingGate],
-  [ViablePersona.UxDesigner]: [ViableSkill.LandingGate],
-  [ViablePersona.LayoutArchitect]: [ViableSkill.LandingGate],
-  [ViablePersona.ComponentArchitect]: [ViableSkill.LandingGate],
-  [ViablePersona.UiViewCoder]: [ViableSkill.LandingGate],
-  [ViablePersona.UiNavCoder]: [ViableSkill.LandingGate],
-}
-
-/** The experience layer of a case whose product usually has a step a guest can begin. */
-const ENCOURAGE_GATE = { landingGate: LandingGatePreference.Encourage }
-
-const GAME_PERSONA_SKILLS = {
-  [ViablePersona.BusinessAnalyst]: [ViableSkill.GameDesign],
-  [ViablePersona.UxDesigner]: [ViableSkill.GameDesign, ViableSkill.GameUi],
-  [ViablePersona.VisualDesigner]: [ViableSkill.GameUi],
-  [ViablePersona.ComponentArchitect]: [ViableSkill.GameScene, ViableSkill.GameUi],
-  [ViablePersona.LayoutArchitect]: [ViableSkill.GameScene, ViableSkill.GameUi],
-  [ViablePersona.UiViewCoder]: [
-    ViableSkill.GameScene, ViableSkill.GameUi, ViableSkill.LibrariesGame,
-  ],
-  [ViablePersona.RuntimeArchitect]: [ViableSkill.GameNetworking],
-  [ViablePersona.WorkerCoder]: [ViableSkill.GameNetworking],
-  [ViablePersona.ApiArchitect]: [ViableSkill.GameNetworking],
-  [ViablePersona.ApiCoder]: [ViableSkill.GameNetworking],
-}
-
-/**
- * The cases the platform ships.
- *
- * Read as a table: the left column is what a prompt has to look like, the right column is what
- * that costs the generated application. Nothing here turns a capability on without also
- * installing what makes it real — a blueprint that promises `agents` over a manifest with no
- * `@owlmeans/agent` in it produces a story that reports success and a library that will not
- * compile.
- */
-export const BLUEPRINT_CASES: Record<BlueprintCase, BlueprintCaseDefinition> = {
-  [BlueprintCase.Web]: {
-    id: BlueprintCase.Web,
-    title: 'Web application',
-    when: `
-Everything the product does fits inside a request: forms, lists, records, search, reports a
-person waits a second for. Nothing has to survive the tab closing, nothing calls a slow third
-party, nothing walks an unbounded set, nothing is scheduled. Most products are this.
-`.trim(),
-    patch: {
-      packages: {
-        capabilities: { postgres: true, kv: false, queue: false, worker: false, agents: false, validation: true, marketingConsent: true },
-        personaSkills: LANDING_GATE_PERSONA_SKILLS,
-      },
-      experience: ENCOURAGE_GATE,
-    },
-  },
-
-  [BlueprintCase.Scalable]: {
-    id: BlueprintCase.Scalable,
-    title: 'Web application with background work',
-    when: `
-Like a web application, except that some named part of it genuinely cannot run inside a request:
-it walks every row a user owns, talks to a slow or rate-limited third party, is scheduled or
-repeated, must survive the tab closing, or must be retried without the user doing anything.
-Choose this only when you can NAME that part; "it might get slow" is not it.
-
-NOT this when the slow part is a MODEL. Background work whose content comes out of a language
-model is one of the two AI kinds below, and choosing this one for it leaves the application unable
-to call a model at all.
-`.trim(),
-    patch: {
-      packages: {
-        capabilities: { postgres: true, kv: true, queue: true, worker: true, agents: false, validation: true, marketingConsent: true },
-        personaSkills: PRODUCER_PERSONA_SKILLS,
-      },
-      // Neutral: the named off-request part is usually operator-side work, and whether a guest
-      // can begin anything is the specification's to say.
-      experience: { landingGate: LandingGatePreference.Allow },
-    },
-  },
-
-  [BlueprintCase.AiPipeline]: {
-    id: BlueprintCase.AiPipeline,
-    title: 'AI pipeline',
-    when: `
-The product's value comes from a language model, and the work it does is a KNOWN sequence:
-transcribe then summarise then file; extract then validate then store; draft then check then send.
-You can name the steps before it runs. The application decides the order; the model performs each
-step.
-
-Any product whose OUTPUT is written by a model is this kind or the one below — never a plain web
-application, and never merely a scalable one.
-`.trim(),
-    patch: {
-      packages: {
-        capabilities: { postgres: true, kv: true, queue: true, worker: true, agents: true, validation: true, marketingConsent: true },
-        deps: AI_DEPS,
-        libraries: AI_LIBRARIES,
-        skills: AI_SKILLS,
-        personaSkills: joinPersonaSkills(AI_PERSONA_SKILLS, LANDING_GATE_PERSONA_SKILLS),
-      },
-      experience: ENCOURAGE_GATE,
-    },
-  },
-
-  [BlueprintCase.AiAgent]: {
-    id: BlueprintCase.AiAgent,
-    title: 'AI agent',
-    when: `
-The product's value comes from a model that decides its own path: how many steps the work takes
-cannot be predicted, and which tool to reach for next is a judgement rather than a rule anyone
-could write down. Choose this over an AI pipeline only when the order genuinely cannot be fixed
-in advance.
-`.trim(),
-    patch: {
-      packages: {
-        capabilities: { postgres: true, kv: true, queue: true, worker: true, agents: true, validation: true, marketingConsent: true },
-        deps: {
-          [SubProject.Backend]: {
-            ...AI_DEPS[SubProject.Backend],
-            '@owlmeans/agent-skills': '^0.1.18-rc.38',
-          },
-        },
-        libraries: AI_LIBRARIES,
-        skills: [...AI_SKILLS, ViableSkill.TargetAgentTools],
-        personaSkills: joinPersonaSkills(AI_PERSONA_SKILLS, LANDING_GATE_PERSONA_SKILLS, {
-          [ViablePersona.WorkerCoder]: [ViableSkill.TargetAgentTools],
-        }),
-      },
-      experience: ENCOURAGE_GATE,
-    },
-  },
-
-  [BlueprintCase.Game]: {
-    id: BlueprintCase.Game,
-    title: 'Browser game',
-    when: `
-The person asked for a GAME, in those words or unmistakably — something played rather than used,
-with a loop, a score or a win condition. Never infer this from "gamified", "playful", "fun" or a
-leaderboard attached to an ordinary product. If the prompt does not plainly ask for a game, this
-is not it.
-`.trim(),
-    patch: {
-      packages: {
-        capabilities: { postgres: true, kv: true, queue: true, worker: true, agents: false, validation: true, marketingConsent: true },
-        deps: {
-          [SubProject.Web]: { three: '^0.186.0', '@types/three': '^0.185.4' },
-        },
-        libraries: { [SubProject.Web]: gameLibraryList, 'ui-state': gameLibraryList },
-        skills: [ViableSkill.GameScene, ViableSkill.GameUi, ViableSkill.LibrariesGame],
-        personaSkills: { ...PRODUCER_PERSONA_SKILLS, ...GAME_PERSONA_SKILLS },
-      },
-      // A game's first value is PLAYING it, and the play screen is its own front door — a
-      // pick-and-preview card on a landing page is the wrong shape for it.
-      experience: { landingGate: LandingGatePreference.Discourage },
-    },
-  },
-}
-
-/**
- * The case a reference names, or `undefined`.
- *
- * Total over anything: an unknown name, a name from a deploy this one does not have, and an
- * absent one all read the same way — no patch, which is the base blueprint. That is the only
- * answer that cannot take a capability away from a project that already has it.
- */
-export const blueprintCaseOf = (name?: string): BlueprintCaseDefinition | undefined =>
-  name == null ? undefined : (BLUEPRINT_CASES as Record<string, BlueprintCaseDefinition>)[name]
-
-/** Every case the platform ships, in the order a classifier should weigh them. */
-export const BLUEPRINT_CASE_ORDER: BlueprintCase[] = [
-  BlueprintCase.Web,
-  BlueprintCase.Scalable,
-  BlueprintCase.AiPipeline,
-  BlueprintCase.AiAgent,
-  BlueprintCase.Game,
-]

package/src/blueprint/resolve.ts

@@ -1,136 +0,0 @@
-import type { ViablePersona } from '../skills/roles.js'
-import type { ViableSkill } from '../skills/consts.js'
-import { blueprintCaseOf } from './case.js'
-import type { Blueprint, BlueprintPatch } from './types.js'
-
-const isPlainObject = (value: unknown): value is Record<string, unknown> =>
-  value != null && typeof value === 'object' && !Array.isArray(value)
-
-/**
- * Merge one layer's override over a resolved value.
- *
- * Objects merge key by key; ARRAYS REPLACE. That asymmetry is deliberate and is the difference
- * between an override and an addition: a blueprint that narrows a library allow-list to three
- * entries means those three, and a concatenating merge would hand the coder back the very imports
- * the override existed to forbid. A layer that wants to add spreads the base itself.
- */
-export const mergeBlueprintValue = <T>(base: T, patch: unknown): T => {
-  if (patch === undefined) return base
-  if (!isPlainObject(base) || !isPlainObject(patch)) return patch as T
-
-  const out: Record<string, unknown> = { ...base }
-  for (const [key, value] of Object.entries(patch)) {
-    if (value === undefined) continue
-    out[key] = mergeBlueprintValue(out[key], value)
-  }
-
-  return out as T
-}
-
-/**
- * Apply an override patch to a blueprint, layer by layer.
- *
- * Frozen on the way out — shallowly at each layer, which is enough to make the accidental
- * `blueprint.packages.capabilities.worker = true` a visible failure rather than a change every
- * later helper silently inherits.
- */
-export const applyBlueprintPatch = (base: Blueprint, patch?: BlueprintPatch): Blueprint => {
-  if (patch == null) return base
-
-  const merged = mergeBlueprintValue(
-    base as unknown as Record<string, unknown>, patch
-  ) as unknown as Blueprint
-
-  return freezeBlueprint(merged)
-}
-
-export const freezeBlueprint = (blueprint: Blueprint): Blueprint => Object.freeze({
-  ...blueprint,
-  technology: Object.freeze({ ...blueprint.technology }),
-  stack: Object.freeze({ ...blueprint.stack }),
-  template: Object.freeze({ ...blueprint.template }),
-  createApp: Object.freeze({ ...blueprint.createApp }),
-  packages: Object.freeze({
-    ...blueprint.packages,
-    capabilities: Object.freeze({ ...blueprint.packages.capabilities }),
-  }),
-  // The one optional layer: frozen when present, and never ADDED when absent, so a blueprint that
-  // has none still compares equal to what it was before the layer existed.
-  ...(blueprint.experience != null ? { experience: Object.freeze({ ...blueprint.experience }) } : {}),
-})
-
-/** Every skill the blueprint asks for, stack first, deduped, order preserved. */
-export const blueprintSkills = (blueprint: Blueprint): Blueprint['stack']['skills'] =>
-  [...new Set([...blueprint.stack.skills, ...blueprint.packages.skills])]
-
-
-const union = <T>(base: readonly T[] = [], extra: readonly T[] = []): T[] =>
-  [...new Set([...base, ...extra])]
-
-/**
- * Apply a CASE to a blueprint — which kind of product is being built on this stack.
- *
- * A case is an ordinary {@link BlueprintPatch} and follows every rule an override does, with two
- * deliberate exceptions: `skills` and `personaSkills` are UNIONED with the base rather than
- * replacing it.
- *
- * The asymmetry is the difference between the two things a patch can be. An override is written
- * by somebody looking at the resolved value and narrowing it — "these three libraries and no
- * others" — and a concatenating merge would hand back the very imports it existed to forbid. A
- * case is written once, in a table, by somebody who cannot see the blueprint it will be applied
- * to; it says what this KIND of product needs IN ADDITION, and replacing there would silently
- * drop every rule the stack itself established. A case that genuinely needs to take a skill away
- * does it by narrowing a capability, which is what stops the prompt being asked at all.
- *
- * Unknown, absent and unregistered case names all resolve to the blueprint unchanged. A project
- * records the case it was drawn with, that record outlives the deploy that knew the name, and
- * "built against the stack as it stands" is a far better answer than a project that cannot open.
- */
-export const applyBlueprintCase = (base: Blueprint, name?: string): Blueprint => {
-  const cased = blueprintCaseOf(name)
-  if (cased == null) return base
-
-  const merged = applyBlueprintPatch(base, cased.patch)
-  const patch = cased.patch
-
-  const personaSkills = patch.packages?.personaSkills
-  const stackSkills = patch.stack?.skills as ViableSkill[] | undefined
-  const packageSkills = patch.packages?.skills as ViableSkill[] | undefined
-
-  return freezeBlueprint({
-    ...merged,
-    stack: { ...merged.stack, skills: union(base.stack.skills, stackSkills) },
-    packages: {
-      ...merged.packages,
-      skills: union(base.packages.skills, packageSkills),
-      ...(personaSkills != null || base.packages.personaSkills != null
-        ? {
-          personaSkills: mergePersonaSkills(base.packages.personaSkills, personaSkills),
-        }
-        : {}),
-    },
-  })
-}
-
-const mergePersonaSkills = (
-  base?: Partial<Record<ViablePersona, ViableSkill[]>>,
-  extra?: Partial<Record<ViablePersona, ViableSkill[]>>,
-): Partial<Record<ViablePersona, ViableSkill[]>> => {
-  const out: Partial<Record<ViablePersona, ViableSkill[]>> = { ...base }
-  for (const [persona, skills] of Object.entries(extra ?? {})) {
-    const key = persona as ViablePersona
-    out[key] = union(out[key], skills as ViableSkill[])
-  }
-
-  return out
-}
-
-/**
- * The skills ONE persona gets from the blueprint, beyond its own.
- *
- * Total, and empty for every persona a blueprint says nothing about — which is every one of them
- * on the blueprint the platform ships. `withPersona` unions this into the policy it composes.
- */
-export const personaSkillsOf = (
-  blueprint: Blueprint, persona: ViablePersona
-): ViableSkill[] => blueprint.packages.personaSkills?.[persona] ?? []

package/src/blueprint/schemas.ts

@@ -1,44 +0,0 @@
-import { BlueprintCase, GameKind } from './case.js'
-
-/**
- * What kind of product a prompt describes.
- *
- * A schema rather than a free answer because the value is a KEY: it is written onto the project
- * record, resolved into a blueprint patch on every run afterwards, and decides which dependencies
- * the tree is staged with. A model that answered "an AI-powered agent app" in prose would leave
- * the caller matching strings, and a miss there is silent — the project simply builds as the
- * default and nobody can say why.
- */
-export interface BlueprintCaseChoice {
-  case: BlueprintCase
-  /** Only meaningful for the game case; ignored everywhere else. */
-  gameKind?: GameKind
-  /** One sentence, from the prompt. Recorded so a later run can disagree with it. */
-  rationale: string
-}
-
-export const BlueprintCaseChoiceSchema = {
-  type: 'object',
-  title: 'BlueprintCaseChoice',
-  description: 'Which kind of application the described product is',
-  properties: {
-    case: {
-      type: 'string',
-      enum: Object.values(BlueprintCase),
-      description: 'The least capable kind that can deliver what was asked for.',
-    },
-    gameKind: {
-      type: 'string',
-      enum: Object.values(GameKind),
-      description: 'Only when the case is `game`. `casual` for one player in one browser, '
-        + '`online-turn` for players acting one after another, `online-live` only when the brief '
-        + 'plainly asks for players acting at the same moment.',
-    },
-    rationale: {
-      type: 'string',
-      description: 'One sentence naming what in the prompt decided it.',
-    },
-  },
-  required: ['case', 'rationale'],
-  additionalProperties: false,
-} as const