@bpmsoftwaresolutions/ai-engine-client 1.1.88 → 1.1.90

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,
+    }),
   };
 }

package/src/domains/scripts.js

@@ -1,8 +1,49 @@
 export function createScriptsDomain(client) {
   return {
-    generate: (payload) => client.generateScript(payload),
-    render: (scriptId) => client.renderScript(scriptId),
-    submitArtifact: (scriptId, payload) => client.submitScriptArtifact(scriptId, payload),
-    getRunEvidence: (query) => client.getScriptRunEvidence(query),
+    generateScript: ({
+      claimId,
+      contextSessionId,
+      workflowRunId,
+      intent = {},
+      renderSpec = {},
+      createdBy,
+    } = {}) => client._request('/api/scripts/generate', {
+      method: 'POST',
+      body: {
+        claimId,
+        contextSessionId,
+        workflowRunId,
+        intent,
+        renderSpec,
+        createdBy,
+      },
+    }),
+    generate: (payload) => client.scripts.generateScript(payload),
+    renderScript: (scriptId) => client._request(`/api/scripts/${scriptId}/render`),
+    render: (scriptId) => client.scripts.renderScript(scriptId),
+    submitScriptArtifact: (scriptId, {
+      workflowRunId,
+      output = {},
+      observations = [],
+      validation = {},
+      recordedBy,
+    } = {}) => client._request(`/api/scripts/${scriptId}/artifacts`, {
+      method: 'POST',
+      body: {
+        workflowRunId,
+        output,
+        observations,
+        validation,
+        recordedBy,
+      },
+    }),
+    submitArtifact: (scriptId, payload) => client.scripts.submitScriptArtifact(scriptId, payload),
+    getScriptRunEvidence: ({ workflowRunId, scriptId } = {}) => client._request('/api/scripts/run-evidence', {
+      query: {
+        workflowRunId,
+        scriptId,
+      },
+    }),
+    getRunEvidence: (query) => client.scripts.getScriptRunEvidence(query),
   };
 }

package/src/domains/search-contacts.js

@@ -1,7 +1,7 @@
 export function createSearchContactsDomain(client) {
   return {
-    search: (query) => client.search(query),
-    getOrganization: (entityId) => client.getOrganization(entityId),
-    getContact: (contactId) => client.getContact(contactId),
+    search: (query) => client._request('/api/search', { query: { q: query } }),
+    getOrganization: (entityId) => client._request(`/api/organizations/${entityId}`),
+    getContact: (contactId) => client._request(`/api/contacts/${contactId}`),
   };
 }

package/src/domains/self-learning.js

@@ -1,10 +1,33 @@
 export function createSelfLearningDomain(client) {
   return {
-    getSelfLearningPosture: (request) => client.getSelfLearningPosture(request),
-    listLearningRecords: (request) => client.listLearningRecords(request),
-    getLearningRecord: (learningRecordId) => client.getLearningRecord(learningRecordId),
-    listPromotionCandidates: (request) => client.listPromotionCandidates(request),
-    getPromotionCandidate: (candidateKey) => client.getPromotionCandidate(candidateKey),
-    listPromotionFlows: (request) => client.listPromotionFlows(request),
+    getSelfLearningPosture: ({ workflowRunId, limit } = {}) => client._request('/api/operator/self-learning/posture', {
+      query: { workflow_run_id: workflowRunId, limit },
+    }),
+    listLearningRecords: ({ workflowRunId, learningCategory, promotionReadiness, limit } = {}) => client._request('/api/operator/self-learning/records', {
+      query: {
+        workflow_run_id: workflowRunId,
+        learning_category: learningCategory,
+        promotion_readiness: promotionReadiness,
+        limit,
+      },
+    }),
+    getLearningRecord: (learningRecordId) => client._request(`/api/operator/self-learning/records/${learningRecordId}`),
+    listPromotionCandidates: ({ workflowRunId, learningCategory, promotionReadiness, limit } = {}) => client._request('/api/operator/self-learning/promotion-candidates', {
+      query: {
+        workflow_run_id: workflowRunId,
+        learning_category: learningCategory,
+        promotion_readiness: promotionReadiness,
+        limit,
+      },
+    }),
+    getPromotionCandidate: (candidateKey) => client._request(`/api/operator/self-learning/promotion-candidates/${candidateKey}`),
+    listPromotionFlows: ({ flowStatus, targetType, candidateKey, limit } = {}) => client._request('/api/operator/self-learning/promotion-flows', {
+      query: {
+        flow_status: flowStatus,
+        target_type: targetType,
+        candidate_key: candidateKey,
+        limit,
+      },
+    }),
   };
 }

