@owlmeans/viable-common 0.0.41 → 0.0.42

package/src/blueprint/consts.ts

@@ -34,6 +34,16 @@ export enum BlueprintCase {
   AiAgent = 'ai-agent',
   /** A browser game: a three.js scene with an ordinary React interface over it. */
   Game = 'game',
+  /**
+   * Work management: the product's core is records of work people create and move through
+   * statuses or a pipeline, built on the planning packages. Single organization.
+   */
+  WorkManagement = 'work-management',
+  /**
+   * Work management whose audiences work inside many organizations. Never classified directly:
+   * code picks it from {@link WorkManagement} when the project's tenancy decision has a flag on.
+   */
+  WorkManagementTenanted = 'work-management-tenanted',
 }
 
 /**
@@ -49,3 +59,29 @@ export enum GameKind {
   OnlineTurn = 'online-turn',
   OnlineLive = 'online-live',
 }
+
+/**
+ * Which kind of work a work-management product keeps — read by the planning kit and the analysis.
+ *
+ * Recorded beside the case on the project card (`fields.workKind`), like {@link GameKind}: it
+ * changes no dependency, only which ready-made card types and flows the product starts from.
+ */
+export enum WorkKind {
+  /** Projects broken into tasks or issues moved across stages to done. */
+  Project = 'project',
+  /** Leads, contacts, accounts and opportunities through a sales pipeline. */
+  Crm = 'crm',
+  /** Requests become tickets assigned to agents and worked to resolution. */
+  ServiceDesk = 'service-desk',
+  /** Items and stock across locations; orders and movements through fulfilment stages. */
+  Inventory = 'inventory',
+  /** Candidates and applications through a hiring workflow per opening. */
+  Recruiting = 'recruiting',
+  /** Jobs dispatched to field workers and tracked to completion. */
+  FieldService = 'field-service',
+  /** Requests, approvals or cases through a defined multi-step process. */
+  Process = 'process',
+}
+
+/** The longest case quote a project card keeps (`fields.caseQuote`) — one sentence, generously. */
+export const CASE_QUOTE_MAX = 1024

package/src/blueprint/types.ts

@@ -166,6 +166,13 @@ export interface TemplateLayer {
   patches: BlueprintPatchSpec[]
   /** Overlay subtrees that belong to one role only — the per-package half of a template. */
   perRole?: Partial<Record<SubProject, string>>
+  /**
+   * Case seed directories under the overlay's `.cases/`, copied over the staged tree in order.
+   *
+   * Names, never paths: the host resolves them against the overlay it resolved. A later seed wins
+   * over an earlier one, so a variant lists its base seed first and itself after it.
+   */
+  seeds?: string[]
 }
 
 export interface BlueprintPatchSpec {

package/src/branding.ts

@@ -25,6 +25,9 @@ export const BRANDING_ENV_KEYS = [
  * safe direction — the opposite failure hands out a paid feature and nobody reports getting more
  * than they paid for.
  *
+ * `BRANDING_PRODUCT` is always EMITTED empty: the product's name is the target's own `APP_TITLE`,
+ * stated from the project card, and the slot metadata carries no human-readable name to deliver.
+ *
  * `BRANDING_GOOGLE_TAG` is always EMITTED, empty when no tag is set, although its metadata key is
  * omitted from a push while unset: the environment is read by the application's own build, which
  * treats `''` as "load no tag", while the metadata key is read by a publisher that may predate it.
@@ -35,6 +38,13 @@ export const brandingEnv = (meta: Partial<SlotMetadata>): Record<string, string>
   BRANDING_TERMS_URL: meta.brandingTermsUrl ?? '',
   BRANDING_PRIVACY_URL: meta.brandingPrivacyUrl ?? '',
   BRANDING_CREDIT: meta.brandingCredit === '' ? '' : '1',
-  BRANDING_PRODUCT: meta.projectName ?? '',
+  // Never `projectName`. That is the project's ALIAS — a lowercase slug the OIDC client id, the
+  // key namespace and the address are composed from — and a build that took it for the product's
+  // name put `slopepact` in the tab, the manifest and the legal pages beside a header saying
+  // `SlopePact`. The human-readable name is the project card's title, which the platform states in
+  // the target's own `APP_TITLE`; every page reads that, and the build falls back to it whenever
+  // this is empty. The key stays, always emitted, so a bundle never carries a bare `process.env`
+  // read — and so an explicit override still has somewhere to arrive.
+  BRANDING_PRODUCT: '',
   BRANDING_GOOGLE_TAG: meta.brandingGoogleTag ?? '',
 })

