@bpmsoftwaresolutions/ai-engine-client 1.1.88 → 1.1.89

package/src/client.js

@@ -1,4 +1,4 @@
-import { AI_ENGINE_CLIENT_CAPABILITIES, GOVERNED_MUTATION_REQUIRED_CAPABILITIES, TASK_BOUND_SUBSTRATE_EXECUTION_POLICY } from './constants/governance.js';
+import { AI_ENGINE_CLIENT_CAPABILITIES } from './constants/governance.js';
 import { AGENT_COMMUNICATION_CONTRACT_VERSION, AGENT_COMMUNICATION_MESSAGE_KINDS, AGENT_COMMUNICATION_RECIPIENT_MODES, AGENT_COMMUNICATION_THREAD_TYPES, AGENT_COMMUNICATION_TRANSFER_KINDS, AGENT_COMMUNICATION_TRANSFER_LIFECYCLE_STATES, AGENT_COMMUNICATION_TRANSFER_MODES, AGENT_COMMUNICATION_TRANSFER_RECEIPT_TYPES } from './constants/agent-communications.js';
 import { AI_ENGINE_CLIENT_VERSION, DEFAULT_TIMEOUT_MS } from './constants/client.js';
 import { LOGA_CONTRACT, LOGA_INTERACTION_CONTRACT, LOGA_NAVIGATION_CONTRACT, LOGA_PROJECTION_WORKFLOW } from './constants/loga.js';
@@ -18,6 +18,7 @@ import { createNotesLabDomain } from './domains/notes-lab.js';
 import { createPortfolioDomain } from './domains/portfolio.js';
 import { createProjectReportsDomain } from './domains/project-reports.js';
 import { createProjectResumeDomain } from './domains/project-resume.js';
+import { createGovernedImplementationDomain } from './domains/governed-implementation.js';
 import { createProjectionsDomain } from './domains/projections.js';
 import { createReportsDomain } from './domains/reports.js';
 import { createRoadmapReportsDomain } from './domains/roadmap-reports.js';
@@ -43,6 +44,17 @@ import { createSkillGovernanceDomain } from './domains/skill-governance.js';
 import { createSkillsDomain } from './domains/skills.js';
 import { createSearchContactsDomain } from './domains/search-contacts.js';
 import { createAgentCommunicationsFacade, createCollaborationFacade } from './compat/facades.js';
+import { createClaimsDomain } from './domains/claims.js';
+import { createSessionGovernanceDomain } from './domains/session-governance.js';
+import { createContextSessionsDomain } from './domains/context-sessions.js';
+import { createContextOrientationDomain } from './domains/context-orientation.js';
+import { createCommitGovernanceDomain } from './domains/commit-governance.js';
+import { createExecutionEligibilityDomain } from './domains/execution-eligibility.js';
+import { createToolBindingApprovalsDomain } from './domains/tool-binding-approvals.js';
+import { createVerifiedMutationsDomain } from './domains/verified-mutations.js';
+import { createWorkflowTurnsDomain } from './domains/workflow-turns.js';
+import { createChartersDomain } from './domains/charters.js';
+import { createWorkStartDomain } from './domains/work-start.js';
 import { createCollaborationDomain } from './domains/collaboration.js';
 import { createMessageWatchDomain } from './domains/message-watch.js';
 import { createPingPongDomain } from './domains/ping-pong.js';
