@bpmsoftwaresolutions/ai-engine-client 1.1.85 → 1.1.87

package/src/domains/presence.js

@@ -0,0 +1,457 @@
+import { cleanText, isPlainObject } from '../utils/communication.js';
+
+export function createPresenceDomain(client) {
+  return {
+    getPresenceBoard: (request) => getPresenceBoard(client, request),
+    getChannelPresence: (request) => getChannelPresence(client, request),
+    markParticipantOnline: (request) => markParticipantOnline(client, request),
+    markParticipantOffline: (request) => markParticipantOffline(client, request),
+    whoIsOnline: (request) => whoIsOnline(client, request),
+    findOnlineParticipant: (request) => findOnlineParticipant(client, request),
+    sendToParticipant: (request) => sendToParticipant(client, request),
+    sendToRole: (request) => sendToRole(client, request),
+    postPresenceHeartbeat: (request) => postPresenceHeartbeat(client, request),
+  };
+}
+
+export async function getPresenceBoard(client, {
+  workflowRunId,
+  workflow_run_id,
+  transferChannelId,
+  transfer_channel_id,
+  participantRole,
+  participant_role,
+  role,
+  capability,
+  includeStale,
+  include_stale,
+} = {}) {
+  const normalizedTransferChannelId = cleanText(transfer_channel_id) || cleanText(transferChannelId);
+  const path = normalizedTransferChannelId
+    ? `/api/operator/projections/agent-communications/presence/${encodeURIComponent(normalizedTransferChannelId)}`
+    : '/api/operator/projections/agent-communications/presence';
+  return client._requestLogaProjection(path, {
+    query: {
+      workflow_run_id: cleanText(workflow_run_id) || cleanText(workflowRunId),
+      transfer_channel_id: normalizedTransferChannelId,
+      participant_role: cleanText(participant_role) || cleanText(participantRole) || cleanText(role),
+      capability: cleanText(capability),
+      include_stale: include_stale ?? includeStale,
+    },
+  });
+}
+
+export async function getChannelPresence(client, {
+  transferChannelId,
+  transfer_channel_id,
+  channelId,
+  channel_id,
+  workflowRunId,
+  workflow_run_id,
+  participantRole,
+  participant_role,
+  role,
+  capability,
+  includeStale,
+  include_stale,
+} = {}) {
+  const normalizedTransferChannelId = cleanText(transfer_channel_id) || cleanText(transferChannelId) || cleanText(channel_id) || cleanText(channelId);
+  if (!normalizedTransferChannelId) {
+    throw new Error('transferChannelId is required.');
+  }
+  return client._requestLogaProjection(`/api/operator/projections/agent-communications/presence/${encodeURIComponent(normalizedTransferChannelId)}`, {
+    query: {
+      workflow_run_id: cleanText(workflow_run_id) || cleanText(workflowRunId),
+      participant_role: cleanText(participant_role) || cleanText(participantRole) || cleanText(role),
+      capability: cleanText(capability),
+      include_stale: include_stale ?? includeStale,
+    },
+  });
+}
+
+export async function postPresenceHeartbeat(client, {
+  transferChannelId,
+  transfer_channel_id,
+  channelId,
+  channel_id,
+  workTransferPacketId,
+  work_transfer_packet_id,
+  workflowRunId,
+  workflow_run_id,
+  participantRole,
+  participant_role,
+  activityState,
+  activity_state,
+  currentPhase,
+  current_phase,
+  currentTaskSummary,
+  current_task_summary,
+  isActive,
+  is_active,
+  agentSessionId,
+  agent_session_id,
+  actorSessionId,
+  actor_session_id,
+  observedAt,
+  observed_at,
+  metadata = {},
+} = {}) {
+  const normalizedTransferChannelId = cleanText(transfer_channel_id) || cleanText(transferChannelId) || cleanText(channel_id) || cleanText(channelId);
+  if (!normalizedTransferChannelId) throw new Error('transferChannelId is required.');
+  return client._request(`/api/agent-communications/transfer-channels/${encodeURIComponent(normalizedTransferChannelId)}/heartbeats`, {
+    method: 'POST',
+    body: {
+      work_transfer_packet_id: cleanText(work_transfer_packet_id) || cleanText(workTransferPacketId),
+      workflow_run_id: cleanText(workflow_run_id) || cleanText(workflowRunId),
+      participant_role: cleanText(participant_role) || cleanText(participantRole),
+      activity_state: cleanText(activity_state) || cleanText(activityState) || 'active',
+      current_phase: cleanText(current_phase) || cleanText(currentPhase),
+      current_task_summary: cleanText(current_task_summary) || cleanText(currentTaskSummary),
+      is_active: Boolean(is_active ?? isActive ?? true),
+      agent_session_id: cleanText(agent_session_id) || cleanText(agentSessionId) || client.agentSessionId,
+      actor_session_id: cleanText(actor_session_id) || cleanText(actorSessionId),
+      observed_at: observed_at || observedAt,
+      metadata: isPlainObject(metadata) ? metadata : {},
+    },
+  });
+}
+
+async function resolvePresenceContext(client, request = {}) {
+  const {
+    transferChannelId,
+    transfer_channel_id,
+    channelId,
+    channel_id,
+    workTransferPacketId,
+    work_transfer_packet_id,
+    packetId,
+    packet_id,
+    workflowRunId,
+    workflow_run_id,
+    participantRole,
+    participant_role,
+    role,
+  } = request;
+  const normalizedTransferChannelId = cleanText(transfer_channel_id) || cleanText(transferChannelId) || cleanText(channel_id) || cleanText(channelId);
+  const normalizedParticipantRole = cleanText(participant_role) || cleanText(participantRole) || cleanText(role);
+  const normalizedWorkflowRunId = cleanText(workflow_run_id) || cleanText(workflowRunId);
+  if (normalizedTransferChannelId) {
+    let normalizedPacketId = cleanText(work_transfer_packet_id) || cleanText(workTransferPacketId) || cleanText(packet_id) || cleanText(packetId);
+    if (!normalizedPacketId) {
+      try {
+        const status = await client.getCommunicationChannelStatus({ transferChannelId: normalizedTransferChannelId });
+        normalizedPacketId = cleanText(status?.packet_id || status?.packetId || status?.work_transfer_packet_id);
+      } catch (error) {
+        void error;
+      }
+    }
+    return { channel_id: normalizedTransferChannelId, packet_id: normalizedPacketId, workflow_run_id: normalizedWorkflowRunId, stop_reason: null };
+  }
+  const presence = await client.whoIsOnline({ workflowRunId: normalizedWorkflowRunId, participantRole: normalizedParticipantRole, includeStale: true });
+  const directoryRows = Array.isArray(presence?.presence)
+    ? presence.presence.filter((row) => row && typeof row === 'object')
+    : Array.isArray(presence?.online_participants)
+      ? presence.online_participants.filter((row) => row && typeof row === 'object')
+      : Array.isArray(presence?.participants)
+        ? presence.participants.filter((row) => row && typeof row === 'object')
+        : [];
+  const filteredRows = normalizedParticipantRole
+    ? directoryRows.filter((row) => cleanText(row.participant_role) === normalizedParticipantRole)
+    : [];
+  const onlineRows = filteredRows.filter((row) => Boolean(row.is_online));
+  const chooseRows = onlineRows.length > 0 ? onlineRows : filteredRows;
+  if (chooseRows.length === 1) {
+    return {
+      channel_id: cleanText(chooseRows[0].transfer_channel_id),
+      packet_id: cleanText(chooseRows[0].work_transfer_packet_id) || cleanText(chooseRows[0].packet_id),
+      workflow_run_id: cleanText(chooseRows[0].workflow_run_id) || normalizedWorkflowRunId,
+      stop_reason: null,
+    };
+  }
+  const openChannels = await client.listOpenCommunicationChannels({ workflowRunId: normalizedWorkflowRunId });
+  const openChannelRows = Array.isArray(openChannels) ? openChannels.filter((row) => row && typeof row === 'object') : [];
+  if (openChannelRows.length === 1) {
+    return {
+      channel_id: cleanText(openChannelRows[0].channel_id || openChannelRows[0].transfer_channel_id),
+      packet_id: cleanText(openChannelRows[0].packet_id || openChannelRows[0].work_transfer_packet_id),
+      workflow_run_id: cleanText(openChannelRows[0].workflow_run_id) || normalizedWorkflowRunId,
+      stop_reason: null,
+    };
+  }
+  if (openChannelRows.length > 1) {
+    return {
+      channel_id: null,
+      packet_id: null,
+      workflow_run_id: normalizedWorkflowRunId,
+      stop_reason: {
+        code: 'multiple_open_channels_need_disambiguation',
+        message: 'Multiple open channels matched the requested coordination context.',
+        details: {
+          workflow_run_id: normalizedWorkflowRunId,
+          participant_role: normalizedParticipantRole,
+          candidate_count: openChannelRows.length,
+          candidate_channel_ids: openChannelRows.map((row) => cleanText(row.channel_id || row.transfer_channel_id)).filter(Boolean),
+        },
+      },
+    };
+  }
+  return {
+    channel_id: null,
+    packet_id: null,
+    workflow_run_id: normalizedWorkflowRunId,
+    stop_reason: {
+      code: 'active_channel_not_found',
+      message: 'Active transfer channel not found.',
+      details: { workflow_run_id: normalizedWorkflowRunId, participant_role: normalizedParticipantRole },
+    },
+  };
+}
+
+export async function markParticipantOnline(client, request = {}) {
+  const {
+    transferChannelId,
+    transfer_channel_id,
+    channelId,
+    channel_id,
+    workTransferPacketId,
+    work_transfer_packet_id,
+    packetId,
+    packet_id,
+    workflowRunId,
+    workflow_run_id,
+    participantRole,
+    participant_role,
+    currentPhase,
+    current_phase,
+    currentTaskSummary,
+    current_task_summary,
+    agentSessionId,
+    agent_session_id,
+    actorSessionId,
+    actor_session_id,
+    observedAt,
+    observed_at,
+    metadata = {},
+  } = request;
+  const normalizedTransferChannelId = cleanText(transfer_channel_id) || cleanText(transferChannelId) || cleanText(channel_id) || cleanText(channelId);
+  if (!normalizedTransferChannelId) throw new Error('transferChannelId is required.');
+  const resolved = await resolvePresenceContext(client, request);
+  return client._request(`/api/agent-communications/transfer-channels/${encodeURIComponent(normalizedTransferChannelId)}/presence/online`, {
+    method: 'POST',
+    body: {
+      transfer_channel_id: normalizedTransferChannelId,
+      work_transfer_packet_id: cleanText(work_transfer_packet_id) || cleanText(workTransferPacketId) || cleanText(packet_id) || cleanText(packetId) || resolved.packet_id,
+      workflow_run_id: cleanText(workflow_run_id) || cleanText(workflowRunId),
+      participant_role: cleanText(participant_role) || cleanText(participantRole),
+      current_phase: cleanText(current_phase) || cleanText(currentPhase),
+      current_task_summary: cleanText(current_task_summary) || cleanText(currentTaskSummary),
+      agent_session_id: cleanText(agent_session_id) || cleanText(agentSessionId) || client.agentSessionId,
+      actor_session_id: cleanText(actor_session_id) || cleanText(actorSessionId),
+      observed_at: cleanText(observed_at) || cleanText(observedAt),
+      metadata: isPlainObject(metadata) ? metadata : {},
+      is_active: true,
+      activity_state: 'active',
+    },
+  });
+}
+
+export async function markParticipantOffline(client, request = {}) {
+  const {
+    transferChannelId,
+    transfer_channel_id,
+    channelId,
+    channel_id,
+    workTransferPacketId,
+    work_transfer_packet_id,
+    packetId,
+    packet_id,
+    workflowRunId,
+    workflow_run_id,
+    participantRole,
+    participant_role,
+    currentPhase,
+    current_phase,
+    currentTaskSummary,
+    current_task_summary,
+    agentSessionId,
+    agent_session_id,
+    actorSessionId,
+    actor_session_id,
+    observedAt,
+    observed_at,
+    metadata = {},
+  } = request;
+  const normalizedTransferChannelId = cleanText(transfer_channel_id) || cleanText(transferChannelId) || cleanText(channel_id) || cleanText(channelId);
+  if (!normalizedTransferChannelId) throw new Error('transferChannelId is required.');
+  const resolved = await resolvePresenceContext(client, request);
+  return client._request(`/api/agent-communications/transfer-channels/${encodeURIComponent(normalizedTransferChannelId)}/presence/offline`, {
+    method: 'POST',
+    body: {
+      transfer_channel_id: normalizedTransferChannelId,
+      work_transfer_packet_id: cleanText(work_transfer_packet_id) || cleanText(workTransferPacketId) || cleanText(packet_id) || cleanText(packetId) || resolved.packet_id,
+      workflow_run_id: cleanText(workflow_run_id) || cleanText(workflowRunId),
+      participant_role: cleanText(participant_role) || cleanText(participantRole),
+      current_phase: cleanText(current_phase) || cleanText(currentPhase),
+      current_task_summary: cleanText(current_task_summary) || cleanText(currentTaskSummary),
+      agent_session_id: cleanText(agent_session_id) || cleanText(agentSessionId) || client.agentSessionId,
+      actor_session_id: cleanText(actor_session_id) || cleanText(actorSessionId),
+      observed_at: cleanText(observed_at) || cleanText(observedAt),
+      metadata: isPlainObject(metadata) ? metadata : {},
+      is_active: false,
+      activity_state: 'offline',
+    },
+  });
+}
+
+export async function whoIsOnline(client, {
+  workflowRunId,
+  workflow_run_id,
+  transferChannelId,
+  transfer_channel_id,
+  participantRole,
+  participant_role,
+  role,
+  capability,
+  includeStale,
+  include_stale,
+} = {}) {
+  const normalizedTransferChannelId = cleanText(transfer_channel_id) || cleanText(transferChannelId);
+  const path = normalizedTransferChannelId
+    ? `/api/agent-communications/transfer-channels/${encodeURIComponent(normalizedTransferChannelId)}/presence`
+    : '/api/agent-communications/presence';
+  return client._request(path, {
+    query: {
+      workflow_run_id: cleanText(workflow_run_id) || cleanText(workflowRunId),
+      participant_role: cleanText(participant_role) || cleanText(participantRole) || cleanText(role),
+      capability: cleanText(capability),
+      include_stale: include_stale ?? includeStale,
+    },
+  });
+}
+
+export async function findOnlineParticipant(client, request = {}) {
+  const {
+    workflowRunId,
+    workflow_run_id,
+    transferChannelId,
+    transfer_channel_id,
+    participantRole,
+    participant_role,
+    role,
+    capability,
+  } = request;
+  const normalizedTransferChannelId = cleanText(transfer_channel_id) || cleanText(transferChannelId);
+  const body = {
+    workflow_run_id: cleanText(workflow_run_id) || cleanText(workflowRunId),
+    transfer_channel_id: normalizedTransferChannelId,
+    participant_role: cleanText(participant_role) || cleanText(participantRole) || cleanText(role),
+    capability: cleanText(capability),
+  };
+  const path = normalizedTransferChannelId
+    ? `/api/agent-communications/transfer-channels/${encodeURIComponent(normalizedTransferChannelId)}/presence/find`
+    : '/api/agent-communications/presence/find';
+  return client._request(path, {
+    method: 'POST',
+    body,
+  });
+}
+
+export async function sendToParticipant(client, {
+  transferChannelId,
+  transfer_channel_id,
+  channelId,
+  channel_id,
+  recipientParticipantId,
+  recipient_participant_id,
+  recipientAgentSessionId,
+  recipient_agent_session_id,
+  recipientActorSessionId,
+  recipient_actor_session_id,
+  senderAgentSessionId,
+  sender_agent_session_id,
+  senderRole,
+  sender_role,
+  recipientRole,
+  recipient_role,
+  role,
+  workflowRunId,
+  workflow_run_id,
+  messageKind,
+  message_kind,
+  expectedMessageKind,
+  expected_message_kind,
+  bodyMarkdown,
+  body_markdown,
+  payload = {},
+  metadata = {},
+} = {}) {
+  const normalizedTransferChannelId = cleanText(transfer_channel_id) || cleanText(transferChannelId) || cleanText(channel_id) || cleanText(channelId);
+  const path = normalizedTransferChannelId
+    ? `/api/agent-communications/transfer-channels/${encodeURIComponent(normalizedTransferChannelId)}/messages/send-to-participant`
+    : '/api/agent-communications/messages/send-to-participant';
+  return client._request(path, {
+    method: 'POST',
+    body: {
+      transfer_channel_id: normalizedTransferChannelId,
+      workflow_run_id: cleanText(workflow_run_id) || cleanText(workflowRunId),
+      recipient_participant_id: cleanText(recipient_participant_id) || cleanText(recipientParticipantId),
+      recipient_agent_session_id: cleanText(recipient_agent_session_id) || cleanText(recipientAgentSessionId),
+      recipient_actor_session_id: cleanText(recipient_actor_session_id) || cleanText(recipientActorSessionId),
+      message_kind: cleanText(message_kind) || cleanText(messageKind),
+      expected_message_kind: cleanText(expected_message_kind) || cleanText(expectedMessageKind),
+      body_markdown: cleanText(body_markdown) || cleanText(bodyMarkdown),
+      sender_agent_session_id: cleanText(sender_agent_session_id) || cleanText(senderAgentSessionId) || client.agentSessionId,
+      sender_role: cleanText(sender_role) || cleanText(senderRole),
+      recipient_role: cleanText(recipient_role) || cleanText(recipientRole) || cleanText(role),
+      payload: isPlainObject(payload) ? payload : {},
+      metadata: isPlainObject(metadata) ? metadata : {},
+    },
+  });
+}
+
+export async function sendToRole(client, {
+  transferChannelId,
+  transfer_channel_id,
+  channelId,
+  channel_id,
+  recipientRole,
+  recipient_role,
+  role,
+  senderAgentSessionId,
+  sender_agent_session_id,
+  senderRole,
+  sender_role,
+  recipientAgentSessionId,
+  recipient_agent_session_id,
+  workflowRunId,
+  workflow_run_id,
+  messageKind,
+  message_kind,
+  expectedMessageKind,
+  expected_message_kind,
+  bodyMarkdown,
+  body_markdown,
+  payload = {},
+  metadata = {},
+} = {}) {
+  const normalizedTransferChannelId = cleanText(transfer_channel_id) || cleanText(transferChannelId) || cleanText(channel_id) || cleanText(channelId);
+  const path = normalizedTransferChannelId
+    ? `/api/agent-communications/transfer-channels/${encodeURIComponent(normalizedTransferChannelId)}/messages/send-to-role`
+    : '/api/agent-communications/messages/send-to-role';
+  return client._request(path, {
+    method: 'POST',
+    body: {
+      transfer_channel_id: normalizedTransferChannelId,
+      workflow_run_id: cleanText(workflow_run_id) || cleanText(workflowRunId),
+      sender_agent_session_id: cleanText(sender_agent_session_id) || cleanText(senderAgentSessionId) || client.agentSessionId,
+      sender_role: cleanText(sender_role) || cleanText(senderRole),
+      recipient_agent_session_id: cleanText(recipient_agent_session_id) || cleanText(recipientAgentSessionId),
+      recipient_role: cleanText(recipient_role) || cleanText(recipientRole) || cleanText(role),
+      message_kind: cleanText(message_kind) || cleanText(messageKind),
+      expected_message_kind: cleanText(expected_message_kind) || cleanText(expectedMessageKind),
+      body_markdown: cleanText(body_markdown) || cleanText(bodyMarkdown),
+      payload: isPlainObject(payload) ? payload : {},
+      metadata: isPlainObject(metadata) ? metadata : {},
+    },
+  });
+}