package/src/domains/self-optimization.js

@@ -1,8 +1,19 @@
 export function createSelfOptimizationDomain(client) {
   return {
-    getSelfOptimizationDashboard: () => client.getSelfOptimizationDashboard(),
-    getSelfOptimizationCandidateQueue: (request) => client.getSelfOptimizationCandidateQueue(request),
-    getSelfOptimizationBacklogPosture: (request) => client.getSelfOptimizationBacklogPosture(request),
-    getSelfOptimizationPendingHandoffs: (request) => client.getSelfOptimizationPendingHandoffs(request),
+    getSelfOptimizationDashboard: () => client._request('/api/operator/self-optimization/dashboard'),
+    getSelfOptimizationCandidateQueue: ({ objectiveCategory, impactPosture, blockedByDefault, limit } = {}) => client._request('/api/operator/self-optimization/candidate-queue', {
+      query: {
+        objective_category: objectiveCategory,
+        impact_posture: impactPosture,
+        blocked_by_default: blockedByDefault,
+        limit,
+      },
+    }),
+    getSelfOptimizationBacklogPosture: ({ snapshotKey } = {}) => client._request('/api/operator/self-optimization/backlog-posture', {
+      query: { snapshot_key: snapshotKey },
+    }),
+    getSelfOptimizationPendingHandoffs: ({ downstreamLane } = {}) => client._request('/api/operator/self-optimization/pending-handoffs', {
+      query: { downstream_lane: downstreamLane },
+    }),
   };
 }

package/src/domains/session-governance.js

@@ -0,0 +1,64 @@
+export function createSessionGovernanceDomain(client) {
+  return {
+    startSessionGovernance: ({
+      intent,
+      objective,
+      allowedScopes,
+      allowedMutationSurfaces,
+      requiredToolKeys,
+      sessionKey,
+      workflowRunId,
+      workflowId,
+      workflowSlug,
+      governedScope,
+      successCriteria,
+      disallowedSurfaces,
+      ...rest
+    } = {}) => client._request('/api/v1/session-governance/startup', {
+      method: 'POST',
+      body: {
+        ...rest,
+        objective: objective ?? intent,
+        allowed_mutation_surfaces: allowedMutationSurfaces ?? allowedScopes,
+        required_tool_keys: requiredToolKeys,
+        session_key: sessionKey,
+        workflow_run_id: workflowRunId,
+        workflow_id: workflowId,
+        workflow_slug: workflowSlug,
+        governed_scope: governedScope,
+        success_criteria: successCriteria,
+        disallowed_surfaces: disallowedSurfaces,
+      },
+    }),
+    startReviewGovernance: ({
+      intent,
+      objective,
+      readScope,
+      requiredToolKeys,
+      sessionKey,
+      workflowRunId,
+      workflowId,
+      workflowSlug,
+      turnPersisted,
+      ...rest
+    } = {}) => client._request('/api/v1/session-governance/review/startup', {
+      method: 'POST',
+      body: {
+        ...rest,
+        intent: intent ?? 'review code',
+        objective: objective ?? intent,
+        read_scope: readScope,
+        required_tool_keys: requiredToolKeys,
+        session_key: sessionKey,
+        workflow_run_id: workflowRunId,
+        workflow_id: workflowId,
+        workflow_slug: workflowSlug ?? 'code-review/read-only',
+        turn_persisted: turnPersisted,
+      },
+    }),
+    evaluateTurnCompliance: (sessionId) => client._request(`/api/v1/session-governance/${encodeURIComponent(sessionId)}/compliance`),
+    blockIfNonCompliant: (sessionId) => client._request(`/api/v1/session-governance/${encodeURIComponent(sessionId)}/block-if-non-compliant`, {
+      method: 'POST',
+    }),
+  };
+}

