@bpmsoftwaresolutions/ai-engine-client 1.1.97 → 1.1.99

package/src/client.js

@@ -15,6 +15,7 @@ import { createGatewayDomain } from './domains/gateway.js';
 import { createHealthDomain } from './domains/health.js';
 import { createLogaDomain } from './domains/loga.js';
 import { createNotesLabDomain } from './domains/notes-lab.js';
+import { createCommunicationTicketsDomain } from './domains/communication-tickets.js';
 import { createPortfolioDomain } from './domains/portfolio.js';
 import { createProjectReportsDomain } from './domains/project-reports.js';
 import { createProjectResumeDomain } from './domains/project-resume.js';
@@ -32,6 +33,7 @@ import { createImplementationItemsDomain } from './domains/implementation-items.
 import { createRepoDomain } from './domains/repo.js';
 import { createProjectCharteringDomain } from './domains/project-chartering.js';
 import { createProjectsDomain } from './domains/projects.js';
+import { createRefactoringTransfersDomain } from './domains/refactoring-transfers.js';
 import { createOperatorStatusDomain } from './domains/operator-status.js';
 import { createRoadmapsDomain } from './domains/roadmaps.js';
 import { createScriptDiscoveryDomain } from './domains/script-discovery.js';
@@ -43,6 +45,9 @@ import { createSelfOptimizationDomain } from './domains/self-optimization.js';
 import { createSkillGovernanceDomain } from './domains/skill-governance.js';
 import { createSkillsDomain } from './domains/skills.js';
 import { createSearchContactsDomain } from './domains/search-contacts.js';
+import { createExternalProjectsDomain } from './domains/external-projects.js';
+import { createExternalAudioDomain } from './domains/external-audio.js';
+import { createExternalWorkflowArtifactsDomain } from './domains/external-workflow-artifacts.js';
 import { createAgentCommunicationsFacade, createCollaborationFacade } from './compat/facades.js';
 import { createClaimsDomain } from './domains/claims.js';
 import { createSessionGovernanceDomain } from './domains/session-governance.js';
@@ -66,6 +71,7 @@ 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 { installClientCompatibilityDelegates } from './compat/aliases.js';
 import { buildHeaders, requestBinary, requestJson, requestLogaProjection, requestText, resolveAccessToken } from './transport/index.js';
 import { normalizeEnum, trimTrailingSlash } from './utils/text.js';
 
