@bpmsoftwaresolutions/ai-engine-client 1.1.88 → 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/charters.js

@@ -0,0 +1,5 @@
+export function createChartersDomain(client) {
+  return {
+    runCharter: (body = {}) => client._request('/api/charters/run', { method: 'POST', body }),
+  };
+}

package/src/domains/claims.js

@@ -0,0 +1,58 @@
+import { cleanText } from '../utils/text.js';
+
+export function createClaimsDomain(client) {
+  return {
+    getClaim: (claimId) => {
+      if (!claimId) throw new Error('claimId is required.');
+      return client._request(`/api/governance/claims/${encodeURIComponent(claimId)}`);
+    },
+    claimIsValid: async (claimId) => {
+      const claim = await client.getClaim(claimId);
+      return cleanText(claim?.status) === 'active';
+    },
+    signoffClaim: (claimId, body = {}) => {
+      if (!claimId) throw new Error('claimId is required.');
+      return client._request(`/api/governance/claims/${encodeURIComponent(claimId)}/signoff`, {
+        method: 'POST',
+        body,
+      });
+    },
+    promoteClaimSurface: ({
+      claimId,
+      workflowId,
+      contextSessionId,
+      actorId,
+      requiredToolKeys,
+      intentId,
+      bindingScope,
+      usageMode,
+      operatorScope,
+      allowedArgumentPolicy,
+      ...rest
+    } = {}) => {
+      if (!claimId) throw new Error('claimId is required.');
+      if (!workflowId) throw new Error('workflowId is required.');
+      if (!contextSessionId) throw new Error('contextSessionId is required.');
+      if (!actorId) throw new Error('actorId is required.');
+      if (!Array.isArray(requiredToolKeys) || requiredToolKeys.length === 0) {
+        throw new Error('requiredToolKeys must be a non-empty array.');
+      }
+      return client._request('/api/governance/claims/promote-surface', {
+        method: 'POST',
+        body: {
+          ...rest,
+          claim_id: claimId,
+          workflow_id: workflowId,
+          context_session_id: contextSessionId,
+          actor_id: actorId,
+          required_tool_keys: requiredToolKeys,
+          intent_id: intentId,
+          binding_scope: bindingScope,
+          usage_mode: usageMode,
+          operator_scope: operatorScope,
+          allowed_argument_policy: allowedArgumentPolicy,
+        },
+      });
+    },
+  };
+}

package/src/domains/commit-governance.js

@@ -0,0 +1,68 @@
+export function createCommitGovernanceDomain(client) {
+  return {
+    evaluateCommitGovernance: ({
+      claimId,
+      contextSessionId,
+      agentId,
+      intentId,
+      changedFiles,
+      declaredScopeFiles,
+      diffSummary,
+      branch,
+      headSha,
+    } = {}) => client._request('/api/commit-governance/evaluate', {
+      method: 'POST',
+      body: {
+        claim_id: claimId,
+        context_session_id: contextSessionId,
+        agent_id: agentId,
+        intent_id: intentId,
+        changed_files: changedFiles,
+        declared_scope_files: declaredScopeFiles,
+        diff_summary: diffSummary,
+        branch,
+        head_sha: headSha,
+      },
+    }),
+    checkGitShipReadiness: ({
+      claimId,
+      actorId,
+      targetBranch,
+      shipCommand,
+      packageName,
+      declaredScopeFiles,
+      stagedFiles,
+      dirtyFiles,
+      branch,
+      headSha,
+      packageJsonVersion,
+      facadeMinClientVersion,
+      packageRelease,
+      packageJsonHash,
+      sdkVersionHash,
+    } = {}) => client._request('/api/commit-governance/ship-readiness', {
+      method: 'POST',
+      body: {
+        claim_id: claimId,
+        actor_id: actorId,
+        target_branch: targetBranch,
+        ship_command: shipCommand,
+        package_name: packageName,
+        declared_scope_files: declaredScopeFiles,
+        staged_files: stagedFiles,
+        dirty_files: dirtyFiles,
+        branch,
+        head_sha: headSha,
+        package_json_version: packageJsonVersion,
+        facade_min_client_version: facadeMinClientVersion,
+        package_release: packageRelease,
+        package_json_hash: packageJsonHash,
+        sdk_version_hash: sdkVersionHash,
+      },
+    }),
+    getCommitGovernanceEvaluation: (evaluationId) => client._request(`/api/commit-governance/evaluations/${encodeURIComponent(evaluationId)}`),
+    listCommitGovernanceEvaluationsByClaim: (claimId, { limit } = {}) => client._request(`/api/commit-governance/claims/${encodeURIComponent(claimId)}/evaluations`, {
+      query: { limit },
+    }),
+  };
+}

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/context-orientation.js

