@bpmsoftwaresolutions/ai-engine-client 1.1.98 → 1.1.101

package/src/client.js

@@ -1,7 +1,5 @@
 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';
 import { createActionsDomain } from './domains/actions.js';
 import { createBenchmarksDomain } from './domains/benchmarks.js';
 import { createCapabilitiesDomain } from './domains/capabilities.js';
@@ -15,6 +13,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 +31,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 +43,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,184 +69,9 @@ 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';
-
-function normalizeThreadType(value) {
-  return normalizeEnum(value, AGENT_COMMUNICATION_THREAD_TYPES, 'coordination', 'thread_type', {
-    task_request: 'request',
-    task: 'request',
-    review_request: 'review',
-    handoff_request: 'handoff',
-  });
-}
-
-function normalizeMessageKind(value) {
-  return normalizeEnum(value, AGENT_COMMUNICATION_MESSAGE_KINDS, 'request', 'message_kind', {
-    task: 'request',
-    note: 'request',
-    update: 'response',
-  });
-}
-
-function normalizeConnectionFirstMessageKind(value, transferKind) {
-  const text = cleanText(value);
-  if (!text) {
-    return normalizeMessageKind(transferKind === 'handoff' ? 'handoff' : 'request');
-  }
-  const normalized = text.toLowerCase();
-  const aliases = {
-    connection_request: 'request',
-    connection_accepted: 'response',
-    connection_acceptance: 'response',
-    handoff_request: 'handoff',
-    handoff_acceptance: 'response',
-    handoff_response: 'response',
-    acceptance: 'response',
-    decline: 'response',
-  };
-  const candidate = aliases[normalized] || text;
-  try {
-    return normalizeMessageKind(candidate);
-  } catch (error) {
-    void error;
-    return normalizeMessageKind(transferKind === 'handoff' ? 'handoff' : 'request');
-  }
-}
-
-function normalizeTransferKind(value) {
-  return normalizeEnum(value, AGENT_COMMUNICATION_TRANSFER_KINDS, 'upstream_remediation', 'transfer_kind', {
-    remediation_request: 'upstream_remediation',
-    review: 'review_request',
-  });
-}
-
-function normalizeTransferMode(value) {
-  return normalizeEnum(value, AGENT_COMMUNICATION_TRANSFER_MODES, 'inline_payload', 'transfer_mode');
-}
-
-function normalizeTransferLifecycleStatus(value) {
-  return normalizeEnum(value, AGENT_COMMUNICATION_TRANSFER_LIFECYCLE_STATES, 'created', 'lifecycle_status');
-}
-
-function normalizeTransferReceiptType(value) {
-  return normalizeEnum(value, AGENT_COMMUNICATION_TRANSFER_RECEIPT_TYPES, 'delivery_receipt', 'receipt_type');
-}
-
-function normalizeRecipientMode(value) {
-  return normalizeEnum(value, AGENT_COMMUNICATION_RECIPIENT_MODES, 'role', 'recipient_mode');
-}
-
-function appendQuery(url, query) {
-  const target = new URL(url);
-  for (const [key, value] of Object.entries(query || {})) {
-    if (value === undefined || value === null || value === '') continue;
-    target.searchParams.set(key, String(value));
-  }
-  return target;
-}
-
-async function readJson(response) {
-  const contentType = response.headers.get('content-type') || '';
-  if (contentType.includes('application/json')) return response.json();
-  const text = await response.text();
-  return { message: text };
-}
-
-function parseContentDispositionFilename(headerValue) {
-  const value = String(headerValue || '');
-  const quotedMatch = value.match(/filename="([^"]+)"/i);
-  if (quotedMatch) return quotedMatch[1];
-  const plainMatch = value.match(/filename=([^;]+)/i);
-  return plainMatch ? plainMatch[1].trim() : null;
-}
-
-function readResponseHeader(headers, name) {
-  if (!headers || typeof headers.get !== 'function') return null;
-  return headers.get(name) || headers.get(name.toLowerCase()) || null;
-}
-
-function extractLogaProjectionMetadata(headers) {
-  const projectionWorkflow = readResponseHeader(headers, 'x-projection-workflow');
-  const projectionVersion = readResponseHeader(headers, 'x-projection-version');
-  const sourceVersion = readResponseHeader(headers, 'x-source-version');
-  const correlationId = readResponseHeader(headers, 'x-correlation-id');
-  const logaContract = readResponseHeader(headers, 'x-loga-contract');
-  const navigationContract = readResponseHeader(headers, 'x-navigation-contract');
-  const projectionType = readResponseHeader(headers, 'x-projection-type');
-  const sourceTruth = readResponseHeader(headers, 'x-source-truth');
-  const refreshPolicy = readResponseHeader(headers, 'x-refresh-policy');
-  const generatedAt = readResponseHeader(headers, 'x-generated-at');
-
-  return {
-    logaContract,
-    navigationContract,
-    interactionContract: LOGA_INTERACTION_CONTRACT,
-    projectionType,
-    projectionWorkflow,
-    projectionVersion,
-    sourceTruth,
-    sourceVersion,
-    correlationId,
-    refreshPolicy,
-    generatedAt,
-    provenance: {
-      sourceTruth,
-      sourceVersion,
-      projectionVersion,
-      projectionWorkflow,
-      correlationId,
-      generatedAt,
-    },
-  };
-}
-
-function isFormDataBody(value) {
-  return typeof FormData !== 'undefined' && value instanceof FormData;
-}
-
-function isBinaryBody(value) {
-  return (
-    value instanceof ArrayBuffer
-    || ArrayBuffer.isView(value)
-    || (typeof Blob !== 'undefined' && value instanceof Blob)
-    || value instanceof URLSearchParams
-    || typeof value === 'string'
-  );
-}
-
-function isJsonBody(value) {
-  if (value === undefined || value === null) return false;
-  if (isFormDataBody(value) || isBinaryBody(value)) return false;
-  return typeof value === 'object';
-}
-
-function cleanText(value) {
-  const text = String(value || '').trim();
-  return text || null;
-}
-
-function compareSemanticVersions(left, right) {
-  const leftParts = String(left || '').split('.').map((part) => Number.parseInt(part, 10) || 0);
-  const rightParts = String(right || '').split('.').map((part) => Number.parseInt(part, 10) || 0);
-  const width = Math.max(leftParts.length, rightParts.length);
-  for (let index = 0; index < width; index += 1) {
-    const a = leftParts[index] || 0;
-    const b = rightParts[index] || 0;
-    if (a > b) return 1;
-    if (a < b) return -1;
-  }
-  return 0;
-}
-
-function cleanList(value) {
-  if (!Array.isArray(value)) return [];
-  return value.map((item) => cleanText(item)).filter(Boolean);
-}
-
-function isPlainObject(value) {
-  return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
+import { cleanText, isPlainObject, trimTrailingSlash } from './utils/text.js';
 
 export class AIEngineClient {
   constructor({ baseUrl, accessToken, tokenProvider, apiKey, clientId, actorId, agentSessionId, fetchImpl, timeoutMs } = {}) {
@@ -326,6 +154,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);
@@ -347,1739 +180,10 @@ export class AIEngineClient {
 
   // ─── Health ────────────────────────────────────────────────────────────────
 
-  async startAgentConnection({
-    workflowRunId,
-    workflow_run_id,
-    upstreamAgent,
-    upstream_agent,
-    upstreamAgentSessionId,
-    upstream_agent_session_id,
-    upstreamAgentId,
-    upstream_agent_id,
-    upstreamRole,
-    upstream_role,
-    recipientMode,
-    recipient_mode,
-    purpose,
-    objective,
-    mode = 'handoff',
-    firstMessage = {},
-    first_message = {},
-    expectedMessageKind,
-    expected_message_kind,
-    participantRole,
-    participant_role,
-    participantLabel,
-    participant_label,
-    senderAgentSessionId,
-    sender_agent_session_id,
-    senderActorSessionId,
-    sender_actor_session_id,
-    cleanupPolicy,
-    cleanup_policy,
-    staleAfterSeconds = 300,
-    stale_after_seconds,
-    operatorNudge,
-    operator_nudge,
-    metadata = {},
-  } = {}) {
-    return this.agentCommunications.startAgentConnection(arguments[0]);
-  }
-
-  async establishAgentCommunicationChannel({
-    projectIdentifier,
-    projectId,
-    claimId,
-    actorId,
-    actorMode = 'operator',
-    executionIntent = 'establish agent communication channel',
-    workflowRunLimit = 5,
-    startWorkBody = {},
-    startWorkRequest = {},
-    resumeProjectWorkOptions = {},
-    transferKind = 'coordination',
-    objective,
-    requestedOutcome,
-    transferChannelId,
-    transfer_channel_id,
-    channelId,
-    channel_id,
-    workTransferPacketId,
-    work_transfer_packet_id,
-    packetId,
-    packet_id,
-    participantRole,
-    participant_role,
-    participantLabel,
-    participant_label,
-    participantKind,
-    participant_kind,
-    agentSessionId,
-    agent_session_id,
-    actorSessionId,
-    actor_session_id,
-    upstreamAgentSessionId,
-    upstream_agent_session_id,
-    upstreamActorSessionId,
-    upstream_actor_session_id,
-    downstreamAgentSessionId,
-    downstream_agent_session_id,
-    downstreamActorSessionId,
-    downstream_actor_session_id,
-    expectedMessageKind = 'connection_accepted',
-    expected_message_kind,
-    expectedNextMessage,
-    expected_next_message,
-    currentPhase = 'channel_ready',
-    current_phase,
-    currentTaskSummary,
-    current_task_summary,
-    channelKind = 'bidirectional',
-    channel_kind,
-    includeTransferChannelProjection = true,
-    includeChannelPresenceProjection = true,
-    includeOperatorProjectionMetadata = true,
-    metadata = {},
-  } = {}) {
-    return this.agentCommunications.establishAgentCommunicationChannel(arguments[0]);
-  }
-
-  async runInterAgentMessagingLoop({
-    transferChannelId,
-    transfer_channel_id,
-    channelId,
-    channel_id,
-    workTransferPacketId,
-    work_transfer_packet_id,
-    workflowRunId,
-    workflow_run_id,
-    participantRole,
-    participant_role,
-    watchingAgentRole,
-    watching_agent_role,
-    expectedFromRole,
-    expected_from_role,
-    expectedMessageKind,
-    expected_message_kind,
-    expectedNextMessage,
-    expected_next_message,
-    replyRequest = {},
-    reply_request = {},
-    replyBodyMarkdown,
-    reply_body_markdown,
-    replyMessageKind,
-    reply_message_kind,
-    replyPayload = {},
-    reply_payload = {},
-    replyScope = {},
-    reply_scope = {},
-    replyEvidenceRefs = [],
-    reply_evidence_refs = [],
-    replyRecipientAgentSessionId,
-    reply_recipient_agent_session_id,
-    replyRecipientActorSessionId,
-    reply_recipient_actor_session_id,
-    replySenderAgentSessionId,
-    reply_sender_agent_session_id,
-    replySenderActorSessionId,
-    reply_sender_actor_session_id,
-    watchRequest = {},
-    watch_request = {},
-    acknowledgeRequest = {},
-    acknowledge_request = {},
-    heartbeatRequest = {},
-    heartbeat_request = {},
-    closeWhenAcknowledged = false,
-    close_when_acknowledged = false,
-    requestClosure = false,
-    request_closure = false,
-    closureReason,
-    closure_reason,
-    failureReason,
-    failure_reason,
-    closureEvidence = {},
-    closure_evidence = {},
-    closureEvidenceManifestSha256,
-    closure_evidence_manifest_sha256,
-    includeTransferChannelProjection = true,
-    includeOperatorProjectionMetadata = true,
-    metadata = {},
-  } = {}) {
-    return this.agentCommunications.runInterAgentMessagingLoop(arguments[0]);
-  }
-
-  async createCrossAgentRemediationTicket({
-    transferChannelId,
-    transfer_channel_id,
-    channelId,
-    channel_id,
-    workTransferPacketId,
-    work_transfer_packet_id,
-    packetId,
-    packet_id,
-    workflowRunId,
-    workflow_run_id,
-    ownershipMove,
-    ownership_move,
-    transferOwnership,
-    transfer_ownership,
-    assignedTo,
-    assigned_to,
-    requestedBy,
-    requested_by,
-    severity,
-    sourceRef,
-    source_ref,
-    findingId,
-    finding_id,
-    blockerId,
-    blocker_id,
-    failedCheckId,
-    failed_check_id,
-    workflowGap,
-    workflow_gap,
-    blockerKind,
-    blocker_kind,
-    blockerSummary,
-    blocker_summary,
-    blockerDetails,
-    blocker_details,
-    expectedResponse,
-    expected_response,
-    participantRole,
-    participant_role,
-    watcherRole,
-    watcher_role,
-    proposalId,
-    proposal_id,
-    collaborationProposalId,
-    collaboration_proposal_id,
-    expectedMessageKind,
-    expected_message_kind,
-    messageWatchId,
-    message_watch_id,
-    replyBodyMarkdown,
-    reply_body_markdown,
-    replyPayload = {},
-    reply_payload = {},
-    replyScope = {},
-    reply_scope = {},
-    replyEvidenceRefs = [],
-    reply_evidence_refs = [],
-    metadata = {},
-    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,
-    };
-  }
-
-  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 postAgentHeartbeat(request = {}) {
-    return this.transferChannels.postAgentHeartbeat(request);
-  }
-
   async postAgentMessage(request = {}) {
     return this._sendAgentCommsMessage(request);
   }
 
-  async acknowledgeAgentMessage({
-    transferChannelId,
-    transfer_channel_id,
-    channelId,
-    channel_id,
-    messageWatchId,
-    message_watch_id,
-    watchId,
-    watch_id,
-    messageId,
-    message_id,
-    messageKind,
-    message_kind,
-    observedMessageId,
-    observed_message_id,
-    observedMessageKind,
-    observed_message_kind,
-    operatorNudge,
-    operator_nudge,
-    metadata = {},
-  } = {}) {
-    const normalizedWatchId = cleanText(message_watch_id) || cleanText(messageWatchId) || cleanText(watch_id) || cleanText(watchId) || await this._resolveMessageWatchId({ transfer_channel_id, transferChannelId, channel_id, channelId });
-    if (!normalizedWatchId) throw new Error('message_watch_id is required.');
-    return this._request(`/api/agent-communications/message-watches/${encodeURIComponent(normalizedWatchId)}/acknowledge-message`, {
-      method: 'POST',
-      body: {
-        observed_message_id: cleanText(observed_message_id) || cleanText(observedMessageId) || cleanText(message_id) || cleanText(messageId),
-        observed_message_kind: cleanText(observed_message_kind) || cleanText(observedMessageKind) || cleanText(message_kind) || cleanText(messageKind),
-        operator_nudge: cleanText(operator_nudge) || cleanText(operatorNudge),
-        metadata: isPlainObject(metadata) ? metadata : {},
-      },
-    });
-  }
-
-  async closeAgentChannel(request = {}) {
-    return this.transferChannels.closeAgentChannel(request);
-  }
-
-  async respondToMessageWatch(request = {}) {
-    return this.messageWatch.respondToMessageWatch(request);
-  }
-
-  async reviseCollaborationProposal(request = {}) {
-    return this.collaborationDomain.reviseCollaborationProposal(request);
-  }
-
-  async raiseCollaborationBlocker(request = {}) {
-    return this.collaborationDomain.raiseCollaborationBlocker(request);
-  }
-
-  async beginCollaborationImplementation(request = {}) {
-    return this.collaborationDomain.beginCollaborationImplementation(request);
-  }
-
-  async requestCollaborationClosure(request = {}) {
-    return this.collaborationDomain.requestCollaborationClosure(request);
-  }
-
-  async bootstrapCommunication() {
-    return this._request('/api/agent-communications/bootstrap');
-  }
-
-  async negotiateCommunicationTransfer({
-    preferredModes,
-    preferred_modes,
-    preferred,
-    capabilities = {},
-    estimatedPayloadKb,
-    estimated_payload_kb,
-    requiresReceipts = true,
-    requires_receipts = true,
-    supportsHashValidation = true,
-    supports_hash_validation = true,
-    transferKind,
-    transfer_kind,
-    workflowRunId,
-    workflow_run_id,
-  } = {}) {
-    const normalizedPreferredModes = Array.isArray(preferred_modes)
-      ? preferred_modes
-      : (Array.isArray(preferredModes) ? preferredModes : (Array.isArray(preferred) ? preferred : ['bundle', 'artifact_refs', 'inline_payload']));
-    return this._request('/api/agent-communications/transfers/negotiate', {
-      method: 'POST',
-      body: {
-        preferred_modes: normalizedPreferredModes.map((mode) => normalizeTransferMode(mode)),
-        capabilities: isPlainObject(capabilities) ? capabilities : {},
-        estimated_payload_kb: Number(estimated_payload_kb ?? estimatedPayloadKb ?? 0) || undefined,
-        requires_receipts: Boolean(requires_receipts ?? requiresReceipts),
-        supports_hash_validation: Boolean(supports_hash_validation ?? supportsHashValidation),
-        transfer_kind: normalizeTransferKind(transfer_kind ?? transferKind ?? 'upstream_remediation'),
-        workflow_run_id: cleanText(workflow_run_id) || cleanText(workflowRunId),
-      },
-    });
-  }
-
-  async resolveCommunicationTarget({
-    intent,
-    transferKind,
-    transfer_kind,
-    recipientMode,
-    recipient_mode,
-    preferredRoleKey,
-    preferred_role_key,
-    preferredAgentSessionId,
-    preferred_agent_session_id,
-    workflowRunId,
-    workflow_run_id,
-  } = {}) {
-    return this._request('/api/agent-communications/targets/resolve', {
-      method: 'POST',
-      body: {
-        intent: cleanText(intent) || cleanText(transfer_kind) || cleanText(transferKind),
-        recipient_mode: normalizeRecipientMode(recipient_mode ?? recipientMode ?? 'role'),
-        preferred_role_key: cleanText(preferred_role_key) || cleanText(preferredRoleKey),
-        preferred_agent_session_id: cleanText(preferred_agent_session_id) || cleanText(preferredAgentSessionId),
-        workflow_run_id: cleanText(workflow_run_id) || cleanText(workflowRunId),
-      },
-    });
-  }
-
-  async createCommunicationEvidencePacket({
-    workflowRunId,
-    workflow_run_id,
-    transferKind,
-    transfer_kind,
-    objective,
-    requestedOutcome,
-    requested_outcome,
-    artifacts = [],
-    artifactRefs,
-    artifact_refs,
-    issues = [],
-    issueRefs,
-    issue_refs,
-    expectedEvidence = [],
-    expected_evidence,
-    metadata = {},
-  } = {}) {
-    return this._request('/api/agent-communications/evidence-packets', {
-      method: 'POST',
-      body: {
-        workflow_run_id: cleanText(workflow_run_id) || cleanText(workflowRunId),
-        transfer_kind: normalizeTransferKind(transfer_kind ?? transferKind ?? 'upstream_remediation'),
-        objective: cleanText(objective),
-        requested_outcome: cleanText(requested_outcome) || cleanText(requestedOutcome),
-        artifacts: Array.isArray(artifacts) ? artifacts : (Array.isArray(artifact_refs) ? artifact_refs : (Array.isArray(artifactRefs) ? artifactRefs : [])),
-        issues: Array.isArray(issues) ? issues : (Array.isArray(issue_refs) ? issue_refs : (Array.isArray(issueRefs) ? issueRefs : [])),
-        expected_evidence: Array.isArray(expected_evidence) ? expected_evidence : (Array.isArray(expectedEvidence) ? expectedEvidence : []),
-        metadata: isPlainObject(metadata) ? metadata : {},
-      },
-    });
-  }
-
-  async listCommunicationFrictionTaxonomy({
-    categoryGroup,
-    category_group,
-    isActive,
-    is_active,
-  } = {}) {
-    return this._request('/api/agent-communications/friction-taxonomy', {
-      query: {
-        category_group: cleanText(category_group) || cleanText(categoryGroup),
-        is_active: is_active !== undefined ? String(Boolean(is_active)) : (isActive !== undefined ? String(Boolean(isActive)) : undefined),
-      },
-    });
-  }
-
-  async recordCommunicationFrictionEvent({
-    workflowRunId,
-    workflow_run_id,
-    workTransferPacketId,
-    work_transfer_packet_id,
-    communicationThreadId,
-    communication_thread_id,
-    communicationMessageId,
-    communication_message_id,
-    taxonomyKey,
-    taxonomy_key,
-    frictionType,
-    friction_type,
-    severity,
-    observedBehavior,
-    observed_behavior,
-    attemptedAction,
-    attempted_action,
-    resolutionPath,
-    resolution_path,
-    missingSurfaceKey,
-    missing_surface_key,
-    promotionCandidate,
-    promotion_candidate,
-    repeatedCount,
-    repeated_count,
-    metadata = {},
-  } = {}) {
-    return this._request('/api/agent-communications/friction-events', {
-      method: 'POST',
-      body: {
-        workflow_run_id: cleanText(workflow_run_id) || cleanText(workflowRunId),
-        work_transfer_packet_id: cleanText(work_transfer_packet_id) || cleanText(workTransferPacketId),
-        communication_thread_id: cleanText(communication_thread_id) || cleanText(communicationThreadId),
-        communication_message_id: cleanText(communication_message_id) || cleanText(communicationMessageId),
-        taxonomy_key: cleanText(taxonomy_key) || cleanText(taxonomyKey) || 'enum_drift',
-        friction_type: cleanText(friction_type) || cleanText(frictionType) || 'discovery',
-        severity: cleanText(severity) || 'warning',
-        observed_behavior: cleanText(observed_behavior) || cleanText(observedBehavior),
-        attempted_action: cleanText(attempted_action) || cleanText(attemptedAction),
-        resolution_path: cleanText(resolution_path) || cleanText(resolutionPath),
-        missing_surface_key: cleanText(missing_surface_key) || cleanText(missingSurfaceKey),
-        promotion_candidate: Boolean(promotion_candidate ?? promotionCandidate),
-        repeated_count: Number(repeated_count ?? repeatedCount ?? 1) || 1,
-        metadata: isPlainObject(metadata) ? metadata : {},
-      },
-    });
-  }
-
-  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,
-    threadType,
-    thread_type,
-    subject,
-    objective,
-    parentThreadId,
-    parent_thread_id,
-    createdByAgentSessionId,
-    created_by_agent_session_id,
-    createdByActorSessionId,
-    created_by_actor_session_id,
-    metadata,
-  } = {}) {
-    return this._request('/api/agent-communications/threads', {
-      method: 'POST',
-      body: {
-        workflow_run_id: cleanText(workflow_run_id) || cleanText(workflowRunId),
-        parent_thread_id: cleanText(parent_thread_id) || cleanText(parentThreadId),
-        thread_type: normalizeThreadType(cleanText(thread_type) || cleanText(threadType)),
-        subject: cleanText(subject),
-        objective: cleanText(objective),
-        created_by_agent_session_id: cleanText(created_by_agent_session_id) || cleanText(createdByAgentSessionId),
-        created_by_actor_session_id: cleanText(created_by_actor_session_id) || cleanText(createdByActorSessionId),
-        metadata: isPlainObject(metadata) ? metadata : {},
-      },
-    });
-  }
-
-  async getCommunicationThread(threadId) {
-    return this._request(`/api/agent-communications/threads/${encodeURIComponent(threadId)}`);
-  }
-
-  async listCommunicationInbox({
-    recipientAgentSessionId,
-    recipient_agent_session_id,
-    recipientRoleKey,
-    recipient_role_key,
-    workflowRunId,
-    workflow_run_id,
-  } = {}) {
-    return this._request('/api/agent-communications/inbox', {
-      query: {
-        recipient_agent_session_id: cleanText(recipient_agent_session_id) || cleanText(recipientAgentSessionId),
-        recipient_role_key: cleanText(recipient_role_key) || cleanText(recipientRoleKey),
-        workflow_run_id: cleanText(workflow_run_id) || cleanText(workflowRunId),
-      },
-    });
-  }
-
-  async getMyInbox({
-    recipientAgentSessionId,
-    recipient_agent_session_id,
-    recipientRoleKey,
-    recipient_role_key,
-    workflowRunId,
-    workflow_run_id,
-  } = {}) {
-    return this._request('/api/agent-communications/inbox/me', {
-      query: {
-        recipient_agent_session_id: cleanText(recipient_agent_session_id) || cleanText(recipientAgentSessionId),
-        recipient_role_key: cleanText(recipient_role_key) || cleanText(recipientRoleKey),
-        workflow_run_id: cleanText(workflow_run_id) || cleanText(workflowRunId),
-      },
-    });
-  }
-
-  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.');
-    return this._request(`/api/agent-communications/messages/${encodeURIComponent(normalizedMessageId)}/verify-sent`, {
-      method: 'POST',
-      body: { message_id: normalizedMessageId },
-    });
-  }
-
-  async verifyMessageReceived({
-    messageId,
-    message_id,
-    recipientAgentSessionId,
-    recipient_agent_session_id,
-    recipientRole,
-    recipient_role,
-    role,
-    participantId,
-    participant_id,
-  } = {}) {
-    const normalizedMessageId = cleanText(message_id) || cleanText(messageId);
-    if (!normalizedMessageId) throw new Error('message_id is required.');
-    return this._request(`/api/agent-communications/messages/${encodeURIComponent(normalizedMessageId)}/verify-received`, {
-      method: 'POST',
-      body: {
-        message_id: normalizedMessageId,
-        recipient_agent_session_id: cleanText(recipient_agent_session_id) || cleanText(recipientAgentSessionId),
-        recipient_role: cleanText(recipient_role) || cleanText(recipientRole) || cleanText(role),
-        participant_id: cleanText(participant_id) || cleanText(participantId),
-      },
-    });
-  }
-
-  async getMessageDeliveryReceipt({ messageId, message_id } = {}) {
-    const normalizedMessageId = cleanText(message_id) || cleanText(messageId);
-    if (!normalizedMessageId) throw new Error('message_id is required.');
-    return this._request(`/api/agent-communications/messages/${encodeURIComponent(normalizedMessageId)}/delivery-receipt`, {
-      method: 'GET',
-    });
-  }
-
-  async _sendAgentCommsMessage(request = {}) {
-    const hasThreadContext = Boolean(
-      cleanText(request.communication_thread_id)
-      || cleanText(request.communicationThreadId)
-      || cleanText(request.thread_id)
-      || cleanText(request.threadId)
-      || cleanText(request.recipient_role_key)
-      || cleanText(request.recipientRoleKey)
-    );
-    const hasTransferChannelContext = Boolean(
-      cleanText(request.transfer_channel_id)
-      || cleanText(request.transferChannelId)
-      || cleanText(request.channel_id)
-      || cleanText(request.channelId)
-      || cleanText(request.sender_role)
-      || cleanText(request.senderRole)
-      || cleanText(request.recipient_role)
-      || cleanText(request.recipientRole)
-      || cleanText(request.role)
-      || cleanText(request.participant_role)
-      || cleanText(request.participantRole)
-      || cleanText(request.participant_id)
-      || cleanText(request.participantId)
-      || cleanText(request.recipient_participant_id)
-      || cleanText(request.recipientParticipantId)
-    );
-    if (hasTransferChannelContext && !hasThreadContext) {
-      if (
-        cleanText(request.participant_id)
-        || cleanText(request.participantId)
-        || cleanText(request.recipient_participant_id)
-        || cleanText(request.recipientParticipantId)
-        || cleanText(request.recipient_agent_session_id)
-        || cleanText(request.recipientAgentSessionId)
-      ) {
-        return this.sendToParticipant(request);
-      }
-      return this.sendToRole(request);
-    }
-    return this.sendCommunicationMessage(request);
-  }
-
-  async sendCommunicationMessage({
-    communicationThreadId,
-    communication_thread_id,
-    threadId,
-    communicationBundleId,
-    communication_bundle_id,
-    senderAgentSessionId,
-    sender_agent_session_id,
-    recipientAgentSessionId,
-    recipient_agent_session_id,
-    recipientRoleKey,
-    recipient_role_key,
-    messageKind,
-    message_kind,
-    bodyMarkdown,
-    body_markdown,
-    messageStatus,
-    message_status,
-    payload = {},
-    scope = {},
-    requiredResponseSchema = {},
-    required_response_schema = {},
-    metadata = {},
-  } = {}) {
-    return this._request('/api/agent-communications/messages', {
-      method: 'POST',
-      body: {
-        communication_thread_id: cleanText(communication_thread_id) || cleanText(communicationThreadId) || cleanText(threadId),
-        communication_bundle_id: cleanText(communication_bundle_id) || cleanText(communicationBundleId),
-        sender_agent_session_id: cleanText(sender_agent_session_id) || cleanText(senderAgentSessionId) || this.agentSessionId,
-        recipient_agent_session_id: cleanText(recipient_agent_session_id) || cleanText(recipientAgentSessionId),
-        recipient_role_key: cleanText(recipient_role_key) || cleanText(recipientRoleKey),
-        message_kind: normalizeMessageKind(cleanText(message_kind) || cleanText(messageKind)),
-        message_status: cleanText(message_status) || cleanText(messageStatus) || 'sent',
-        body_markdown: cleanText(body_markdown) || cleanText(bodyMarkdown),
-        payload: isPlainObject(payload) ? payload : {},
-        scope: isPlainObject(scope) ? scope : {},
-        required_response_schema: isPlainObject(requiredResponseSchema)
-          ? requiredResponseSchema
-          : (isPlainObject(required_response_schema) ? required_response_schema : {}),
-        metadata: isPlainObject(metadata) ? metadata : {},
-      },
-    });
-  }
-
-  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,
-    acceptedByAgentSessionId,
-    accepted_by_agent_session_id,
-    acceptedByActorSessionId,
-    accepted_by_actor_session_id,
-    acceptedByClaimId,
-    accepted_by_claim_id,
-    advanceToInProgress,
-    advance_to_in_progress,
-    metadata = {},
-  } = {}) {
-    const normalizedPacketId = cleanText(work_transfer_packet_id) || cleanText(workTransferPacketId);
-    if (!normalizedPacketId) throw new Error('work_transfer_packet_id is required.');
-    return this._request(`/api/agent-communications/transfers/${encodeURIComponent(normalizedPacketId)}/accept`, {
-      method: 'POST',
-      body: {
-        accepted_by_agent_session_id: cleanText(accepted_by_agent_session_id) || cleanText(acceptedByAgentSessionId),
-        accepted_by_actor_session_id: cleanText(accepted_by_actor_session_id) || cleanText(acceptedByActorSessionId),
-        accepted_by_claim_id: cleanText(accepted_by_claim_id) || cleanText(acceptedByClaimId),
-        advance_to_in_progress: Boolean(advance_to_in_progress ?? advanceToInProgress),
-        metadata: isPlainObject(metadata) ? metadata : {},
-      },
-    });
-  }
-
-  async closeCommunicationTransferPacket({
-    workTransferPacketId,
-    work_transfer_packet_id,
-    closureStatus,
-    closure_status,
-    closureReason,
-    closure_reason,
-    failureReason,
-    failure_reason,
-    closedByAgentSessionId,
-    closed_by_agent_session_id,
-    closedByActorSessionId,
-    closed_by_actor_session_id,
-    closedByClaimId,
-    closed_by_claim_id,
-    evidence = {},
-    evidenceManifestSha256,
-    evidence_manifest_sha256,
-    metadata = {},
-  } = {}) {
-    const normalizedPacketId = cleanText(work_transfer_packet_id) || cleanText(workTransferPacketId);
-    if (!normalizedPacketId) throw new Error('work_transfer_packet_id is required.');
-    return this._request(`/api/agent-communications/transfers/${encodeURIComponent(normalizedPacketId)}/close`, {
-      method: 'POST',
-      body: {
-        closure_status: normalizeTransferLifecycleStatus(cleanText(closure_status) || cleanText(closureStatus) || 'closed'),
-        closure_reason: cleanText(closure_reason) || cleanText(closureReason),
-        failure_reason: cleanText(failure_reason) || cleanText(failureReason),
-        closed_by_agent_session_id: cleanText(closed_by_agent_session_id) || cleanText(closedByAgentSessionId),
-        closed_by_actor_session_id: cleanText(closed_by_actor_session_id) || cleanText(closedByActorSessionId),
-        closed_by_claim_id: cleanText(closed_by_claim_id) || cleanText(closedByClaimId),
-        evidence: isPlainObject(evidence) ? evidence : {},
-        evidence_manifest_sha256: cleanText(evidence_manifest_sha256) || cleanText(evidenceManifestSha256),
-        metadata: isPlainObject(metadata) ? metadata : {},
-      },
-    });
-  }
-
-  async getCommunicationTransferHealth({
-    workflowRunId,
-    workflow_run_id,
-    workTransferPacketId,
-    work_transfer_packet_id,
-  } = {}) {
-    return this._request('/api/agent-communications/transfers/health', {
-      query: {
-        workflow_run_id: cleanText(workflow_run_id) || cleanText(workflowRunId),
-        work_transfer_packet_id: cleanText(work_transfer_packet_id) || cleanText(workTransferPacketId),
-      },
-    });
-  }
-
-  async acceptCommunicationMessage(messageId) {
-    return this._request(`/api/agent-communications/messages/${encodeURIComponent(messageId)}/accept`, {
-      method: 'POST',
-      body: {},
-    });
-  }
-
-  async respondToCommunicationMessage({
-    agentMessageId,
-    agent_message_id,
-    messageId,
-    status,
-    bodyMarkdown,
-    body_markdown,
-    payload = {},
-    metadata = {},
-    evidenceRefs,
-    evidence_refs,
-  } = {}) {
-    const normalizedMessageId = cleanText(agent_message_id) || cleanText(agentMessageId) || cleanText(messageId);
-    if (!normalizedMessageId) {
-      throw new Error('agent_message_id is required.');
-    }
-    return this._request(`/api/agent-communications/messages/${encodeURIComponent(normalizedMessageId)}/respond-with-evidence`, {
-      method: 'POST',
-      body: {
-        status: cleanText(status) || 'answered',
-        body_markdown: cleanText(body_markdown) || cleanText(bodyMarkdown),
-        payload: isPlainObject(payload) ? payload : {},
-        metadata: isPlainObject(metadata) ? metadata : {},
-        evidence_refs: Array.isArray(evidence_refs) ? evidence_refs : (Array.isArray(evidenceRefs) ? evidenceRefs : []),
-      },
-    });
-  }
-
-  async attachCommunicationMessageEvidence({
-    agentMessageId,
-    agent_message_id,
-    messageId,
-    evidenceType,
-    evidence_type,
-    evidenceRef,
-    evidence_ref,
-    sourceTruth,
-    source_truth,
-    trustLevel,
-    trust_level,
-    metadata = {},
-  } = {}) {
-    const normalizedMessageId = cleanText(agent_message_id) || cleanText(agentMessageId) || cleanText(messageId);
-    if (!normalizedMessageId) {
-      throw new Error('agent_message_id is required.');
-    }
-    return this._request(`/api/agent-communications/messages/${encodeURIComponent(normalizedMessageId)}/evidence-links`, {
-      method: 'POST',
-      body: {
-        evidence_type: cleanText(evidence_type) || cleanText(evidenceType),
-        evidence_ref: cleanText(evidence_ref) || cleanText(evidenceRef),
-        source_truth: cleanText(source_truth) || cleanText(sourceTruth),
-        trust_level: cleanText(trust_level) || cleanText(trustLevel) || 'candidate',
-        metadata: isPlainObject(metadata) ? metadata : {},
-      },
-    });
-  }
-
-  async createCommunicationHandoff({
-    workflowRunId,
-    workflow_run_id,
-    title,
-    agentSessionId,
-    agent_session_id,
-    handoffKind,
-    handoff_kind,
-    handoffPriority,
-    handoff_priority,
-    summaryText,
-    summary_text,
-    handoffPayload = {},
-    handoff_payload = {},
-    createdBy,
-    created_by,
-    supersedesHandoffId,
-    supersedes_handoff_id,
-  } = {}) {
-    return this._request('/api/agent-communications/handoffs', {
-      method: 'POST',
-      body: {
-        workflow_run_id: cleanText(workflow_run_id) || cleanText(workflowRunId),
-        title: cleanText(title),
-        agent_session_id: cleanText(agent_session_id) || cleanText(agentSessionId) || this.agentSessionId,
-        handoff_kind: cleanText(handoff_kind) || cleanText(handoffKind) || 'general',
-        handoff_priority: cleanText(handoff_priority) || cleanText(handoffPriority) || 'normal',
-        summary_text: cleanText(summary_text) || cleanText(summaryText),
-        handoff_payload: isPlainObject(handoffPayload)
-          ? handoffPayload
-          : (isPlainObject(handoff_payload) ? handoff_payload : {}),
-        created_by: cleanText(created_by) || cleanText(createdBy),
-        supersedes_handoff_id: cleanText(supersedes_handoff_id) || cleanText(supersedesHandoffId),
-      },
-    });
-  }
-
-  async acceptCommunicationHandoff(handoffId) {
-    return this._request(`/api/agent-communications/handoffs/${encodeURIComponent(handoffId)}/accept`, {
-      method: 'POST',
-      body: {},
-    });
-  }
-
-  async getPortfolioClosureReadiness(...args) {
-    return this.portfolio.getPortfolioClosureReadiness(...args);
-  }
-
-  async getPortfolioStatus(...args) {
-    return this.portfolio.getPortfolioStatus(...args);
-  }
-
-  async describeDatabaseCatalog({ includeSystemSchemas, limit } = {}) {
-    return this.database.schema.getOverview({ includeSystemSchemas, limit });
-  }
-
-  async listDatabaseSchemas({ includeSystemSchemas, limit } = {}) {
-    return this.database.schema.listSchemas({ includeSystemSchemas, limit });
-  }
-
-  async listDatabaseTables({ schemaName, includeSystemSchemas, limit } = {}) {
-    return this.database.schema.listTables({ schemaName, includeSystemSchemas, limit });
-  }
-
-  async listDatabaseColumns({ schemaName, tableName } = {}) {
-    return this.database.schema.listColumns({ schemaName, tableName });
-  }
-
-  async listDatabaseIndexes({ schemaName, tableName, includeSystemSchemas, limit } = {}) {
-    return this.database.schema.listIndexes({ schemaName, tableName, includeSystemSchemas, limit });
-  }
-
-  async describeDatabaseTable({ schemaName, tableName, includeSystemSchemas } = {}) {
-    return this.database.schema.describeTable({ schemaName, tableName, includeSystemSchemas });
-  }
-
-  async createDatabaseBackup({ databaseName, outputName, noWait } = {}) {
-    return this._request('/api/operator/database/backups', {
-      method: 'POST',
-      body: {
-        database_name: databaseName,
-        output_name: outputName,
-        no_wait: noWait,
-      },
-    });
-  }
-
-  async getPortfolioBundle() {
-    return this.portfolio.getPortfolioBundle();
-  }
-
-  async getExternalProjectStatus(projectId) {
-    return this._request(`/api/v1/projects/${projectId}/status`);
-  }
-
-  async getExternalProjectRoadmapSummary(projectId) {
-    return this._request(`/api/v1/projects/${projectId}/implementation-roadmap/summary`);
-  }
-
-  async getExternalProjectRoadmapActiveItem(projectId) {
-    return this._request(`/api/v1/projects/${projectId}/implementation-roadmap/active-item`);
-  }
-
-  async listExternalProjectOpenTasks(projectId) {
-    return this._request(`/api/v1/projects/${projectId}/open-tasks`);
-  }
-
-  async getExternalProjectStatusBundle(projectId) {
-    return this._request(`/api/v1/projects/${projectId}/status-bundle`);
-  }
-
-  async createExternalAudioRender({ text, voice, model, speed, file } = {}) {
-    if (file) {
-      const form = new FormData();
-      form.append('file', file);
-      if (voice !== undefined) form.append('voice', String(voice));
-      if (model !== undefined) form.append('model', String(model));
-      if (speed !== undefined) form.append('speed', String(speed));
-      return this._request('/api/v1/audio-renders', { method: 'POST', body: form });
-    }
-    return this._request('/api/v1/audio-renders', {
-      method: 'POST',
-      body: { text, voice, model, speed },
-    });
-  }
-
-  async getExternalAudioRender(audioRenderRunId) {
-    return this._request(`/api/v1/audio-renders/${audioRenderRunId}`);
-  }
-
-  async downloadExternalAudioRender(audioRenderRunId) {
-    return this._requestBinary(`/api/v1/audio-renders/${audioRenderRunId}/download`);
-  }
-
-  async listExternalWorkflowRunArtifacts(workflowRunId) {
-    return this._request(`/api/v1/runs/${workflowRunId}/artifacts`);
-  }
-
-  async downloadExternalWorkflowRunArtifact(workflowRunId, artifactType) {
-    return this._requestBinary(`/api/v1/runs/${workflowRunId}/artifacts/${artifactType}/download`);
-  }
-
   // ─── Core HTTP ─────────────────────────────────────────────────────────────
 
   async _resolveAccessToken() {
@@ -2114,94 +218,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);