@@ -326,6 +332,11 @@ export class AIEngineClient {
     this.presence = createPresenceDomain(this);
     this.pingPong = createPingPongDomain(this);
     this.agentCommunications = createAgentCommunicationsDomain(this);
+    this.communicationTickets = createCommunicationTicketsDomain(this);
+    this.refactoringTransfers = createRefactoringTransfersDomain(this);
+    this.externalProjects = createExternalProjectsDomain(this);
+    this.externalAudio = createExternalAudioDomain(this);
+    this.externalWorkflowArtifacts = createExternalWorkflowArtifactsDomain(this);
     this.collaborationDomain = createCollaborationDomain(this);
     this.agentComms = createAgentCommunicationsFacade(this);
     this.collaboration = createCollaborationFacade(this);
@@ -570,720 +581,11 @@ export class AIEngineClient {
     includeTransferChannelProjection = true,
     includeOperatorProjectionMetadata = true,
   } = {}) {
-    const missingSurfaces = [];
-    const normalizedMetadata = isPlainObject(metadata) ? metadata : {};
-    const normalizedTransferChannelId = cleanText(transfer_channel_id) || cleanText(transferChannelId) || cleanText(channel_id) || cleanText(channelId);
-    const normalizedWorkTransferPacketId = cleanText(work_transfer_packet_id) || cleanText(workTransferPacketId) || cleanText(packet_id) || cleanText(packetId);
-    const normalizedWorkflowRunId = cleanText(workflow_run_id) || cleanText(workflowRunId);
-    const normalizedRequestedBy = cleanText(requested_by) || cleanText(requestedBy) || this.agentSessionId || this.actorId;
-    const normalizedAssignedTo = cleanText(assigned_to) || cleanText(assignedTo);
-    const normalizedSeverity = cleanText(severity) || 'medium';
-    const normalizedSourceRef = cleanText(source_ref) || cleanText(sourceRef) || cleanText(finding_id) || cleanText(findingId) || cleanText(blocker_id) || cleanText(blockerId) || cleanText(failed_check_id) || cleanText(failedCheckId) || cleanText(workflow_gap) || cleanText(workflowGap);
-    const normalizedExpectedResponse = cleanText(expected_response) || cleanText(expectedResponse) || 'assignee acknowledgement';
-    const normalizedParticipantRole = cleanText(participant_role) || cleanText(participantRole) || 'requester';
-    const normalizedWatcherRole = cleanText(watcher_role) || cleanText(watcherRole) || 'watcher';
-    const normalizedBlockerKind = cleanText(blocker_kind) || cleanText(blockerKind) || 'remediation';
-    const normalizedBlockerSummary = cleanText(blocker_summary) || cleanText(blockerSummary) || normalizedSourceRef || normalizedExpectedResponse;
-    const normalizedBlockerDetails = cleanText(blocker_details) || cleanText(blockerDetails) || normalizedExpectedResponse;
-    const normalizedExpectedMessageKind = cleanText(expected_message_kind) || cleanText(expectedMessageKind) || 'response';
-    const normalizedReplyPayload = isPlainObject(reply_payload) ? reply_payload : (isPlainObject(replyPayload) ? replyPayload : {});
-    const normalizedReplyScope = isPlainObject(reply_scope) ? reply_scope : (isPlainObject(replyScope) ? replyScope : {});
-    const normalizedReplyEvidenceRefs = Array.isArray(reply_evidence_refs) ? reply_evidence_refs : (Array.isArray(replyEvidenceRefs) ? replyEvidenceRefs : []);
-    const shouldMoveOwnership = Boolean(ownership_move ?? ownershipMove ?? transfer_ownership ?? transferOwnership);
-    const hasExplicitChannel = Boolean(normalizedTransferChannelId);
-
-    if (!hasExplicitChannel && !shouldMoveOwnership) {
-      throw new Error('channel_id is required unless ownershipMove is true.');
-    }
-
-    let resumedChannel = null;
-    let resolvedTransferChannelId = normalizedTransferChannelId;
-    let resolvedWorkTransferPacketId = normalizedWorkTransferPacketId;
-
-    if (hasExplicitChannel) {
-      const resumeSurface = typeof this.resumeTransferChannel === 'function'
-        ? this.resumeTransferChannel.bind(this)
-        : null;
-      if (!resumeSurface) missingSurfaces.push('resumeTransferChannel');
-      if (resumeSurface) {
-        resumedChannel = await resumeSurface({
-          transferChannelId: normalizedTransferChannelId,
-          workTransferPacketId: normalizedWorkTransferPacketId,
-          workflowRunId: normalizedWorkflowRunId,
-          participantRole: normalizedParticipantRole,
-          participantKind: 'agent_session',
-          participantLabel: normalizedParticipantRole,
-          agentSessionId: this.agentSessionId,
-          currentPhase: 'remediation',
-          currentTaskSummary: normalizedBlockerSummary,
-          lastSeenMessageId: cleanText(message_watch_id) || cleanText(messageWatchId),
-          metadata: {
-            ...normalizedMetadata,
-            source: 'createCrossAgentRemediationTicket',
-          },
-        });
-        const resumedPayload = isPlainObject(resumedChannel) ? resumedChannel : {};
-        resolvedTransferChannelId = cleanText(resumedPayload.transfer_channel_id)
-          || cleanText(resumedPayload.channel_id)
-          || cleanText(resumedPayload.transfer_channel?.transfer_channel_id)
-          || cleanText(resumedPayload.communication_transfer_channel?.transfer_channel_id)
-          || resolvedTransferChannelId;
-        resolvedWorkTransferPacketId = cleanText(resumedPayload.work_transfer_packet_id)
-          || cleanText(resumedPayload.work_transfer_packet?.work_transfer_packet_id)
-          || cleanText(resumedPayload.communication_transfer_channel?.work_transfer_packet_id)
-          || resolvedWorkTransferPacketId;
-      }
-    }
-
-    if (shouldMoveOwnership) {
-      const transferSurface = typeof this.transferWorkPacket === 'function'
-        ? this.transferWorkPacket.bind(this)
-        : null;
-      if (!transferSurface) missingSurfaces.push('transferWorkPacket');
-      if (transferSurface) {
-        const transferResult = await transferSurface({
-          workflowRunId: normalizedWorkflowRunId,
-          transferKind: 'upstream_remediation',
-          objective: normalizedBlockerSummary,
-          requestedOutcome: normalizedExpectedResponse,
-          target: {
-            intent: 'upstream_remediation',
-            recipient_mode: normalizedAssignedTo ? 'agent_session' : 'role',
-            preferred_agent_session_id: normalizedAssignedTo,
-            preferred_role_key: normalizedAssignedTo || normalizedWatcherRole,
-          },
-          artifacts: [],
-          issues: [],
-          expectedEvidence: [],
-          preferredModes: ['bundle', 'artifact_refs', 'inline_payload'],
-          capabilities: {},
-          senderAgentSessionId: this.agentSessionId,
-          senderActorSessionId: null,
-          subject: normalizedBlockerSummary,
-          bodyMarkdown: cleanText(reply_body_markdown) || cleanText(replyBodyMarkdown) || normalizedBlockerDetails,
-          messageKind: normalizedExpectedMessageKind,
-          metadata: {
-            ...normalizedMetadata,
-            source: 'createCrossAgentRemediationTicket',
-            source_ref: normalizedSourceRef,
-            assigned_to: normalizedAssignedTo,
-            requested_by: normalizedRequestedBy,
-          },
-        });
-        const transferPayload = isPlainObject(transferResult) ? transferResult : {};
-        resolvedWorkTransferPacketId = cleanText(transferPayload.work_transfer_packet?.work_transfer_packet_id)
-          || cleanText(transferPayload.work_transfer_packet_id)
-          || cleanText(transferPayload.transfer_packet_id)
-          || cleanText(transferPayload.packet_id)
-          || resolvedWorkTransferPacketId;
-        resolvedTransferChannelId = cleanText(transferPayload.communication_transfer_channel?.transfer_channel_id)
-          || cleanText(transferPayload.communication_transfer_channel?.channel_id)
-          || cleanText(transferPayload.channel_id)
-          || resolvedTransferChannelId;
-      }
-    }
-
-    if (!resolvedTransferChannelId) {
-      throw new Error('channel ownership is ambiguous.');
-    }
-    if (!resolvedWorkTransferPacketId) {
-      throw new Error('work_transfer_packet_id is required.');
-    }
-
-    const blockerSurface = typeof this.raiseCollaborationBlocker === 'function'
-      ? this.raiseCollaborationBlocker.bind(this)
-      : null;
-    if (!blockerSurface) missingSurfaces.push('raiseCollaborationBlocker');
-    const blockerResult = blockerSurface && resolvedTransferChannelId
-      ? await blockerSurface({
-          transferChannelId: resolvedTransferChannelId,
-          workTransferPacketId: resolvedWorkTransferPacketId,
-          workflowRunId: normalizedWorkflowRunId,
-          participantRole: normalizedParticipantRole,
-          blockerKind: normalizedBlockerKind,
-          blockerState: 'open',
-          blockedSide: normalizedWatcherRole,
-          blockerSummary: normalizedBlockerSummary,
-          blockerDetails: normalizedBlockerDetails,
-          expectedNextUpdate: normalizedExpectedResponse,
-          nextOwner: normalizedAssignedTo,
-          reviewerAgentSessionId: this.agentSessionId,
-          reviewerActorSessionId: null,
-          metadata: {
-            ...normalizedMetadata,
-            source: 'createCrossAgentRemediationTicket',
-            source_ref: normalizedSourceRef,
-            assigned_to: normalizedAssignedTo,
-            requested_by: normalizedRequestedBy,
-          },
-        })
-      : null;
-
-    const proposalIdCandidate = cleanText(collaboration_proposal_id) || cleanText(collaborationProposalId) || cleanText(proposal_id) || cleanText(proposalId);
-    const proposalSurface = proposalIdCandidate && typeof this.reviewCollaborationProposal === 'function'
-      ? this.reviewCollaborationProposal.bind(this)
-      : null;
-    if (proposalIdCandidate && !proposalSurface) missingSurfaces.push('reviewCollaborationProposal');
-    const proposalResult = proposalSurface && resolvedTransferChannelId
-      ? await proposalSurface({
-          transferChannelId: resolvedTransferChannelId,
-          collaborationProposalId: proposalIdCandidate,
-          decision: 'accept',
-          nextOwner: normalizedAssignedTo,
-          phase: 'remediation',
-          decisionReason: normalizedBlockerSummary,
-          evidenceRefs: normalizedReplyEvidenceRefs,
-          reviewerRole: normalizedParticipantRole,
-          reviewerAgentSessionId: this.agentSessionId,
-          reviewerActorSessionId: null,
-          reviewedByClaimId: null,
-          metadata: {
-            ...normalizedMetadata,
-            source: 'createCrossAgentRemediationTicket',
-            source_ref: normalizedSourceRef,
-          },
-        })
-      : null;
-
-    const watchSurface = typeof this.startMessageWatch === 'function'
-      ? this.startMessageWatch.bind(this)
-      : null;
-    if (!watchSurface) missingSurfaces.push('startMessageWatch');
-    const watchResult = watchSurface && resolvedTransferChannelId && resolvedWorkTransferPacketId
-      ? await watchSurface({
-          transferChannelId: resolvedTransferChannelId,
-          workTransferPacketId: resolvedWorkTransferPacketId,
-          workflowRunId: normalizedWorkflowRunId,
-          watchingAgentRole: normalizedWatcherRole,
-          expectedFromRole: normalizedAssignedTo || normalizedParticipantRole,
-          expectedMessageKind: normalizedExpectedMessageKind,
-          watchType: 'expected_peer_message',
-          watchingAgentSessionId: this.agentSessionId,
-          expectedPayload: {
-            source_ref: normalizedSourceRef,
-            severity: normalizedSeverity,
-            assigned_to: normalizedAssignedTo,
-            requested_by: normalizedRequestedBy,
-          },
-          currentStatus: 'watching',
-          operatorNudge: normalizedExpectedResponse,
-          metadata: {
-            ...normalizedMetadata,
-            source: 'createCrossAgentRemediationTicket',
-          },
-        })
-      : null;
-
-    const heartbeatSurface = typeof this.postCollaborationHeartbeat === 'function'
-      ? this.postCollaborationHeartbeat.bind(this)
-      : typeof this.postAgentHeartbeat === 'function'
-        ? this.postAgentHeartbeat.bind(this)
-        : null;
-    if (!heartbeatSurface) missingSurfaces.push('postCollaborationHeartbeat');
-    const heartbeatResult = heartbeatSurface && resolvedTransferChannelId && resolvedWorkTransferPacketId
-      ? await heartbeatSurface({
-          transferChannelId: resolvedTransferChannelId,
-          workTransferPacketId: resolvedWorkTransferPacketId,
-          workflowRunId: normalizedWorkflowRunId,
-          participantRole: normalizedParticipantRole,
-          activityState: 'active',
-          agentSessionId: this.agentSessionId,
-          currentPhase: 'remediation',
-          currentTaskSummary: normalizedBlockerSummary,
-          isActive: true,
-          metadata: {
-            ...normalizedMetadata,
-            source: 'createCrossAgentRemediationTicket',
-          },
-        })
-      : null;
-
-    const transferChannelProjectionSurface = typeof this.getTransferChannelProjection === 'function'
-      ? this.getTransferChannelProjection.bind(this)
-      : typeof this.getLogaTransferChannelThreadProjection === 'function'
-        ? this.getLogaTransferChannelThreadProjection.bind(this)
-        : null;
-    if (!transferChannelProjectionSurface) missingSurfaces.push('getTransferChannelProjection');
-    const transferChannelProjection = includeTransferChannelProjection && transferChannelProjectionSurface && resolvedTransferChannelId
-      ? await transferChannelProjectionSurface(resolvedTransferChannelId).catch(() => null)
-      : null;
-
-    const blockerPayload = isPlainObject(blockerResult) ? blockerResult : {};
-    const proposalPayload = isPlainObject(proposalResult) ? proposalResult : {};
-    const watchPayload = isPlainObject(watchResult) ? watchResult : {};
-    const heartbeatPayload = isPlainObject(heartbeatResult) ? heartbeatResult : {};
-    const blockerRecord = isPlainObject(blockerPayload.collaboration_blocker)
-      ? blockerPayload.collaboration_blocker
-      : blockerPayload;
-    const watchRecord = isPlainObject(watchPayload.message_watch)
-      ? watchPayload.message_watch
-      : watchPayload;
-    const heartbeatRecord = isPlainObject(heartbeatPayload.collaboration_heartbeat)
-      ? heartbeatPayload.collaboration_heartbeat
-      : heartbeatPayload;
-
-    const blockerRecordId = cleanText(blockerRecord.collaboration_blocker_id)
-      || cleanText(blockerRecord.blocker_id)
-      || cleanText(blockerPayload.collaboration_blocker_id)
-      || cleanText(blockerPayload.blocker_id)
-      || null;
-    const remediationTicketId = cleanText(transferChannelProjection?.remediation_ticket_id)
-      || cleanText(transferChannelProjection?.work_transfer_packet_id)
-      || cleanText(transferChannelProjection?.transfer_packet_id)
-      || resolvedWorkTransferPacketId
-      || null;
-    const watchId = cleanText(watchRecord.message_watch_id)
-      || cleanText(watchRecord.watch_id)
-      || null;
-    const heartbeatStatus = cleanText(heartbeatRecord.activity_state)
-      || cleanText(heartbeatRecord.status)
-      || 'active';
-    const waitingSide = cleanText(watchRecord.waiting_side)
-      || cleanText(blockerRecord.blocked_side)
-      || cleanText(proposalPayload.next_owner)
-      || normalizedWatcherRole;
-    const expectedResponseText = cleanText(blockerRecord.expected_next_update)
-      || cleanText(watchRecord.expected_message_kind)
-      || cleanText(heartbeatRecord.expected_message_kind)
-      || normalizedExpectedResponse;
-    const status = missingSurfaces.length > 0 ? 'partial' : 'ready';
-    const operatorProjectionMetadata = includeOperatorProjectionMetadata
-      ? {
-          transfer_channel_projection: transferChannelProjection,
-          blocker: blockerPayload,
-          proposal: proposalPayload,
-          message_watch: watchPayload,
-          heartbeat: heartbeatPayload,
-        }
-      : null;
-
-    return {
-      status,
-      remediation_ticket_id: remediationTicketId,
-      blocker_id: blockerRecordId,
-      channel_id: resolvedTransferChannelId || null,
-      transfer_packet_id: resolvedWorkTransferPacketId || null,
-      assigned_to: normalizedAssignedTo,
-      requested_by: normalizedRequestedBy,
-      severity: normalizedSeverity,
-      source_ref: normalizedSourceRef,
-      expected_response: expectedResponseText,
-      watch_id: watchId,
-      heartbeat_status: heartbeatStatus,
-      operator_projection_metadata: operatorProjectionMetadata,
-      missing_surfaces: [...new Set(missingSurfaces)],
-      resume_channel: resumedChannel,
-      blocker: blockerPayload,
-      proposal: proposalPayload,
-      watch: watchPayload,
-      heartbeat: heartbeatPayload,
-    };
+    return this.communicationTickets.createCrossAgentRemediationTicket(arguments[0]);
   }
 
