@yemi33/minions 0.1.2423 → 0.1.2425

package/engine/api-contracts/qa-process.js

@@ -0,0 +1,764 @@
+'use strict';
+
+const qaFromPrd = require('../qa-from-prd');
+const keepProcesses = require('../keep-process-sweep');
+const qaRunbooks = require('../qa-runbooks');
+const qaRuns = require('../qa-runs');
+const qaSessions = require('../qa-sessions');
+const shared = require('../shared');
+
+const sessionIdPath = {
+  policy: 'required',
+  fields: [{
+    name: 'id',
+    type: 'string',
+    required: true,
+    maxLength: qaSessions.LIMITS.idMax,
+    pattern: 'kebab-case',
+    validatorSource: 'qa-sessions._isSafeSessionId',
+  }],
+};
+const runIdPath = {
+  policy: 'required',
+  fields: [{
+    name: 'id',
+    type: 'string',
+    required: true,
+    maxLength: qaRuns.QA_RUN_ID_MAX,
+    validatorSource: 'qa-runs._isSafeRunId',
+  }],
+};
+const runbookIdPath = {
+  policy: 'required',
+  fields: [{
+    name: 'id',
+    type: 'string',
+    required: true,
+    maxLength: qaRunbooks.LIMITS.idMax,
+    pattern: 'kebab-case',
+    validatorSource: 'qa-runbooks._isSafeId',
+  }],
+};
+
+module.exports = {
+  owner: 'qa-process',
+  routes: [
+    'GET /api/qa-runs-summary',
+    'GET /api/qa-sessions-summary',
+    'GET /api/meetings-total',
+    'POST /api/qa/runbooks/run',
+    'GET /api/qa/runs',
+    'GET /api/qa/runs/<id>',
+    'DELETE /api/qa/runs/<id>',
+    'GET /api/qa/artifacts/<runId>/<path>',
+    'GET /api/qa/runbooks',
+    'GET /api/qa/runbooks/<id>',
+    'POST /api/qa/runbooks',
+    'DELETE /api/qa/runbooks/<id>',
+    'POST /api/qa/session',
+    'POST /api/qa/from-prd',
+    'GET /api/qa/sessions',
+    'POST /api/qa/sessions/<id>/approve',
+    'POST /api/qa/sessions/<id>/edit',
+    'POST /api/qa/sessions/<id>/cancel',
+    'POST /api/qa/sessions/<id>/kill',
+    'POST /api/qa/sessions/<id>/dismiss',
+    'GET /api/qa/sessions/<id>/test',
+    'GET /api/qa/sessions/<id>',
+    'GET /api/qa/runners',
+    'POST /api/qa/runners/reload',
+    'POST /api/meetings',
+    'GET /api/meetings',
+    'GET /api/meetings/<id>',
+    'POST /api/meetings/note',
+    'POST /api/meetings/advance',
+    'POST /api/meetings/end',
+    'POST /api/meetings/archive',
+    'POST /api/meetings/unarchive',
+    'POST /api/meetings/delete',
+  ],
+  bodyless: [
+    'DELETE /api/qa/runs/<id>',
+    'DELETE /api/qa/runbooks/<id>',
+    'POST /api/qa/sessions/<id>/approve',
+    'POST /api/qa/runners/reload',
+  ],
+  overrides: {
+    'GET /api/qa-runs-summary': { noInput: true },
+    'GET /api/qa-sessions-summary': { noInput: true },
+    'GET /api/meetings-total': { noInput: true },
+    'GET /api/meetings': { noInput: true },
+    'GET /api/meetings/<id>': {
+      audit: 'audited',
+      path: {
+        policy: 'required',
+        fields: [
+          {
+            name: 'id',
+            type: 'identifier',
+            required: true,
+            maxLength: 128,
+            pattern: '^MTG-[\\w]+$',
+            allowedValuesSource: 'meetings[].id',
+          },
+        ],
+      },
+      negativeTests: [
+        { strategy: 'return-not-found-for-valid-missing-meeting-id', expectedStatus: 404 },
+      ],
+    },
+    'GET /api/qa/runners': { noInput: true },
+    'POST /api/qa/runbooks/run': {
+      audit: 'audited',
+      body: {
+        policy: 'required',
+        fields: [
+          {
+            name: 'runbookId',
+            type: 'string',
+            required: true,
+            maxLength: qaRunbooks.LIMITS.idMax,
+            pattern: 'kebab-case',
+            validatorSource: 'qa-runbooks._isSafeId',
+          },
+          {
+            name: 'targetName',
+            type: 'string',
+            required: true,
+            maxLength: qaRunbooks.LIMITS.targetNameMax,
+          },
+          {
+            name: 'agent',
+            type: 'string',
+            required: false,
+            allowedValuesSource: 'config.agents keys',
+          },
+        ],
+      },
+      constraints: [
+        { kind: 'no-unknown-fields', location: 'body' },
+        { kind: 'resource-exists', field: 'runbookId', source: 'qa-runbooks' },
+        { kind: 'healthy-target', field: 'targetName', source: 'managed-processes or keep-processes' },
+      ],
+      negativeTests: [
+        { strategy: 'invalid-runbook-id-before-lookup', expectedStatus: 400 },
+        { strategy: 'missing-or-unhealthy-target-before-create', expectedStatus: 404 },
+        { strategy: 'snapshot-runs-and-work-items-on-rejection', expectedStatus: '4xx' },
+      ],
+    },
+    'GET /api/qa/runs': {
+      audit: 'audited',
+      query: {
+        policy: 'optional',
+        fields: [
+          {
+            name: 'limit',
+            type: 'integer',
+            required: false,
+            min: 1,
+            max: qaRuns.QA_RUNS_MAX_RECORDS,
+          },
+          {
+            name: 'status',
+            type: 'string',
+            required: false,
+            allowedValues: Object.values(qaRuns.QA_RUN_STATUS),
+          },
+        ],
+      },
+      constraints: [{ kind: 'single-value-query-fields' }],
+      negativeTests: [
+        { strategy: 'invalid-fractional-or-out-of-range-limit', expectedStatus: 400 },
+        { strategy: 'invalid-or-duplicate-status', expectedStatus: 400 },
+      ],
+    },
+    'GET /api/qa/runs/<id>': {
+      audit: 'audited',
+      path: runIdPath,
+      negativeTests: [
+        { strategy: 'unsafe-id', expectedStatus: 400 },
+        { strategy: 'well-formed-missing-id', expectedStatus: 404 },
+      ],
+    },
+    'DELETE /api/qa/runs/<id>': {
+      audit: 'audited',
+      path: runIdPath,
+      constraints: [
+        { kind: 'body-forbidden' },
+        { kind: 'terminal-state-required', source: 'qa-runs.TERMINAL_STATUSES' },
+      ],
+      negativeTests: [
+        { strategy: 'non-empty-body-before-delete', expectedStatus: 400 },
+        { strategy: 'well-formed-missing-id', expectedStatus: 404 },
+        { strategy: 'non-terminal-run', expectedStatus: 409 },
+        { strategy: 'snapshot-run-and-artifact-directory-on-rejection', expectedStatus: '4xx' },
+      ],
+    },
+    'GET /api/qa/artifacts/<runId>/<path>': {
+      audit: 'audited',
+      path: {
+        policy: 'required',
+        fields: [
+          {
+            name: 'runId',
+            type: 'string',
+            required: true,
+            maxLength: qaRuns.QA_RUN_ID_MAX,
+            validatorSource: 'qa-runs._isSafeRunId',
+          },
+          {
+            name: 'path',
+            type: 'path',
+            required: true,
+            maxLength: qaRuns.QA_ARTIFACT_PATH_MAX,
+            segmentMaxLength: qaRuns.QA_ARTIFACT_SEGMENT_MAX,
+          },
+        ],
+      },
+      constraints: [
+        { kind: 'relative-path-within-root', rootSource: 'qa-runs.qaArtifactsDirForRun' },
+        { kind: 'realpath-within-root', rejectStatus: 403 },
+      ],
+      negativeTests: [
+        { strategy: 'path-traversal-or-symlink-escape', expectedStatus: 403 },
+        { strategy: 'well-formed-missing-artifact', expectedStatus: 404 },
+      ],
+    },
+    'GET /api/qa/runbooks': {
+      audit: 'audited',
+      query: {
+        policy: 'optional',
+        fields: [
+          {
+            name: 'project',
+            type: 'string',
+            required: false,
+            maxLength: qaSessions.LIMITS.projectMax,
+            allowedValuesSource: 'config.projects[].name',
+          },
+        ],
+      },
+      constraints: [{ kind: 'single-value-query-fields' }],
+      negativeTests: [
+        { strategy: 'invalid-project-shape', expectedStatus: 400 },
+        { strategy: 'unknown-project', expectedStatus: 404 },
+      ],
+    },
+    'GET /api/qa/runbooks/<id>': {
+      audit: 'audited',
+      path: runbookIdPath,
+      negativeTests: [
+        { strategy: 'unsafe-id', expectedStatus: 400 },
+        { strategy: 'well-formed-missing-id', expectedStatus: 404 },
+      ],
+    },
+    'POST /api/qa/runbooks': {
+      audit: 'audited',
+      body: {
+        policy: 'required',
+        fields: [
+          {
+            name: 'id',
+            type: 'string',
+            required: true,
+            maxLength: qaRunbooks.LIMITS.idMax,
+            pattern: 'kebab-case',
+          },
+          { name: 'name', type: 'string', required: true, maxLength: qaRunbooks.LIMITS.nameMax },
+          {
+            name: 'project',
+            type: 'string',
+            required: true,
+            maxLength: qaSessions.LIMITS.projectMax,
+            allowedValuesSource: 'config.projects[].name',
+          },
+          {
+            name: 'targetName',
+            type: 'string',
+            required: true,
+            maxLength: qaRunbooks.LIMITS.targetNameMax,
+          },
+          {
+            name: 'steps',
+            type: 'array',
+            required: true,
+            maxLength: qaRunbooks.LIMITS.stepsMax,
+            itemFields: [
+              {
+                name: 'description',
+                type: 'string',
+                required: true,
+                maxLength: qaRunbooks.LIMITS.stepDescriptionMax,
+              },
+              {
+                name: 'command',
+                type: 'string',
+                required: false,
+                maxLength: qaRunbooks.LIMITS.stepCommandMax,
+              },
+            ],
+          },
+          {
+            name: 'expectedArtifacts',
+            type: 'array',
+            required: true,
+            maxLength: qaRunbooks.LIMITS.artifactsMax,
+            itemFields: [
+              {
+                name: 'type',
+                type: 'string',
+                required: true,
+                allowedValues: qaRunbooks.ARTIFACT_TYPES,
+              },
+              {
+                name: 'label',
+                type: 'string',
+                required: true,
+                maxLength: qaRunbooks.LIMITS.artifactLabelMax,
+              },
+              {
+                name: 'path',
+                type: 'string',
+                required: false,
+                maxLength: qaRunbooks.LIMITS.artifactPathMax,
+              },
+            ],
+          },
+        ],
+      },
+      constraints: [
+        { kind: 'no-unknown-fields', location: 'body', recursive: true },
+        { kind: 'globally-unique-id', conflictStatus: 409 },
+      ],
+      negativeTests: [
+        { strategy: 'invalid-top-level-or-nested-field', expectedStatus: 400 },
+        { strategy: 'unknown-project-before-file-write', expectedStatus: 404 },
+        { strategy: 'cross-project-id-collision', expectedStatus: 409 },
+        { strategy: 'snapshot-runbook-files-on-rejection', expectedStatus: '4xx' },
+      ],
+    },
+    'DELETE /api/qa/runbooks/<id>': {
+      audit: 'audited',
+      path: runbookIdPath,
+      constraints: [{ kind: 'body-forbidden' }],
+      negativeTests: [
+        { strategy: 'non-empty-body-before-delete', expectedStatus: 400 },
+        { strategy: 'well-formed-missing-id', expectedStatus: 404 },
+        { strategy: 'snapshot-runbook-files-on-rejection', expectedStatus: '4xx' },
+      ],
+    },
+    'GET /api/qa/sessions': {
+      audit: 'audited',
+      query: {
+        policy: 'optional',
+        fields: [
+          {
+            name: 'limit',
+            type: 'integer',
+            required: false,
+            min: 1,
+            max: qaSessions.QA_SESSIONS_MAX_RECORDS,
+          },
+          {
+            name: 'state',
+            type: 'string',
+            required: false,
+            allowedValues: Object.values(qaSessions.QA_SESSION_STATE),
+            allowedValuesSource: 'qa-sessions.QA_SESSION_STATE',
+          },
+        ],
+      },
+      constraints: [{ kind: 'single-value-query-fields' }],
+      negativeTests: [
+        { strategy: 'invalid-fractional-or-out-of-range-limit', expectedStatus: 400 },
+        { strategy: 'invalid-or-duplicate-state', expectedStatus: 400 },
+      ],
+    },
+    'POST /api/qa/session': {
+      audit: 'audited',
+      body: {
+        policy: 'required',
+        fields: [
+          {
+            name: 'target',
+            type: 'object',
+            required: true,
+            variants: [...qaSessions.VALID_TARGET_KINDS],
+            fieldMaxLength: qaSessions.LIMITS.targetFieldMax,
+          },
+          { name: 'flowsRaw', type: 'string', required: true, maxLength: qaSessions.LIMITS.flowsMax },
+          {
+            name: 'mode',
+            type: 'string',
+            required: false,
+            default: 'confirm',
+            allowedValues: [...qaSessions.VALID_MODES],
+          },
+          {
+            name: 'capture',
+            type: 'object',
+            required: false,
+            fields: ['video:boolean', 'screenshots:boolean', 'logs:boolean'],
+          },
+          {
+            name: 'runner',
+            type: 'string',
+            required: false,
+            maxLength: qaSessions.LIMITS.runnerNameMax,
+            allowedValuesSource: 'qa-runners registry',
+          },
+          {
+            name: 'project',
+            type: 'string',
+            required: false,
+            maxLength: qaSessions.LIMITS.projectMax,
+            allowedValuesSource: 'config.projects[].name',
+          },
+          {
+            name: 'projects',
+            type: 'array',
+            required: false,
+            maxLength: qaSessions.LIMITS.projectsMax,
+            itemType: 'string',
+            itemMaxLength: qaSessions.LIMITS.projectMax,
+            allowedValuesSource: 'config.projects[].name',
+          },
+          {
+            name: 'createdBy',
+            type: 'string',
+            required: false,
+            maxLength: keepProcesses.KEEP_PROCESS_AGENT_ID_MAX,
+          },
+        ],
+      },
+      headers: {
+        policy: 'optional',
+        fields: [
+          {
+            name: 'X-Minions-Agent',
+            type: 'string',
+            required: false,
+            maxLength: keepProcesses.KEEP_PROCESS_AGENT_ID_MAX,
+            pattern: '^[A-Za-z0-9][A-Za-z0-9_-]*$',
+          },
+        ],
+      },
+      constraints: [
+        { kind: 'no-unknown-fields', location: 'body', recursive: true },
+        { kind: 'mutually-exclusive', fields: ['project', 'projects'] },
+        { kind: 'resolve-projects-before-create' },
+      ],
+      negativeTests: [
+        { strategy: 'project-domain-string-errors-to-structured-details', expectedStatus: 400 },
+        { strategy: 'unknown-nested-field-or-runner-or-project', expectedStatus: '4xx' },
+        { strategy: 'snapshot-sessions-and-work-items-on-rejection', expectedStatus: '4xx' },
+      ],
+    },
+    'POST /api/qa/from-prd': {
+      audit: 'audited',
+      body: {
+        policy: 'required',
+        fields: [
+          {
+            name: 'prd',
+            type: 'string',
+            required: true,
+            maxLength: qaFromPrd.QA_PRD_FILENAME_MAX,
+            allowedValuesSource: 'approved/completed PRDs',
+          },
+          {
+            name: 'mode',
+            type: 'string',
+            required: false,
+            default: 'confirm',
+            allowedValues: [...qaSessions.VALID_MODES],
+          },
+          {
+            name: 'runner',
+            type: 'string',
+            required: false,
+            maxLength: qaSessions.LIMITS.runnerNameMax,
+            allowedValuesSource: 'qa-runners registry',
+          },
+        ],
+      },
+      headers: {
+        policy: 'optional',
+        fields: [
+          {
+            name: 'X-Minions-Agent',
+            type: 'string',
+            required: false,
+            maxLength: keepProcesses.KEEP_PROCESS_AGENT_ID_MAX,
+            pattern: '^[A-Za-z0-9][A-Za-z0-9_-]*$',
+          },
+          {
+            name: 'X-CC-Turn-Id',
+            type: 'string',
+            required: false,
+            maxLength: shared.CC_TURN_ID_MAX,
+            validatorSource: 'api-validation.validateIdentifier',
+          },
+        ],
+      },
+      constraints: [
+        { kind: 'safe-filename', field: 'prd', root: 'prd/' },
+        { kind: 'no-unknown-fields', location: 'body' },
+        { kind: 'resolve-projects-before-create' },
+      ],
+      negativeTests: [
+        { strategy: 'invalid-mode-runner-or-filename-before-file-read', expectedStatus: 400 },
+        { strategy: 'non-ready-or-missing-prd', expectedStatus: 400 },
+        { strategy: 'snapshot-sessions-and-work-items-on-rejection', expectedStatus: 400 },
+      ],
+    },
+    'GET /api/qa/sessions/<id>': {
+      audit: 'audited',
+      path: sessionIdPath,
+      negativeTests: [
+        { strategy: 'unsafe-id', expectedStatus: 400 },
+        { strategy: 'well-formed-missing-id', expectedStatus: 404 },
+      ],
+    },
+    'GET /api/qa/sessions/<id>/test': {
+      audit: 'audited',
+      path: sessionIdPath,
+      constraints: [
+        { kind: 'sandboxed-session-test-file', source: 'qa-sessions.getSessionTestFile' },
+      ],
+      negativeTests: [
+        { strategy: 'unsafe-id', expectedStatus: 400 },
+        { strategy: 'missing-session-or-test-file', expectedStatus: 404 },
+      ],
+    },
+    'POST /api/qa/sessions/<id>/approve': {
+      audit: 'audited',
+      path: sessionIdPath,
+      constraints: [{
+        kind: 'required-state-before-create-run',
+        field: 'state',
+        allowedValues: [qaSessions.QA_SESSION_STATE.AWAITING_APPROVAL],
+      }],
+      negativeTests: [
+        { strategy: 'request-body', expectedStatus: 400 },
+        { strategy: 'missing-session', expectedStatus: 404 },
+        { strategy: 'wrong-state-before-run-or-work-item-create', expectedStatus: 409 },
+      ],
+    },
+    'POST /api/qa/runners/reload': {
+      audit: 'audited',
+      constraints: [{ kind: 'body-forbidden' }],
+      negativeTests: [
+        { strategy: 'request-body-before-plugin-load', expectedStatus: 400 },
+        { strategy: 'plugin-spy-zero-calls-on-rejection', expectedStatus: 400 },
+      ],
+    },
+    'POST /api/qa/sessions/<id>/edit': {
+      audit: 'audited',
+      path: sessionIdPath,
+      body: {
+        policy: 'required',
+        fields: [{
+          name: 'feedback',
+          type: 'string',
+          required: true,
+          maxLength: qaSessions.LIMITS.feedbackMax,
+        }],
+      },
+      constraints: [{
+        kind: 'required-state-before-queue',
+        field: 'state',
+        allowedValues: [qaSessions.QA_SESSION_STATE.AWAITING_APPROVAL],
+      }],
+      negativeTests: [
+        { strategy: 'invalid-feedback', expectedStatus: 400 },
+        { strategy: 'missing-session', expectedStatus: 404 },
+        { strategy: 'wrong-state-before-work-item-create', expectedStatus: 409 },
+      ],
+    },
+    'POST /api/qa/sessions/<id>/cancel': {
+      audit: 'audited',
+      path: sessionIdPath,
+      body: {
+        policy: 'optional',
+        fields: [{
+          name: 'reason',
+          type: 'string',
+          required: false,
+          maxLength: qaSessions.LIMITS.summaryMax,
+        }],
+      },
+      constraints: [{
+        kind: 'allowed-transition',
+        source: 'qa-sessions.ALLOWED_TRANSITIONS',
+        target: qaSessions.QA_SESSION_STATE.KILLED,
+      }],
+      negativeTests: [
+        { strategy: 'invalid-reason', expectedStatus: 400 },
+        { strategy: 'terminal-state', expectedStatus: 409 },
+      ],
+    },
+    'POST /api/qa/sessions/<id>/kill': {
+      audit: 'audited',
+      path: sessionIdPath,
+      body: {
+        policy: 'optional',
+        fields: [{
+          name: 'reason',
+          type: 'string',
+          required: false,
+          maxLength: qaSessions.LIMITS.summaryMax,
+        }],
+      },
+      constraints: [{
+        kind: 'allowed-transition-before-process-kill',
+        source: 'qa-sessions.ALLOWED_TRANSITIONS',
+        target: qaSessions.QA_SESSION_STATE.KILLED,
+      }],
+      negativeTests: [
+        { strategy: 'invalid-reason', expectedStatus: 400 },
+        { strategy: 'terminal-state-before-managed-process-kill', expectedStatus: 409 },
+        { strategy: 'process-spy-zero-calls-on-rejection', expectedStatus: '4xx' },
+      ],
+    },
+    'POST /api/qa/sessions/<id>/dismiss': {
+      audit: 'audited',
+      path: sessionIdPath,
+      body: {
+        policy: 'optional',
+        fields: [{
+          name: 'summary',
+          type: 'string',
+          required: false,
+          maxLength: qaSessions.LIMITS.summaryMax,
+        }],
+      },
+      constraints: [{
+        kind: 'allowed-transition',
+        source: 'qa-sessions.ALLOWED_TRANSITIONS',
+        target: qaSessions.QA_SESSION_STATE.DONE,
+      }],
+      negativeTests: [
+        { strategy: 'invalid-summary', expectedStatus: 400 },
+        { strategy: 'terminal-or-wrong-state', expectedStatus: 409 },
+      ],
+    },
+    'POST /api/meetings': {
+      audit: 'audited',
+      body: {
+        policy: 'required',
+        fields: [
+          { name: 'title', type: 'string', required: true, minLength: 1, maxLength: 200 },
+          { name: 'agenda', type: 'string', required: true, minLength: 1, maxLength: 20000 },
+          {
+            name: 'participants',
+            type: 'array<string>',
+            required: true,
+            minLength: 2,
+            maxLength: 50,
+            unique: true,
+            allowedValuesSource: 'config.agents keys',
+          },
+        ],
+      },
+      constraints: [
+        { kind: 'unique-configured-agents', field: 'participants', minItems: 2, maxItems: 50 },
+      ],
+      negativeTests: [
+        { strategy: 'reject-unbounded-title-or-agenda', expectedStatus: 400 },
+        { strategy: 'reject-malformed-duplicate-or-unconfigured-participants', expectedStatus: 400 },
+        { strategy: 'snapshot-meeting-dispatch-and-inbox-state-on-rejection', expectedStatus: 400 },
+      ],
+    },
+    'POST /api/meetings/note': {
+      audit: 'audited',
+      body: {
+        policy: 'required',
+        fields: [
+          { name: 'id', type: 'string', required: true },
+          { name: 'note', type: 'string', required: true, minLength: 1, maxLength: 4000 },
+        ],
+      },
+      constraints: [
+        { kind: 'meeting-status', field: 'id', allowedValuesSource: 'shared.MEETING_STATUS active-round values' },
+      ],
+      negativeTests: [
+        { strategy: 'reject-malformed-id-or-note-before-mutation', expectedStatus: 400 },
+        { strategy: 'reject-terminal-meeting-note', expectedStatus: 409 },
+        { strategy: 'return-not-found-for-valid-missing-meeting-id', expectedStatus: 404 },
+      ],
+    },
+    'POST /api/meetings/advance': {
+      audit: 'audited',
+      body: {
+        policy: 'required',
+        fields: [{ name: 'id', type: 'string', required: true }],
+      },
+      constraints: [
+        { kind: 'meeting-status', field: 'id', allowedValuesSource: 'shared.MEETING_STATUS active-round values' },
+        { kind: 'round-transition', allowedValuesSource: 'meeting round-transition helpers' },
+      ],
+      negativeTests: [
+        { strategy: 'reject-malformed-id-before-dispatch-teardown', expectedStatus: 400 },
+        { strategy: 'reject-terminal-meeting-transition', expectedStatus: 409 },
+        { strategy: 'return-not-found-for-valid-missing-meeting-id', expectedStatus: 404 },
+      ],
+    },
+    'POST /api/meetings/end': {
+      audit: 'audited',
+      body: {
+        policy: 'required',
+        fields: [{ name: 'id', type: 'string', required: true }],
+      },
+      constraints: [
+        { kind: 'meeting-status', field: 'id', allowedValuesSource: 'shared.MEETING_STATUS active-round values' },
+      ],
+      negativeTests: [
+        { strategy: 'reject-malformed-id-before-dispatch-teardown', expectedStatus: 400 },
+        { strategy: 'reject-terminal-meeting-transition', expectedStatus: 409 },
+        { strategy: 'return-not-found-for-valid-missing-meeting-id', expectedStatus: 404 },
+      ],
+    },
+    'POST /api/meetings/archive': {
+      audit: 'audited',
+      body: {
+        policy: 'required',
+        fields: [{ name: 'id', type: 'string', required: true }],
+      },
+      constraints: [
+        { kind: 'meeting-status', field: 'id', allowedValues: ['completed'] },
+      ],
+      negativeTests: [
+        { strategy: 'reject-malformed-id', expectedStatus: 400 },
+        { strategy: 'reject-non-completed-meeting', expectedStatus: 409 },
+        { strategy: 'return-not-found-for-valid-missing-meeting-id', expectedStatus: 404 },
+      ],
+    },
+    'POST /api/meetings/unarchive': {
+      audit: 'audited',
+      body: {
+        policy: 'required',
+        fields: [{ name: 'id', type: 'string', required: true }],
+      },
+      constraints: [
+        { kind: 'meeting-status', field: 'id', allowedValues: ['archived'] },
+      ],
+      negativeTests: [
+        { strategy: 'reject-malformed-id', expectedStatus: 400 },
+        { strategy: 'reject-non-archived-meeting', expectedStatus: 409 },
+        { strategy: 'return-not-found-for-valid-missing-meeting-id', expectedStatus: 404 },
+      ],
+    },
+    'POST /api/meetings/delete': {
+      audit: 'audited',
+      body: {
+        policy: 'required',
+        fields: [{ name: 'id', type: 'string', required: true }],
+      },
+      negativeTests: [
+        { strategy: 'reject-malformed-id-before-dispatch-teardown', expectedStatus: 400 },
+        { strategy: 'return-not-found-for-valid-missing-meeting-id', expectedStatus: 404 },
+      ],
+    },
+  },
+};