@owlmeans/viable-common 0.0.40 → 0.0.42

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)