-  async transferRefactoringBundle({
-    projectIdentifier,
-    projectId,
-    startWorkBody = {},
-    startWorkRequest = {},
-    resumeProjectWorkOptions = {},
-    transferChannelId,
-    transfer_channel_id,
-    channelId,
-    channel_id,
-    workTransferPacketId,
-    work_transfer_packet_id,
-    workflowRunId,
-    workflow_run_id,
-    sourceAgent,
-    source_agent,
-    sourceAgentSessionId,
-    source_agent_session_id,
-    targetAgent,
-    target_agent,
-    targetAgentSessionId,
-    target_agent_session_id,
-    targetAgentLabel,
-    target_agent_label,
-    sourceRef,
-    source_ref,
-    problemStatement,
-    problem_statement,
-    affectedFilesOrSymbols,
-    affected_files_or_symbols,
-    recommendedAction,
-    recommended_action,
-    acceptanceCriteria,
-    acceptance_criteria,
-    evidenceRefs = [],
-    evidence_refs = [],
-    riskLevel,
-    risk_level,
-    handoffNotes,
-    handoff_notes,
-    ownershipAssignment = {},
-    ownership_assignment = {},
-    proposal = {},
-    refactoringBundle = {},
-    refactoring_bundle = {},
-    participantRole,
-    participant_role,
-    includeTransferChannelProjection = true,
-    includeOperatorProjectionMetadata = true,
-    metadata = {},
-  } = {}) {
-    const missingSurfaces = [];
-    const normalizedMetadata = isPlainObject(metadata) ? metadata : {};
-    const normalizedBundle = isPlainObject(refactoring_bundle)
-      ? refactoring_bundle
-      : (isPlainObject(refactoringBundle) ? refactoringBundle : {});
-    const normalizedOwnershipAssignment = isPlainObject(ownership_assignment)
-      ? ownership_assignment
-      : (isPlainObject(ownershipAssignment) ? ownershipAssignment : {});
-    const normalizedProposal = isPlainObject(proposal) ? proposal : {};
-    const normalizedProjectReference = cleanText(projectIdentifier) || cleanText(projectId);
-    const normalizedSourceAgent = cleanText(source_agent) || cleanText(sourceAgent) || this.agentSessionId || this.actorId;
-    const normalizedTargetAgent = cleanText(target_agent) || cleanText(targetAgent) || cleanText(target_agent_session_id) || cleanText(targetAgentSessionId);
-    const normalizedTargetLabel = cleanText(target_agent_label) || cleanText(targetAgentLabel) || normalizedTargetAgent;
-    const normalizedParticipantRole = cleanText(participant_role) || cleanText(participantRole) || 'requester';
-    const normalizedSourceRef = cleanText(source_ref) || cleanText(sourceRef) || cleanText(normalizedBundle.source_ref);
-    const normalizedProblemStatement = cleanText(problem_statement) || cleanText(problemStatement) || cleanText(normalizedBundle.problem_statement);
-    const normalizedAffectedFiles = Array.isArray(affected_files_or_symbols)
-      ? affected_files_or_symbols
-      : (Array.isArray(affectedFilesOrSymbols) ? affectedFilesOrSymbols : normalizedBundle.affected_files_or_symbols || []);
-    const normalizedRecommendedAction = cleanText(recommended_action) || cleanText(recommendedAction) || cleanText(normalizedBundle.recommended_action);
-    const normalizedAcceptanceCriteria = Array.isArray(acceptance_criteria)
-      ? acceptance_criteria
-      : (Array.isArray(acceptanceCriteria) ? acceptanceCriteria : normalizedBundle.acceptance_criteria || []);
-    const normalizedEvidenceRefs = Array.isArray(evidence_refs) ? evidence_refs : (Array.isArray(evidenceRefs) ? evidenceRefs : normalizedBundle.evidence_refs || []);
-    const normalizedRiskLevel = cleanText(risk_level) || cleanText(riskLevel) || cleanText(normalizedBundle.risk_level) || 'medium';
-    const normalizedHandoffNotes = cleanText(handoff_notes) || cleanText(handoffNotes) || cleanText(normalizedBundle.handoff_notes);
-    const shouldMoveOwnership = Boolean(normalizedTargetAgent || normalizedOwnershipAssignment.owner_agent_session_id);
-    if (!normalizedTargetAgent) {
-      throw new Error('target_agent is required.');
-    }
-
-    let continuation = null;
-    let startWorkResult = null;
-    if (normalizedProjectReference) {
-      if (typeof this.resumeProjectWork === 'function') {
-        continuation = await this.resumeProjectWork({
-          projectIdentifier: normalizedProjectReference,
-          projectId: normalizedProjectReference,
-          requireClaim: false,
-          ...resumeProjectWorkOptions,
-          ...normalizedMetadata.resume_project_work_options,
-        });
-      } else {
-        missingSurfaces.push('resumeProjectWork');
-      }
-    } else if (Object.keys(isPlainObject(startWorkRequest) ? startWorkRequest : {}).length > 0 || Object.keys(isPlainObject(startWorkBody) ? startWorkBody : {}).length > 0) {
-      if (typeof this.startWork === 'function') {
-        startWorkResult = await this.startWork({
-          ...(isPlainObject(startWorkBody) ? startWorkBody : {}),
-          ...(isPlainObject(startWorkRequest) ? startWorkRequest : {}),
-        });
-      } else {
-        missingSurfaces.push('startWork');
-      }
-    } else {
-      throw new Error('projectIdentifier is required.');
-    }
-
-    const projectPayload = isPlainObject(continuation?.project)
-      ? continuation.project
-      : isPlainObject(startWorkResult?.project)
-        ? startWorkResult.project
-        : isPlainObject(continuation?.summary)
-          ? continuation.summary
-          : {};
-    const resolvedProjectId = cleanText(projectPayload.project_id) || cleanText(projectPayload.projectId) || normalizedProjectReference;
-    const resolvedWorkflowId = cleanText(projectPayload.workflow_id) || cleanText(projectPayload.workflowId) || cleanText(continuation?.workflow_id) || cleanText(startWorkResult?.workflow_id);
-    const resolvedWorkflowRunId = cleanText(projectPayload.workflow_run_id) || cleanText(projectPayload.workflowRunId) || cleanText(continuation?.workflow_run_id) || cleanText(startWorkResult?.workflow_run_id) || cleanText(startWorkResult?.workflowRunId) || cleanText(workflow_run_id) || cleanText(workflowRunId);
-    if (!resolvedProjectId || !resolvedWorkflowRunId) {
-      throw new Error('project/work identifiers are ambiguous.');
-    }
-
-    const transferSurface = typeof this.transferWorkPacket === 'function'
-      ? this.transferWorkPacket.bind(this)
-      : null;
-    if (!transferSurface) missingSurfaces.push('transferWorkPacket');
-    const transferResult = transferSurface
-      ? await transferSurface({
-          workflowRunId: resolvedWorkflowRunId,
-          transferKind: 'upstream_remediation',
-          objective: normalizedProblemStatement || normalizedRecommendedAction || 'Refactoring bundle transfer',
-          requestedOutcome: normalizedRecommendedAction || normalizedProblemStatement || 'Receive refactoring bundle acknowledgement.',
-          target: {
-            intent: 'upstream_remediation',
-            recipient_mode: 'agent_session',
-            preferred_agent_session_id: normalizedTargetAgent,
-            preferred_role_key: normalizedTargetLabel,
-          },
-          artifacts: normalizedAffectedFiles,
-          issues: [],
-          expectedEvidence: normalizedAcceptanceCriteria,
-          preferredModes: ['bundle', 'artifact_refs', 'inline_payload'],
-          capabilities: {},
-          senderAgentSessionId: normalizedSourceAgent,
-          senderActorSessionId: null,
-          subject: normalizedProblemStatement || normalizedRecommendedAction || 'Refactoring bundle transfer',
-          bodyMarkdown: normalizedHandoffNotes || normalizedRecommendedAction || normalizedProblemStatement,
-          messageKind: 'handoff',
-          metadata: {
-            ...normalizedMetadata,
-            source: 'transferRefactoringBundle',
-            source_ref: normalizedSourceRef,
-            risk_level: normalizedRiskLevel,
-          },
-        })
-      : null;
-    const transferPayload = isPlainObject(transferResult) ? transferResult : {};
-    let resolvedWorkTransferPacketId = cleanText(work_transfer_packet_id)
-      || cleanText(workTransferPacketId)
-      || cleanText(transferPayload.work_transfer_packet?.work_transfer_packet_id)
-      || cleanText(transferPayload.work_transfer_packet_id)
-      || cleanText(transferPayload.transfer_packet_id)
-      || cleanText(transferPayload.packet_id)
-      || null;
-    const transferChannel = isPlainObject(transferPayload.communication_transfer_channel) ? transferPayload.communication_transfer_channel : {};
-    let resolvedTransferChannelId = cleanText(transfer_channel_id)
-      || cleanText(transferChannelId)
-      || cleanText(channel_id)
-      || cleanText(channelId)
-      || cleanText(transferChannel.transfer_channel_id)
-      || cleanText(transferChannel.channel_id)
-      || null;
-
-    const shouldResumeChannel = Boolean(cleanText(transfer_channel_id) || cleanText(transferChannelId) || cleanText(channel_id) || cleanText(channelId));
-    const channelSurface = shouldResumeChannel
-      ? (typeof this.resumeTransferChannel === 'function'
-        ? this.resumeTransferChannel.bind(this)
-        : null)
-      : (typeof this.openTransferChannel === 'function'
-        ? this.openTransferChannel.bind(this)
-        : null);
-    if (!channelSurface) missingSurfaces.push(shouldResumeChannel ? 'resumeTransferChannel' : 'openTransferChannel');
-    const channelResult = channelSurface && resolvedWorkTransferPacketId
-      ? await channelSurface({
-          transferChannelId: resolvedTransferChannelId,
-          workTransferPacketId: resolvedWorkTransferPacketId,
-          workflowRunId: resolvedWorkflowRunId,
-          channelKind: 'bidirectional',
-          downstreamAgentSessionId: normalizedTargetAgent,
-          downstreamActorSessionId: null,
-          upstreamAgentSessionId: normalizedSourceAgent,
-          upstreamActorSessionId: null,
-          evidenceRequiredForClosure: true,
-          metadata: {
-            ...normalizedMetadata,
-            source: 'transferRefactoringBundle',
-          },
-        })
-      : null;
-    const channelPayload = isPlainObject(channelResult) ? channelResult : {};
-    resolvedTransferChannelId = cleanText(channelPayload.transfer_channel_id)
-      || cleanText(channelPayload.channel_id)
-      || cleanText(channelPayload.transfer_channel?.transfer_channel_id)
-      || cleanText(channelPayload.communication_transfer_channel?.transfer_channel_id)
-      || resolvedTransferChannelId;
-
-    const ownershipSurface = typeof this.assignCollaborationOwnership === 'function'
-      ? this.assignCollaborationOwnership.bind(this)
-      : null;
-    if (!ownershipSurface) missingSurfaces.push('assignCollaborationOwnership');
-    const ownershipResult = ownershipSurface && resolvedTransferChannelId && normalizedTargetAgent
-      ? await ownershipSurface({
-          transferChannelId: resolvedTransferChannelId,
-          workTransferPacketId: resolvedWorkTransferPacketId,
-          workflowRunId: resolvedWorkflowRunId,
-          participantRole: normalizedParticipantRole,
-          ownerAgentSessionId: normalizedTargetAgent,
-          ownerActorSessionId: null,
-          ownerLabel: normalizedTargetLabel,
-          assignmentState: 'assigned',
-          assignmentReason: normalizedProblemStatement || normalizedRecommendedAction,
-          currentPhase: 'refactoring_bundle_transfer',
-          assignedByAgentSessionId: normalizedSourceAgent,
-          assignedByActorSessionId: null,
-          metadata: {
-            ...normalizedMetadata,
-            source: 'transferRefactoringBundle',
-            source_ref: normalizedSourceRef,
-          },
-        })
-      : null;
-    const ownershipPayload = isPlainObject(ownershipResult) ? ownershipResult : {};
-
-    const proposalSurface = typeof this.postCollaborationProposal === 'function'
-      ? this.postCollaborationProposal.bind(this)
-      : null;
-    if (!proposalSurface) missingSurfaces.push('postCollaborationProposal');
-    const proposalResult = proposalSurface && resolvedTransferChannelId && resolvedWorkTransferPacketId
-      ? await proposalSurface({
-          transferChannelId: resolvedTransferChannelId,
-          workTransferPacketId: resolvedWorkTransferPacketId,
-          workflowRunId: resolvedWorkflowRunId,
-          proposalKind: 'refactoring_bundle',
-          proposalState: 'proposed',
-          participantRole: normalizedParticipantRole,
-          proposalSummary: normalizedProblemStatement || normalizedRecommendedAction || 'Refactoring bundle transfer',
-          currentPhase: 'refactoring_bundle_transfer',
-          expectedNextUpdate: normalizedAcceptanceCriteria.join('; ') || normalizedRecommendedAction,
-          requiredEvidence: normalizedAcceptanceCriteria,
-          responseSchema: {
-            source_ref: normalizedSourceRef,
-            risk_level: normalizedRiskLevel,
-            target_agent: normalizedTargetAgent,
-          },
-          blockerSummary: normalizedProblemStatement || normalizedRecommendedAction,
-          revisionNumber: 1,
-          proposerAgentSessionId: normalizedSourceAgent,
-          proposerActorSessionId: null,
-          metadata: {
-            ...normalizedMetadata,
-            source: 'transferRefactoringBundle',
-            affected_files_or_symbols: normalizedAffectedFiles,
-          },
-        })
-      : null;
-    const proposalPayload = isPlainObject(proposalResult) ? proposalResult : {};
-
-    const watchSurface = typeof this.startMessageWatch === 'function'
-      ? this.startMessageWatch.bind(this)
-      : null;
-    if (!watchSurface) missingSurfaces.push('startMessageWatch');
-    const watchResult = watchSurface && resolvedTransferChannelId && resolvedWorkTransferPacketId
-      ? await watchSurface({
-          transferChannelId: resolvedTransferChannelId,
-          workTransferPacketId: resolvedWorkTransferPacketId,
-          workflowRunId: resolvedWorkflowRunId,
-          watchingAgentRole: normalizedSourceAgent,
-          expectedFromRole: normalizedTargetAgent,
-          expectedMessageKind: 'response',
-          watchType: 'expected_peer_message',
-          watchingAgentSessionId: normalizedSourceAgent,
-          expectedPayload: {
-            source_ref: normalizedSourceRef,
-            expected_acknowledgement: 'refactoring bundle received',
-            target_agent: normalizedTargetAgent,
-          },
-          currentStatus: 'watching',
-          operatorNudge: normalizedHandoffNotes || normalizedRecommendedAction || normalizedProblemStatement,
-          metadata: {
-            ...normalizedMetadata,
-            source: 'transferRefactoringBundle',
-          },
-        })
-      : null;
-    const watchPayload = isPlainObject(watchResult) ? watchResult : {};
-
-    const heartbeatSurface = typeof this.postCollaborationHeartbeat === 'function'
-      ? this.postCollaborationHeartbeat.bind(this)
-      : typeof this.postAgentHeartbeat === 'function'
-        ? this.postAgentHeartbeat.bind(this)
-        : null;
-    if (!heartbeatSurface) missingSurfaces.push('postCollaborationHeartbeat');
-    const heartbeatResult = heartbeatSurface && resolvedTransferChannelId && resolvedWorkTransferPacketId
-      ? await heartbeatSurface({
-          transferChannelId: resolvedTransferChannelId,
-          workTransferPacketId: resolvedWorkTransferPacketId,
-          workflowRunId: resolvedWorkflowRunId,
-          participantRole: normalizedParticipantRole,
-          activityState: 'active',
-          agentSessionId: normalizedSourceAgent,
-          currentPhase: 'refactoring_bundle_transfer',
-          currentTaskSummary: normalizedProblemStatement || normalizedRecommendedAction || 'Refactoring bundle transfer',
-          isActive: true,
-          metadata: {
-            ...normalizedMetadata,
-            source: 'transferRefactoringBundle',
-          },
-        })
-      : null;
-    const heartbeatPayload = isPlainObject(heartbeatResult) ? heartbeatResult : {};
-
-    const transferChannelProjectionSurface = typeof this.getTransferChannelProjection === 'function'
-      ? this.getTransferChannelProjection.bind(this)
-      : typeof this.getLogaTransferChannelThreadProjection === 'function'
-        ? this.getLogaTransferChannelThreadProjection.bind(this)
-        : null;
-    if (!transferChannelProjectionSurface) missingSurfaces.push('getTransferChannelProjection');
-    const transferChannelProjection = includeTransferChannelProjection && transferChannelProjectionSurface && resolvedTransferChannelId
-      ? await transferChannelProjectionSurface(resolvedTransferChannelId).catch(() => null)
-      : null;
-
-    const transferPacketId = cleanText(transferPayload.work_transfer_packet?.work_transfer_packet_id)
-      || cleanText(transferPayload.work_transfer_packet_id)
-      || cleanText(transferPayload.transfer_packet_id)
-      || cleanText(transferPayload.packet_id)
-      || resolvedWorkTransferPacketId
-      || null;
-    const channelIdResolved = resolvedTransferChannelId || cleanText(channelPayload.transfer_channel_id) || cleanText(channelPayload.channel_id) || null;
-    const ownershipAssignmentId = cleanText(ownershipPayload.collaboration_ownership_assignment_id)
-      || cleanText(ownershipPayload.ownership_assignment_id)
-      || cleanText(ownershipPayload.collaboration_ownership_assignment?.collaboration_ownership_assignment_id)
-      || cleanText(ownershipPayload.collaboration_ownership_assignment?.ownership_assignment_id)
-      || null;
-    const proposalId = cleanText(proposalPayload.collaboration_proposal_id)
-      || cleanText(proposalPayload.proposal_id)
-      || cleanText(proposalPayload.collaboration_proposal?.collaboration_proposal_id)
-      || cleanText(proposalPayload.collaboration_proposal?.proposal_id)
-      || null;
-    const watchId = cleanText(watchPayload.message_watch_id)
-      || cleanText(watchPayload.watch_id)
-      || cleanText(watchPayload.message_watch?.message_watch_id)
-      || cleanText(watchPayload.message_watch?.watch_id)
-      || null;
-    const heartbeatStatus = cleanText(heartbeatPayload.collaboration_heartbeat?.activity_state)
-      || cleanText(heartbeatPayload.activity_state)
-      || cleanText(heartbeatPayload.status)
-      || cleanText(heartbeatPayload.collaboration_heartbeat?.status)
-      || 'active';
-    const expectedAcknowledgement = cleanText(watchPayload.expected_message_kind)
-      || cleanText(watchPayload.message_watch?.expected_message_kind)
-      || cleanText(watchPayload.message_watch?.expected_acknowledgement)
-      || 'response';
-    const operatorProjectionMetadata = includeOperatorProjectionMetadata
-      ? {
-          transfer_channel_projection: transferChannelProjection,
-          transfer: transferPayload,
-          channel: channelPayload,
-          ownership_assignment: ownershipPayload,
-          proposal: proposalPayload,
-          message_watch: watchPayload,
-          heartbeat: heartbeatPayload,
-        }
-      : null;
-
-    return {
-      status: missingSurfaces.length > 0 ? 'partial' : 'ready',
-      project_id: resolvedProjectId,
-      source_agent: normalizedSourceAgent,
-      target_agent: normalizedTargetAgent,
-      transfer_packet_id: transferPacketId,
-      channel_id: channelIdResolved,
-      ownership_assignment_id: ownershipAssignmentId,
-      proposal_id: proposalId,
-      watch_id: watchId,
-      expected_acknowledgement: expectedAcknowledgement,
-      heartbeat_status: heartbeatStatus,
-      operator_projection_metadata: operatorProjectionMetadata,
-      missing_surfaces: [...new Set(missingSurfaces)],
-      transfer: transferPayload,
-      channel: channelPayload,
-      ownership_assignment: ownershipPayload,
-      proposal: proposalPayload,
-      message_watch: watchPayload,
-      heartbeat: heartbeatPayload,
-    };
-  }
-
-  async _resolveMessageWatchId(request = {}) {
-    return this.messageWatch.resolveMessageWatchId(request);
-  }
-
-  async acceptAgentChannel(request = {}) {
-    return this.messageWatch.acceptAgentChannel(request);
+  async transferRefactoringBundle(request = {}) {
+    return this.refactoringTransfers.transferRefactoringBundle(request);
   }
 
   async postAgentHeartbeat(request = {}) {
@@ -1332,10 +634,6 @@ export class AIEngineClient {
     return this.transferChannels.closeAgentChannel(request);
   }
 
-  async respondToMessageWatch(request = {}) {
-    return this.messageWatch.respondToMessageWatch(request);
-  }
-
   async reviseCollaborationProposal(request = {}) {
     return this.collaborationDomain.reviseCollaborationProposal(request);
   }
@@ -1348,10 +646,6 @@ export class AIEngineClient {
     return this.collaborationDomain.beginCollaborationImplementation(request);
   }
 
-  async requestCollaborationClosure(request = {}) {
-    return this.collaborationDomain.requestCollaborationClosure(request);
-  }
-
   async bootstrapCommunication() {
     return this._request('/api/agent-communications/bootstrap');
   }
@@ -1510,18 +804,6 @@ export class AIEngineClient {
     });
   }
 
