@bpmsoftwaresolutions/ai-engine-client 1.1.86 → 1.1.87

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bpmsoftwaresolutions/ai-engine-client",
-  "version": "1.1.86",
+  "version": "1.1.87",
   "description": "Thin npm client for the AI Engine operator and retrieval APIs",
   "type": "module",
   "main": "./src/index.js",

package/src/client.js

@@ -47,6 +47,7 @@ import { createTransferBundlesDomain } from './domains/transfer-bundles.js';
 import { createTransferChannelsDomain } from './domains/transfer-channels.js';
 import { createToolRegistryDomain } from './domains/tool-registry.js';
 import { createWorkflowCompositionDomain } from './domains/workflow-composition.js';
+import { createWorkflowsDomain } from './domains/workflows.js';
 import { createWarehouseDomain } from './domains/warehouse.js';
 import { buildHeaders, requestBinary, requestJson, requestLogaProjection, requestText, resolveAccessToken } from './transport/index.js';
 import { normalizeEnum, trimTrailingSlash } from './utils/text.js';
@@ -404,6 +405,7 @@ export class AIEngineClient {
     this.retrievalWrapper = createRetrievalWrapperDomain(this);
     this.repo = createRepoDomain(this);
     this.retrievalManagement = createRetrievalManagementDomain(this);
+    this.workflows = createWorkflowsDomain(this);
     this.capabilities = createCapabilitiesDomain(this);
     this.benchmarks = createBenchmarksDomain(this);
     this.selfLearning = createSelfLearningDomain(this);
@@ -561,18 +563,7 @@ export class AIEngineClient {
   }
 
   async runReportDefinition({ reportKey, definition = {}, requestedBy } = {}) {
-    const normalizedReportKey = cleanText(reportKey);
-    if (!normalizedReportKey) {
-      throw new Error('reportKey is required.');
-    }
-    return this._request('/api/gateway/reports/run', {
-      method: 'POST',
-      body: {
-        report_key: normalizedReportKey,
-        definition: isPlainObject(definition) ? definition : {},
-        requested_by: cleanText(requestedBy),
-      },
-    });
+    return this.reports.run({ reportKey, definition, requestedBy });
   }
 
   async renderProjection({ projectionType, viewContract = {}, requestedBy } = {}) {
@@ -3706,315 +3697,243 @@ export class AIEngineClient {
   // ─── Retrieval Wrapper ─────────────────────────────────────────────────────
 
   async getCommandCard({ commandKey, alias, intentText, requestedBy } = {}) {
-    return this._request('/api/operator/retrieval/wrapper/command-card', {
-      query: { command_key: commandKey, alias, intent_text: intentText, requested_by: requestedBy },
-    });
+    return this.retrievalWrapper.getCommandCard({ commandKey, alias, intentText, requestedBy });
   }
 
   async resolveOperatingProcedure({ procedureKey, intentText, requestedBy } = {}) {
-    return this._request('/api/operator/retrieval/wrapper/operating-procedure', {
-      query: { procedure_key: procedureKey, intent_text: intentText, requested_by: requestedBy },
-    });
+    return this.retrievalWrapper.resolveOperatingProcedure({ procedureKey, intentText, requestedBy });
   }
 
   async getSymbolDefinition({ symbolKey, qualifiedName, symbolName, projectScope, includeCode = true, maxLines = 120, requestedBy } = {}) {
-    return this._request('/api/operator/retrieval/wrapper/symbol-definition', {
-      query: {
-        symbol_key: symbolKey,
-        qualified_name: qualifiedName,
-        symbol_name: symbolName,
-        project_scope: projectScope,
-        include_code: includeCode,
-        max_lines: maxLines,
-        requested_by: requestedBy,
-      },
-    });
+    return this.retrievalWrapper.getSymbolDefinition({ symbolKey, qualifiedName, symbolName, projectScope, includeCode, maxLines, requestedBy });
   }
 
   async getRelatedCode({ symbolKey, qualifiedName, relationshipType, depth = 1, includeCode = false, maxLines = 80, requestedBy } = {}) {
-    return this._request('/api/operator/retrieval/wrapper/related-code', {
-      query: {
-        symbol_key: symbolKey,
-        qualified_name: qualifiedName,
-        relationship_type: relationshipType,
-        depth,
-        include_code: includeCode,
-        max_lines: maxLines,
-        requested_by: requestedBy,
-      },
-    });
+    return this.retrievalWrapper.getRelatedCode({ symbolKey, qualifiedName, relationshipType, depth, includeCode, maxLines, requestedBy });
   }
 
   // ─── Repo Inventory ───────────────────────────────────────────────────────
 
   async listRepositories({ limit } = {}) {
-    return this._request('/api/repo/repositories', {
-      query: { limit },
-    });
+    return this.repo.listRepositories({ limit });
   }
 
   async getRepository(repositoryId) {
-    return this._request(`/api/repo/repositories/${repositoryId}`);
+    return this.repo.getRepository(repositoryId);
   }
 
   async listProjects({ repositoryId, repoKey, limit } = {}) {
-    return this._request('/api/repo/projects', {
-      query: { repository_id: repositoryId, repo_key: repoKey, limit },
-    });
+    return this.repo.listProjects({ repositoryId, repoKey, limit });
   }
 
   async getProject(projectId) {
-    return this._request(`/api/repo/projects/${projectId}`);
+    return this.repo.getProject(projectId);
   }
 
   async listCodeFiles({ repositoryId, projectId, language, pathPrefix, page = 1, pageSize = 50 } = {}) {
-    return this._request('/api/repo/files', {
-      query: {
-        repository_id: repositoryId,
-        project_id: projectId,
-        language,
-        path_prefix: pathPrefix,
-        page,
-        page_size: pageSize,
-      },
-    });
+    return this.repo.listCodeFiles({ repositoryId, projectId, language, pathPrefix, page, pageSize });
   }
 
   async getCodeFile(fileId) {
-    return this._request(`/api/repo/files/${fileId}`);
+    return this.repo.getCodeFile(fileId);
   }
 
   async getCodeFileContentWindow(fileId, { startLine = 1, endLine } = {}) {
-    return this._request(`/api/repo/files/${fileId}/content-window`, {
-      query: { start_line: startLine, end_line: endLine ?? startLine },
-    });
+    return this.repo.getCodeFileContentWindow(fileId, { startLine, endLine });
   }
 
   async listCodeSymbolsByFile(fileId, { limit = 500 } = {}) {
-    return this._request(`/api/repo/files/${fileId}/symbols`, {
-      query: { limit },
-    });
+    return this.repo.listCodeSymbolsByFile(fileId, { limit });
   }
 
   async getCodeSymbol(symbolId, { includeCode = false, maxLines = 120 } = {}) {
-    return this._request(`/api/repo/symbols/${symbolId}`, {
-      query: { include_code: includeCode, max_lines: maxLines },
-    });
+    return this.repo.getCodeSymbol(symbolId, { includeCode, maxLines });
   }
 
   async searchSymbols({ query, projectScope, maxResults = 10 } = {}) {
-    return this._request('/api/repo/symbols/search', {
-      query: { query, project_scope: projectScope, max_results: maxResults },
-    });
+    return this.repo.searchSymbols({ query, projectScope, maxResults });
   }
 
   async getSymbolRelationships(symbolId, { relationshipType, depth = 1 } = {}) {
-    return this._request(`/api/repo/symbols/${symbolId}/relationships`, {
-      query: { relationship_type: relationshipType, depth },
-    });
+    return this.repo.getSymbolRelationships(symbolId, { relationshipType, depth });
   }
 
   async listCodeRelationships({ repositoryId, projectId, relationshipType, limit = 100 } = {}) {
-    return this._request('/api/repo/relationships', {
-      query: { repository_id: repositoryId, project_id: projectId, relationship_type: relationshipType, limit },
-    });
+    return this.repo.listCodeRelationships({ repositoryId, projectId, relationshipType, limit });
   }
 
   async listActionObservations({ repositoryId, projectPath, filePath, symbolId, actionKind, limit = 100 } = {}) {
-    return this._request('/api/repo/action-observations', {
-      query: { repository_id: repositoryId, project_path: projectPath, file_path: filePath, symbol_id: symbolId, action_kind: actionKind, limit },
-    });
+    return this.repo.listActionObservations({ repositoryId, projectPath, filePath, symbolId, actionKind, limit });
   }
 
   async listCodebaseShapeFindings({ repositoryId, projectPath, filePath, severity, status, limit = 100 } = {}) {
-    return this._request('/api/repo/shape/findings', {
-      query: { repository_id: repositoryId, project_path: projectPath, file_path: filePath, severity, status, limit },
-    });
+    return this.repo.listCodebaseShapeFindings({ repositoryId, projectPath, filePath, severity, status, limit });
   }
 
   async listObjectFlowObservations({ repositoryId, projectPath, filePath, objectKind, boundaryKind, limit = 100 } = {}) {
-    return this._request('/api/repo/object-flow-observations', {
-      query: { repository_id: repositoryId, project_path: projectPath, file_path: filePath, object_kind: objectKind, boundary_kind: boundaryKind, limit },
-    });
+    return this.repo.listObjectFlowObservations({ repositoryId, projectPath, filePath, objectKind, boundaryKind, limit });
   }
 
   async getChangeAnalysis({ fileId, symbolId, limit = 25 } = {}) {
-    return this._request('/api/repo/change-analysis', {
-      query: { file_id: fileId, symbol_id: symbolId, limit },
-    });
+    return this.repo.getChangeAnalysis({ fileId, symbolId, limit });
   }
 
   async listRefactorCandidates({ repositoryRoot, limit = 10 } = {}) {
-    return this._request('/api/repo/refactor-candidates', {
-      query: { repository_root: repositoryRoot, limit },
-    });
+    return this.repo.listRefactorCandidates({ repositoryRoot, limit });
   }
 
   async analyzeRefactorCandidate({ filePath, requestedBy, packetId, refactorIntent } = {}) {
-    return this._request('/api/repo/refactor-candidate-analysis', {
-      method: 'POST',
-      body: { file_path: filePath, requested_by: requestedBy, packet_id: packetId, refactor_intent: refactorIntent },
-    });
+    return this.repo.analyzeRefactorCandidate({ filePath, requestedBy, packetId, refactorIntent });
   }
 
   async getRepoRetrievalPacket(retrievalPacketId) {
-    return this._request(`/api/repo/retrieval/packets/${retrievalPacketId}`);
+    return this.repo.getRepoRetrievalPacket(retrievalPacketId);
   }
 
   async getRepoRetrievalPacketFragments(retrievalPacketId) {
-    return this._request(`/api/repo/retrieval/packets/${retrievalPacketId}/fragments`);
+    return this.repo.getRepoRetrievalPacketFragments(retrievalPacketId);
   }
 
   async evaluateProposalScope({ filePath, projectId, changeType = 'refactor', requestedBy, refactorIntent } = {}) {
-    return this._request('/api/repo/proposal-scope-evaluation', {
-      method: 'POST',
-      body: { file_path: filePath, project_id: projectId, change_type: changeType, requested_by: requestedBy, refactor_intent: refactorIntent },
-    });
+    return this.repo.evaluateProposalScope({ filePath, projectId, changeType, requestedBy, refactorIntent });
   }
 
   // ─── Retrieval Management ──────────────────────────────────────────────────
 
   async getRetrievalStatus() {
-    return this._request('/api/operator/retrieval/status');
+    return this.retrievalManagement.getRetrievalStatus();
   }
 
   async getRetrievalProfileMetrics() {
-    return this._request('/api/operator/retrieval/profiles/metrics');
+    return this.retrievalManagement.getRetrievalProfileMetrics();
   }
 
   async getRetrievalFeedbackMetrics() {
-    return this._request('/api/operator/retrieval/feedback-metrics');
+    return this.retrievalManagement.getRetrievalFeedbackMetrics();
   }
 
   async getRetrievalQuery(retrievalQueryId) {
-    return this._request(`/api/operator/retrieval/queries/${retrievalQueryId}`);
+    return this.retrievalManagement.getRetrievalQuery(retrievalQueryId);
   }
 
   async getRetrievalPacket(retrievalPacketId) {
-    return this._request(`/api/operator/retrieval/packets/${retrievalPacketId}`);
+    return this.retrievalManagement.getRetrievalPacket(retrievalPacketId);
   }
 
   async generateRetrievalCandidates(body) {
-    return this._request('/api/operator/retrieval/generate-candidates', { method: 'POST', body });
+    return this.retrievalManagement.generateRetrievalCandidates(body);
   }
 
   async selectRetrievalPacket(body) {
-    return this._request('/api/operator/retrieval/select-packet', { method: 'POST', body });
+    return this.retrievalManagement.selectRetrievalPacket(body);
   }
 
   async recordRetrievalFeedback(body) {
-    return this._request('/api/operator/retrieval/feedback', { method: 'POST', body });
+    return this.retrievalManagement.recordRetrievalFeedback(body);
   }
 
   async deriveRetrievalOptimizationCandidates(body) {
-    return this._request('/api/operator/retrieval/optimization-candidates', { method: 'POST', body });
+    return this.retrievalManagement.deriveRetrievalOptimizationCandidates(body);
   }
 
   async validatePromptAssembly(body) {
-    return this._request('/api/operator/retrieval/validate-prompt-assembly', { method: 'POST', body });
+    return this.retrievalManagement.validatePromptAssembly(body);
   }
 
   // ─── Workflows ─────────────────────────────────────────────────────────────
 
   async listWorkflows({ status, includeSteps } = {}) {
-    return this._request('/api/workflows', {
-      query: { status, include_steps: includeSteps },
-    });
+    return this.workflows.listWorkflows({ status, includeSteps });
   }
 
   async createWorkflow({ name, slug, description, goal, governanceProfile, steps = [] } = {}) {
-    return this._request('/api/workflows', {
-      method: 'POST',
-      body: { name, slug, description, goal, governance_profile: governanceProfile, steps },
-    });
+    return this.workflows.createWorkflow({ name, slug, description, goal, governanceProfile, steps });
   }
 
   async getWorkflow(workflowId) {
-    return this._request(`/api/workflows/${workflowId}`);
+    return this.workflows.getWorkflow(workflowId);
   }
 
   async replaceWorkflowSteps(workflowId, steps) {
-    return this._request(`/api/workflows/${workflowId}/steps`, { method: 'PUT', body: { steps } });
+    return this.workflows.replaceWorkflowSteps(workflowId, steps);
   }
 
   async publishWorkflow(workflowId) {
-    return this._request(`/api/workflows/${workflowId}/publish`, { method: 'POST' });
+    return this.workflows.publishWorkflow(workflowId);
   }
 
   async cloneWorkflow(workflowId) {
-    return this._request(`/api/workflows/${workflowId}/clone`, { method: 'POST' });
+    return this.workflows.cloneWorkflow(workflowId);
   }
 
   // ─── Workflow Governance ───────────────────────────────────────────────────
 
   async evaluateWorkflowGovernance(workflowId) {
-    return this._request(`/api/workflows/${workflowId}/governance/evaluate`, { method: 'POST' });
+    return this.workflows.evaluateWorkflowGovernance(workflowId);
   }
 
   async listWorkflowGovernanceDecisions(workflowId) {
-    return this._request(`/api/workflows/${workflowId}/governance/decisions`);
+    return this.workflows.listWorkflowGovernanceDecisions(workflowId);
   }
 
   async getWorkflowGovernanceSimulation(workflowId) {
-    return this._request(`/api/workflows/${workflowId}/governance/simulation`);
+    return this.workflows.getWorkflowGovernanceSimulation(workflowId);
   }
 
   async listWorkflowGovernanceBundles(workflowId) {
-    return this._request(`/api/workflows/${workflowId}/governance/bundles`);
+    return this.workflows.listWorkflowGovernanceBundles(workflowId);
   }
 
   async listWorkflowGovernanceApprovals(workflowId) {
-    return this._request(`/api/workflows/${workflowId}/governance/approvals`);
+    return this.workflows.listWorkflowGovernanceApprovals(workflowId);
   }
 
   async listWorkflowGovernanceEvents(workflowId) {
-    return this._request(`/api/workflows/${workflowId}/governance/events`);
+    return this.workflows.listWorkflowGovernanceEvents(workflowId);
   }
 
   async getWorkflowGovernanceReview(workflowId) {
-    return this._request(`/api/workflows/${workflowId}/governance/review`);
+    return this.workflows.getWorkflowGovernanceReview(workflowId);
   }
 
   async createWorkflowGovernanceReviewDecision(workflowId, body) {
-    return this._request(`/api/workflows/${workflowId}/governance/review-decisions`, {
-      method: 'POST', body,
-    });
+    return this.workflows.createWorkflowGovernanceReviewDecision(workflowId, body);
   }
 
   // ─── Workflow Runs ─────────────────────────────────────────────────────────
 
   async createWorkflowRun(body) {
-    return this._request('/api/workflow-runs', { method: 'POST', body });
+    return this.workflows.createWorkflowRun(body);
   }
 
   async getWorkflowRun(workflowRunId) {
-    return this._request(`/api/workflow-runs/${workflowRunId}`);
+    return this.workflows.getWorkflowRun(workflowRunId);
   }
 
   async listWorkflowArtifacts(workflowRunId) {
-    return this._request(`/api/workflow-runs/${workflowRunId}/artifacts`);
+    return this.workflows.listWorkflowArtifacts(workflowRunId);
   }
 
   async getWorkflowRunSubstrate(workflowRunId) {
-    return this._request(`/api/workflow-runs/${workflowRunId}/substrate`);
+    return this.workflows.getWorkflowRunSubstrate(workflowRunId);
   }
 
   async getWorkflowPlayback(workflowRunId) {
-    return this._request(`/api/operator/workflow-runs/${workflowRunId}/playback`);
+    return this.workflows.getWorkflowPlayback(workflowRunId);
   }
 
   async resumeWorkflowRun(workflowRunId, body = {}) {
-    return this._request(`/api/workflow-runs/${workflowRunId}/resume`, { method: 'POST', body });
+    return this.workflows.resumeWorkflowRun(workflowRunId, body);
   }
 
   // ─── Workflow Inspector ────────────────────────────────────────────────────
 
   async listRecentInspectorRuns({ limit } = {}) {
-    return this._request('/api/workflow-inspector/runs/recent', { query: { limit } });
+    return this.workflows.listRecentInspectorRuns({ limit });
   }
 
   async inspectWorkflowRun(workflowRunId) {
-    return this._request(`/api/workflow-inspector/runs/${workflowRunId}`);
+    return this.workflows.inspectWorkflowRun(workflowRunId);
   }
 
   // ─── Manual & Approval Tasks ───────────────────────────────────────────────

package/src/domains/repo.js

@@ -1,25 +1,128 @@
 export function createRepoDomain(client) {
   return {
-    listRepositories: (request) => client.listRepositories(request),
-    getRepository: (repositoryId) => client.getRepository(repositoryId),
-    listProjects: (request) => client.listProjects(request),
-    getProject: (projectId) => client.getProject(projectId),
-    listCodeFiles: (request) => client.listCodeFiles(request),
-    getCodeFile: (fileId) => client.getCodeFile(fileId),
-    getCodeFileContentWindow: (fileId, request) => client.getCodeFileContentWindow(fileId, request),
-    listCodeSymbolsByFile: (fileId, request) => client.listCodeSymbolsByFile(fileId, request),
-    getCodeSymbol: (symbolId, request) => client.getCodeSymbol(symbolId, request),
-    searchSymbols: (request) => client.searchSymbols(request),
-    getSymbolRelationships: (symbolId, request) => client.getSymbolRelationships(symbolId, request),
-    listCodeRelationships: (request) => client.listCodeRelationships(request),
-    listActionObservations: (request) => client.listActionObservations(request),
-    listCodebaseShapeFindings: (request) => client.listCodebaseShapeFindings(request),
-    listObjectFlowObservations: (request) => client.listObjectFlowObservations(request),
-    getChangeAnalysis: (request) => client.getChangeAnalysis(request),
-    listRefactorCandidates: (request) => client.listRefactorCandidates(request),
-    analyzeRefactorCandidate: (request) => client.analyzeRefactorCandidate(request),
-    getRepoRetrievalPacket: (retrievalPacketId) => client.getRepoRetrievalPacket(retrievalPacketId),
-    getRepoRetrievalPacketFragments: (retrievalPacketId) => client.getRepoRetrievalPacketFragments(retrievalPacketId),
-    evaluateProposalScope: (request) => client.evaluateProposalScope(request),
+    listRepositories({ limit } = {}) {
+      return client._request('/api/repo/repositories', {
+        query: { limit },
+      });
+    },
+
+    getRepository(repositoryId) {
+      return client._request(`/api/repo/repositories/${repositoryId}`);
+    },
+
+    listProjects({ repositoryId, repoKey, limit } = {}) {
+      return client._request('/api/repo/projects', {
+        query: { repository_id: repositoryId, repo_key: repoKey, limit },
+      });
+    },
+
+    getProject(projectId) {
+      return client._request(`/api/repo/projects/${projectId}`);
+    },
+
+    listCodeFiles({ repositoryId, projectId, language, pathPrefix, page = 1, pageSize = 50 } = {}) {
+      return client._request('/api/repo/files', {
+        query: {
+          repository_id: repositoryId,
+          project_id: projectId,
+          language,
+          path_prefix: pathPrefix,
+          page,
+          page_size: pageSize,
+        },
+      });
+    },
+
+    getCodeFile(fileId) {
+      return client._request(`/api/repo/files/${fileId}`);
+    },
+
+    getCodeFileContentWindow(fileId, { startLine = 1, endLine } = {}) {
+      return client._request(`/api/repo/files/${fileId}/content-window`, {
+        query: { start_line: startLine, end_line: endLine ?? startLine },
+      });
+    },
+
+    listCodeSymbolsByFile(fileId, { limit = 500 } = {}) {
+      return client._request(`/api/repo/files/${fileId}/symbols`, {
+        query: { limit },
+      });
+    },
+
+    getCodeSymbol(symbolId, { includeCode = false, maxLines = 120 } = {}) {
+      return client._request(`/api/repo/symbols/${symbolId}`, {
+        query: { include_code: includeCode, max_lines: maxLines },
+      });
+    },
+
+    searchSymbols({ query, projectScope, maxResults = 10 } = {}) {
+      return client._request('/api/repo/symbols/search', {
+        query: { query, project_scope: projectScope, max_results: maxResults },
+      });
+    },
+
+    getSymbolRelationships(symbolId, { relationshipType, depth = 1 } = {}) {
+      return client._request(`/api/repo/symbols/${symbolId}/relationships`, {
+        query: { relationship_type: relationshipType, depth },
+      });
+    },
+
+    listCodeRelationships({ repositoryId, projectId, relationshipType, limit = 100 } = {}) {
+      return client._request('/api/repo/relationships', {
+        query: { repository_id: repositoryId, project_id: projectId, relationship_type: relationshipType, limit },
+      });
+    },
+
+    listActionObservations({ repositoryId, projectPath, filePath, symbolId, actionKind, limit = 100 } = {}) {
+      return client._request('/api/repo/action-observations', {
+        query: { repository_id: repositoryId, project_path: projectPath, file_path: filePath, symbol_id: symbolId, action_kind: actionKind, limit },
+      });
+    },
+
+    listCodebaseShapeFindings({ repositoryId, projectPath, filePath, severity, status, limit = 100 } = {}) {
+      return client._request('/api/repo/shape/findings', {
+        query: { repository_id: repositoryId, project_path: projectPath, file_path: filePath, severity, status, limit },
+      });
+    },
+
+    listObjectFlowObservations({ repositoryId, projectPath, filePath, objectKind, boundaryKind, limit = 100 } = {}) {
+      return client._request('/api/repo/object-flow-observations', {
+        query: { repository_id: repositoryId, project_path: projectPath, file_path: filePath, object_kind: objectKind, boundary_kind: boundaryKind, limit },
+      });
+    },
+
+    getChangeAnalysis({ fileId, symbolId, limit = 25 } = {}) {
+      return client._request('/api/repo/change-analysis', {
+        query: { file_id: fileId, symbol_id: symbolId, limit },
+      });
+    },
+
+    listRefactorCandidates({ repositoryRoot, limit = 10 } = {}) {
+      return client._request('/api/repo/refactor-candidates', {
+        query: { repository_root: repositoryRoot, limit },
+      });
+    },
+
+    analyzeRefactorCandidate({ filePath, requestedBy, packetId, refactorIntent } = {}) {
+      return client._request('/api/repo/refactor-candidate-analysis', {
+        method: 'POST',
+        body: { file_path: filePath, requested_by: requestedBy, packet_id: packetId, refactor_intent: refactorIntent },
+      });
+    },
+
+    getRepoRetrievalPacket(retrievalPacketId) {
+      return client._request(`/api/repo/retrieval/packets/${retrievalPacketId}`);
+    },
+
+    getRepoRetrievalPacketFragments(retrievalPacketId) {
+      return client._request(`/api/repo/retrieval/packets/${retrievalPacketId}/fragments`);
+    },
+
+    evaluateProposalScope({ filePath, projectId, changeType = 'refactor', requestedBy, refactorIntent } = {}) {
+      return client._request('/api/repo/proposal-scope-evaluation', {
+        method: 'POST',
+        body: { file_path: filePath, project_id: projectId, change_type: changeType, requested_by: requestedBy, refactor_intent: refactorIntent },
+      });
+    },
   };
 }

package/src/domains/reports.js

@@ -1,5 +1,20 @@
+import { cleanText, isPlainObject } from '../utils/text.js';
+
 export function createReportsDomain(client) {
   return {
-    run: (request) => client.runReportDefinition(request),
+    run({ 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),
+        },
+      });
+    },
   };
 }