package/src/connect/consts.ts

@@ -394,6 +394,14 @@ export const connect = Object.freeze({
     attach: 'viable:manager-api:connect:project:attach',
     reinit: 'viable:manager-api:connect:project:reinit',
     modify: 'viable:manager-api:connect:project:modify',
+    /**
+     * Planning kits — ready sets of card types and status flows the platform writes into a
+     * target's common package (`describe` lists them, `apply` writes one and rebuilds the slot).
+     */
+    kit: Object.freeze({
+      describe: 'viable:manager-api:connect:project:kit:describe',
+      apply: 'viable:manager-api:connect:project:kit:apply',
+    }),
     /**
      * The project's own branding — copyright, organization, the two legal links, the Google tag.
      * The platform credit is deliberately NOT here: hiding it is a paid capability with its own

package/src/connect/entrypoints.ts

@@ -3,7 +3,7 @@ import { route, RouteMethod } from '@owlmeans/route'
 import { connect } from './consts.js'
 import {
   ConnectAttachBodySchema, ConnectConfirmBodySchema, ConnectConvertCreateBodySchema,
-  ConnectConvertProceedBodySchema, ConnectCreateBodySchema, ConnectInquiryParamsSchema,
+  ConnectConvertProceedBodySchema, ConnectCreateBodySchema, ConnectInquiryParamsSchema, ConnectKitApplyBodySchema,
   ConnectModifyBodySchema, ConnectOpParamsSchema, ConnectOpResultSchema,
   ConnectPipelineParamsSchema, ConnectPipelineResumeBodySchema, ConnectProjectBrandingSaveSchema,
   ConnectProjectIdSchema, ConnectSessionOpenSchema, ConnectSessionParamsSchema, ConnectPullQuerySchema,
@@ -11,7 +11,8 @@ import {
 } from './schemas.js'
 import type {
   ConnectAttachBody, ConnectConfirmBody, ConnectConvertCreateBody, ConnectConvertProceedBody,
-  ConnectCreateBody, ConnectInquiryAnswerBody, ConnectModifyBody,
+  ConnectCreateBody, ConnectInquiryAnswerBody, ConnectKitApplyBody, ConnectKitApplyResult, ConnectKitDescribe,
+  ConnectModifyBody,
   ConnectPipelineParams, ConnectPipelineResumeBody, ConnectProjectBranding,
   ConnectProjectBrandingSave, ConnectSessionOpen,
   ConnectPipelineState, ConnectProjectStatus, ConnectPullQuery, ConnectSessionParams,
@@ -143,6 +144,24 @@ export const connectProtocols = (opts: ConnectEntrypointOptions) => {
       }),
       contract.request({ params: typed<{ id: string }>(ConnectProjectIdSchema), body: typed<ConnectModifyBody>(ConnectModifyBodySchema) }, typed<ConnectProjectStatus>())
     ),
+    // Planning kits: one path, read and applied under the owned base like every project route.
+    kit: {
+      describe: protocol(
+        route(connect.project.kit.describe, '/project/:id/kits', {
+          parent: base, method: RouteMethod.GET,
+        }),
+        contract.request({ params: typed<{ id: string }>(ConnectProjectIdSchema) }, typed<ConnectKitDescribe>()),
+      ),
+      apply: protocol(
+        route(connect.project.kit.apply, '/project/:id/kits', {
+          parent: base, method: RouteMethod.POST,
+        }),
+        contract.request({
+          params: typed<{ id: string }>(ConnectProjectIdSchema),
+          body: typed<ConnectKitApplyBody>(ConnectKitApplyBodySchema),
+        }, typed<ConnectKitApplyResult>()),
+      ),
+    },
     // Under `base` like every sibling — the guard and the ownership gate — and never under the
     // paid gate: saving branding is free, and the paid credit switch is not reachable from here.
     branding: {

package/src/connect/references.ts

@@ -5,7 +5,8 @@ import { connect } from './consts.js'
 import type { ConnectOp, ConnectOpResult } from './ops.js'
 import type {
   ConnectAttachBody, ConnectConfirmBody, ConnectCreateBody, ConnectConvertCreateBody,
-  ConnectConvertProceedBody, ConnectInquiryAnswerBody, ConnectModifyBody, ConnectOpSubmission,
+  ConnectConvertProceedBody, ConnectInquiryAnswerBody, ConnectKitApplyBody, ConnectKitApplyResult,
+  ConnectKitDescribe, ConnectModifyBody, ConnectOpSubmission,
   ConnectPipelineParams, ConnectPipelineResumeBody, ConnectPipelineState, ConnectProjectBranding,
   ConnectProjectBrandingSave, ConnectProjectStatus, ConnectProjectSummary, ConnectPullQuery,
   ConnectSessionOpen, ConnectSessionParams, ConnectSessionView, ConnectStoryStatus,
@@ -35,6 +36,10 @@ export interface ConnectReferences {
     attach: ConnectReference<{ body: ConnectAttachBody }, ConnectProjectStatus>
     reinit: ConnectReference<{ params: { id: string } }, ConnectProjectStatus>
     modify: ConnectReference<{ params: { id: string }, body: ConnectModifyBody }, ConnectProjectStatus>
+    kit: {
+      describe: ConnectReference<{ params: { id: string } }, ConnectKitDescribe>
+      apply: ConnectReference<{ params: { id: string }, body: ConnectKitApplyBody }, ConnectKitApplyResult>
+    }
     branding: {
       get: ConnectReference<{ params: { id: string } }, ConnectProjectBranding>
       save: ConnectReference<{
@@ -96,6 +101,12 @@ export const connectRef: ConnectReferences = {
     attach: entrypointRef<{ body: ConnectAttachBody }, ConnectProjectStatus>(connect.project.attach),
     reinit: entrypointRef<{ params: { id: string } }, ConnectProjectStatus>(connect.project.reinit),
     modify: entrypointRef<{ params: { id: string }, body: ConnectModifyBody }, ConnectProjectStatus>(connect.project.modify),
+    kit: {
+      describe: entrypointRef<{ params: { id: string } }, ConnectKitDescribe>(connect.project.kit.describe),
+      apply: entrypointRef<{
+        params: { id: string }, body: ConnectKitApplyBody
+      }, ConnectKitApplyResult>(connect.project.kit.apply),
+    },
     branding: {
       get: entrypointRef<{ params: { id: string } }, ConnectProjectBranding>(connect.project.branding.get),
       save: entrypointRef<{

package/src/connect/schemas.ts

@@ -11,7 +11,8 @@ import type {
   ConnectAttachBody, ConnectConfirmBody, ConnectConvertCreateBody, ConnectConvertProceedBody,
   ConnectCreateBody, ConnectLlmBody, ConnectModifyBody, ConnectPipelineParams,
   ConnectPipelineResumeBody, ConnectProjectBrandingSave, ConnectProjectLlmBody, ConnectSession,
-  ConnectSessionOpen, ConnectPullQuery, ConnectSessionParams
+  ConnectSessionOpen, ConnectPullQuery, ConnectSessionParams, ConnectKitApplyBody, ConnectKitApplyResult,
+  ConnectKitDescribe, PlanningKitView
 } from './types.js'
 
 /**
@@ -202,6 +203,91 @@ export const ConnectModifyBodySchema = {
   additionalProperties: false,
 } as JSONSchemaType<ConnectModifyBody>
 
+const kitKey = { type: 'string', minLength: 1, maxLength: 128 } as const
+const kitText = { type: 'string', maxLength: 4096 } as const
+const kitStrings = { type: 'array', items: kitKey, maxItems: 256 } as const
+
+/** A planning kit as `project.kit.describe` lists it. Closed, like every view this package pins. */
+export const PlanningKitViewSchema = {
+  type: 'object',
+  properties: {
+    id: kitKey,
+    kind: kitKey,
+    title: kitText,
+    purpose: kitText,
+    container: {
+      type: 'object',
+      properties: { key: kitKey, label: kitText },
+      required: ['key', 'label'],
+      additionalProperties: false,
+    },
+    types: {
+      type: 'array',
+      maxItems: 256,
+      items: {
+        type: 'object',
+        properties: { key: kitKey, label: kitText, flow: kitKey },
+        required: ['key', 'label', 'flow'],
+        additionalProperties: false,
+      },
+    },
+    flows: {
+      type: 'array',
+      maxItems: 256,
+      items: {
+        type: 'object',
+        properties: {
+          key: kitKey,
+          label: kitText,
+          statuses: {
+            type: 'array',
+            maxItems: 256,
+            items: {
+              type: 'object',
+              properties: { key: kitKey, label: kitText, intrinsic: kitKey },
+              required: ['key', 'label', 'intrinsic'],
+              additionalProperties: false,
+            },
+          },
+        },
+        required: ['key', 'label', 'statuses'],
+        additionalProperties: false,
+      },
+    },
+  },
+  required: ['id', 'kind', 'title', 'purpose', 'container', 'types', 'flows'],
+  additionalProperties: false,
+} as unknown as JSONSchemaType<PlanningKitView>
+
+export const ConnectKitDescribeSchema = {
+  type: 'object',
+  properties: { kits: { type: 'array', items: PlanningKitViewSchema, maxItems: 64 } },
+  required: ['kits'],
+  additionalProperties: false,
+} as unknown as JSONSchemaType<ConnectKitDescribe>
+
+/** `types` keeps only these card-type keys of the kit; omitted (or `null`) keeps every type. */
+export const ConnectKitApplyBodySchema = {
+  type: 'object',
+  properties: {
+    kit: kitKey,
+    types: { ...kitStrings, nullable: true },
+  },
+  required: ['kit'],
+  additionalProperties: false,
+} as unknown as JSONSchemaType<ConnectKitApplyBody>
+
+export const ConnectKitApplyResultSchema = {
+  type: 'object',
+  properties: {
+    applied: kitStrings,
+    skipped: kitStrings,
+    warnings: { type: 'array', items: kitText, maxItems: 256 },
+  },
+  required: ['applied', 'skipped', 'warnings'],
+  additionalProperties: false,
+} as unknown as JSONSchemaType<ConnectKitApplyResult>
+
 export const ConnectAttachBodySchema = {
   type: 'object',
   properties: {

package/src/connect/types.ts

@@ -409,3 +409,58 @@ export interface ConnectPipelineState {
   heartbeatAt: string
   updatedAt: string
 }
+
+/** One status of a planning kit's flow. `intrinsic` is the planning intrinsic it maps to. */
+export interface PlanningKitStatusView {
+  key: string
+  label: string
+  intrinsic: string
+}
+
+/** One status flow a planning kit declares. */
+export interface PlanningKitFlowView {
+  key: string
+  label: string
+  statuses: PlanningKitStatusView[]
+}
+
+/** One card type a planning kit declares; `flow` is the key of its main flow. */
+export interface PlanningKitTypeView {
+  key: string
+  label: string
+  flow: string
+}
+
+/**
+ * A planning kit as a connector sees it: a ready set of card types and status flows for one kind
+ * of work-management product, written into the target's common package on `apply`.
+ */
+export interface PlanningKitView {
+  id: string
+  /** The work kind the kit serves — a bare string, so a newer kind never fails an older reader. */
+  kind: string
+  title: string
+  purpose: string
+  /** The project-level container type the kit's cards live in. */
+  container: { key: string, label: string }
+  types: PlanningKitTypeView[]
+  flows: PlanningKitFlowView[]
+}
+
+/** What `project.kit.describe` answers. */
+export interface ConnectKitDescribe {
+  kits: PlanningKitView[]
+}
+
+/** Apply one kit; `types` keeps only these card-type keys of it (every type when omitted). */
+export interface ConnectKitApplyBody {
+  kit: string
+  types?: string[]
+}
+
+/** What `project.kit.apply` answers: the type keys written, those left out, and warnings. */
+export interface ConnectKitApplyResult {
+  applied: string[]
+  skipped: string[]
+  warnings: string[]
+}

package/src/planning/schemas.ts

@@ -2,6 +2,7 @@ import type { JSONSchemaType } from 'ajv'
 import { CODE_MAX } from '@owlmeans/planning'
 import { ProjectArea } from '../areas/consts.js'
 import { TENANCY_QUOTE_MAX } from '../areas/tenancy.js'
+import { CASE_QUOTE_MAX, WorkKind } from '../blueprint/consts.js'
 import { StoryKind } from '../ba/consts.js'
 import { ConnectLlm, ConnectTarget } from '../connect/consts.js'
 import { ProjectOriginSchema } from '../convert/schemas.js'
@@ -25,6 +26,8 @@ export const ViableProjectFieldsSchema = {
     blueprint: { type: 'string', minLength: 1, maxLength: 64, nullable: true },
     blueprintCase: { type: 'string', minLength: 1, maxLength: 64, nullable: true },
     gameKind: { type: 'string', minLength: 1, maxLength: 64, nullable: true },
+    workKind: { type: 'string', enum: [...Object.values(WorkKind), null], nullable: true },
+    caseQuote: { type: 'string', minLength: 1, maxLength: CASE_QUOTE_MAX, nullable: true },
     target: { type: 'string', enum: [...Object.values(ConnectTarget), null], nullable: true },
     origin: { ...ProjectOriginSchema, nullable: true },
     connectLlmMode: { type: 'string', enum: [...Object.values(ConnectLlm), null], nullable: true },

package/src/planning/types.ts

@@ -1,5 +1,6 @@
 import type { Card, Project, Specification } from '@owlmeans/planning'
 import type { ProjectArea } from '../areas/consts.js'
+import type { WorkKind } from '../blueprint/consts.js'
 import type { ViableTenancyDecision } from '../areas/tenancy.js'
 import type { StoryKind } from '../ba/consts.js'
 import type { ConnectLlm, ConnectTarget } from '../connect/consts.js'
@@ -25,6 +26,10 @@ export type ViableProjectFields = {
   blueprintCase?: string
   /** How a game is played; absent for every other case. */
   gameKind?: string
+  /** Which kind of work a work-management product keeps; absent for every other case. */
+  workKind?: WorkKind
+  /** The requester's sentence the work-management case was verified against. */
+  caseQuote?: string
   /** Where the tree lives; absent is the platform's own slot. */
   target?: ConnectTarget
   /** Where converted code came from; present only on an import. */

package/src/slot/consts.ts

@@ -37,8 +37,24 @@ export enum SlotCommandType {
   Files = 'files',
   Shell = 'shell',
   Git = 'git',
+  Database = 'database',
 }
 
+/** Inspection of the live dev database; mutations belong in target source migrations. */
+export enum SlotDatabaseCommand {
+  Info = 'databaseInfo',
+  Query = 'databaseQuery',
+}
+
+export const DATABASE_READ_LIMITS = {
+  defaultRows: 100,
+  maxRows: 1000,
+  maxBytes: 131_072,
+  maxQueryChars: 16_000,
+  maxParams: 100,
+  timeoutMs: 10_000,
+} as const
+
 export enum SlotGitCommand {
   Ensure = 'ensure',
   /**
@@ -306,6 +322,7 @@ export const COMMAND_TIMEOUTS: Partial<Record<SlotCommandType, number>> = {
   [SlotCommandType.Files]: 60_000,
   [SlotCommandType.Git]: 120_000,
   [SlotCommandType.Shell]: 1_200_000,
+  [SlotCommandType.Database]: 45_000,
 }
 
 export const DEFAULT_COMMAND_TIMEOUT = 60_000
@@ -356,6 +373,7 @@ const perCommandTimeout = (type: SlotCommandType, command: string): number | und
   switch (type) {
     case SlotCommandType.Shell: return SHELL_COMMAND_TIMEOUTS[command]
     case SlotCommandType.Git: return GIT_COMMAND_TIMEOUTS[command as SlotGitCommand]
+    case SlotCommandType.Database: return COMMAND_TIMEOUTS[SlotCommandType.Database]
     default: return FILE_COMMAND_TIMEOUTS[command as SlotFileCommand]
   }
 }
@@ -387,6 +405,8 @@ export const commandDeadline = (type: SlotCommandType, command: string): number
       return COMMAND_DEADLINES[command] ?? DEFAULT_COMMAND_DEADLINE
     case SlotCommandType.Git:
       return GIT_COMMAND_DEADLINES[command as SlotGitCommand] ?? DEFAULT_GIT_COMMAND_DEADLINE
+    case SlotCommandType.Database:
+      return 30_000
     default:
       return FILE_COMMAND_DEADLINES[command as SlotFileCommand] ?? DEFAULT_FILE_COMMAND_DEADLINE
   }

package/src/slot/schemas.ts

@@ -1,5 +1,5 @@
 import type { JSONSchemaType } from 'ajv'
-import { SlotCommandType, SlotFileCommand, SlotGitCommand, SlotShellCommand } from './consts.js'
+import { SlotCommandType, SlotDatabaseCommand, SlotFileCommand, SlotGitCommand, SlotShellCommand } from './consts.js'
 import type { SlotCommandPayload, SlotGitCloneArgs } from './types.js'
 
 export const SlotCommandPayloadSchema = {
@@ -14,6 +14,7 @@ export const SlotCommandPayloadSchema = {
         { type: 'string', enum: Object.values(SlotFileCommand) },
         { type: 'string', enum: Object.values(SlotShellCommand) },
         { type: 'string', enum: Object.values(SlotGitCommand) },
+        { type: 'string', enum: Object.values(SlotDatabaseCommand) },
       ]
     },
     args: {

package/src/slot/types.ts

@@ -1,6 +1,35 @@
-import type { SlotCommandType, SlotFileCommand, SlotGitCommand, SlotShellCommand, SubProject } from './consts.js'
+import type { SlotCommandType, SlotDatabaseCommand, SlotFileCommand, SlotGitCommand, SlotShellCommand, SubProject } from './consts.js'
 
-export type SlotCommand = SlotFileCommand | SlotShellCommand | SlotGitCommand
+export type SlotCommand = SlotFileCommand | SlotShellCommand | SlotGitCommand | SlotDatabaseCommand
+
+/** Driver identity is open-ended; inspect it before choosing a query language. No credentials. */
+export interface SlotDatabaseInfo {
+  kind: string
+  queryLanguage: string
+  database: string
+  schema: string
+  role: string
+  version: string
+  readOnly: boolean
+  limits: { defaultRows: number; maxRows: number; maxBytes: number; maxQueryChars: number; maxParams: number; timeoutMs: number }
+}
+
+export interface SlotDatabaseQueryArgs {
+  query: string
+  params?: Array<string | number | boolean | null>
+  maxRows?: number
+  timeoutMs?: number
+}
+
+export type SlotDatabaseQueryResult = {
+  ok: true
+  columns: Array<{ name: string; dataType: string }>
+  rows: Record<string, unknown>[]
+  truncated: boolean
+} | {
+  ok: false
+  error: { message: string; code?: string; detail?: string; hint?: string; position?: string }
+}
 
 export interface SlotCommandPayload {
   type: SlotCommandType

package/src/types.ts

@@ -7,6 +7,11 @@ export interface SlotMetadata extends
 }
 
 export interface SlotConstMetadata {
+  /**
+   * The project's ALIAS — a lowercase slug, an identifier. The OIDC client id base, the key
+   * namespace prefix and the address are composed from it, so it never reaches a person as the
+   * product's name; that is the project card's `title`.
+   */
   projectName: string
   oidcClientId: string
   oidcRealm: string

package/tests/branding.spec.ts

@@ -25,18 +25,29 @@ describe('brandingEnv', () => {
 
   it('composes the rest of the branding env from whatever is present, blank otherwise', () => {
     expect(brandingEnv({
-      brandingCopyright: '© 2026 Acme', projectName: 'Acme CRM',
+      brandingCopyright: '© 2026 Acme', projectName: 'acme-crm',
     })).toEqual({
       BRANDING_COPYRIGHT: '© 2026 Acme',
       BRANDING_ORGANIZATION: '',
       BRANDING_TERMS_URL: '',
       BRANDING_PRIVACY_URL: '',
       BRANDING_CREDIT: '1',
-      BRANDING_PRODUCT: 'Acme CRM',
+      BRANDING_PRODUCT: '',
       BRANDING_GOOGLE_TAG: '',
     })
   })
 
+  it('never delivers the project alias as the product name', () => {
+    // `projectName` is the lowercase slug the OIDC client and the address are composed from. Taken
+    // for the product's name it titled the document `slopepact` over a header saying `SlopePact`.
+    // The name a person reads is the target's own `APP_TITLE`, which the build falls back to when
+    // this is empty — and the key is still emitted, so the bundle has no bare `process.env` read.
+    for (const projectName of ['slopepact', 'Acme CRM', '']) {
+      expect(brandingEnv({ projectName }).BRANDING_PRODUCT).toBe('')
+    }
+    expect(Object.keys(brandingEnv({ projectName: 'slopepact' }))).toContain('BRANDING_PRODUCT')
+  })
+
   it('carries the Google tag, and emits it empty when none is set', () => {
     // The METADATA key is omitted from a push while unset (an older publisher refuses it); the
     // ENVIRONMENT key is always there, and '' is what tells the build to load no tag.

package/tests/connect-entrypoints.spec.ts

@@ -4,7 +4,10 @@ import { aliasOf, protocols } from '@owlmeans/entrypoint'
 import { DEFAULT_GUARD } from '@owlmeans/auth-common'
 import { RouteMethod, RouteProtocols } from '@owlmeans/route'
 import { connect, CONNECT_BRANDING_GOOGLE_TAG_MAX } from '../src/connect/consts.js'
-import { ConnectProjectBrandingSaveSchema } from '../src/connect/schemas.js'
+import {
+  ConnectKitApplyBodySchema, ConnectKitApplyResultSchema, ConnectKitDescribeSchema, ConnectProjectBrandingSaveSchema,
+  PlanningKitViewSchema,
+} from '../src/connect/schemas.js'
 import { connectProtocols } from '../src/connect/entrypoints.js'
 import { connectRef } from '../src/connect/references.js'
 
@@ -18,8 +21,8 @@ describe('@owlmeans/viable-common — connector protocol tree', () => {
     expect(tree.convert.proceed.alias).toBe(connect.convert.proceed)
     expect(tree.inquiry.answer.alias).toBe(connect.inquiry.answer)
     expect(tree.files.list.alias).toBe(connect.files.list)
-    expect(protocols(tree)).toHaveLength(26)
-    expect(new Set(protocols(tree).map(protocol => protocol.alias)).size).toBe(26)
+    expect(protocols(tree)).toHaveLength(28)
+    expect(new Set(protocols(tree).map(protocol => protocol.alias)).size).toBe(28)
   })
 
   test('declares exactly the routes a connector calls — every alias, reference and path, and no socket', () => {
@@ -29,11 +32,11 @@ describe('@owlmeans/viable-common — connector protocol tree', () => {
 
     expect(addresses).toEqual([
       'GET /convert/:id', 'GET /convert/:id/check', 'GET /pipeline/:id/:runId', 'GET /project',
-      'GET /project/:id/branding', 'GET /project/:id/files', 'GET /project/:id/status',
+      'GET /project/:id/branding', 'GET /project/:id/files', 'GET /project/:id/kits', 'GET /project/:id/status',
       'GET /project/:id/story/:storyId/status', 'GET /session/:sessionId/ops',
       'POST /convert', 'POST /convert/:id/proceed', 'POST /convert/:id/purge', 'POST /convert/:id/start',
       'POST /pipeline/:id/:runId/resume', 'POST /project', 'POST /project/:id/branding',
-      'POST /project/:id/confirm', 'POST /project/:id/inquiry/:inquiryId', 'POST /project/:id/modify',
+      'POST /project/:id/confirm', 'POST /project/:id/inquiry/:inquiryId', 'POST /project/:id/kits', 'POST /project/:id/modify',
       'POST /project/:id/reinit', 'POST /project/attach', 'POST /session', 'POST /session/:sessionId/close',
       'POST /session/:sessionId/ops/:opId', 'POST /session/delegated',
     ])
@@ -94,4 +97,48 @@ describe('@owlmeans/viable-common — connector protocol tree', () => {
     expect((connect.project as Record<string, unknown>).job).toBeUndefined()
     expect((connectRef.project as Record<string, unknown>).job).toBeUndefined()
   })
+
+  test('describes and applies planning kits at one project path, under the owned base and no paid gate', () => {
+    const paid = connectProtocols({
+      guard: DEFAULT_GUARD,
+      gate: { alias: 'test-gate', params: ['owner'] },
+      localLlm: { alias: 'test-paid-llm', params: ['cap'] },
+    })
+    const { describe: list, apply } = paid.project.kit
+
+    expect([list.alias, apply.alias]).toEqual([connect.project.kit.describe, connect.project.kit.apply])
+    expect([list.route.route.path, apply.route.route.path]).toEqual(['/project/:id/kits', '/project/:id/kits'])
+    expect([list.route.route.method, apply.route.route.method]).toEqual([RouteMethod.GET, RouteMethod.POST])
+    expect([aliasOf(list.route.route.parent), aliasOf(apply.route.route.parent)]).toEqual([connect.base, connect.base])
+    expect([list.gate, apply.gate]).toEqual([undefined, undefined])
+    expect([connectRef.project.kit.describe.alias, connectRef.project.kit.apply.alias])
+      .toEqual([connect.project.kit.describe, connect.project.kit.apply])
+  })
+
+  test('the kit view, the describe reply, the apply body and its result are closed shapes', () => {
+    const ajv = new Ajv({ strict: false })
+    const view = ajv.compile(PlanningKitViewSchema)
+    const reply = ajv.compile(ConnectKitDescribeSchema)
+    const body = ajv.compile(ConnectKitApplyBodySchema)
+    const result = ajv.compile(ConnectKitApplyResultSchema)
+    const kit = {
+      id: 'project', kind: 'project', title: 'Project tracking', purpose: 'Tasks moving to done',
+      container: { key: 'workspace', label: 'Project' },
+      types: [{ key: 'task', label: 'Task', flow: 'task' }],
+      flows: [{ key: 'task', label: 'Task', statuses: [{ key: 'open', label: 'Open', intrinsic: 'planned' }] }],
+    }
+
+    expect(view(kit)).toBe(true)
+    expect(view({ ...kit, extra: true })).toBe(false)
+    expect(view({ ...kit, types: [{ key: 'task', label: 'Task' }] })).toBe(false)
+    expect(reply({ kits: [kit] })).toBe(true)
+    expect(body({ kit: 'project' })).toBe(true)
+    expect(body({ kit: 'project', types: ['task', 'bug'] })).toBe(true)
+    expect(body({ kit: 'project', types: null })).toBe(true)
+    expect(body({ kit: '' })).toBe(false)
+    expect(body({ types: ['task'] })).toBe(false)
+    expect(body({ kit: 'project', force: true })).toBe(false)
+    expect(result({ applied: ['task'], skipped: ['bug'], warnings: [] })).toBe(true)
+    expect(result({ applied: ['task'], skipped: [] })).toBe(false)
+  })
 })

package/tests/planning.spec.ts

@@ -263,6 +263,14 @@ describe('viable-common - the viable field schemas', () => {
     expect(project({ alias: 'slot-booker' })).toBe(false)
   })
 
+  test('a project records a work kind from the closed set and a bounded case quote', () => {
+    expect(project({ blueprintCase: 'work-management', workKind: 'crm', caseQuote: 'A CRM for ski resorts.' })).toBe(true)
+    expect(project({ workKind: null, caseQuote: null })).toBe(true)
+    expect(project({ workKind: 'kanban' })).toBe(false)
+    expect(project({ caseQuote: '' })).toBe(false)
+    expect(project({ caseQuote: 'x'.repeat(1025) })).toBe(false)
+  })
+
   test('a story carries the landing flag, spelled or nulled', () => {
     expect(story({ area: ProjectArea.User, primary: false, landing: true })).toBe(true)
     expect(story({ area: ProjectArea.User, primary: false, landing: null })).toBe(true)