-  async postCollaborationProposal(request = {}) {
-    return this.collaborationDomain.postCollaborationProposal(request);
-  }
-
-  async assignCollaborationOwnership(request = {}) {
-    return this.collaborationDomain.assignCollaborationOwnership(request);
-  }
-
-  async transferWorkPacket(request = {}) {
-    return this.transferBundles.transferWorkPacket(request);
-  }
-
   async openCommunicationThread({
     workflowRunId,
     workflow_run_id,
@@ -1590,42 +872,6 @@ export class AIEngineClient {
     });
   }
 
-  async whoIsOnline(request = {}) {
-    return this.presence.whoIsOnline(request);
-  }
-
-  async findOnlineParticipant(request = {}) {
-    return this.presence.findOnlineParticipant(request);
-  }
-
-  async sendToParticipant(request = {}) {
-    return this.presence.sendToParticipant(request);
-  }
-
-  async sendToRole(request = {}) {
-    return this.presence.sendToRole(request);
-  }
-
-  async startCoordinationPingPong(request = {}) {
-    return this.pingPong.startCoordinationPingPong(request);
-  }
-
-  async sendCoordinationPing(request = {}) {
-    return this.pingPong.sendCoordinationPing(request);
-  }
-
-  async sendCoordinationPong(request = {}) {
-    return this.pingPong.sendCoordinationPong(request);
-  }
-
-  async getCoordinationPingPongStatus(request = {}) {
-    return this.pingPong.getCoordinationPingPongStatus(request);
-  }
-
-  async stopCoordinationPingPong(request = {}) {
-    return this.pingPong.stopCoordinationPingPong(request);
-  }
-
   async verifyMessageSent({ messageId, message_id } = {}) {
     const normalizedMessageId = cleanText(message_id) || cleanText(messageId);
     if (!normalizedMessageId) throw new Error('message_id is required.');
@@ -1754,46 +1000,6 @@ export class AIEngineClient {
     });
   }
 
