@bpmsoftwaresolutions/ai-engine-client 1.1.89 → 1.1.90

package/src/domains/actions.js

@@ -1,5 +1,23 @@
+import { cleanText, isPlainObject } from '../utils/text.js';
+
 export function createActionsDomain(client) {
   return {
-    submit: (request) => client.submitActionIntent(request),
+    submitActionIntent: ({ action, target = {}, payload = {}, requiredScope, requestedBy } = {}) => {
+      const normalizedAction = cleanText(action);
+      if (!normalizedAction) {
+        throw new Error('action is required.');
+      }
+      return client._request('/api/gateway/actions/submit', {
+        method: 'POST',
+        body: {
+          action: normalizedAction,
+          target: isPlainObject(target) ? target : {},
+          payload: isPlainObject(payload) ? payload : {},
+          required_scope: cleanText(requiredScope) || 'ai-engine.write',
+          requested_by: cleanText(requestedBy),
+        },
+      });
+    },
+    submit: (request) => client.actions.submitActionIntent(request),
   };
 }

package/src/domains/benchmarks.js

@@ -1,13 +1,13 @@
 export function createBenchmarksDomain(client) {
   return {
-    getSessionPerformanceMetrics: (request) => client.getSessionPerformanceMetrics(request),
-    captureBenchmarkSnapshot: (body) => client.captureBenchmarkSnapshot(body),
-    listBenchmarks: (request) => client.listBenchmarks(request),
-    getBenchmarkMetrics: (benchmarkName) => client.getBenchmarkMetrics(benchmarkName),
-    getBenchmarkDelta: (request) => client.getBenchmarkDelta(request),
-    getBenchmarkTrend: (request) => client.getBenchmarkTrend(request),
-    getPerformanceDashboard: (request) => client.getPerformanceDashboard(request),
-    listRecentBenchmarkRuns: (request) => client.listRecentBenchmarkRuns(request),
-    getBenchmarkRun: (benchmarkRunId) => client.getBenchmarkRun(benchmarkRunId),
+    getSessionPerformanceMetrics: (request) => client.performance.getSessionPerformanceMetrics(request),
+    captureBenchmarkSnapshot: (body) => client.performance.captureBenchmarkSnapshot(body),
+    listBenchmarks: (request) => client.performance.listBenchmarks(request),
+    getBenchmarkMetrics: (benchmarkName) => client.performance.getBenchmarkMetrics(benchmarkName),
+    getBenchmarkDelta: (request) => client.performance.getBenchmarkDelta(request),
+    getBenchmarkTrend: (request) => client.performance.getBenchmarkTrend(request),
+    getPerformanceDashboard: (request) => client.performance.getPerformanceDashboard(request),
+    listRecentBenchmarkRuns: ({ limit } = {}) => client._request('/api/benchmarks/reasoners/runs/recent', { query: { limit } }),
+    getBenchmarkRun: (benchmarkRunId) => client._request(`/api/benchmarks/reasoners/runs/${benchmarkRunId}`),
   };
 }

package/src/domains/capabilities.js

@@ -1,7 +1,7 @@
 export function createCapabilitiesDomain(client) {
   return {
-    listCapabilities: () => client.listCapabilities(),
-    createCapability: (body) => client.createCapability(body),
-    testCapability: (capabilityId, body) => client.testCapability(capabilityId, body),
+    listCapabilities: () => client._request('/api/capabilities'),
+    createCapability: (body) => client._request('/api/capabilities', { method: 'POST', body }),
+    testCapability: (capabilityId, body = {}) => client._request(`/api/capabilities/${capabilityId}/test`, { method: 'POST', body }),
   };
 }

package/src/domains/context-assembly.js