package/src/domains/skill-governance.js

@@ -1,7 +1,9 @@
 export function createSkillGovernanceDomain(client) {
   return {
-    createSkillGovernanceChange: (body) => client.createSkillGovernanceChange(body),
-    listSkillGovernanceChanges: (request) => client.listSkillGovernanceChanges(request),
-    getSkillGovernanceChange: (governanceChangeId) => client.getSkillGovernanceChange(governanceChangeId),
+    createSkillGovernanceChange: (body) => client._request('/api/operator/skill-governance/changes', { method: 'POST', body }),
+    listSkillGovernanceChanges: ({ limit, processStatus, changeStatus } = {}) => client._request('/api/operator/skill-governance/changes', {
+      query: { limit, process_status: processStatus, change_status: changeStatus },
+    }),
+    getSkillGovernanceChange: (governanceChangeId) => client._request(`/api/operator/skill-governance/changes/${governanceChangeId}`),
   };
 }

package/src/domains/skills.js

@@ -1,13 +1,26 @@
 export function createSkillsDomain(client) {
   return {
-    currentSkillRegistryStatus: () => client.currentSkillRegistryStatus(),
-    getSkillContract: (request) => client.getSkillContract(request),
-    getSkillGovernance: (request) => client.getSkillGovernance(request),
-    createSkillContractDraft: (body) => client.createSkillContractDraft(body),
-    recordSkillPatternReview: (skillVersionId, body) => client.recordSkillPatternReview(skillVersionId, body),
-    approveSkillContract: (skillVersionId, body) => client.approveSkillContract(skillVersionId, body),
-    createWorkflowSkillContract: (body) => client.createWorkflowSkillContract(body),
-    listWorkflowSkillBindings: (workflowId, request) => client.listWorkflowSkillBindings(workflowId, request),
-    seedFrequentOperationSkills: (request) => client.seedFrequentOperationSkills(request),
+    currentSkillRegistryStatus: () => client._request('/api/operator/current-skill-registry-status'),
+    getSkillContract: ({ skillId, skillKey } = {}) => client._request('/api/skills/contract', { query: { skill_id: skillId, skill_key: skillKey } }),
+    getSkillGovernance: ({ skillId, skillKey, skillVersionId } = {}) => client._request('/api/operator/skills/governance', {
+      query: { skill_id: skillId, skill_key: skillKey, skill_version_id: skillVersionId },
+    }),
+    createSkillContractDraft: (body) => client._request('/api/operator/skills/contracts/drafts', { method: 'POST', body }),
+    recordSkillPatternReview: (skillVersionId, body) => client._request(`/api/operator/skills/contracts/${skillVersionId}/pattern-reviews`, {
+      method: 'POST',
+      body,
+    }),
+    approveSkillContract: (skillVersionId, body = {}) => client._request(`/api/operator/skills/contracts/${skillVersionId}/approve`, {
+      method: 'POST',
+      body,
+    }),
+    createWorkflowSkillContract: (body) => client._request('/api/skills/workflow-contracts', { method: 'POST', body }),
+    listWorkflowSkillBindings: (workflowId, { workflowStepId } = {}) => client._request(`/api/workflows/${workflowId}/skill-bindings`, {
+      query: { workflow_step_id: workflowStepId },
+    }),
+    seedFrequentOperationSkills: ({ createdBy } = {}) => client._request('/api/operator/skills/seed-frequent-operations', {
+      method: 'POST',
+      body: { created_by: createdBy },
+    }),
   };
 }

package/src/domains/tool-binding-approvals.js