package/src/domains/retrieval-management.js

@@ -1,14 +1,23 @@
 export function createRetrievalManagementDomain(client) {
   return {
-    getRetrievalStatus: () => client.getRetrievalStatus(),
-    getRetrievalProfileMetrics: () => client.getRetrievalProfileMetrics(),
-    getRetrievalFeedbackMetrics: () => client.getRetrievalFeedbackMetrics(),
-    getRetrievalQuery: (retrievalQueryId) => client.getRetrievalQuery(retrievalQueryId),
-    getRetrievalPacket: (retrievalPacketId) => client.getRetrievalPacket(retrievalPacketId),
-    generateRetrievalCandidates: (body) => client.generateRetrievalCandidates(body),
-    selectRetrievalPacket: (body) => client.selectRetrievalPacket(body),
-    recordRetrievalFeedback: (body) => client.recordRetrievalFeedback(body),
-    deriveRetrievalOptimizationCandidates: (body) => client.deriveRetrievalOptimizationCandidates(body),
-    validatePromptAssembly: (body) => client.validatePromptAssembly(body),
+    getRetrievalStatus: () => client._request('/api/operator/retrieval/status'),
+
+    getRetrievalProfileMetrics: () => client._request('/api/operator/retrieval/profiles/metrics'),
+
+    getRetrievalFeedbackMetrics: () => client._request('/api/operator/retrieval/feedback-metrics'),
+
+    getRetrievalQuery: (retrievalQueryId) => client._request(`/api/operator/retrieval/queries/${retrievalQueryId}`),
+
+    getRetrievalPacket: (retrievalPacketId) => client._request(`/api/operator/retrieval/packets/${retrievalPacketId}`),
+
+    generateRetrievalCandidates: (body) => client._request('/api/operator/retrieval/generate-candidates', { method: 'POST', body }),
+
+    selectRetrievalPacket: (body) => client._request('/api/operator/retrieval/select-packet', { method: 'POST', body }),
+
+    recordRetrievalFeedback: (body) => client._request('/api/operator/retrieval/feedback', { method: 'POST', body }),
+
+    deriveRetrievalOptimizationCandidates: (body) => client._request('/api/operator/retrieval/optimization-candidates', { method: 'POST', body }),
+
+    validatePromptAssembly: (body) => client._request('/api/operator/retrieval/validate-prompt-assembly', { method: 'POST', body }),
   };
 }