@@ -1,10 +1,20 @@
 export function createContextAssemblyDomain(client) {
   return {
-    getContextAssemblyContract: (workflowRunId, request) => client.getContextAssemblyContract(workflowRunId, request),
-    getContextAssemblyStatus: (workflowRunId, request) => client.getContextAssemblyStatus(workflowRunId, request),
-    getOperatorContext: (workflowRunId, request) => client.getOperatorContext(workflowRunId, request),
-    getContextFragments: (workflowRunId, request) => client.getContextFragments(workflowRunId, request),
-    getContextReuse: (workflowRunId, request) => client.getContextReuse(workflowRunId, request),
-    listPromptAssemblies: (workflowRunId) => client.listPromptAssemblies(workflowRunId),
+    getContextAssemblyContract: (workflowRunId, { stepRunId } = {}) => client._request(`/api/context-assembly/workflow-runs/${workflowRunId}/contract`, {
+      query: { step_run_id: stepRunId },
+    }),
+    getContextAssemblyStatus: (workflowRunId, { stepRunId } = {}) => client._request(`/api/context-assembly/workflow-runs/${workflowRunId}/status`, {
+      query: { step_run_id: stepRunId },
+    }),
+    getOperatorContext: (workflowRunId, { stepRunId } = {}) => client._request(`/api/operator/runs/${workflowRunId}/context`, {
+      query: { step_run_id: stepRunId },
+    }),
+    getContextFragments: (workflowRunId, { stepRunId } = {}) => client._request(`/api/operator/runs/${workflowRunId}/context/fragments`, {
+      query: { step_run_id: stepRunId },
+    }),
+    getContextReuse: (workflowRunId, { stepRunId } = {}) => client._request(`/api/operator/runs/${workflowRunId}/context/reuse`, {
+      query: { step_run_id: stepRunId },
+    }),
+    listPromptAssemblies: (workflowRunId) => client._request(`/api/operator/workflow-runs/${workflowRunId}/prompt-assemblies`),
   };
 }

package/src/domains/database.js