@@ -0,0 +1,102 @@
+export function createToolBindingApprovalsDomain(client) {
+  return {
+    createWorkflowToolBindingApprovalLane: ({
+      operatorActorType,
+      requesterActor,
+      requestedToolKeys,
+      blockedReason,
+      rollbackPlan,
+      requesterActorType,
+      operatorActorId,
+      targetWorkflowId,
+      targetWorkflowRunId,
+      relatedGapRecordIds,
+      requestedBindingScope,
+      riskClassification,
+      metadata,
+      ...rest
+    } = {}) => {
+      if (!operatorActorType) throw new Error('operatorActorType is required.');
+      if (!requesterActor) throw new Error('requesterActor is required.');
+      if (!Array.isArray(requestedToolKeys) || requestedToolKeys.length === 0) {
+        throw new Error('requestedToolKeys must be a non-empty array.');
+      }
+      if (!blockedReason) throw new Error('blockedReason is required.');
+      if (!rollbackPlan) throw new Error('rollbackPlan is required.');
+      return client._request('/api/governance/bootstrap/workflow-tool-binding-approval/create', {
+        method: 'POST',
+        body: {
+          ...rest,
+          operator_actor_type: operatorActorType,
+          requester_actor: requesterActor,
+          requested_tool_keys: requestedToolKeys,
+          blocked_reason: blockedReason,
+          rollback_plan: rollbackPlan,
+          requester_actor_type: requesterActorType,
+          operator_actor_id: operatorActorId,
+          target_workflow_id: targetWorkflowId,
+          target_workflow_run_id: targetWorkflowRunId,
+          related_gap_record_ids: relatedGapRecordIds,
+          requested_binding_scope: requestedBindingScope,
+          risk_classification: riskClassification,
+          metadata,
+        },
+      });
+    },
+    recordWorkflowToolBindingApprovalDecision: (approvalRequestId, {
+      operatorActorType,
+      decision,
+      operatorActorId,
+      decisionNotes,
+      decisionConditions,
+      ...rest
+    } = {}) => {
+      if (!approvalRequestId) throw new Error('approvalRequestId is required.');
+      if (!operatorActorType) throw new Error('operatorActorType is required.');
+      if (!decision) throw new Error('decision is required.');
+      return client._request(`/api/governance/bootstrap/workflow-tool-binding-approval/${encodeURIComponent(approvalRequestId)}/approval-decision`, {
+        method: 'POST',
+        body: {
+          ...rest,
+          operator_actor_type: operatorActorType,
+          operator_actor_id: operatorActorId,
+          decision,
+          decision_notes: decisionNotes,
+          decision_conditions: decisionConditions,
+        },
+      });
+    },
+    executeWorkflowToolBindingApprovalBinding: (approvalRequestId, {
+      operatorActorType,
+      operatorActorId,
+      ...rest
+    } = {}) => {
+      if (!approvalRequestId) throw new Error('approvalRequestId is required.');
+      if (!operatorActorType) throw new Error('operatorActorType is required.');
+      return client._request(`/api/governance/bootstrap/workflow-tool-binding-approval/${encodeURIComponent(approvalRequestId)}/binding-execution`, {
+        method: 'POST',
+        body: {
+          ...rest,
+          operator_actor_type: operatorActorType,
+          operator_actor_id: operatorActorId,
+        },
+      });
+    },
+    revalidateWorkflowToolBindingStartup: (approvalRequestId, {
+      operatorActorType,
+      operatorActorId,
+      ...rest
+    } = {}) => {
+      if (!approvalRequestId) throw new Error('approvalRequestId is required.');
+      if (!operatorActorType) throw new Error('operatorActorType is required.');
+      return client._request(`/api/governance/bootstrap/workflow-tool-binding-approval/${encodeURIComponent(approvalRequestId)}/startup-revalidation`, {
+        method: 'POST',
+        body: {
+          ...rest,
+          operator_actor_type: operatorActorType,
+          operator_actor_id: operatorActorId,
+        },
+      });
+    },
+  };
+}