package/src/domains/retrieval-wrapper.js

@@ -1,7 +1,43 @@
 export function createRetrievalWrapperDomain(client) {
   return {
-    getCommandCard: (request) => client.getCommandCard(request),
-    getSymbolDefinition: (request) => client.getSymbolDefinition(request),
-    getRelatedCode: (request) => client.getRelatedCode(request),
+    getCommandCard({ commandKey, alias, intentText, requestedBy } = {}) {
+      return client._request('/api/operator/retrieval/wrapper/command-card', {
+        query: { command_key: commandKey, alias, intent_text: intentText, requested_by: requestedBy },
+      });
+    },
+
+    resolveOperatingProcedure({ procedureKey, intentText, requestedBy } = {}) {
+      return client._request('/api/operator/retrieval/wrapper/operating-procedure', {
+        query: { procedure_key: procedureKey, intent_text: intentText, requested_by: requestedBy },
+      });
+    },
+
+    getSymbolDefinition({ symbolKey, qualifiedName, symbolName, projectScope, includeCode = true, maxLines = 120, requestedBy } = {}) {
+      return client._request('/api/operator/retrieval/wrapper/symbol-definition', {
+        query: {
+          symbol_key: symbolKey,
+          qualified_name: qualifiedName,
+          symbol_name: symbolName,
+          project_scope: projectScope,
+          include_code: includeCode,
+          max_lines: maxLines,
+          requested_by: requestedBy,
+        },
+      });
+    },
+
+    getRelatedCode({ symbolKey, qualifiedName, relationshipType, depth = 1, includeCode = false, maxLines = 80, requestedBy } = {}) {
+      return client._request('/api/operator/retrieval/wrapper/related-code', {
+        query: {
+          symbol_key: symbolKey,
+          qualified_name: qualifiedName,
+          relationship_type: relationshipType,
+          depth,
+          include_code: includeCode,
+          max_lines: maxLines,
+          requested_by: requestedBy,
+        },
+      });
+    },
   };
 }