@@ -1,14 +1,143 @@
+import { cleanList, cleanText, isPlainObject } from '../utils/text.js';
 import { createDatabaseBackupsDomain } from './database/backups.js';
 
 export function createDatabaseDomain(client) {
   return {
-    createDatabaseBackup: (request) => client.createDatabaseBackup(request),
-    listDatabaseBackups: (request) => client.listDatabaseBackups(request),
-    getDatabaseBackup: (request) => client.getDatabaseBackup(request),
-    listDatabaseBackupOperations: (request) => client.listDatabaseBackupOperations(request),
-    runAzureSqlBacpacBackup: (request) => client.runAzureSqlBacpacBackup(request),
-    listAzureSqlBacpacBackups: (request) => client.listAzureSqlBacpacBackups(request),
-    listAzureSqlBacpacBackupOperations: (request) => client.listAzureSqlBacpacBackupOperations(request),
+    query: ({
+      surface,
+      contractKey,
+      parameters = {},
+      fields = [],
+      fieldAllowlist = [],
+      actorScopes = [],
+      requiredScopes = [],
+      shape = 'json',
+      requestedBy,
+    } = {}) => {
+      const normalizedSurface = cleanText(surface) || cleanText(contractKey);
+      if (!normalizedSurface) {
+        throw new Error('surface is required.');
+      }
+      const normalizedShape = cleanText(shape) || 'json';
+      if (!['json', 'table', 'cards', 'markdown'].includes(normalizedShape)) {
+        throw new Error('shape must be one of json, table, cards, or markdown.');
+      }
+      const normalizedFields = cleanList(fields);
+      const normalizedAllowlist = cleanList(fieldAllowlist);
+      const disallowedFields = normalizedFields.filter((field) => !normalizedAllowlist.includes(field));
+      if (normalizedAllowlist.length > 0 && disallowedFields.length > 0) {
+        throw new Error(`Requested fields are not allowed: ${disallowedFields.join(', ')}.`);
+      }
+      const normalizedActorScopes = cleanList(actorScopes);
+      const normalizedRequiredScopes = cleanList(requiredScopes);
+      const missingScopes = normalizedRequiredScopes.filter((scope) => !normalizedActorScopes.includes(scope));
+      if (missingScopes.length > 0) {
+        throw new Error(`Missing required scopes: ${missingScopes.join(', ')}.`);
+      }
+      return client._request('/api/gateway/query', {
+        method: 'POST',
+        body: {
+          surface: normalizedSurface,
+          parameters: isPlainObject(parameters) ? parameters : {},
+          fields: normalizedFields,
+          field_allowlist: normalizedAllowlist,
+          actor_scopes: normalizedActorScopes,
+          required_scopes: normalizedRequiredScopes,
+          shape: normalizedShape,
+          requested_by: cleanText(requestedBy),
+        },
+      });
+    },
+    createDatabaseBackup: ({ databaseName, outputName, noWait } = {}) => client._request('/api/operator/database/backups', {
+      method: 'POST',
+      body: {
+        database_name: databaseName,
+        output_name: outputName,
+        no_wait: noWait,
+      },
+    }),
+    listDatabaseBackups: ({ prefix, limit } = {}) => client._request('/api/operator/database/backups', {
+      query: {
+        prefix,
+        limit,
+      },
+    }),
+    getDatabaseBackup: ({ backupId } = {}) => client._request(`/api/operator/database/backups/${encodeURIComponent(backupId)}`),
+    listDatabaseBackupOperations: ({ databaseName, operationFilter, limit } = {}) => client._request('/api/operator/database/backups/operations', {
+      query: {
+        database_name: databaseName,
+        operation_filter: operationFilter,
+        limit,
+      },
+    }),
+    runAzureSqlBacpacBackup: ({
+      databaseName,
+      storageAccount,
+      container,
+      resourceGroup,
+      serverName,
+      outputName,
+      adminUser,
+      adminPassword,
+      subscription,
+      storageKey,
+      skipContainerCreate,
+      noWait,
+    } = {}) => client._request('/api/operator/database/backups/azure-sql-bacpac', {
+      method: 'POST',
+      body: {
+        database_name: databaseName,
+        storage_account: storageAccount,
+        container,
+        resource_group: resourceGroup,
+        server_name: serverName,
+        output_name: outputName,
+        admin_user: adminUser,
+        admin_password: adminPassword,
+        subscription,
+        storage_key: storageKey,
+        skip_container_create: skipContainerCreate,
+        no_wait: noWait,
+      },
+    }),
+    listAzureSqlBacpacBackups: ({
+      storageAccount,
+      container,
+      resourceGroup,
+      serverName,
+      subscription,
+      storageKey,
+      prefix,
+      limit,
+    } = {}) => client._request('/api/operator/database/backups/azure-sql-bacpac', {
+      query: {
+        storage_account: storageAccount,
+        container,
+        resource_group: resourceGroup,
+        server_name: serverName,
+        subscription,
+        storage_key: storageKey,
+        prefix,
+        limit,
+      },
+    }),
+    listAzureSqlBacpacBackupOperations: ({
+      databaseName,
+      resourceGroup,
+      serverName,
+      subscription,
+      operationFilter,
+      limit,
+    } = {}) => client._request('/api/operator/database/backups/azure-sql-bacpac/operations', {
+      query: {
+        database_name: databaseName,
+        resource_group: resourceGroup,
+        server_name: serverName,
+        subscription,
+        operation_filter: operationFilter,
+        limit,
+      },
+    }),
     backups: createDatabaseBackupsDomain(client),
   };
 }

package/src/domains/design-intelligence.js

@@ -1,16 +1,16 @@
 export function createDesignIntelligenceDomain(client) {
   return {
-    getDesignIntelligenceDashboard: () => client.getDesignIntelligenceDashboard(),
-    listDesignDecisions: () => client.listDesignDecisions(),
-    getDesignDecision: (decisionId) => client.getDesignDecision(decisionId),
-    getDesignDecisionVariants: (decisionId) => client.getDesignDecisionVariants(decisionId),
-    getDesignDecisionCritique: (decisionId) => client.getDesignDecisionCritique(decisionId),
-    getDesignDecisionLineage: (decisionId) => client.getDesignDecisionLineage(decisionId),
-    listDesignPatterns: () => client.listDesignPatterns(),
-    getDecisionLabCanvas: () => client.getDecisionLabCanvas(),
-    getDesignRecommendations: () => client.getDesignRecommendations(),
-    getDesignPromotions: () => client.getDesignPromotions(),
-    previewDesignPromotion: (body) => client.previewDesignPromotion(body),
-    getDesignIntelligenceMetrics: () => client.getDesignIntelligenceMetrics(),
+    getDesignIntelligenceDashboard: () => client._request('/api/design-intelligence/dashboard'),
+    listDesignDecisions: () => client._request('/api/design-intelligence/decisions'),
+    getDesignDecision: (decisionId) => client._request(`/api/design-intelligence/decisions/${decisionId}`),
+    getDesignDecisionVariants: (decisionId) => client._request(`/api/design-intelligence/decisions/${decisionId}/variants`),
+    getDesignDecisionCritique: (decisionId) => client._request(`/api/design-intelligence/decisions/${decisionId}/critique`),
+    getDesignDecisionLineage: (decisionId) => client._request(`/api/design-intelligence/decisions/${decisionId}/lineage`),
+    listDesignPatterns: () => client._request('/api/design-intelligence/patterns'),
+    getDecisionLabCanvas: () => client._request('/api/design-intelligence/decision-lab/canvas'),
+    getDesignRecommendations: () => client._request('/api/design-intelligence/recommendations'),
+    getDesignPromotions: () => client._request('/api/design-intelligence/promotions'),
+    previewDesignPromotion: (body) => client._request('/api/design-intelligence/promotions/preview', { method: 'POST', body }),
+    getDesignIntelligenceMetrics: () => client._request('/api/design-intelligence/metrics'),
   };
 }