@@ -55,8 +67,6 @@ 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';
-import { normalizeMetadataTaskBinding, normalizeTaskBindingPolicy } from './utils/task-binding.js';
-import { executeVerifiedMutation } from './utils/verified-mutations.js';
 
 function normalizeThreadType(value) {
   return normalizeEnum(value, AGENT_COMMUNICATION_THREAD_TYPES, 'coordination', 'thread_type', {
@@ -234,58 +244,6 @@ function isPlainObject(value) {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 
-function isActiveBinding(binding) {
-  return isPlainObject(binding) && (
-    binding.is_active === true ||
-    binding.is_active === 1 ||
-    binding.is_active === 'true' ||
-    binding.is_active === 'True'
-  );
-}
-
-function activeToolKeysFromRegistry(registry) {
-  const bindings = Array.isArray(registry?.bindings) ? registry.bindings : [];
-  const seen = new Set();
-  const keys = [];
-  for (const binding of bindings) {
-    if (!isActiveBinding(binding)) continue;
-    const key = cleanText(binding.tool_key);
-    if (!key || seen.has(key)) continue;
-    seen.add(key);
-    keys.push(key);
-  }
-  return keys;
-}
-
-function reminderTokens(reminders) {
-  const tokens = [];
-  for (const reminder of Array.isArray(reminders) ? reminders : []) {
-    if (!isPlainObject(reminder)) continue;
-    for (const value of [reminder.reminder_key, reminder.reminder_id]) {
-      const token = cleanText(value);
-      if (token && !tokens.includes(token)) tokens.push(token);
-    }
-  }
-  return tokens;
-}
-
-function contextSessionIdFromInput(input) {
-  if (isPlainObject(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);
-}
-
-function buildEligibilityError(message, details = {}) {
-  const error = new Error(message);
-  error.code = 'EXECUTION_ELIGIBILITY_FAILED';
-  error.details = details;
-  return error;
-}
-
 export class AIEngineClient {
   constructor({ baseUrl, accessToken, tokenProvider, apiKey, clientId, actorId, agentSessionId, fetchImpl, timeoutMs } = {}) {
     if (!baseUrl) throw new Error('baseUrl is required.');
@@ -314,6 +272,18 @@ export class AIEngineClient {
     this.projectChartering = createProjectCharteringDomain(this);
     this.projectReports = createProjectReportsDomain(this);
     this.projectResume = createProjectResumeDomain(this);
+    this.claims = createClaimsDomain(this);
+    this.sessionGovernance = createSessionGovernanceDomain(this);
+    this.executionEligibility = createExecutionEligibilityDomain(this);
+    this.toolBindingApprovals = createToolBindingApprovalsDomain(this);
+    this.workflowTurns = createWorkflowTurnsDomain(this);
+    this.contextSessions = createContextSessionsDomain(this);
+    this.contextOrientation = createContextOrientationDomain(this);
+    this.commitGovernance = createCommitGovernanceDomain(this);
+    this.verifiedMutations = createVerifiedMutationsDomain(this);
+    this.charters = createChartersDomain(this);
+    this.workStart = createWorkStartDomain(this);
+    this.governedImplementation = createGovernedImplementationDomain(this);
     this.roadmaps = createRoadmapsDomain(this);
     this.roadmapReports = createRoadmapReportsDomain(this);
     this.implementationPackets = createImplementationPacketsDomain(this);
@@ -3087,252 +3057,44 @@ export class AIEngineClient {
     return this._request('/api/dashboard');
   }
 
-  async startSessionGovernance({
-    intent,
-    objective,
-    allowedScopes,
-    allowedMutationSurfaces,
-    requiredToolKeys,
-    sessionKey,
-    workflowRunId,
-    workflowId,
-    workflowSlug,
-    governedScope,
-    successCriteria,
-    disallowedSurfaces,
-    ...rest
-  } = {}) {
-    return this._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,
-      },
-    });
+  async startSessionGovernance(request = {}) {
+    return this.sessionGovernance.startSessionGovernance(request);
   }
 
-  async startReviewGovernance({
-    intent,
-    objective,
-    readScope,
-    requiredToolKeys,
-    sessionKey,
-    workflowRunId,
-    workflowId,
-    workflowSlug,
-    turnPersisted,
-    ...rest
-  } = {}) {
-    return this._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,
-      },
-    });
+  async startReviewGovernance(request = {}) {
+    return this.sessionGovernance.startReviewGovernance(request);
   }
 
   async startWork(body = {}) {
-    return this._request('/api/work/start', { method: 'POST', body });
+    return this.workStart.startWork(body);
   }
 
-  async startClaimedWork({
-    claimName,
-    actorId,
-    intentId,
-    declaredScopeFiles,
-    allowedMutationSurfaces,
-    runtimeSessionId,
-    executionPurpose,
-    successCriteria,
-    mutationAllowed,
-    metadata,
-    ...rest
-  } = {}) {
-    return this._request('/api/governance/claims/start-claimed-work', {
-      method: 'POST',
-      body: {
-        ...rest,
-        claim_name: claimName,
-        actor_id: actorId,
-        intent_id: intentId,
-        declared_scope_files: declaredScopeFiles,
-        allowed_mutation_surfaces: allowedMutationSurfaces,
-        runtime_session_id: runtimeSessionId,
-        execution_purpose: executionPurpose,
-        success_criteria: successCriteria,
-        mutation_allowed: mutationAllowed,
-        metadata: normalizeMetadataTaskBinding(metadata),
-      },
-    });
+  async startClaimedWork(request = {}) {
+    return this.workStart.startClaimedWork(request);
   }
 
   async claimWorkItem(body = {}) {
-    const normalizedBody = isPlainObject(body)
-      ? {
-          ...body,
-          ...(isPlainObject(body.task_binding)
-            ? { task_binding: normalizeTaskBindingPolicy(body.task_binding) }
-            : {}),
-          metadata: normalizeMetadataTaskBinding(body.metadata),
-        }
-      : body;
-    return this._request('/api/governance/claims/claim-work-item', { method: 'POST', body: normalizedBody });
+    return this.workStart.claimWorkItem(body);
   }
 
-  async bindClaimedWorkItem({
-    claimId,
-    contextSessionId,
-    workflowRunId,
-    agentSessionId,
-    claimedItemId,
-    claimedItemKey,
-    claimName,
-    actorId,
-    workflowId,
-    workflowSlug,
-    requiredToolKeys,
-    declaredScopeFiles,
-    allowedMutationSurfaces,
-    successCriteria,
-    acknowledgedReminders,
-    intentConfirmation,
-    actorSignature,
-    autoSignoff = true,
-    metadata,
-  } = {}) {
-    const normalizedContextSessionId = contextSessionIdFromInput({
-      contextSessionId,
-      context_session_id: contextSessionId,
-      claim: { context_session_id: contextSessionId },
-    });
-    const normalizedClaimId = cleanText(claimId);
-    const normalizedWorkflowRunId = cleanText(workflowRunId);
-    const normalizedAgentSessionId = cleanText(agentSessionId);
-    const normalizedClaimedItemId = cleanText(claimedItemId);
-    const normalizedClaimedItemKey = cleanText(claimedItemKey);
-    const normalizedClaimedItemRef = normalizedClaimedItemId || normalizedClaimedItemKey;
-    if (!normalizedContextSessionId) throw new Error('contextSessionId is required.');
-    if (!normalizedWorkflowRunId) throw new Error('workflowRunId is required.');
-    if (!normalizedAgentSessionId) throw new Error('agentSessionId is required.');
-    if (!normalizedClaimedItemRef) throw new Error('claimedItemId or claimedItemKey is required.');
-
-    const normalizedWorkflowId = cleanText(workflowId);
-    const normalizedWorkflowSlug = cleanText(workflowSlug);
-    let normalizedRequiredToolKeys = cleanList(requiredToolKeys);
-    let workflowRegistry = null;
-    if (normalizedRequiredToolKeys.length === 0 && (normalizedWorkflowId || normalizedWorkflowSlug)) {
-      workflowRegistry = await this.getWorkflowToolRegistry({
-        workflowId: normalizedWorkflowId,
-        workflowSlug: normalizedWorkflowSlug,
-      });
-      normalizedRequiredToolKeys = activeToolKeysFromRegistry(workflowRegistry);
-    }
-
-    const lockClaimResult = await this.lockContextSessionClaim(normalizedContextSessionId);
-    const lockedContextSession = lockClaimResult?.context_session || lockClaimResult;
-    const lockedContextSessionId = contextSessionIdFromInput(lockedContextSession) || normalizedContextSessionId;
-
-    const claimWorkItemResult = await this.claimWorkItem({
-      context_session_id: lockedContextSessionId,
-      workflow_run_id: normalizedWorkflowRunId,
-      agent_session_id: normalizedAgentSessionId,
-      claimed_item_id: normalizedClaimedItemId,
-      claimed_item_key: normalizedClaimedItemKey,
-      claim_name: claimName,
-      actor_id: actorId,
-      workflow_id: normalizedWorkflowId,
-      workflow_slug: normalizedWorkflowSlug,
-      required_tool_keys: normalizedRequiredToolKeys,
-      declared_scope_files: cleanList(declaredScopeFiles).length > 0
-        ? cleanList(declaredScopeFiles)
-        : [normalizedClaimedItemRef],
-      allowed_mutation_surfaces: cleanList(allowedMutationSurfaces).length > 0
-        ? cleanList(allowedMutationSurfaces)
-        : ['project_roadmap_task'],
-      success_criteria: successCriteria,
-      metadata,
-    });
-
-    let signedClaim = null;
-    const resolvedClaimId = cleanText(claimWorkItemResult?.claim_id) || normalizedClaimId;
-    if (autoSignoff && resolvedClaimId) {
-      const claimEnvelope = isPlainObject(claimWorkItemResult?.claim) ? claimWorkItemResult.claim : claimWorkItemResult;
-      const reminders = cleanList(acknowledgedReminders).length > 0
-        ? cleanList(acknowledgedReminders)
-        : reminderTokens(claimEnvelope?.required_reminders);
-      if (reminders.length > 0) {
-        signedClaim = await this.signoffClaim(resolvedClaimId, {
-          acknowledged_reminders: reminders,
-          intent_confirmation: cleanText(intentConfirmation) || 'I confirm this governed execution intent and scope.',
-          actor_signature: cleanText(actorSignature) || cleanText(actorId) || this.actorId,
-        });
-      }
-    }
-
-    return {
-      claim_id: resolvedClaimId,
-      context_session_id: lockedContextSessionId,
-      workflow_run_id: normalizedWorkflowRunId,
-      agent_session_id: normalizedAgentSessionId,
-      required_tool_keys: normalizedRequiredToolKeys,
-      workflow_registry: workflowRegistry,
-      lock_claim_result: lockClaimResult,
-      claim_work_item_result: claimWorkItemResult,
-      signed_claim: signedClaim,
-      approved_tool_keys: cleanList(
-        signedClaim?.approved_tool_keys ||
-        signedClaim?.claim?.approved_tool_keys ||
-        claimWorkItemResult?.approved_tool_keys ||
-        claimWorkItemResult?.claim?.approved_tool_keys
-      ),
-    };
+  async bindClaimedWorkItem(request = {}) {
+    return this.workStart.bindClaimedWorkItem(request);
   }
 
   async getClaim(claimId) {
-    if (!claimId) throw new Error('claimId is required.');
-    return this._request(`/api/governance/claims/${encodeURIComponent(claimId)}`);
+    return this.claims.getClaim(claimId);
   }
 
   async claimIsValid(claimId) {
-    const claim = await this.getClaim(claimId);
-    return cleanText(claim?.status) === 'active';
+    return this.claims.claimIsValid(claimId);
   }
 
   async getExecutionEligibility(body = {}) {
-    return this._request('/api/governance/execution-eligibility', {
-      method: 'POST',
-      body: {
-        required_capabilities: GOVERNED_MUTATION_REQUIRED_CAPABILITIES,
-        verification_required: true,
-        ...body,
-      },
-    });
+    return this.executionEligibility.getExecutionEligibility(body);
   }
 
   async signoffClaim(claimId, body = {}) {
-    if (!claimId) throw new Error('claimId is required.');
-    return this._request(`/api/governance/claims/${encodeURIComponent(claimId)}/signoff`, {
-      method: 'POST',
-      body,
-    });
+    return this.claims.signoffClaim(claimId, body);
   }
 
   /**
@@ -3411,124 +3173,36 @@ export class AIEngineClient {
    * @param {object} [params.metadata]
    * @returns {Promise<object>}
    */
-  async 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 this._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,
-      },
-    });
+  async createWorkflowToolBindingApprovalLane(request = {}) {
+    return this.toolBindingApprovals.createWorkflowToolBindingApprovalLane(request);
   }
 
-  async 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 this._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,
-      },
-    });
+  async recordWorkflowToolBindingApprovalDecision(approvalRequestId, request = {}) {
+    return this.toolBindingApprovals.recordWorkflowToolBindingApprovalDecision(approvalRequestId, request);
   }
 