package/src/domains/workflows.js

@@ -0,0 +1,99 @@
+export function createWorkflowsDomain(client) {
+  return {
+    listWorkflows({ status, includeSteps } = {}) {
+      return client._request('/api/workflows', {
+        query: { status, include_steps: includeSteps },
+      });
+    },
+
+    createWorkflow({ name, slug, description, goal, governanceProfile, steps = [] } = {}) {
+      return client._request('/api/workflows', {
+        method: 'POST',
+        body: { name, slug, description, goal, governance_profile: governanceProfile, steps },
+      });
+    },
+
+    getWorkflow(workflowId) {
+      return client._request(`/api/workflows/${workflowId}`);
+    },
+
+    replaceWorkflowSteps(workflowId, steps) {
+      return client._request(`/api/workflows/${workflowId}/steps`, { method: 'PUT', body: { steps } });
+    },
+
+    publishWorkflow(workflowId) {
+      return client._request(`/api/workflows/${workflowId}/publish`, { method: 'POST' });
+    },
+
+    cloneWorkflow(workflowId) {
+      return client._request(`/api/workflows/${workflowId}/clone`, { method: 'POST' });
+    },
+
+    evaluateWorkflowGovernance(workflowId) {
+      return client._request(`/api/workflows/${workflowId}/governance/evaluate`, { method: 'POST' });
+    },
+
+    listWorkflowGovernanceDecisions(workflowId) {
+      return client._request(`/api/workflows/${workflowId}/governance/decisions`);
+    },
+
+    getWorkflowGovernanceSimulation(workflowId) {
+      return client._request(`/api/workflows/${workflowId}/governance/simulation`);
+    },
+
+    listWorkflowGovernanceBundles(workflowId) {
+      return client._request(`/api/workflows/${workflowId}/governance/bundles`);
+    },
+
+    listWorkflowGovernanceApprovals(workflowId) {
+      return client._request(`/api/workflows/${workflowId}/governance/approvals`);
+    },
+
+    listWorkflowGovernanceEvents(workflowId) {
+      return client._request(`/api/workflows/${workflowId}/governance/events`);
+    },
+
+    getWorkflowGovernanceReview(workflowId) {
+      return client._request(`/api/workflows/${workflowId}/governance/review`);
+    },
+
+    createWorkflowGovernanceReviewDecision(workflowId, body) {
+      return client._request(`/api/workflows/${workflowId}/governance/review-decisions`, {
+        method: 'POST',
+        body,
+      });
+    },
+
+    createWorkflowRun(body) {
+      return client._request('/api/workflow-runs', { method: 'POST', body });
+    },
+
+    getWorkflowRun(workflowRunId) {
+      return client._request(`/api/workflow-runs/${workflowRunId}`);
+    },
+
+    listWorkflowArtifacts(workflowRunId) {
+      return client._request(`/api/workflow-runs/${workflowRunId}/artifacts`);
+    },
+
+    getWorkflowRunSubstrate(workflowRunId) {
+      return client._request(`/api/workflow-runs/${workflowRunId}/substrate`);
+    },
+
+    getWorkflowPlayback(workflowRunId) {
+      return client._request(`/api/operator/workflow-runs/${workflowRunId}/playback`);
+    },
+
+    resumeWorkflowRun(workflowRunId, body = {}) {
+      return client._request(`/api/workflow-runs/${workflowRunId}/resume`, { method: 'POST', body });
+    },
+
+    listRecentInspectorRuns({ limit } = {}) {
+      return client._request('/api/workflow-inspector/runs/recent', { query: { limit } });
+    },
+
+    inspectWorkflowRun(workflowRunId) {
+      return client._request(`/api/workflow-inspector/runs/${workflowRunId}`);
+    },
+  };
+}

package/src/index.js

@@ -1,5 +1,5 @@
 export { AIEngineClient, createAIEngineClient } from './client.js';
-export const AI_ENGINE_CLIENT_VERSION = '1.1.86';
+export const AI_ENGINE_CLIENT_VERSION = '1.1.87';
 export { GOVERNED_MUTATION_REQUIRED_CAPABILITIES, AI_ENGINE_CLIENT_CAPABILITIES, TASK_BOUND_SUBSTRATE_EXECUTION_POLICY } from './constants/governance.js';
 export { LOGA_CONTRACT, LOGA_INTERACTION_CONTRACT, LOGA_NAVIGATION_CONTRACT, LOGA_PROJECTION_WORKFLOW } from './constants/loga.js';
 export {