package/src/domains/execution-telemetry.js

@@ -1,8 +1,18 @@
 export function createExecutionTelemetryDomain(client) {
   return {
-    getCurrent: () => client.getExecutionTelemetryCurrent(),
-    listProcessRuns: (request) => client.listExecutionProcessRuns(request),
-    getProcessRun: (processRunId) => client.getExecutionProcessRun(processRunId),
-    getGeneratedExecutionUsability: (request) => client.getGeneratedExecutionUsability(request),
+    getExecutionTelemetryCurrent: () => client._request('/api/operator/execution-telemetry/current'),
+    getCurrent: () => client._request('/api/operator/execution-telemetry/current'),
+    listExecutionProcessRuns: ({ limit, artifactKind, status, since } = {}) => client._request('/api/operator/execution-telemetry/process-runs', {
+      query: { limit, artifact_kind: artifactKind, status, since },
+    }),
+    listProcessRuns: (request) => client.executionTelemetry.listExecutionProcessRuns(request),
+    getExecutionProcessRun: (processRunId) => client._request(`/api/operator/execution-telemetry/process-runs/${processRunId}`),
+    getProcessRun: (processRunId) => client.executionTelemetry.getExecutionProcessRun(processRunId),
+    getGeneratedExecutionUsability: ({ artifactPath, limit } = {}) => client._request('/api/operator/generated-execution-usability', {
+      query: { artifact_path: artifactPath, limit },
+    }),
+    getLogaGeneratedExecutionUsabilityProjection: ({ artifactPath, limit } = {}) => client._requestLogaProjection('/api/loga/ai-engine/generated-execution-usability', {
+      query: { artifact_path: artifactPath, limit },
+    }),
   };
 }

package/src/domains/health.js

@@ -1,5 +1,16 @@
 export function createHealthDomain(client) {
   return {
-    ping: () => client.ping(),
+    ping: async () => {
+      const [health, workflow] = await Promise.all([
+        client._request('/healthz'),
+        client.currentWorkflowStatus(),
+      ]);
+      return {
+        status: health.status || 'ok',
+        workflow_name: workflow?.summary?.workflow_name || null,
+        run_status: workflow?.summary?.run_status || null,
+        base_url: client.baseUrl,
+      };
+    },
   };
 }

package/src/domains/loga.js