-  async createCommunicationBundle(request = {}) {
-    return this.transferBundles.createCommunicationBundle(request);
-  }
-
-  async getCommunicationBundle(bundleId) {
-    return this.transferBundles.getCommunicationBundle(bundleId);
-  }
-
-  async listCommunicationBundles(request = {}) {
-    return this.transferBundles.listCommunicationBundles(request);
-  }
-
-  async addCommunicationBundleItem(request = {}) {
-    return this.transferBundles.addCommunicationBundleItem(request);
-  }
-
-  async uploadCommunicationBundle(request = {}) {
-    return this.transferBundles.uploadCommunicationBundle(request);
-  }
-
-  async attachCommunicationBundleToMessage(request = {}) {
-    return this.transferBundles.attachCommunicationBundleToMessage(request);
-  }
-
-  async recordCommunicationBundleReceipt(request = {}) {
-    return this.transferBundles.recordCommunicationBundleReceipt(request);
-  }
-
-  async recordCommunicationBundleCleanupEvent(request = {}) {
-    return this.transferBundles.recordCommunicationBundleCleanupEvent(request);
-  }
-
-  async claimCommunicationBundle(request = {}) {
-    return this.transferBundles.claimCommunicationBundle(request);
-  }
-
-  async recordCommunicationTransferReceipt(request = {}) {
-    return this.transferBundles.recordCommunicationTransferReceipt(request);
-  }
-
   async acceptCommunicationTransferPacket({
     workTransferPacketId,
     work_transfer_packet_id,
@@ -1982,76 +1188,28 @@ export class AIEngineClient {
     });
   }
 