package/src/domains/repo.js

@@ -1,25 +1,128 @@
 export function createRepoDomain(client) {
   return {
-    listRepositories: (request) => client.listRepositories(request),
-    getRepository: (repositoryId) => client.getRepository(repositoryId),
-    listProjects: (request) => client.listProjects(request),
-    getProject: (projectId) => client.getProject(projectId),
-    listCodeFiles: (request) => client.listCodeFiles(request),
-    getCodeFile: (fileId) => client.getCodeFile(fileId),
-    getCodeFileContentWindow: (fileId, request) => client.getCodeFileContentWindow(fileId, request),
-    listCodeSymbolsByFile: (fileId, request) => client.listCodeSymbolsByFile(fileId, request),
-    getCodeSymbol: (symbolId, request) => client.getCodeSymbol(symbolId, request),
-    searchSymbols: (request) => client.searchSymbols(request),
-    getSymbolRelationships: (symbolId, request) => client.getSymbolRelationships(symbolId, request),
-    listCodeRelationships: (request) => client.listCodeRelationships(request),
-    listActionObservations: (request) => client.listActionObservations(request),
-    listCodebaseShapeFindings: (request) => client.listCodebaseShapeFindings(request),
-    listObjectFlowObservations: (request) => client.listObjectFlowObservations(request),
-    getChangeAnalysis: (request) => client.getChangeAnalysis(request),
-    listRefactorCandidates: (request) => client.listRefactorCandidates(request),
-    analyzeRefactorCandidate: (request) => client.analyzeRefactorCandidate(request),
-    getRepoRetrievalPacket: (retrievalPacketId) => client.getRepoRetrievalPacket(retrievalPacketId),
-    getRepoRetrievalPacketFragments: (retrievalPacketId) => client.getRepoRetrievalPacketFragments(retrievalPacketId),
-    evaluateProposalScope: (request) => client.evaluateProposalScope(request),
+    listRepositories({ limit } = {}) {
+      return client._request('/api/repo/repositories', {
+        query: { limit },
+      });
+    },
+
+    getRepository(repositoryId) {
+      return client._request(`/api/repo/repositories/${repositoryId}`);
+    },
+
+    listProjects({ repositoryId, repoKey, limit } = {}) {
+      return client._request('/api/repo/projects', {
+        query: { repository_id: repositoryId, repo_key: repoKey, limit },
+      });
+    },
+
+    getProject(projectId) {
+      return client._request(`/api/repo/projects/${projectId}`);
+    },
+
+    listCodeFiles({ repositoryId, projectId, language, pathPrefix, page = 1, pageSize = 50 } = {}) {
+      return client._request('/api/repo/files', {
+        query: {
+          repository_id: repositoryId,
+          project_id: projectId,
+          language,
+          path_prefix: pathPrefix,
+          page,
+          page_size: pageSize,
+        },
+      });
+    },
+
+    getCodeFile(fileId) {
+      return client._request(`/api/repo/files/${fileId}`);
+    },
+
+    getCodeFileContentWindow(fileId, { startLine = 1, endLine } = {}) {
+      return client._request(`/api/repo/files/${fileId}/content-window`, {
+        query: { start_line: startLine, end_line: endLine ?? startLine },
+      });
+    },
+
+    listCodeSymbolsByFile(fileId, { limit = 500 } = {}) {
+      return client._request(`/api/repo/files/${fileId}/symbols`, {
+        query: { limit },
+      });
+    },
+
+    getCodeSymbol(symbolId, { includeCode = false, maxLines = 120 } = {}) {
+      return client._request(`/api/repo/symbols/${symbolId}`, {
+        query: { include_code: includeCode, max_lines: maxLines },
+      });
+    },
+
+    searchSymbols({ query, projectScope, maxResults = 10 } = {}) {
+      return client._request('/api/repo/symbols/search', {
+        query: { query, project_scope: projectScope, max_results: maxResults },
+      });
+    },
+
+    getSymbolRelationships(symbolId, { relationshipType, depth = 1 } = {}) {
+      return client._request(`/api/repo/symbols/${symbolId}/relationships`, {
+        query: { relationship_type: relationshipType, depth },
+      });
+    },
+
+    listCodeRelationships({ repositoryId, projectId, relationshipType, limit = 100 } = {}) {
+      return client._request('/api/repo/relationships', {
+        query: { repository_id: repositoryId, project_id: projectId, relationship_type: relationshipType, limit },
+      });
+    },
+
+    listActionObservations({ repositoryId, projectPath, filePath, symbolId, actionKind, limit = 100 } = {}) {
+      return client._request('/api/repo/action-observations', {
+        query: { repository_id: repositoryId, project_path: projectPath, file_path: filePath, symbol_id: symbolId, action_kind: actionKind, limit },
+      });
+    },
+
+    listCodebaseShapeFindings({ repositoryId, projectPath, filePath, severity, status, limit = 100 } = {}) {
+      return client._request('/api/repo/shape/findings', {
+        query: { repository_id: repositoryId, project_path: projectPath, file_path: filePath, severity, status, limit },
+      });
+    },
+
+    listObjectFlowObservations({ repositoryId, projectPath, filePath, objectKind, boundaryKind, limit = 100 } = {}) {
+      return client._request('/api/repo/object-flow-observations', {
+        query: { repository_id: repositoryId, project_path: projectPath, file_path: filePath, object_kind: objectKind, boundary_kind: boundaryKind, limit },
+      });
+    },
+
+    getChangeAnalysis({ fileId, symbolId, limit = 25 } = {}) {
+      return client._request('/api/repo/change-analysis', {
+        query: { file_id: fileId, symbol_id: symbolId, limit },
+      });
+    },
+
+    listRefactorCandidates({ repositoryRoot, limit = 10 } = {}) {
+      return client._request('/api/repo/refactor-candidates', {
+        query: { repository_root: repositoryRoot, limit },
+      });
+    },
+
+    analyzeRefactorCandidate({ filePath, requestedBy, packetId, refactorIntent } = {}) {
+      return client._request('/api/repo/refactor-candidate-analysis', {
+        method: 'POST',
+        body: { file_path: filePath, requested_by: requestedBy, packet_id: packetId, refactor_intent: refactorIntent },
+      });
+    },
+
+    getRepoRetrievalPacket(retrievalPacketId) {
+      return client._request(`/api/repo/retrieval/packets/${retrievalPacketId}`);
+    },
+
+    getRepoRetrievalPacketFragments(retrievalPacketId) {
+      return client._request(`/api/repo/retrieval/packets/${retrievalPacketId}/fragments`);
+    },
+
+    evaluateProposalScope({ filePath, projectId, changeType = 'refactor', requestedBy, refactorIntent } = {}) {
+      return client._request('/api/repo/proposal-scope-evaluation', {
+        method: 'POST',
+        body: { file_path: filePath, project_id: projectId, change_type: changeType, requested_by: requestedBy, refactor_intent: refactorIntent },
+      });
+    },
   };
 }