@@ -1,13 +1,58 @@
 export function createLogaDomain(client) {
   return {
-    submitUxGateRemediation: (payload) => client.submitUxGateRemediation(payload),
-    listUxGateRemediations: (query) => client.listUxGateRemediations(query),
-    getUxGateRemediation: (remediationId) => client.getUxGateRemediation(remediationId),
-    appendUxRemediationTicketNote: (remediationId, payload) => client.appendUxRemediationTicketNote(remediationId, payload),
-    listUxRemediationTicketNotes: (remediationId) => client.listUxRemediationTicketNotes(remediationId),
-    promoteUxGateRemediationImplementationCandidate: (remediationId, payload) =>
-      client.promoteUxGateRemediationImplementationCandidate(remediationId, payload),
-    getUxGateRemediationProjection: (remediationId) => client.getLogaUxGateRemediationProjection(remediationId),
-    getGeneratedExecutionUsabilityProjection: (query) => client.getLogaGeneratedExecutionUsabilityProjection(query),
+    submitUxGateRemediation: ({
+      projectionType,
+      projectionId,
+      gateRunId,
+      findingIds,
+      remediationPayload,
+      sourceTruth = 'sql',
+      clientEvidence,
+      createdBy,
+    } = {}) => client._request('/api/loga/ux-gate-remediations', {
+      method: 'POST',
+      body: {
+        projectionType,
+        projectionId,
+        gateRunId,
+        findingIds,
+        remediationPayload,
+        sourceTruth,
+        clientEvidence,
+        createdBy,
+      },
+    }),
+    listUxGateRemediations: ({ projectionType, status } = {}) => client._request('/api/loga/ux-gate-remediations', {
+      query: { projectionType, status },
+    }),
+    getUxGateRemediation: (remediationId) => client._request(`/api/loga/ux-gate-remediations/${remediationId}`),
+    appendUxRemediationTicketNote: (remediationId, {
+      noteKind,
+      body,
+      visibility,
+      authorActorId,
+      evidenceRefs,
+      metadata,
+    } = {}) => client._request(`/api/loga/ux-gate-remediations/${remediationId}/notes`, {
+      method: 'POST',
+      body: {
+        noteKind,
+        body,
+        visibility,
+        authorActorId,
+        evidenceRefs,
+        metadata,
+      },
+    }),
+    listUxRemediationTicketNotes: (remediationId) => client._request(`/api/loga/ux-gate-remediations/${remediationId}/notes`),
+    promoteUxGateRemediationImplementationCandidate: (remediationId, { promotedBy } = {}) => client._request(`/api/loga/ux-gate-remediations/${remediationId}/implementation-candidate`, {
+      method: 'POST',
+      body: { promotedBy },
+    }),
+    getLogaUxGateRemediationProjection: (remediationId) => client._requestLogaProjection(`/api/operator/projections/ux-gate-remediations/${remediationId}`),
+    getUxGateRemediationProjection: (remediationId) => client.loga.getLogaUxGateRemediationProjection(remediationId),
+    getGeneratedExecutionUsabilityProjection: (query) => client._requestLogaProjection('/api/loga/ai-engine/generated-execution-usability', {
+      query,
+    }),
   };
 }

package/src/domains/notes-lab.js

@@ -1,7 +1,7 @@
 export function createNotesLabDomain(client) {
   return {
-    getNotesLabConfig: () => client.getNotesLabConfig(),
-    submitNote: (body) => client.submitNote(body),
-    approveNoteReview: (body) => client.approveNoteReview(body),
+    getNotesLabConfig: () => client._request('/api/notes-lab/config'),
+    submitNote: (body) => client._request('/api/notes-lab/submit', { method: 'POST', body }),
+    approveNoteReview: (body) => client._request('/api/notes-lab/approve-review', { method: 'POST', body }),
   };
 }

package/src/domains/operator-status.js