-  async getPortfolioClosureReadiness(...args) {
-    return this.portfolio.getPortfolioClosureReadiness(...args);
-  }
-
-  async getPortfolioStatus(...args) {
-    return this.portfolio.getPortfolioStatus(...args);
-  }
-
   async describeDatabaseCatalog({ includeSystemSchemas, limit } = {}) {
-    return this._request('/api/operator/database/schema', {
-      query: {
-        view: 'overview',
-        include_system_schemas: includeSystemSchemas,
-        limit,
-      },
-    });
+    return this.database.schema.getOverview({ includeSystemSchemas, limit });
   }
 
   async listDatabaseSchemas({ includeSystemSchemas, limit } = {}) {
-    return this._request('/api/operator/database/schema', {
-      query: {
-        view: 'schemas',
-        include_system_schemas: includeSystemSchemas,
-        limit,
-      },
-    });
+    return this.database.schema.listSchemas({ includeSystemSchemas, limit });
   }
 
   async listDatabaseTables({ schemaName, includeSystemSchemas, limit } = {}) {
-    return this._request('/api/operator/database/schema', {
-      query: {
-        view: 'tables',
-        schema_name: schemaName,
-        include_system_schemas: includeSystemSchemas,
-        limit,
-      },
-    });
+    return this.database.schema.listTables({ schemaName, includeSystemSchemas, limit });
   }
 
   async listDatabaseColumns({ schemaName, tableName } = {}) {
-    return this._request('/api/operator/database/schema', {
-      query: {
-        view: 'columns',
-        schema_name: schemaName,
-        table_name: tableName,
-      },
-    });
+    return this.database.schema.listColumns({ schemaName, tableName });
   }
 
   async listDatabaseIndexes({ schemaName, tableName, includeSystemSchemas, limit } = {}) {
-    return this._request('/api/operator/database/schema', {
-      query: {
-        view: 'indexes',
-        schema_name: schemaName,
-        table_name: tableName,
-        include_system_schemas: includeSystemSchemas,
-        limit,
-      },
-    });
+    return this.database.schema.listIndexes({ schemaName, tableName, includeSystemSchemas, limit });
   }
 
   async describeDatabaseTable({ schemaName, tableName, includeSystemSchemas } = {}) {
-    return this._request('/api/operator/database/schema', {
-      query: {
-        view: 'table',
-        schema_name: schemaName,
-        table_name: tableName,
-        include_system_schemas: includeSystemSchemas,
-      },
-    });
+    return this.database.schema.describeTable({ schemaName, tableName, includeSystemSchemas });
   }
 
   async createDatabaseBackup({ databaseName, outputName, noWait } = {}) {
@@ -2065,10 +1223,6 @@ export class AIEngineClient {
     });
   }
 
-  async getPortfolioBundle() {
-    return this.portfolio.getPortfolioBundle();
-  }
-
   async getExternalProjectStatus(projectId) {
     return this._request(`/api/v1/projects/${projectId}/status`);
   }