@@ -0,0 +1,48 @@
+export function createContextOrientationDomain(client) {
+  return {
+    conductOrientation: async ({
+      agentId,
+      runtimeSessionId,
+      intentId,
+      executionPurpose,
+      agentSignature,
+      understandingSummary,
+      lockClaim = true,
+    } = {}) => {
+      const { context_session, reminders } = await client.contextSessions.openContextSession({
+        agentId,
+        runtimeSessionId,
+        intentId,
+        executionPurpose,
+      });
+      const sessionId = context_session.context_session_id;
+
+      const required = (reminders || []).filter((reminder) => reminder.severity === 'required');
+      let acknowledgedCount = 0;
+      for (const reminder of required) {
+        await client.contextSessions.acknowledgeReminder(sessionId, {
+          reminderId: reminder.reminder_id,
+          agentSignature,
+          understandingSummary,
+        });
+        acknowledgedCount++;
+      }
+
+      const completion = await client.contextSessions.completeOrientation(sessionId);
+
+      let claimLockResult = null;
+      if (lockClaim) {
+        claimLockResult = await client.contextSessions.lockContextSessionClaim(sessionId);
+      }
+
+      return {
+        context_session_id: sessionId,
+        intent_id: intentId,
+        context_session: claimLockResult?.context_session || completion.context_session,
+        gate_result: claimLockResult?.gate_result || completion.gate_result,
+        acknowledged_count: acknowledgedCount,
+        claim_locked: lockClaim && !!claimLockResult,
+      };
+    },
+  };
+}

package/src/domains/context-sessions.js

@@ -0,0 +1,46 @@
+import { cleanText } from '../utils/text.js';
+
+export function contextSessionIdFromInput(input) {
+  if (input !== null && typeof input === 'object' && !Array.isArray(input)) {
+    return cleanText(input.contextSessionId)
+      || cleanText(input.context_session_id)
+      || cleanText(input.context_session?.context_session_id)
+      || cleanText(input.claim?.context_session_id);
+  }
+  return cleanText(input);
+}
+
+export function createContextSessionsDomain(client) {
+  return {
+    openContextSession: ({ agentId, runtimeSessionId, intentId, executionPurpose, notes } = {}) => client._request('/api/context-session/open', {
+      method: 'POST',
+      body: {
+        agent_id: agentId,
+        runtime_session_id: runtimeSessionId,
+        intent_id: intentId,
+        execution_purpose: executionPurpose,
+        notes,
+      },
+    }),
+    getOrientationWindow: (contextSessionId) => client._request(`/api/context-session/${encodeURIComponent(contextSessionId)}/window`),
+    acknowledgeReminder: (contextSessionId, { reminderId, agentSignature, understandingSummary } = {}) => client._request(`/api/context-session/${encodeURIComponent(contextSessionId)}/acknowledge`, {
+      method: 'POST',
+      body: {
+        reminder_id: reminderId,
+        agent_signature: agentSignature,
+        understanding_summary: understandingSummary,
+      },
+    }),
+    completeOrientation: (contextSessionId) => client._request(`/api/context-session/${encodeURIComponent(contextSessionId)}/complete`, {
+      method: 'POST',
+    }),
+    lockContextSessionClaim: (input) => {
+      const contextSessionId = contextSessionIdFromInput(input);
+      if (!contextSessionId) throw new Error('contextSessionId is required.');
+      return client._request(`/api/context-session/${encodeURIComponent(contextSessionId)}/lock-claim`, {
+        method: 'POST',
+      });
+    },
+    getContextSessionGateStatus: (contextSessionId) => client._request(`/api/context-session/${encodeURIComponent(contextSessionId)}/gate-status`),
+  };
+}

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-eligibility.js

@@ -0,0 +1,44 @@
+import { cleanText } from '../utils/text.js';
+import { GOVERNED_MUTATION_REQUIRED_CAPABILITIES } from '../constants/governance.js';
+
+export function buildEligibilityError(message, details = {}) {
+  const error = new Error(message);
+  error.code = 'EXECUTION_ELIGIBILITY_FAILED';
+  error.details = details;
+  return error;
+}
+
+export function createExecutionEligibilityDomain(client) {
+  return {
+    getExecutionEligibility: (body = {}) => client._request('/api/governance/execution-eligibility', {
+      method: 'POST',
+      body: {
+        required_capabilities: GOVERNED_MUTATION_REQUIRED_CAPABILITIES,
+        verification_required: true,
+        ...body,
+      },
+    }),
+    _assertExecutionEligibility: async (body = {}) => {
+      const eligibility = await client.getExecutionEligibility(body);
+      if (eligibility?.execution_eligible && eligibility?.mutation_allowed) {
+        return eligibility;
+      }
+      const remediation = cleanText(eligibility?.remediation_command);
+      const verification = cleanText(eligibility?.verification_command);
+      throw buildEligibilityError(
+        [
+          `Execution eligibility gate blocked mutation${cleanText(body?.requested_mutation_surface) ? ` on ${cleanText(body.requested_mutation_surface)}` : ''}.`,
+          remediation ? `Fix: ${remediation}` : null,
+          verification ? `Then verify: ${verification}` : null,
+        ].filter(Boolean).join(' '),
+        {
+          required_gate: eligibility?.required_gate || 'execution_eligibility.required_gate',
+          execution_eligibility: eligibility ?? null,
+          requested_mutation_surface: cleanText(body?.requested_mutation_surface) || null,
+          remediation_command: remediation || null,
+          verification_command: verification || null,
+        },
+      );
+    },
+  };
+}

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/governed-implementation.js

@@ -0,0 +1,7 @@
+export function createGovernedImplementationDomain(client) {
+  return {
+    getExecutionEligibility: (body = {}) => client.executionEligibility.getExecutionEligibility(body),
+    _assertExecutionEligibility: (body = {}) => client.executionEligibility._assertExecutionEligibility(body),
+    executeVerifiedMutation: (request = {}) => client.verifiedMutations.executeVerifiedMutation(request),
+  };
+}

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