@@ -1,15 +1,35 @@
 export function createOperatorStatusDomain(client) {
   return {
-    currentWorkflowStatus: () => client.currentWorkflowStatus(),
-    currentArchitectureIntegrityStatus: () => client.currentArchitectureIntegrityStatus(),
-    currentSecurityGovernanceStatus: (request) => client.currentSecurityGovernanceStatus(request),
-    getExecutionTelemetryCurrent: () => client.getExecutionTelemetryCurrent(),
-    listExecutionProcessRuns: (request) => client.listExecutionProcessRuns(request),
-    getExecutionProcessRun: (processRunId) => client.getExecutionProcessRun(processRunId),
-    getGeneratedExecutionUsability: (request) => client.getGeneratedExecutionUsability(request),
-    getLogaGeneratedExecutionUsabilityProjection: (request) => client.getLogaGeneratedExecutionUsabilityProjection(request),
-    getAntiPatternRules: () => client.getAntiPatternRules(),
-    currentCodebaseShapeStatus: () => client.currentCodebaseShapeStatus(),
-    getLatestMemoryProjection: () => client.getLatestMemoryProjection(),
+    currentWorkflowStatus: () => client._request('/api/operator/current-workflow-status'),
+    getCurrentWorkflowStatus: () => client._request('/api/operator/current-workflow-status'),
+    currentArchitectureIntegrityStatus: () => client._request('/api/operator/current-architecture-integrity-status'),
+    getCurrentArchitectureIntegrityStatus: () => client._request('/api/operator/current-architecture-integrity-status'),
+    currentSecurityGovernanceStatus: ({ environment, topN } = {}) => client._request('/api/operator/current-security-governance-status', {
+      query: { environment, top_n: topN },
+    }),
+    getCurrentSecurityGovernanceStatus: (request) => client._request('/api/operator/current-security-governance-status', {
+      query: { environment: request?.environment, top_n: request?.topN },
+    }),
+    getExecutionTelemetryCurrent: () => client._request('/api/operator/execution-telemetry/current'),
+    listExecutionProcessRuns: ({ limit, artifactKind, status, since } = {}) => client._request('/api/operator/execution-telemetry/process-runs', {
+      query: { limit, artifact_kind: artifactKind, status, since },
+    }),
+    getExecutionProcessRun: (processRunId) => client._request(`/api/operator/execution-telemetry/process-runs/${processRunId}`),
+    getGeneratedExecutionUsability: ({ artifactPath, limit } = {}) => client._request('/api/operator/generated-execution-usability', {
+      query: { artifact_path: artifactPath, limit },
+    }),
+    getLogaGeneratedExecutionUsabilityProjection: ({ artifactPath, limit } = {}) => client._requestLogaProjection('/api/loga/ai-engine/generated-execution-usability', {
+      query: { artifact_path: artifactPath, limit },
+    }),
+    getAntiPatternRules: () => client._request('/api/governance/anti-pattern-rules'),
+    currentCodebaseShapeStatus: () => client._request('/api/operator/current-codebase-shape-status'),
+    getLatestMemoryProjection: () => client._request('/api/v1/latest-memory-projection'),
+    currentProjectStatus: ({ projectId } = {}) => client._request('/api/operator/current-project-status', {
+      query: { project_id: projectId },
+    }),
+    getDashboard: () => client._request('/api/dashboard'),
+    getCommunicationCapabilities: () => client._request('/api/agent-communications/capabilities'),
+    getCollaborationCapabilities: () => client._request('/api/agent-communications/collaboration-capabilities'),
+    getDeploymentCapabilities: () => client._request('/api/agent-communications/deployment-capabilities'),
   };
 }

package/src/domains/performance.js

@@ -1,8 +1,19 @@
 export function createPerformanceDomain(client) {
   return {
-    getSessionPerformanceMetrics: (request) => client.getSessionPerformanceMetrics(request),
-    getBenchmarkDelta: (request) => client.getBenchmarkDelta(request),
-    getBenchmarkTrend: (request) => client.getBenchmarkTrend(request),
-    getPerformanceDashboard: (request) => client.getPerformanceDashboard(request),
+    getSessionPerformanceMetrics: ({ clientType, workflowRunId, sessionId } = {}) => client._request('/api/operator/performance/sessions', {
+      query: { client_type: clientType, workflow_run_id: workflowRunId, session_id: sessionId },
+    }),
+    captureBenchmarkSnapshot: (body) => client._request('/api/operator/performance/benchmarks', { method: 'POST', body }),
+    listBenchmarks: ({ benchmarkScope } = {}) => client._request('/api/operator/performance/benchmarks', {
+      query: { benchmark_scope: benchmarkScope },
+    }),
+    getBenchmarkMetrics: (benchmarkName) => client._request(`/api/operator/performance/benchmarks/${benchmarkName}/metrics`),
+    getBenchmarkDelta: ({ baseline, current } = {}) => client._request('/api/operator/performance/delta', { query: { baseline, current } }),
+    getBenchmarkTrend: ({ metricKey, dimensionValue, limit } = {}) => client._request('/api/operator/performance/trend', {
+      query: { metric_key: metricKey, dimension_value: dimensionValue, limit },
+    }),
+    getPerformanceDashboard: ({ clientType, workflowRunId } = {}) => client._request('/api/operator/performance/dashboard', {
+      query: { client_type: clientType, workflow_run_id: workflowRunId },
+    }),
   };
 }