-  async executeWorkflowToolBindingApprovalBinding(approvalRequestId, {
-    operatorActorType,
-    operatorActorId,
-    ...rest
-  } = {}) {
-    if (!approvalRequestId) throw new Error('approvalRequestId is required.');
-    if (!operatorActorType) throw new Error('operatorActorType is required.');
-    return this._request(`/api/governance/bootstrap/workflow-tool-binding-approval/${encodeURIComponent(approvalRequestId)}/binding-execution`, {
-      method: 'POST',
-      body: {
-        ...rest,
-        operator_actor_type: operatorActorType,
-        operator_actor_id: operatorActorId,
-      },
-    });
+  async executeWorkflowToolBindingApprovalBinding(approvalRequestId, request = {}) {
+    return this.toolBindingApprovals.executeWorkflowToolBindingApprovalBinding(approvalRequestId, request);
   }
 
-  async revalidateWorkflowToolBindingStartup(approvalRequestId, {
-    operatorActorType,
-    operatorActorId,
-    ...rest
-  } = {}) {
-    if (!approvalRequestId) throw new Error('approvalRequestId is required.');
-    if (!operatorActorType) throw new Error('operatorActorType is required.');
-    return this._request(`/api/governance/bootstrap/workflow-tool-binding-approval/${encodeURIComponent(approvalRequestId)}/startup-revalidation`, {
-      method: 'POST',
-      body: {
-        ...rest,
-        operator_actor_type: operatorActorType,
-        operator_actor_id: operatorActorId,
-      },
-    });
+  async revalidateWorkflowToolBindingStartup(approvalRequestId, request = {}) {
+    return this.toolBindingApprovals.revalidateWorkflowToolBindingStartup(approvalRequestId, request);
   }
 
   async completeTurn(body = {}) {
-    return this._request('/api/turns/complete', { method: 'POST', body });
+    return this.workflowTurns.completeTurn(body);
   }
 
   async evaluateTurnCompliance(sessionId) {
-    return this._request(`/api/v1/session-governance/${encodeURIComponent(sessionId)}/compliance`);
+    return this.sessionGovernance.evaluateTurnCompliance(sessionId);
   }
 
   async blockIfNonCompliant(sessionId) {
-    return this._request(`/api/v1/session-governance/${encodeURIComponent(sessionId)}/block-if-non-compliant`, {
-      method: 'POST',
-    });
+    return this.sessionGovernance.blockIfNonCompliant(sessionId);
   }
 
   async runCharter(body = {}) {
-    return this._request('/api/charters/run', { method: 'POST', body });
+    return this.charters.runCharter(body);
   }
 
   async createProjectDelivery(body = {}) {
@@ -3556,7 +3230,7 @@ export class AIEngineClient {
   }
 
   async persistAssistantTurn(body) {
-    return this._request('/api/v1/assistant-turns', { method: 'POST', body });
+    return this.workflowTurns.persistAssistantTurn(body);
   }
 
   async getExternalProjectStatus(projectId) {
@@ -4391,7 +4065,7 @@ export class AIEngineClient {
     expectedState,
     evidenceLabel,
   } = {}) {
-    return executeVerifiedMutation({
+    return this.verifiedMutations.executeVerifiedMutation({
       mutationName,
       mutationFn,
       verificationFn,
@@ -4872,173 +4546,50 @@ export class AIEngineClient {
 
   // ─── Commit Governance ────────────────────────────────────────────────────
 
-  async evaluateCommitGovernance({
-    claimId,
-    contextSessionId,
-    agentId,
-    intentId,
-    changedFiles,
-    declaredScopeFiles,
-    diffSummary,
-    branch,
-    headSha,
-  } = {}) {
-    return this._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,
-      },
-    });
+  async evaluateCommitGovernance(request = {}) {
+    return this.commitGovernance.evaluateCommitGovernance(request);
   }
 
-  async checkGitShipReadiness({
-    claimId,
-    actorId,
-    targetBranch,
-    shipCommand,
-    packageName,
-    declaredScopeFiles,
-    stagedFiles,
-    dirtyFiles,
-    branch,
-    headSha,
-    packageJsonVersion,
-    facadeMinClientVersion,
-    packageRelease,
-    packageJsonHash,
-    sdkVersionHash,
-  } = {}) {
-    return this._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,
-      },
-    });
+  async checkGitShipReadiness(request = {}) {
+    return this.commitGovernance.checkGitShipReadiness(request);
   }
 
   async getCommitGovernanceEvaluation(evaluationId) {
-    return this._request(`/api/commit-governance/evaluations/${encodeURIComponent(evaluationId)}`);
+    return this.commitGovernance.getCommitGovernanceEvaluation(evaluationId);
   }
 
   async listCommitGovernanceEvaluationsByClaim(claimId, { limit } = {}) {
-    return this._request(`/api/commit-governance/claims/${encodeURIComponent(claimId)}/evaluations`, {
-      query: { limit },
-    });
+    return this.commitGovernance.listCommitGovernanceEvaluationsByClaim(claimId, { limit });
   }
 
   // ─── Context Session Orientation ──────────────────────────────────────────
 
-  async openContextSession({ agentId, runtimeSessionId, intentId, executionPurpose, notes } = {}) {
-    return this._request('/api/context-session/open', {
-      method: 'POST',
-      body: {
-        agent_id: agentId,
-        runtime_session_id: runtimeSessionId,
-        intent_id: intentId,
-        execution_purpose: executionPurpose,
-        notes,
-      },
-    });
+  async openContextSession(request = {}) {
+    return this.contextSessions.openContextSession(request);
   }
 
   async getOrientationWindow(contextSessionId) {
-    return this._request(`/api/context-session/${encodeURIComponent(contextSessionId)}/window`);
+    return this.contextSessions.getOrientationWindow(contextSessionId);
   }
 
-  async acknowledgeReminder(contextSessionId, { reminderId, agentSignature, understandingSummary } = {}) {
-    return this._request(`/api/context-session/${encodeURIComponent(contextSessionId)}/acknowledge`, {
-      method: 'POST',
-      body: {
-        reminder_id: reminderId,
-        agent_signature: agentSignature,
-        understanding_summary: understandingSummary,
-      },
-    });
+  async acknowledgeReminder(contextSessionId, request = {}) {
+    return this.contextSessions.acknowledgeReminder(contextSessionId, request);
   }
 
   async completeOrientation(contextSessionId) {
-    return this._request(`/api/context-session/${encodeURIComponent(contextSessionId)}/complete`, {
-      method: 'POST',
-    });
+    return this.contextSessions.completeOrientation(contextSessionId);
   }
 
   async lockContextSessionClaim(input) {
-    const contextSessionId = contextSessionIdFromInput(input);
-    if (!contextSessionId) throw new Error('contextSessionId is required.');
-    return this._request(`/api/context-session/${encodeURIComponent(contextSessionId)}/lock-claim`, {
-      method: 'POST',
-    });
+    return this.contextSessions.lockContextSessionClaim(input);
   }
 
   async getContextSessionGateStatus(contextSessionId) {
-    return this._request(`/api/context-session/${encodeURIComponent(contextSessionId)}/gate-status`);
+    return this.contextSessions.getContextSessionGateStatus(contextSessionId);
   }
 
-  async conductOrientation({
-    agentId,
-    runtimeSessionId,
-    intentId,
-    executionPurpose,
-    agentSignature,
-    understandingSummary,
-    lockClaim = true,
-  } = {}) {
-    const { context_session, reminders } = await this.openContextSession({
-      agentId,
-      runtimeSessionId,
-      intentId,
-      executionPurpose,
-    });
-    const sessionId = context_session.context_session_id;
-
-    const required = (reminders || []).filter(r => r.severity === 'required');
-    let acknowledgedCount = 0;
-    for (const reminder of required) {
-      await this.acknowledgeReminder(sessionId, {
-        reminderId: reminder.reminder_id,
-        agentSignature,
-        understandingSummary,
-      });
-      acknowledgedCount++;
-    }
-
-    const completion = await this.completeOrientation(sessionId);
-
-    let claimLockResult = null;
-    if (lockClaim) {
-      claimLockResult = await this.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,
-    };
+  async conductOrientation(request = {}) {
+    return this.contextOrientation.conductOrientation(request);
   }
 
   // ─── Core HTTP ─────────────────────────────────────────────────────────────
@@ -5052,23 +4603,7 @@ export class AIEngineClient {
   }
 
   async _assertExecutionEligibility(body = {}) {
-    const eligibility = await this.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,
-      },
-    );
+    return this.executionEligibility._assertExecutionEligibility(body);
   }
 
   async _request(path, { method = 'GET', query, headers, body } = {}) {