@aifabrix/builder 2.50.0 → 2.51.1

package/lib/programmatic/openapi-component-schemas.js

@@ -12,10 +12,15 @@ const { enrichOpenApiComponentSchemas } = require('./openapi-description-enriche
 const { buildSuccessEnvelopeSchema } = require('./openapi-schema-helpers');
 const { OPENAPI_REQUEST_SCHEMAS } = require('./openapi-request-schemas');
 const { OPENAPI_RESULT_SCHEMAS } = require('./openapi-result-schemas');
+const { OPENAPI_APPLY_RESULT_SCHEMAS } = require('./openapi-apply-result-schemas');
 const {
   OPENAPI_MANIFEST_REQUEST_SCHEMAS,
   OPENAPI_MANIFEST_RESULT_SCHEMAS
 } = require('./openapi-manifest-schemas');
+const {
+  OPENAPI_EVIDENCE_REQUEST_SCHEMAS,
+  OPENAPI_EVIDENCE_RESULT_SCHEMAS
+} = require('./openapi-evidence-schemas');
 
 const RESPONSE_ENVELOPES = [
   ['ListSystemsResponse', 'ListSystemsData'],
@@ -27,6 +32,9 @@ const RESPONSE_ENVELOPES = [
   ['ValidateResultResponse', 'ValidateResultData'],
   ['PreviewUploadResponse', 'PreviewUploadData'],
   ['UploadResultResponse', 'UploadResultData'],
+  ['DeployResultResponse', 'DeployResultData'],
+  ['ProtectionUploadResponse', 'ProtectionUploadData'],
+  ['ProtectionCreateResponse', 'ProtectionCreateData'],
   ['TestResultResponse', 'TestResultData'],
   ['CertifyResultResponse', 'CertifyResultData'],
   ['LifecycleReportResponse', 'LifecycleReportData'],
@@ -39,7 +47,11 @@ const RESPONSE_ENVELOPES = [
   ['ManifestSectionViewResponse', 'ManifestSectionViewData'],
   ['ManifestPatchResultResponse', 'ManifestPatchResultData'],
   ['ManifestSectionsListResponse', 'ManifestSectionsListData'],
-  ['ManifestRepairResultResponse', 'ManifestRepairResultData']
+  ['ManifestRepairResultResponse', 'ManifestRepairResultData'],
+  ['EvidenceAuthoringMetadataResponse', 'EvidenceAuthoringMetadataData'],
+  ['EvidenceDownloadResponse', 'EvidenceDownloadData'],
+  ['EvidenceUploadResponse', 'EvidenceUploadData'],
+  ['EvidenceActivateResponse', 'EvidenceActivateData']
 ];
 
 /**
@@ -53,8 +65,11 @@ function buildOpenApiComponentSchemas() {
   return enrichOpenApiComponentSchemas({
     ...OPENAPI_REQUEST_SCHEMAS,
     ...OPENAPI_MANIFEST_REQUEST_SCHEMAS,
+    ...OPENAPI_EVIDENCE_REQUEST_SCHEMAS,
     ...OPENAPI_RESULT_SCHEMAS,
+    ...OPENAPI_APPLY_RESULT_SCHEMAS,
     ...OPENAPI_MANIFEST_RESULT_SCHEMAS,
+    ...OPENAPI_EVIDENCE_RESULT_SCHEMAS,
     EmptyResultData: { type: 'object', properties: {}, additionalProperties: false },
     ...envelopes
   });

package/lib/programmatic/openapi-description-enricher.js

@@ -14,6 +14,7 @@ const { CERTIFY_SCHEMA_DESCRIPTIONS } = require('./openapi-schema-descriptions-c
 const { MANIFEST_SCHEMA_DESCRIPTIONS } = require('./openapi-schema-descriptions-manifest');
 const { MCP_SCHEMA_DESCRIPTIONS } = require('./openapi-schema-descriptions-mcp');
 const { HELP_SCHEMA_DESCRIPTIONS } = require('./openapi-schema-descriptions-help');
+const { EVIDENCE_SCHEMA_DESCRIPTIONS } = require('./openapi-schema-descriptions-evidence');
 
 /** @type {Record<string, Object>} */
 const MERGED_SCHEMA_DESCRIPTIONS = {
@@ -22,7 +23,8 @@ const MERGED_SCHEMA_DESCRIPTIONS = {
   ...CERTIFY_SCHEMA_DESCRIPTIONS,
   ...MANIFEST_SCHEMA_DESCRIPTIONS,
   ...MCP_SCHEMA_DESCRIPTIONS,
-  ...HELP_SCHEMA_DESCRIPTIONS
+  ...HELP_SCHEMA_DESCRIPTIONS,
+  ...EVIDENCE_SCHEMA_DESCRIPTIONS
 };
 
 /**

package/lib/programmatic/openapi-descriptions.js

@@ -53,25 +53,32 @@ const OPERATION_DESCRIPTIONS = Object.freeze({
   getManifestSection: {
     summary: 'Read one system manifest section',
     description:
-      'Return section value, schema fragment, quality, dependency graph, and sectionReadToken. MUST call before patchSection.',
+      'Return section value, schema fragment, quality, dependency graph, and sectionReadToken. ' +
+      'Recommended before patch when quality or missingInputs are needed; token is optional on PATCH.',
     tags: ['manifest']
   },
   patchManifestSection: {
     summary: 'Patch one system manifest section',
     description:
-      'Apply governed merge/replace to a system section. Requires intent and sectionReadToken from GET. Mutating.',
+      'Apply governed merge/replace to a system section. Requires intent. ' +
+      'sectionReadToken from GET is optional — when omitted, the server re-reads the section before write. ' +
+      'Stale tokens return 409. Mutating.',
     tags: ['manifest']
   },
   getDatasourceManifestSection: {
     summary: 'Read one datasource manifest section',
     description:
-      'Return datasource section value, quality, missingInputs, and sectionReadToken. MUST call before patchSection.',
+      'Return datasource section value, quality, missingInputs, and sectionReadToken. ' +
+      'Recommended before patch when quality or missingInputs are needed; token is optional on PATCH.',
     tags: ['manifest']
   },
   patchDatasourceManifestSection: {
     summary: 'Patch one datasource manifest section',
     description:
-      'Apply governed merge/replace to a datasource section. Requires intent and sectionReadToken. Mutating.',
+      'Apply governed merge/replace to a datasource section. Requires intent. ' +
+      'sectionReadToken is optional (server re-reads when omitted; stale token → 409). ' +
+      'For scalar sections (e.g. datasource.resourceType), send patch as { "value": "<scalar>" } or ' +
+      '{ "<leafName>": "<scalar>" }. Mutating.',
     tags: ['manifest']
   },
   runManifestRepair: {
@@ -115,6 +122,24 @@ const OPERATION_DESCRIPTIONS = Object.freeze({
       'Full dev publish: validate, sync deploy JSON, push credentials, pipeline upload. Requires external-system:publish in dev. Mutating; use Idempotency-Key; may take up to MAX_UPLOAD_TIMEOUT_MS.',
     tags: ['apply']
   },
+  runDeploySystem: {
+    summary: 'Deploy integration via controller (promote)',
+    description:
+      'Controller deploy for external systems (CLI aifabrix deploy parity). Optional body.gate matches CLI --gate (operations,trust,governance,full). Certificate seal is a platform side-effect of published Deploy — not a separate certificates issue call. Mutating; use Idempotency-Key.',
+    tags: ['apply']
+  },
+  runProtectionUpload: {
+    summary: 'Upload protection manifest for a datasource',
+    description:
+      'Validate and upload the workspace protection manifest for the datasource (CLI aifabrix protection upload parity). Optional sync after upload. Mutating; use Idempotency-Key.',
+    tags: ['apply']
+  },
+  runProtectionCreate: {
+    summary: 'Scaffold a local protection manifest',
+    description:
+      'Probe dataplane + dimension catalog and write integration/.protection scaffold (CLI aifabrix protection create parity). Mutating; use Idempotency-Key.',
+    tags: ['apply']
+  },
   materializeTemplate: {
     summary: 'Materialize workspace from template',
     description:
@@ -128,7 +153,8 @@ const OPERATION_DESCRIPTIONS = Object.freeze({
   },
   runWorkspaceDiff: {
     summary: 'Diff workspace draft',
-    description: 'Invoke Enterprise MCP workspace.diff for local draft vs remote/template baseline.',
+    description:
+      'Diff local workspace draft vs remote/template baseline via Enterprise MCP workspace.diff when published; otherwise returns a local draft snapshot (source=local) without failing.',
     tags: ['workspace']
   },
   resetWorkspaceFromTemplate: {
@@ -167,6 +193,30 @@ const OPERATION_DESCRIPTIONS = Object.freeze({
     summary: 'Readiness probe',
     description: 'Returns ready with configured dataplaneUrl. Does not verify Dataplane connectivity in V1.',
     tags: ['infra']
+  },
+  getEvidenceMetadata: {
+    summary: 'Evidence authoring metadata',
+    description:
+      'Return live Evidence kinds, aspects, resource types, Role Assistant capabilities, writable fields, and certification/activation constraints for the selected roleKey. Read-only aggregation over Dataplane and Controller catalogs.',
+    tags: ['evidence']
+  },
+  downloadEvidence: {
+    summary: 'Download Role Assistant Evidence',
+    description:
+      'List or search Evidence for the selected roleKey using existing Dataplane Evidence filters. Read-only projection for AI authoring.',
+    tags: ['evidence']
+  },
+  uploadEvidenceCandidates: {
+    summary: 'Upload Evidence candidates',
+    description:
+      'Load one or many Evidence rows as inactive candidates, validate each row, and technically certify valid rows. Never activates. Mutating; use Idempotency-Key.',
+    tags: ['evidence']
+  },
+  activateEvidenceCandidates: {
+    summary: 'Activate certified Evidence',
+    description:
+      'Activate one or many human-approved certified Evidence ids. Organizational gate after technical certification. Mutating; use Idempotency-Key.',
+    tags: ['evidence']
   }
 });
 

package/lib/programmatic/openapi-evidence-schemas.js

@@ -0,0 +1,161 @@
+/**
+ * Frozen OpenAPI request/result schemas for Evidence authoring routes (162.0).
+ *
+ * @fileoverview BTA-facing Evidence metadata/download/upload/activate models
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { frozenObject, schemaRef, stringArraySchema } = require('./openapi-schema-helpers');
+
+/** @type {Record<string, Object>} */
+const OPENAPI_EVIDENCE_REQUEST_SCHEMAS = {
+  EvidenceUploadRow: frozenObject(
+    {
+      key: { type: 'string' },
+      resourceType: { type: 'string' },
+      roleKey: { type: 'string' },
+      kindKey: { type: 'string' },
+      kindVersion: { type: 'string' },
+      title: { type: 'string' },
+      description: { type: 'string' },
+      when: { type: 'string' },
+      expectedBehavior: { type: 'string' },
+      aspect: { type: 'string' },
+      order: { type: 'integer' },
+      status: { type: 'string', enum: ['candidate', 'active', 'disabled', 'archived'] }
+    },
+    ['title', 'when', 'expectedBehavior']
+  ),
+  EvidenceUploadRequest: frozenObject(
+    {
+      roleKey: {
+        type: 'string',
+        description: 'Optional override; defaults to the path roleKey.'
+      },
+      rows: { type: 'array', items: schemaRef('EvidenceUploadRow') },
+      comment: { type: 'string' }
+    },
+    ['rows']
+  ),
+  EvidenceActivateRequest: frozenObject(
+    {
+      evidenceIds: stringArraySchema()
+    },
+    ['evidenceIds']
+  )
+};
+
+/** @type {Record<string, Object>} */
+const OPENAPI_EVIDENCE_RESULT_SCHEMAS = {
+  EvidenceKindSummary: frozenObject({
+    key: { type: ['string', 'null'] },
+    version: { type: ['string', 'null'] },
+    displayName: { type: ['string', 'null'] },
+    purpose: { type: ['string', 'null'] }
+  }),
+  EvidenceResourceTypeSummary: frozenObject({
+    key: { type: ['string', 'null'] },
+    displayName: { type: ['string', 'null'] },
+    category: { type: ['string', 'null'] }
+  }),
+  EvidenceAuthoringConstraints: frozenObject({
+    certification: frozenObject({
+      validationStatus: { type: 'string' },
+      candidateStatus: { type: 'string' }
+    }),
+    activation: frozenObject({
+      requiresCertified: { type: 'boolean' },
+      requiresAuthority: { type: 'boolean' }
+    })
+  }),
+  EvidenceAuthoringMetadataData: frozenObject(
+    {
+      roleKey: { type: 'string' },
+      evidenceKinds: { type: 'array', items: schemaRef('EvidenceKindSummary') },
+      aspects: stringArraySchema(),
+      resourceTypes: { type: 'array', items: schemaRef('EvidenceResourceTypeSummary') },
+      assistantCapabilities: stringArraySchema(),
+      writableFields: stringArraySchema(),
+      requiredFields: stringArraySchema(),
+      constraints: schemaRef('EvidenceAuthoringConstraints')
+    },
+    [
+      'roleKey',
+      'evidenceKinds',
+      'aspects',
+      'resourceTypes',
+      'assistantCapabilities',
+      'writableFields',
+      'requiredFields',
+      'constraints'
+    ]
+  ),
+  EvidenceRowProjection: frozenObject({
+    id: { type: 'string' },
+    key: { type: ['string', 'null'] },
+    resourceType: { type: ['string', 'null'] },
+    roleKey: { type: ['string', 'null'] },
+    kindKey: { type: ['string', 'null'] },
+    kindVersion: { type: ['string', 'null'] },
+    title: { type: 'string' },
+    description: { type: ['string', 'null'] },
+    when: { type: 'string' },
+    expectedBehavior: { type: 'string' },
+    aspect: { type: ['string', 'null'] },
+    order: { type: 'integer' },
+    status: { type: 'string' },
+    fingerprint: { type: ['string', 'null'] }
+  }),
+  EvidenceDownloadData: frozenObject(
+    {
+      roleKey: { type: 'string' },
+      count: { type: 'integer', minimum: 0 },
+      data: { type: 'array', items: schemaRef('EvidenceRowProjection') }
+    },
+    ['roleKey', 'count', 'data']
+  ),
+  EvidenceUploadItemOutcome: frozenObject({
+    rowIndex: { type: 'integer' },
+    evidenceId: { type: ['string', 'null'] },
+    evidenceRef: { type: ['string', 'null'] },
+    status: { type: 'string' },
+    message: { type: 'string' },
+    issues: { type: 'array', items: { type: 'string' } }
+  }),
+  EvidenceUploadData: frozenObject(
+    {
+      roleKey: { type: 'string' },
+      inserted: { type: 'integer', minimum: 0 },
+      updated: { type: 'integer', minimum: 0 },
+      accepted: { type: 'array', items: schemaRef('EvidenceUploadItemOutcome') },
+      rejected: { type: 'array', items: schemaRef('EvidenceUploadItemOutcome') },
+      warnings: { type: 'array', items: schemaRef('EvidenceUploadItemOutcome') },
+      certified: { type: 'array', items: schemaRef('EvidenceUploadItemOutcome') },
+      readyToActivate: { type: 'boolean' }
+    },
+    ['roleKey', 'accepted', 'rejected', 'warnings', 'certified', 'readyToActivate']
+  ),
+  EvidenceActivateItemOutcome: frozenObject({
+    evidenceId: { type: 'string' },
+    result: schemaRef('EvidenceRowProjection'),
+    error: { type: 'string' },
+    status: { type: ['integer', 'null'] }
+  }),
+  EvidenceActivateData: frozenObject(
+    {
+      requested: { type: 'integer', minimum: 0 },
+      activated: { type: 'array', items: schemaRef('EvidenceActivateItemOutcome') },
+      failed: { type: 'array', items: schemaRef('EvidenceActivateItemOutcome') },
+      success: { type: 'boolean' }
+    },
+    ['requested', 'activated', 'failed', 'success']
+  )
+};
+
+module.exports = {
+  OPENAPI_EVIDENCE_REQUEST_SCHEMAS,
+  OPENAPI_EVIDENCE_RESULT_SCHEMAS
+};

package/lib/programmatic/openapi-manifest-schemas.js

@@ -54,10 +54,14 @@ const OPENAPI_MANIFEST_REQUEST_SCHEMAS = {
       intent: { type: 'string', minLength: 1, description: 'Why this patch is made — audit and repair hints.' },
       patch: { type: 'object', description: 'Section-scoped merge/replace payload.' },
       mode: { type: 'string', enum: ['merge', 'replace'], description: 'Merge into or replace section value.' },
-      sectionReadToken: { type: 'string', description: 'Token from prior GET; stale token returns 409.' },
+      sectionReadToken: {
+        type: 'string',
+        description:
+          'Optional token from prior GET. When omitted, the server re-reads the section immediately before write. Stale token returns 409.'
+      },
       dryRun: { type: 'boolean', description: 'Validate patch without writing files.' }
     },
-    ['intent', 'patch', 'mode', 'sectionReadToken']
+    ['intent', 'patch', 'mode']
   ),
   ManifestRepairRequest: frozenObject(
     {

package/lib/programmatic/openapi-operation-bindings.js

@@ -40,6 +40,14 @@ const DATASOURCE_KEY_PARAM = {
   description: 'Datasource key within the integration workspace.'
 };
 
+const ROLE_KEY_PARAM = {
+  name: 'roleKey',
+  in: 'path',
+  required: true,
+  schema: { type: 'string' },
+  description: 'Role Assistant key that scopes Evidence authoring.'
+};
+
 const IDEMPOTENCY_HEADER = {
   name: 'Idempotency-Key',
   in: 'header',
@@ -208,6 +216,21 @@ const OPERATION_BINDINGS = Object.freeze({
     requestBody: jsonRequestBody('UploadRequest'),
     successResponse: 'UploadResultResponse'
   },
+  runDeploySystem: {
+    parameters: [SYSTEM_KEY_PARAM],
+    requestBody: jsonRequestBody('DeployRequest'),
+    successResponse: 'DeployResultResponse'
+  },
+  runProtectionUpload: {
+    parameters: [SYSTEM_KEY_PARAM, DATASOURCE_KEY_PARAM],
+    requestBody: jsonRequestBody('ProtectionUploadRequest'),
+    successResponse: 'ProtectionUploadResponse'
+  },
+  runProtectionCreate: {
+    parameters: [SYSTEM_KEY_PARAM, DATASOURCE_KEY_PARAM],
+    requestBody: jsonRequestBody('ProtectionCreateRequest'),
+    successResponse: 'ProtectionCreateResponse'
+  },
   materializeTemplate: {
     parameters: [SYSTEM_KEY_PARAM],
     requestBody: jsonRequestBody('TemplateMaterializeRequest'),
@@ -251,6 +274,82 @@ const OPERATION_BINDINGS = Object.freeze({
   },
   ready: {
     successResponse: 'ReadyResponse'
+  },
+  getEvidenceMetadata: {
+    parameters: [ROLE_KEY_PARAM],
+    successResponse: 'EvidenceAuthoringMetadataResponse'
+  },
+  downloadEvidence: {
+    parameters: [ROLE_KEY_PARAM],
+    queryParameters: [
+      {
+        name: 'resourceType',
+        in: 'query',
+        required: false,
+        schema: { type: 'string' },
+        description: 'Filter Evidence by catalog resource type key.'
+      },
+      {
+        name: 'status',
+        in: 'query',
+        required: false,
+        schema: { type: 'string', enum: ['candidate', 'active', 'disabled', 'archived'] },
+        description: 'Filter Evidence by lifecycle status.'
+      },
+      {
+        name: 'kindKey',
+        in: 'query',
+        required: false,
+        schema: { type: 'string' },
+        description: 'Filter Evidence by kind key.'
+      },
+      {
+        name: 'aspect',
+        in: 'query',
+        required: false,
+        schema: { type: 'string' },
+        description: 'Filter Evidence by aspect label.'
+      },
+      {
+        name: 'search',
+        in: 'query',
+        required: false,
+        schema: { type: 'string' },
+        description: 'Search Evidence title or text fields.'
+      },
+      {
+        name: 'genericOnly',
+        in: 'query',
+        required: false,
+        schema: { type: 'boolean' },
+        description: 'When true, return only generic (non role-bound) Evidence.'
+      },
+      {
+        name: 'limit',
+        in: 'query',
+        required: false,
+        schema: { type: 'integer', minimum: 1 },
+        description: 'Maximum number of Evidence rows to return.'
+      },
+      {
+        name: 'offset',
+        in: 'query',
+        required: false,
+        schema: { type: 'integer', minimum: 0 },
+        description: 'Offset for Evidence list pagination.'
+      }
+    ],
+    successResponse: 'EvidenceDownloadResponse'
+  },
+  uploadEvidenceCandidates: {
+    parameters: [ROLE_KEY_PARAM],
+    requestBody: jsonRequestBody('EvidenceUploadRequest'),
+    successResponse: 'EvidenceUploadResponse'
+  },
+  activateEvidenceCandidates: {
+    parameters: [ROLE_KEY_PARAM],
+    requestBody: jsonRequestBody('EvidenceActivateRequest'),
+    successResponse: 'EvidenceActivateResponse'
   }
 });
 

package/lib/programmatic/openapi-request-schemas.js

@@ -96,6 +96,37 @@ const OPENAPI_REQUEST_SCHEMAS = {
     force: { type: 'boolean' },
     probe: { type: 'boolean' }
   }),
+  DeployRequest: frozenObject({
+    gate: {
+      type: 'string',
+      description:
+        'Optional pre-promote gates, same as CLI --gate (comma-separated: operations, trust, governance, full).'
+    },
+    subjectEmail: { type: 'string', format: 'email' },
+    probe: { type: 'boolean' },
+    sync: { type: 'boolean' },
+    verbose: { type: 'boolean' }
+  }),
+  ProtectionUploadRequest: frozenObject({
+    dryRun: { type: 'boolean' },
+    sync: { type: 'boolean' },
+    verbose: { type: 'boolean' }
+  }),
+  ProtectionCreateRequest: frozenObject({
+    type: { type: 'string' },
+    dimensionKey: { type: 'string' },
+    field: { type: 'string' },
+    fkName: { type: 'string' },
+    protectionKey: { type: 'string' },
+    displayName: { type: 'string' },
+    ruleKey: { type: 'string' },
+    principalExpression: { type: 'string' },
+    valueExpression: { type: 'string' },
+    dryRun: { type: 'boolean' },
+    force: { type: 'boolean' },
+    verbose: { type: 'boolean' },
+    disabled: { type: 'boolean' }
+  }),
   TestRequest: frozenObject({
     runType: schemaRef('TestRunType'),
     noPublish: { type: 'boolean' }
@@ -103,7 +134,11 @@ const OPENAPI_REQUEST_SCHEMAS = {
   CertifyRequest: frozenObject({
     noPublish: { type: 'boolean' },
     pack: { type: 'string' },
-    lifecycleBody: schemaRef('LifecycleRunRequest')
+    lifecycleBody: schemaRef('LifecycleRunRequest'),
+    subjectEmail: { type: 'string', format: 'email' },
+    subjectEmails: stringArraySchema(),
+    subjectUserIds: stringArraySchema(),
+    certificationProfile: { type: 'string' }
   }),
   LifecycleRunRequest: frozenObject({
     subjectEmail: { type: 'string', format: 'email' },

package/lib/programmatic/openapi-result-schemas.js

@@ -12,18 +12,35 @@ const { frozenObject, schemaRef, stringArraySchema } = require('./openapi-schema
 
 /** @type {Record<string, Object>} */
 const OPENAPI_RESULT_SCHEMAS = {
-  ProblemDetails: frozenObject(
-    {
-      type: { type: 'string', format: 'uri-reference' },
-      title: { type: 'string' },
-      status: { type: 'integer', minimum: 100, maximum: 599 },
-      detail: { type: 'string' },
-      instance: { type: 'string' },
-      correlationId: { type: 'string' },
-      errors: { type: 'array', items: schemaRef('ProblemValidationError') }
-    },
-    ['type', 'title', 'status', 'detail']
+  ProblemDetail: Object.assign(
+    frozenObject(
+      {
+        type: { type: 'string', format: 'uri-reference' },
+        title: { type: 'string' },
+        status: { type: 'integer', minimum: 100, maximum: 599 },
+        detail: { type: 'string' },
+        instance: { type: 'string' },
+        correlationId: { type: 'string' },
+        errors: { type: 'array', items: schemaRef('ProblemValidationError') }
+      },
+      ['type', 'title', 'status', 'detail', 'correlationId', 'instance', 'errors']
+    ),
+    {
+      example: {
+        type: '/Errors/Unauthorized',
+        title: 'Unauthorized',
+        status: 401,
+        detail: 'Missing or invalid Bearer token.',
+        instance: '/api/v1/builder/workspaces/me/systems',
+        correlationId: '00000000-0000-4000-8000-000000000003',
+        errors: []
+      }
+    }
   ),
+  /** Prefer ProblemDetail; allOf alias for published REST lint (OAPI-148). */
+  ProblemDetails: {
+    allOf: [schemaRef('ProblemDetail')]
+  },
   ProblemValidationError: frozenObject(
     {
       field: { type: 'string' },
@@ -34,7 +51,7 @@ const OPENAPI_RESULT_SCHEMAS = {
   ),
   LifecycleVerdict: {
     type: 'string',
-    enum: ['VERIFIED', 'FAILED', 'NOT_VERIFIED']
+    enum: ['VERIFIED', 'FAILED', 'NOT_VERIFIED', 'NOT_APPLICABLE']
   },
   CertificationLevel: {
     type: 'string',

package/lib/programmatic/openapi-schema-descriptions-certify.js

@@ -14,7 +14,11 @@ const CERTIFY_SCHEMA_DESCRIPTIONS = {
     _schema: 'Optional flags for certification pillar commands.',
     noPublish: 'When true, skip publishing local files before verify commands.',
     pack: 'Governance scenario pack key for verify-governance.',
-    lifecycleBody: 'Optional subject and dry-run options when pillar is lifecycle-run.'
+    lifecycleBody: 'Optional subject and dry-run options when pillar is lifecycle-run.',
+    subjectEmail: 'Subject user email for governance pack generate (governance pillar).',
+    subjectEmails: 'Additional subject emails for governance pack generate.',
+    subjectUserIds: 'Subject user ids for governance pack generate.',
+    certificationProfile: 'Certification profile for governance generate (bronze, silver, …).'
   },
   LifecycleRunRequest: {
     _schema: 'Options for lifecycle-run certification pillar.',

package/lib/programmatic/openapi-schema-descriptions-core.js

@@ -22,7 +22,7 @@ const CORE_SCHEMA_DESCRIPTIONS = {
   RepositorySyncDirection: {
     _schema: 'Repository sync direction: pull remote into workspace or push workspace to remote.'
   },
-  ProblemDetails: {
+  ProblemDetail: {
     _schema: 'RFC 7807 problem response for builder-api errors (application/problem+json).',
     type: 'Problem type URI or identifier.',
     title: 'Short human-readable error title.',
@@ -32,14 +32,17 @@ const CORE_SCHEMA_DESCRIPTIONS = {
     correlationId: 'Correlation id for log lookup across services.',
     errors: 'Field-level validation errors when status is 400.'
   },
+  ProblemDetails: {
+    _schema: 'Alias of ProblemDetail (allOf) for backward-compatible $refs.'
+  },
   ProblemValidationError: {
-    _schema: 'Single field validation error inside ProblemDetails.errors.',
+    _schema: 'Single field validation error inside ProblemDetail.errors.',
     field: 'JSON pointer or field name that failed validation.',
     message: 'Validation failure message.',
     value: 'Rejected value when safe to echo (may be omitted for secrets).'
   },
   LifecycleVerdict: {
-    _schema: 'Lifecycle verification outcome: VERIFIED, FAILED, or NOT_VERIFIED.'
+    _schema: 'Lifecycle verification outcome: VERIFIED, FAILED, NOT_VERIFIED, or NOT_APPLICABLE.'
   },
   CertificationLevel: {
     _schema: 'Certification tier: BRONZE through PLATINUM, or NONE when uncertified.'