@@ -2154,94 +1308,4 @@ export class AIEngineClient {
 export function createAIEngineClient(options) {
   return new AIEngineClient(options);
 }
-function defineCompatibilityMethods(proto, targetName, methodNames) {
-  for (const methodName of methodNames) {
-    if (Object.prototype.hasOwnProperty.call(proto, methodName)) continue;
-    Object.defineProperty(proto, methodName, {
-      value: function delegatedClientMethod(...args) {
-        return this[targetName][methodName](...args);
-      },
-      configurable: true,
-      writable: true,
-    });
-  }
-}
-
-function defineCompatibilityAliases(proto, targetName, methodMap) {
-  for (const [methodName, targetMethodName] of Object.entries(methodMap)) {
-    if (Object.prototype.hasOwnProperty.call(proto, methodName)) continue;
-    Object.defineProperty(proto, methodName, {
-      value: function delegatedClientMethod(...args) {
-        return this[targetName][targetMethodName](...args);
-      },
-      configurable: true,
-      writable: true,
-    });
-  }
-}
-
-function installClientCompatibilityDelegates(ClientClass) {
-  const proto = ClientClass.prototype;
-  defineCompatibilityMethods(proto, 'health', ['ping']);
-  defineCompatibilityMethods(proto, 'operatorStatus', ['currentWorkflowStatus', 'getCurrentWorkflowStatus', 'currentArchitectureIntegrityStatus', 'getCurrentArchitectureIntegrityStatus', 'currentSecurityGovernanceStatus', 'getCurrentSecurityGovernanceStatus', 'getExecutionTelemetryCurrent', 'listExecutionProcessRuns', 'getExecutionProcessRun', 'getGeneratedExecutionUsability', 'getLogaGeneratedExecutionUsabilityProjection', 'getAntiPatternRules', 'currentCodebaseShapeStatus', 'getLatestMemoryProjection', 'currentProjectStatus', 'getDashboard', 'getCommunicationCapabilities', 'getCollaborationCapabilities', 'getDeploymentCapabilities']);
-  defineCompatibilityMethods(proto, 'database', ['query', 'createDatabaseBackup', 'listDatabaseBackups', 'getDatabaseBackup', 'listDatabaseBackupOperations', 'runAzureSqlBacpacBackup', 'listAzureSqlBacpacBackups', 'listAzureSqlBacpacBackupOperations']);
-  defineCompatibilityMethods(proto, 'reports', ['runReport', 'runReportDefinition']);
-  defineCompatibilityMethods(proto, 'retrievalWrapper', ['getCommandCard', 'resolveOperatingProcedure', 'getSymbolDefinition', 'getRelatedCode']);
-  defineCompatibilityMethods(proto, 'repo', ['listRepositories', 'getRepository', 'listCodeFiles', 'getCodeFile', 'getCodeFileContentWindow', 'listCodeSymbolsByFile', 'getCodeSymbol', 'searchSymbols', 'getSymbolRelationships', 'listCodeRelationships', 'listActionObservations', 'listCodebaseShapeFindings', 'listObjectFlowObservations', 'getChangeAnalysis', 'listRefactorCandidates', 'analyzeRefactorCandidate', 'getRepoRetrievalPacket', 'getRepoRetrievalPacketFragments', 'evaluateProposalScope']);
-  defineCompatibilityMethods(proto, 'retrievalManagement', ['getRetrievalStatus', 'getRetrievalProfileMetrics', 'getRetrievalFeedbackMetrics', 'getRetrievalQuery', 'getRetrievalPacket', 'generateRetrievalCandidates', 'selectRetrievalPacket', 'recordRetrievalFeedback', 'deriveRetrievalOptimizationCandidates', 'validatePromptAssembly']);
-  defineCompatibilityMethods(proto, 'workflows', ['listWorkflows', 'createWorkflow', 'getWorkflow', 'replaceWorkflowSteps', 'publishWorkflow', 'cloneWorkflow', 'evaluateWorkflowGovernance', 'listWorkflowGovernanceDecisions', 'getWorkflowGovernanceSimulation', 'listWorkflowGovernanceBundles', 'listWorkflowGovernanceApprovals', 'listWorkflowGovernanceEvents', 'getWorkflowGovernanceReview', 'createWorkflowGovernanceReviewDecision', 'createWorkflowRun', 'getWorkflowRun', 'listWorkflowArtifacts', 'getWorkflowRunSubstrate', 'getWorkflowPlayback', 'resumeWorkflowRun', 'listRecentInspectorRuns', 'inspectWorkflowRun']);
-  defineCompatibilityMethods(proto, 'projects', ['listProjects', 'getProject', 'listProjectWorkflowRuns', 'closeProject', 'closeActiveProject', 'getProjectBundle', 'listProjectOpenTasks', 'closeRoadmapItemWorkflow']);
-  defineCompatibilityMethods(proto, 'projectChartering', ['createProjectCharter', 'createProjectDelivery', 'approveProjectCharterIntent', 'approveImplementationRoadmap', 'runProjectCharter', 'beginImplementationRoadmap', 'routeImplementationItem']);
-  defineCompatibilityMethods(proto, 'projectReports', ['getProjectCharterReport', 'createProjectMarkdownDownload', 'downloadProjectMarkdownReport', 'downloadProjectCharterReportMarkdown']);
-  defineCompatibilityMethods(proto, 'projectResume', ['resumeProjectWork']);
-  defineCompatibilityMethods(proto, 'roadmaps', ['listProjectRoadmaps', 'getProjectRoadmap', 'getProjectRoadmapSummary', 'getProjectRoadmapActiveItem', 'listProjectOpenTasks', 'getProjectPerformanceMetrics', 'ensureProjectRoadmapTaskSurface']);
-  defineCompatibilityMethods(proto, 'roadmapReports', ['getProjectImplementationRoadmapReport', 'downloadProjectImplementationRoadmapReportMarkdown']);
-  defineCompatibilityMethods(proto, 'implementationTasks', ['createImplementationTask', 'listImplementationTasks', 'listImplementationSubtasks', 'updateImplementationTask', 'assignImplementationTask', 'completeImplementationTask']);
-  defineCompatibilityMethods(proto, 'implementationPackets', ['importImplementationPacket', 'listImplementationPackets', 'getImplementationPacket', 'bindImplementationPacketToWorkflow', 'getWorkflowImplementationRoadmap', 'getWorkflowResumeContext', 'importImplementationPacketAndMaterializeRoadmap']);
-  defineCompatibilityMethods(proto, 'implementationChecks', ['getImplementationItemAcceptanceChecks', 'updateAcceptanceCheckStatus', 'updateAcceptanceCheckStatusVerified']);
-  defineCompatibilityMethods(proto, 'implementationArtifacts', ['getArtifactManifest', 'getDecisionPacket', 'verifyImplementationItemArtifacts']);
-  defineCompatibilityMethods(proto, 'implementationItems', ['updateImplementationItemStatus', 'updateImplementationItemStatusVerified']);
-  defineCompatibilityMethods(proto, 'implementationEvidence', ['addImplementationItemEvidence', 'addImplementationItemActivity', 'listImplementationItemActivity']);
-  defineCompatibilityMethods(proto, 'implementationGates', ['createImplementationPacketGateDecision']);
-  defineCompatibilityMethods(proto, 'workflowTurns', ['completeTurn', 'persistAssistantTurn']);
-  defineCompatibilityMethods(proto, 'claims', ['getClaim', 'claimIsValid', 'signoffClaim', 'promoteClaimSurface']);
-  defineCompatibilityMethods(proto, 'sessionGovernance', ['startSessionGovernance', 'startReviewGovernance', 'evaluateTurnCompliance', 'blockIfNonCompliant']);
-  defineCompatibilityMethods(proto, 'workStart', ['startWork', 'startClaimedWork', 'claimWorkItem', 'bindClaimedWorkItem']);
-  defineCompatibilityMethods(proto, 'executionEligibility', ['getExecutionEligibility', '_assertExecutionEligibility']);
-  defineCompatibilityMethods(proto, 'toolBindingApprovals', ['createWorkflowToolBindingApprovalLane', 'recordWorkflowToolBindingApprovalDecision', 'executeWorkflowToolBindingApprovalBinding', 'revalidateWorkflowToolBindingStartup']);
-  defineCompatibilityMethods(proto, 'verifiedMutations', ['executeVerifiedMutation']);
-  defineCompatibilityMethods(proto, 'charters', ['runCharter']);
-  defineCompatibilityMethods(proto, 'pingPong', ['checkCoordinationPingPongPreflight', 'startCoordinationPingPong', 'sendCoordinationPing', 'sendCoordinationPong', 'getCoordinationPingPongStatus', 'stopCoordinationPingPong']);
-  defineCompatibilityAliases(proto, 'pingPong', { pingAgentCommunicationPeer: 'sendCoordinationPing', pongAgentCommunicationPeer: 'sendCoordinationPong' });
-  defineCompatibilityMethods(proto, 'transferChannels', ['listCommunicationChannels', 'listOpenCommunicationChannels', 'getCommunicationChannelStatus', 'getCommunicationChannelParticipants', 'openTransferChannel', 'joinTransferChannel', 'resumeTransferChannel', 'replyToTransferChannel', 'closeTransferChannel', 'requestTransferClosure', 'openAgentChannel', 'connectToTransferChannel', 'startAgentConnection', 'postAgentHeartbeat', 'closeAgentChannel']);
-  defineCompatibilityMethods(proto, 'messageWatch', ['startMessageWatch', 'acknowledgeExpectedMessage', 'expireMessageWatch', 'respondToMessageWatch', 'acceptAgentChannel', 'resolveMessageWatchId']);
-  defineCompatibilityMethods(proto, 'presence', ['getPresenceBoard', 'getChannelPresence', 'markParticipantOnline', 'markParticipantOffline', 'whoIsOnline', 'findOnlineParticipant', 'sendToParticipant', 'sendToRole', 'postPresenceHeartbeat']);
-  defineCompatibilityMethods(proto, 'collaborationDomain', ['reviewCollaborationProposal', 'reviseCollaborationProposal', 'postCollaborationProposal', 'acceptCollaborationProposal', 'assignCollaborationOwnership', 'raiseCollaborationBlocker', 'resolveCollaborationBlocker', 'postCollaborationHeartbeat', 'beginCollaborationImplementation', 'requestCollaborationClosure']);
-  defineCompatibilityMethods(proto, 'transferBundles', ['transferWorkPacket', 'getTransferBundle', 'listTransferBundles', 'createTransferReceipt', 'listTransferReceipts', 'createCommunicationBundle', 'getCommunicationBundle', 'listCommunicationBundles', 'addCommunicationBundleItem', 'uploadCommunicationBundle', 'attachCommunicationBundleToMessage', 'recordCommunicationBundleReceipt', 'recordCommunicationBundleCleanupEvent', 'claimCommunicationBundle', 'recordCommunicationTransferReceipt']);
-  defineCompatibilityMethods(proto, 'workflowComposition', ['registerModernizationAsset', 'classifyModernizationAsset', 'discoverSalvageCandidates', 'createModernizationWorkPacket', 'requestModernizationWrapperExecution', 'getModernizationWrapperEvidence', 'decideModernizationGate']);
-  defineCompatibilityMethods(proto, 'currentProject', ['currentProjectStatus']);
-  defineCompatibilityMethods(proto, 'projections', ['renderProjection', 'getLogaOperatorHomeProjection', 'getLogaProjectCatalogProjection', 'getLogaProjectPortfolioProjection', 'getLogaProjectRoadmapProjection', 'getLogaRoadmapItemProjection', 'getLogaWorkflowRunProjection', 'getLogaEvidencePacketProjection', 'getLogaTransferHomeProjection', 'getLogaTransferInboxProjection', 'getLogaTransferPacketProjection', 'getLogaTransferNegotiationEventsProjection', 'getLogaTransferFrictionLaneProjection', 'getLogaTransferReceiptsProjection', 'getLogaTransferClosureReviewProjection', 'getTransferChannelProjection']);
-  defineCompatibilityAliases(proto, 'projections', { getLogaTransferChannelThreadProjection: 'getTransferChannelProjection' });
-  defineCompatibilityMethods(proto, 'loga', ['submitUxGateRemediation', 'listUxGateRemediations', 'getUxGateRemediation', 'appendUxRemediationTicketNote', 'listUxRemediationTicketNotes', 'promoteUxGateRemediationImplementationCandidate', 'getLogaUxGateRemediationProjection', 'getUxGateRemediationProjection']);
-  defineCompatibilityMethods(proto, 'actions', ['submitActionIntent']);
-  defineCompatibilityMethods(proto, 'executionTelemetry', ['getExecutionTelemetryCurrent', 'listExecutionProcessRuns', 'getExecutionProcessRun', 'getGeneratedExecutionUsability', 'getLogaGeneratedExecutionUsabilityProjection']);
-  defineCompatibilityMethods(proto, 'scripts', ['generateScript', 'renderScript', 'submitScriptArtifact', 'getScriptRunEvidence']);
-  defineCompatibilityMethods(proto, 'capabilities', ['listCapabilities', 'createCapability', 'testCapability']);
-  defineCompatibilityMethods(proto, 'skills', ['currentSkillRegistryStatus', 'getSkillContract', 'getSkillGovernance', 'createSkillContractDraft', 'recordSkillPatternReview', 'approveSkillContract', 'createWorkflowSkillContract', 'listWorkflowSkillBindings', 'seedFrequentOperationSkills']);
-  defineCompatibilityMethods(proto, 'skillGovernance', ['createSkillGovernanceChange', 'listSkillGovernanceChanges', 'getSkillGovernanceChange']);
-  defineCompatibilityMethods(proto, 'toolRegistry', ['currentToolRegistryStatus', 'getWorkflowToolRegistry', 'currentAssistantToolContext', 'getTool', 'getToolHistory', 'getToolInvocations', 'getToolEventReplayBundle', 'getToolGovernance', 'createToolReviewDecision', 'createToolGateDecision']);
-  defineCompatibilityMethods(proto, 'contextAssembly', ['getContextAssemblyContract', 'getContextAssemblyStatus', 'getOperatorContext', 'getContextFragments', 'getContextReuse', 'listPromptAssemblies']);
-  defineCompatibilityMethods(proto, 'performance', ['getSessionPerformanceMetrics', 'captureBenchmarkSnapshot', 'listBenchmarks', 'getBenchmarkMetrics', 'getBenchmarkDelta', 'getBenchmarkTrend', 'getPerformanceDashboard']);
-  defineCompatibilityMethods(proto, 'selfLearning', ['getSelfLearningPosture', 'listLearningRecords', 'getLearningRecord', 'listPromotionCandidates', 'getPromotionCandidate', 'listPromotionFlows']);
-  defineCompatibilityMethods(proto, 'selfOptimization', ['getSelfOptimizationDashboard', 'getSelfOptimizationCandidateQueue', 'getSelfOptimizationBacklogPosture', 'getSelfOptimizationPendingHandoffs']);
-  defineCompatibilityMethods(proto, 'designIntelligence', ['getDesignIntelligenceDashboard', 'listDesignDecisions', 'getDesignDecision', 'getDesignDecisionVariants', 'getDesignDecisionCritique', 'getDesignDecisionLineage', 'listDesignPatterns', 'getDecisionLabCanvas', 'getDesignRecommendations', 'getDesignPromotions', 'previewDesignPromotion', 'getDesignIntelligenceMetrics']);
-  defineCompatibilityMethods(proto, 'scriptDiscovery', ['scanScripts', 'listDiscoveredScriptAssets', 'listDiscoveredCapabilities', 'listWorkflowCandidates', 'promoteWorkflowCandidate']);
-  defineCompatibilityMethods(proto, 'notesLab', ['getNotesLabConfig', 'submitNote', 'approveNoteReview']);
-  defineCompatibilityMethods(proto, 'searchContacts', ['search', 'getOrganization', 'getContact']);
-  defineCompatibilityMethods(proto, 'benchmarks', ['listRecentBenchmarkRuns', 'getBenchmarkRun']);
-  defineCompatibilityMethods(proto, 'commitGovernance', ['evaluateCommitGovernance', 'checkGitShipReadiness', 'getCommitGovernanceEvaluation', 'listCommitGovernanceEvaluationsByClaim']);
-  defineCompatibilityMethods(proto, 'contextSessions', ['openContextSession', 'getOrientationWindow', 'acknowledgeReminder', 'completeOrientation', 'lockContextSessionClaim', 'getContextSessionGateStatus']);
-  defineCompatibilityMethods(proto, 'contextOrientation', ['conductOrientation']);
-  defineCompatibilityMethods(proto, 'portfolio', ['getPortfolioStatus', 'getPortfolioBundle', 'getPortfolioClosureReadiness']);
-}
 installClientCompatibilityDelegates(AIEngineClient);