package/src/domains/projections.js

@@ -1,13 +1,69 @@
+import { cleanText, isPlainObject } from '../utils/text.js';
+
 export function createProjectionsDomain(client) {
   return {
-    render: (request) => client.renderProjection(request),
-    getTransferHomeProjection: () => client.getLogaTransferHomeProjection(),
-    getTransferInboxProjection: (query) => client.getLogaTransferInboxProjection(query),
-    getTransferPacketProjection: (workTransferPacketId) => client.getLogaTransferPacketProjection(workTransferPacketId),
-    getTransferChannelProjection: (transferChannelId) => client.getTransferChannelProjection(transferChannelId),
-    getTransferNegotiationEventsProjection: (query) => client.getLogaTransferNegotiationEventsProjection(query),
-    getTransferFrictionLaneProjection: (query) => client.getLogaTransferFrictionLaneProjection(query),
-    getTransferReceiptsProjection: (query) => client.getLogaTransferReceiptsProjection(query),
-    getTransferClosureReviewProjection: (workTransferPacketId) => client.getLogaTransferClosureReviewProjection(workTransferPacketId),
+    renderProjection: ({ projectionType, viewContract = {}, requestedBy } = {}) => {
+      const normalizedProjectionType = cleanText(projectionType);
+      if (!normalizedProjectionType) {
+        throw new Error('projectionType is required.');
+      }
+      return client._request('/api/gateway/projections/render', {
+        method: 'POST',
+        body: {
+          projection_type: normalizedProjectionType,
+          view_contract: isPlainObject(viewContract) ? viewContract : {},
+          requested_by: cleanText(requestedBy),
+        },
+      });
+    },
+    render: (request) => client.projections.renderProjection(request),
+    getLogaOperatorHomeProjection: () => client._requestLogaProjection('/api/operator/projections/home'),
+    getLogaProjectCatalogProjection: () => client._requestLogaProjection('/api/operator/projections/project-catalog'),
+    getLogaProjectPortfolioProjection: () => client._requestLogaProjection('/api/operator/projections/project-portfolio'),
+    getLogaProjectRoadmapProjection: (projectId) => client._requestLogaProjection(`/api/operator/projections/projects/${projectId}/roadmap.md`),
+    getLogaRoadmapItemProjection: (projectId, itemKey) => client._requestLogaProjection(`/api/operator/projections/projects/${projectId}/roadmap/items/${itemKey}`),
+    getLogaWorkflowRunProjection: (workflowRunId) => client._requestLogaProjection(`/api/operator/projections/workflow-runs/${workflowRunId}`),
+    getLogaEvidencePacketProjection: (packetKey) => client._requestLogaProjection(`/api/operator/projections/evidence-packets/${packetKey}`),
+    getLogaTransferHomeProjection: () => client._requestLogaProjection('/api/operator/projections/transfers/home'),
+    getLogaTransferInboxProjection: ({ workflowRunId, recipientAgentSessionId, recipientRoleKey } = {}) => client._requestLogaProjection('/api/operator/projections/transfers/inbox', {
+      query: {
+        workflow_run_id: workflowRunId,
+        recipient_agent_session_id: recipientAgentSessionId,
+        recipient_role_key: recipientRoleKey,
+      },
+    }),
+    getLogaTransferPacketProjection: (workTransferPacketId) => client._requestLogaProjection(`/api/operator/projections/transfers/${workTransferPacketId}`),
+    getLogaTransferNegotiationEventsProjection: ({ workTransferPacketId, workflowRunId } = {}) => {
+      const path = workTransferPacketId
+        ? `/api/operator/projections/transfers/${workTransferPacketId}/negotiation-events`
+        : '/api/operator/projections/transfers/negotiation-events';
+      return client._requestLogaProjection(path, {
+        query: { workflow_run_id: workflowRunId },
+      });
+    },
+    getLogaTransferFrictionLaneProjection: ({ workflowRunId } = {}) => client._requestLogaProjection('/api/operator/projections/transfers/friction-lane', {
+      query: { workflow_run_id: workflowRunId },
+    }),
+    getLogaTransferReceiptsProjection: ({ workTransferPacketId, workflowRunId } = {}) => client._requestLogaProjection('/api/operator/projections/transfers/receipts', {
+      query: {
+        work_transfer_packet_id: workTransferPacketId,
+        workflow_run_id: workflowRunId,
+      },
+    }),
+    getLogaTransferClosureReviewProjection: (workTransferPacketId) => client._requestLogaProjection(`/api/operator/projections/transfers/${workTransferPacketId}/closure-review`),
+    getTransferChannelProjection: (transferChannelId) => {
+      const normalizedTransferChannelId = cleanText(transferChannelId);
+      if (!normalizedTransferChannelId) {
+        throw new Error('transferChannelId is required.');
+      }
+      return client._requestLogaProjection(`/api/operator/projections/transfers/channels/${encodeURIComponent(normalizedTransferChannelId)}`);
+    },
+    getTransferHomeProjection: () => client._requestLogaProjection('/api/operator/projections/transfers/home'),
+    getTransferInboxProjection: (request) => client.projections.getLogaTransferInboxProjection(request),
+    getTransferPacketProjection: (workTransferPacketId) => client.projections.getLogaTransferPacketProjection(workTransferPacketId),
+    getTransferNegotiationEventsProjection: (request) => client.projections.getLogaTransferNegotiationEventsProjection(request),
+    getTransferFrictionLaneProjection: (request) => client.projections.getLogaTransferFrictionLaneProjection(request),
+    getTransferReceiptsProjection: (request) => client.projections.getLogaTransferReceiptsProjection(request),
+    getTransferClosureReviewProjection: (workTransferPacketId) => client.projections.getLogaTransferClosureReviewProjection(workTransferPacketId),
   };
 }