package/src/domains/reports.js

@@ -1,5 +1,20 @@
+import { cleanText, isPlainObject } from '../utils/text.js';
+
 export function createReportsDomain(client) {
   return {
-    run: (request) => client.runReportDefinition(request),
+    run({ reportKey, definition = {}, requestedBy } = {}) {
+      const normalizedReportKey = cleanText(reportKey);
+      if (!normalizedReportKey) {
+        throw new Error('reportKey is required.');
+      }
+      return client._request('/api/gateway/reports/run', {
+        method: 'POST',
+        body: {
+          report_key: normalizedReportKey,
+          definition: isPlainObject(definition) ? definition : {},
+          requested_by: cleanText(requestedBy),
+        },
+      });
+    },
   };
 }

package/src/domains/retrieval-management.js

@@ -1,14 +1,23 @@
 export function createRetrievalManagementDomain(client) {
   return {
-    getRetrievalStatus: () => client.getRetrievalStatus(),
-    getRetrievalProfileMetrics: () => client.getRetrievalProfileMetrics(),
-    getRetrievalFeedbackMetrics: () => client.getRetrievalFeedbackMetrics(),
-    getRetrievalQuery: (retrievalQueryId) => client.getRetrievalQuery(retrievalQueryId),
-    getRetrievalPacket: (retrievalPacketId) => client.getRetrievalPacket(retrievalPacketId),
-    generateRetrievalCandidates: (body) => client.generateRetrievalCandidates(body),
-    selectRetrievalPacket: (body) => client.selectRetrievalPacket(body),
-    recordRetrievalFeedback: (body) => client.recordRetrievalFeedback(body),
-    deriveRetrievalOptimizationCandidates: (body) => client.deriveRetrievalOptimizationCandidates(body),
-    validatePromptAssembly: (body) => client.validatePromptAssembly(body),
+    getRetrievalStatus: () => client._request('/api/operator/retrieval/status'),
+
+    getRetrievalProfileMetrics: () => client._request('/api/operator/retrieval/profiles/metrics'),
+
+    getRetrievalFeedbackMetrics: () => client._request('/api/operator/retrieval/feedback-metrics'),
+
+    getRetrievalQuery: (retrievalQueryId) => client._request(`/api/operator/retrieval/queries/${retrievalQueryId}`),
+
+    getRetrievalPacket: (retrievalPacketId) => client._request(`/api/operator/retrieval/packets/${retrievalPacketId}`),
+
+    generateRetrievalCandidates: (body) => client._request('/api/operator/retrieval/generate-candidates', { method: 'POST', body }),
+
+    selectRetrievalPacket: (body) => client._request('/api/operator/retrieval/select-packet', { method: 'POST', body }),
+
+    recordRetrievalFeedback: (body) => client._request('/api/operator/retrieval/feedback', { method: 'POST', body }),
+
+    deriveRetrievalOptimizationCandidates: (body) => client._request('/api/operator/retrieval/optimization-candidates', { method: 'POST', body }),
+
+    validatePromptAssembly: (body) => client._request('/api/operator/retrieval/validate-prompt-assembly', { method: 'POST', body }),
   };
 }