package/src/domains/reports.js

@@ -2,7 +2,22 @@ import { cleanText, isPlainObject } from '../utils/text.js';
 
 export function createReportsDomain(client) {
   return {
-    run({ reportKey, definition = {}, requestedBy } = {}) {
+    runReport: ({ reportKey, definition = {}, requestedBy } = {}) => {
+      const normalizedReportKey = cleanText(reportKey);
+      if (!normalizedReportKey) {
+        throw new Error('reportKey is required.');
+      }
+      return client._request('/api/gateway/reports/run', {
+        method: 'POST',
+        body: {
+          report_key: normalizedReportKey,
+          definition: isPlainObject(definition) ? definition : {},
+          requested_by: cleanText(requestedBy),
+        },
+      });
+    },
+    run: (request) => client.reports.runReport(request),
+    runReportDefinition: ({ reportKey, definition = {}, requestedBy } = {}) => {
       const normalizedReportKey = cleanText(reportKey);
       if (!normalizedReportKey) {
         throw new Error('reportKey is required.');

package/src/domains/script-discovery.js

@@ -1,9 +1,12 @@
 export function createScriptDiscoveryDomain(client) {
   return {
-    scanScripts: (body) => client.scanScripts(body),
-    listDiscoveredScriptAssets: (request) => client.listDiscoveredScriptAssets(request),
-    listDiscoveredCapabilities: (request) => client.listDiscoveredCapabilities(request),
-    listWorkflowCandidates: (request) => client.listWorkflowCandidates(request),
-    promoteWorkflowCandidate: (workflowCandidateId, body) => client.promoteWorkflowCandidate(workflowCandidateId, body),
+    scanScripts: (body = {}) => client._request('/api/script-discovery/scan', { method: 'POST', body }),
+    listDiscoveredScriptAssets: ({ limit } = {}) => client._request('/api/script-discovery/script-assets', { query: { limit } }),
+    listDiscoveredCapabilities: ({ limit } = {}) => client._request('/api/script-discovery/discovered-capabilities', { query: { limit } }),
+    listWorkflowCandidates: ({ limit } = {}) => client._request('/api/script-discovery/workflow-candidates', { query: { limit } }),
+    promoteWorkflowCandidate: (workflowCandidateId, body = {}) => client._request(`/api/script-discovery/workflow-candidates/${workflowCandidateId}/promote`, {
+      method: 'POST',
+      body,
+    }),
   };
 }