@bpmsoftwaresolutions/ai-engine-client 1.1.88 → 1.1.90

package/src/client.js

@@ -1,4 +1,4 @@
-import { AI_ENGINE_CLIENT_CAPABILITIES, GOVERNED_MUTATION_REQUIRED_CAPABILITIES, TASK_BOUND_SUBSTRATE_EXECUTION_POLICY } from './constants/governance.js';
+import { AI_ENGINE_CLIENT_CAPABILITIES } from './constants/governance.js';
 import { AGENT_COMMUNICATION_CONTRACT_VERSION, AGENT_COMMUNICATION_MESSAGE_KINDS, AGENT_COMMUNICATION_RECIPIENT_MODES, AGENT_COMMUNICATION_THREAD_TYPES, AGENT_COMMUNICATION_TRANSFER_KINDS, AGENT_COMMUNICATION_TRANSFER_LIFECYCLE_STATES, AGENT_COMMUNICATION_TRANSFER_MODES, AGENT_COMMUNICATION_TRANSFER_RECEIPT_TYPES } from './constants/agent-communications.js';
 import { AI_ENGINE_CLIENT_VERSION, DEFAULT_TIMEOUT_MS } from './constants/client.js';
 import { LOGA_CONTRACT, LOGA_INTERACTION_CONTRACT, LOGA_NAVIGATION_CONTRACT, LOGA_PROJECTION_WORKFLOW } from './constants/loga.js';
@@ -18,6 +18,7 @@ import { createNotesLabDomain } from './domains/notes-lab.js';
 import { createPortfolioDomain } from './domains/portfolio.js';
 import { createProjectReportsDomain } from './domains/project-reports.js';
 import { createProjectResumeDomain } from './domains/project-resume.js';
+import { createGovernedImplementationDomain } from './domains/governed-implementation.js';
 import { createProjectionsDomain } from './domains/projections.js';
 import { createReportsDomain } from './domains/reports.js';
 import { createRoadmapReportsDomain } from './domains/roadmap-reports.js';
@@ -43,6 +44,17 @@ import { createSkillGovernanceDomain } from './domains/skill-governance.js';
 import { createSkillsDomain } from './domains/skills.js';
 import { createSearchContactsDomain } from './domains/search-contacts.js';
 import { createAgentCommunicationsFacade, createCollaborationFacade } from './compat/facades.js';
+import { createClaimsDomain } from './domains/claims.js';
+import { createSessionGovernanceDomain } from './domains/session-governance.js';
+import { createContextSessionsDomain } from './domains/context-sessions.js';
+import { createContextOrientationDomain } from './domains/context-orientation.js';
+import { createCommitGovernanceDomain } from './domains/commit-governance.js';
+import { createExecutionEligibilityDomain } from './domains/execution-eligibility.js';
+import { createToolBindingApprovalsDomain } from './domains/tool-binding-approvals.js';
+import { createVerifiedMutationsDomain } from './domains/verified-mutations.js';
+import { createWorkflowTurnsDomain } from './domains/workflow-turns.js';
+import { createChartersDomain } from './domains/charters.js';
+import { createWorkStartDomain } from './domains/work-start.js';
 import { createCollaborationDomain } from './domains/collaboration.js';
 import { createMessageWatchDomain } from './domains/message-watch.js';
 import { createPingPongDomain } from './domains/ping-pong.js';
@@ -55,8 +67,6 @@ import { createWorkflowsDomain } from './domains/workflows.js';
 import { createWarehouseDomain } from './domains/warehouse.js';
 import { buildHeaders, requestBinary, requestJson, requestLogaProjection, requestText, resolveAccessToken } from './transport/index.js';
 import { normalizeEnum, trimTrailingSlash } from './utils/text.js';
-import { normalizeMetadataTaskBinding, normalizeTaskBindingPolicy } from './utils/task-binding.js';
-import { executeVerifiedMutation } from './utils/verified-mutations.js';
 
 function normalizeThreadType(value) {
   return normalizeEnum(value, AGENT_COMMUNICATION_THREAD_TYPES, 'coordination', 'thread_type', {
@@ -234,58 +244,6 @@ function isPlainObject(value) {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 
-function isActiveBinding(binding) {
-  return isPlainObject(binding) && (
-    binding.is_active === true ||
-    binding.is_active === 1 ||
-    binding.is_active === 'true' ||
-    binding.is_active === 'True'
-  );
-}
-
-function activeToolKeysFromRegistry(registry) {
-  const bindings = Array.isArray(registry?.bindings) ? registry.bindings : [];
-  const seen = new Set();
-  const keys = [];
-  for (const binding of bindings) {
-    if (!isActiveBinding(binding)) continue;
-    const key = cleanText(binding.tool_key);
-    if (!key || seen.has(key)) continue;
-    seen.add(key);
-    keys.push(key);
-  }
-  return keys;
-}
-
-function reminderTokens(reminders) {
-  const tokens = [];
-  for (const reminder of Array.isArray(reminders) ? reminders : []) {
-    if (!isPlainObject(reminder)) continue;
-    for (const value of [reminder.reminder_key, reminder.reminder_id]) {
-      const token = cleanText(value);
-      if (token && !tokens.includes(token)) tokens.push(token);
-    }
-  }
-  return tokens;
-}
-
-function contextSessionIdFromInput(input) {
-  if (isPlainObject(input)) {
-    return cleanText(input.contextSessionId)
-      || cleanText(input.context_session_id)
-      || cleanText(input.context_session?.context_session_id)
-      || cleanText(input.claim?.context_session_id);
-  }
-  return cleanText(input);
-}
-
-function buildEligibilityError(message, details = {}) {
-  const error = new Error(message);
-  error.code = 'EXECUTION_ELIGIBILITY_FAILED';
-  error.details = details;
-  return error;
-}
-
 export class AIEngineClient {
   constructor({ baseUrl, accessToken, tokenProvider, apiKey, clientId, actorId, agentSessionId, fetchImpl, timeoutMs } = {}) {
     if (!baseUrl) throw new Error('baseUrl is required.');
@@ -314,6 +272,18 @@ export class AIEngineClient {
     this.projectChartering = createProjectCharteringDomain(this);
     this.projectReports = createProjectReportsDomain(this);
     this.projectResume = createProjectResumeDomain(this);
+    this.claims = createClaimsDomain(this);
+    this.sessionGovernance = createSessionGovernanceDomain(this);
+    this.executionEligibility = createExecutionEligibilityDomain(this);
+    this.toolBindingApprovals = createToolBindingApprovalsDomain(this);
+    this.workflowTurns = createWorkflowTurnsDomain(this);
+    this.contextSessions = createContextSessionsDomain(this);
+    this.contextOrientation = createContextOrientationDomain(this);
+    this.commitGovernance = createCommitGovernanceDomain(this);
+    this.verifiedMutations = createVerifiedMutationsDomain(this);
+    this.charters = createChartersDomain(this);
+    this.workStart = createWorkStartDomain(this);
+    this.governedImplementation = createGovernedImplementationDomain(this);
     this.roadmaps = createRoadmapsDomain(this);
     this.roadmapReports = createRoadmapReportsDomain(this);
     this.implementationPackets = createImplementationPacketsDomain(this);
@@ -375,251 +345,6 @@ export class AIEngineClient {
 
   // ─── Health ────────────────────────────────────────────────────────────────
 
-  async ping() {
-    const [health, workflow] = await Promise.all([
-      this._request('/healthz'),
-      this.currentWorkflowStatus(),
-    ]);
-    return {
-      status: health.status || 'ok',
-      workflow_name: workflow?.summary?.workflow_name || null,
-      run_status: workflow?.summary?.run_status || null,
-      base_url: this.baseUrl,
-    };
-  }
-
-  // ─── Operator Status ───────────────────────────────────────────────────────
-
-  async currentWorkflowStatus() {
-    return this._request('/api/operator/current-workflow-status');
-  }
-
-  async currentArchitectureIntegrityStatus() {
-    return this._request('/api/operator/current-architecture-integrity-status');
-  }
-
-  async currentSecurityGovernanceStatus({ environment, topN } = {}) {
-    return this._request('/api/operator/current-security-governance-status', {
-      query: { environment, top_n: topN },
-    });
-  }
-
-  async getExecutionTelemetryCurrent() {
-    return this._request('/api/operator/execution-telemetry/current');
-  }
-
-  async listExecutionProcessRuns({ limit, artifactKind, status, since } = {}) {
-    return this._request('/api/operator/execution-telemetry/process-runs', {
-      query: { limit, artifact_kind: artifactKind, status, since },
-    });
-  }
-
-  async getExecutionProcessRun(processRunId) {
-    return this._request(`/api/operator/execution-telemetry/process-runs/${processRunId}`);
-  }
-
-  async getGeneratedExecutionUsability({ artifactPath, limit } = {}) {
-    return this._request('/api/operator/generated-execution-usability', {
-      query: { artifact_path: artifactPath, limit },
-    });
-  }
-
-  async getLogaGeneratedExecutionUsabilityProjection({ artifactPath, limit } = {}) {
-    return this._requestLogaProjection('/api/loga/ai-engine/generated-execution-usability', {
-      query: { artifact_path: artifactPath, limit },
-    });
-  }
-
-  async getAntiPatternRules() {
-    return this._request('/api/governance/anti-pattern-rules');
-  }
-
-  async currentCodebaseShapeStatus() {
-    return this._request('/api/operator/current-codebase-shape-status');
-  }
-
-  async getLatestMemoryProjection() {
-    return this._request('/api/v1/latest-memory-projection');
-  }
-
-  // ─── Data Access Gateway ──────────────────────────────────────────────────
-
-  async query({
-    surface,
-    contractKey,
-    parameters = {},
-    fields = [],
-    fieldAllowlist = [],
-    actorScopes = [],
-    requiredScopes = [],
-    shape = 'json',
-    requestedBy,
-  } = {}) {
-    const normalizedSurface = cleanText(surface) || cleanText(contractKey);
-    if (!normalizedSurface) {
-      throw new Error('surface is required.');
-    }
-    const normalizedShape = cleanText(shape) || 'json';
-    if (!['json', 'table', 'cards', 'markdown'].includes(normalizedShape)) {
-      throw new Error('shape must be one of json, table, cards, or markdown.');
-    }
-    const normalizedFields = cleanList(fields);
-    const normalizedAllowlist = cleanList(fieldAllowlist);
-    const disallowedFields = normalizedFields.filter((field) => !normalizedAllowlist.includes(field));
-    if (normalizedAllowlist.length > 0 && disallowedFields.length > 0) {
-      throw new Error(`Requested fields are not allowed: ${disallowedFields.join(', ')}.`);
-    }
-    const normalizedActorScopes = cleanList(actorScopes);
-    const normalizedRequiredScopes = cleanList(requiredScopes);
-    const missingScopes = normalizedRequiredScopes.filter((scope) => !normalizedActorScopes.includes(scope));
-    if (missingScopes.length > 0) {
-      throw new Error(`Missing required scopes: ${missingScopes.join(', ')}.`);
-    }
-    return this._request('/api/gateway/query', {
-      method: 'POST',
-      body: {
-        surface: normalizedSurface,
-        parameters: isPlainObject(parameters) ? parameters : {},
-        fields: normalizedFields,
-        field_allowlist: normalizedAllowlist,
-        actor_scopes: normalizedActorScopes,
-        required_scopes: normalizedRequiredScopes,
-        shape: normalizedShape,
-        requested_by: cleanText(requestedBy),
-      },
-    });
-  }
-
-  async runReportDefinition({ reportKey, definition = {}, requestedBy } = {}) {
-    return this.reports.run({ reportKey, definition, requestedBy });
-  }
-
-  async renderProjection({ projectionType, viewContract = {}, requestedBy } = {}) {
-    const normalizedProjectionType = cleanText(projectionType);
-    if (!normalizedProjectionType) {
-      throw new Error('projectionType is required.');
-    }
-    return this._request('/api/gateway/projections/render', {
-      method: 'POST',
-      body: {
-        projection_type: normalizedProjectionType,
-        view_contract: isPlainObject(viewContract) ? viewContract : {},
-        requested_by: cleanText(requestedBy),
-      },
-    });
-  }
-
-  async submitActionIntent({ action, target = {}, payload = {}, requiredScope, requestedBy } = {}) {
-    const normalizedAction = cleanText(action);
-    if (!normalizedAction) {
-      throw new Error('action is required.');
-    }
-    return this._request('/api/gateway/actions/submit', {
-      method: 'POST',
-      body: {
-        action: normalizedAction,
-        target: isPlainObject(target) ? target : {},
-        payload: isPlainObject(payload) ? payload : {},
-        required_scope: cleanText(requiredScope) || 'ai-engine.write',
-        requested_by: cleanText(requestedBy),
-      },
-    });
-  }
-
-  async getCommunicationCapabilities() {
-    return this._request('/api/agent-communications/capabilities');
-  }
-
-  async getCollaborationCapabilities() {
-    return this._request('/api/agent-communications/collaboration-capabilities');
-  }
-
-  async getDeploymentCapabilities() {
-    return this._request('/api/agent-communications/deployment-capabilities');
-  }
-
-  async checkCoordinationPingPongPreflight({
-    packageVersion,
-  } = {}) {
-    return this.pingPong.checkCoordinationPingPongPreflight({ packageVersion });
-  }
-
-  async listCommunicationChannels(request = {}) {
-    return this.transferChannels.listCommunicationChannels(request);
-  }
-
-  async listOpenCommunicationChannels(request = {}) {
-    return this.transferChannels.listOpenCommunicationChannels(request);
-  }
-
-  async getCommunicationChannelStatus(request = {}) {
-    return this.transferChannels.getCommunicationChannelStatus(request);
-  }
-
-  async getCommunicationChannelParticipants(request = {}) {
-    return this.transferChannels.getCommunicationChannelParticipants(request);
-  }
-
-  async getPresenceBoard(request = {}) {
-    return this.presence.getPresenceBoard(request);
-  }
-
-  async getChannelPresence(request = {}) {
-    return this.presence.getChannelPresence(request);
-  }
-
-  async markParticipantOnline(request = {}) {
-    return this.presence.markParticipantOnline(request);
-  }
-
-  async markParticipantOffline(request = {}) {
-    return this.presence.markParticipantOffline(request);
-  }
-
-  async reviewCollaborationProposal(request = {}) {
-    return this.collaborationDomain.reviewCollaborationProposal(request);
-  }
-
-  async connectToTransferChannel(request = {}) {
-    return this.transferChannels.connectToTransferChannel(request);
-  }
-
-  async openAgentChannel(request = {}) {
-    return this.transferChannels.openAgentChannel(request);
-  }
-
-  async openTransferChannel(request = {}) {
-    return this.transferChannels.openTransferChannel(request);
-  }
-
-  async joinTransferChannel(request = {}) {
-    return this.transferChannels.joinTransferChannel(request);
-  }
-
-  async resumeTransferChannel(request = {}) {
-    return this.transferChannels.resumeTransferChannel(request);
-  }
-
-  async postCollaborationHeartbeat(request = {}) {
-    return this.transferChannels.postAgentHeartbeat(request);
-  }
-
-  async replyToTransferChannel(request = {}) {
-    return this.transferChannels.replyToTransferChannel(request);
-  }
-
-  async startMessageWatch(request = {}) {
-    return this.messageWatch.startMessageWatch(request);
-  }
-
-  async acknowledgeExpectedMessage(request = {}) {
-    return this.messageWatch.acknowledgeExpectedMessage(request);
-  }
-
-  async closeTransferChannel(request = {}) {
-    return this.transferChannels.closeTransferChannel(request);
-  }
-
   async startAgentConnection({
     workflowRunId,
     workflow_run_id,
@@ -2966,2128 +2691,316 @@ export class AIEngineClient {
     });
   }
 
-  async currentProjectStatus({ projectId } = {}) {
-    return this._request('/api/operator/current-project-status', {
-      query: { project_id: projectId },
-    });
-  }
+  async getPortfolioClosureReadiness({
+    projectLimit = 25,
+    includeInactive = false,
+    includeLogaPortfolioProjection = false,
+    includeLogaRoadmapProjections = false,
+  } = {}) {
+    const portfolioBundle = await this._request('/api/operator/portfolio/bundle');
+    const projectListPayload = await this.projects.listProjects({ limit: projectLimit, includeInactive });
+
+    const bundleProjects = Array.isArray(portfolioBundle?.projects)
+      ? portfolioBundle.projects.filter((project) => isPlainObject(project))
+      : [];
+    const listedProjects = Array.isArray(projectListPayload?.projects)
+      ? projectListPayload.projects.filter((project) => isPlainObject(project))
+      : Array.isArray(projectListPayload)
+        ? projectListPayload.filter((project) => isPlainObject(project))
+        : [];
+    const activeProjects = listedProjects.length > 0 ? listedProjects : bundleProjects;
+    const logaPortfolioProjection = includeLogaPortfolioProjection
+      ? await this.getLogaProjectPortfolioProjection()
+      : null;
+    const logaRoadmapProjections = {};
 
-  async createDatabaseBackup({ databaseName, outputName, noWait } = {}) {
-    return this._request('/api/operator/database/backups', {
-      method: 'POST',
-      body: {
-        database_name: databaseName,
-        output_name: outputName,
-        no_wait: noWait,
-      },
-    });
+    const projectReadiness = [];
+    for (const project of activeProjects) {
+      const projectId = cleanText(project.project_id) || cleanText(project.projectId);
+      if (!projectId) {
+        continue;
+      }
+
+      const roadmapSummaryPayload = await this.getProjectRoadmapSummary(projectId);
+      const roadmapSummary = isPlainObject(roadmapSummaryPayload?.summary) ? roadmapSummaryPayload.summary : {};
+      const activeItemPayload = await this.getProjectRoadmapActiveItem(projectId);
+      const activeItem = isPlainObject(activeItemPayload?.active_item)
+        ? activeItemPayload.active_item
+        : isPlainObject(activeItemPayload)
+          ? activeItemPayload
+          : {};
+      const openTasksPayload = await this.listProjectOpenTasks(projectId);
+      const openTasks = Array.isArray(openTasksPayload?.tasks)
+        ? openTasksPayload.tasks.filter((task) => isPlainObject(task))
+        : Array.isArray(openTasksPayload)
+          ? openTasksPayload.filter((task) => isPlainObject(task))
+          : [];
+
+      const activeItemStatus = cleanText(activeItem.item_status) || cleanText(activeItem.status);
+      const completionPercentage = Number(
+        roadmapSummary.completion_percentage
+        ?? roadmapSummary.completion_pct
+        ?? roadmapSummary.progress_percentage
+        ?? 0,
+      );
+      const totalItems = Number(
+        roadmapSummary.total_items
+        ?? roadmapSummary.item_count
+        ?? roadmapSummary.total_count
+        ?? 0,
+      );
+      const openItems = Number(
+        roadmapSummary.open_items
+        ?? roadmapSummary.open_item_count
+        ?? roadmapSummary.remaining_items
+        ?? openTasks.length,
+      );
+      const terminalStatuses = new Set(['accepted', 'verified', 'done', 'completed', 'closed']);
+      const activeItemReady = !activeItemStatus || terminalStatuses.has(activeItemStatus.toLowerCase());
+      const projectReady = openItems === 0 && openTasks.length === 0 && activeItemReady && completionPercentage >= 100;
+      const blockingReason = projectReady
+        ? null
+        : [
+            openTasks.length > 0 ? `${openTasks.length} open task(s) remain` : null,
+            openItems > 0 ? `${openItems} roadmap item(s) remain open` : null,
+            !activeItemReady ? `active item status is ${activeItemStatus || 'missing'}` : null,
+            completionPercentage < 100 ? `completion is ${completionPercentage.toFixed(1)}%` : null,
+          ].filter(Boolean).join('; ') || 'portfolio closure readiness is not satisfied';
+
+      const roadmapCompletion = {
+        completion_percentage: completionPercentage,
+        total_items: totalItems,
+        open_items: openItems,
+        completed_items: Math.max(totalItems - openItems, 0),
+      };
+      const projectReadinessEntry = {
+        project: {
+          project_id: projectId,
+          project_name: cleanText(project.project_name) || cleanText(project.projectName) || null,
+          project_slug: cleanText(project.project_slug) || cleanText(project.projectSlug) || null,
+          process_status: cleanText(project.process_status) || cleanText(project.processStatus) || null,
+          charter_status: cleanText(project.charter_status) || cleanText(project.charterStatus) || null,
+        },
+        roadmap_completion: roadmapCompletion,
+        active_item: activeItem,
+        open_task_count: openTasks.length,
+        closure_ready: projectReady,
+        blocking_reason: blockingReason,
+      };
+      if (includeLogaRoadmapProjections) {
+        projectReadinessEntry.loga_roadmap_projection = await this.getLogaProjectRoadmapProjection(projectId);
+        logaRoadmapProjections[projectId] = projectReadinessEntry.loga_roadmap_projection;
+      }
+      projectReadiness.push(projectReadinessEntry);
+    }
+
+    const closureReady = projectReadiness.length === 0 || projectReadiness.every((project) => project.closure_ready === true);
+    const blockingProject = projectReadiness.find((project) => project.closure_ready !== true);
+
+    return {
+      portfolio_summary: isPlainObject(portfolioBundle?.summary) ? portfolioBundle.summary : {},
+      portfolio_bundle: portfolioBundle,
+      active_projects: projectReadiness,
+      closure_readiness: closureReady,
+      blocking_reason: closureReady ? null : `${cleanText(blockingProject?.project?.project_name) || cleanText(blockingProject?.project?.project_id) || 'project'}: ${blockingProject?.blocking_reason || 'closure readiness is not satisfied'}`,
+      blocking_project_id: closureReady ? null : cleanText(blockingProject?.project?.project_id),
+      blocking_project_name: closureReady ? null : cleanText(blockingProject?.project?.project_name),
+      project_count: projectReadiness.length,
+      open_task_count: projectReadiness.reduce((total, project) => total + Number(project.open_task_count || 0), 0),
+      loga_portfolio_projection: logaPortfolioProjection,
+      loga_roadmap_projections: includeLogaRoadmapProjections ? logaRoadmapProjections : null,
+    };
   }
 
-  async listDatabaseBackups({ prefix, limit } = {}) {
-    return this._request('/api/operator/database/backups', {
+  async getPortfolioStatus({
+    projectId,
+    project_id,
+  } = {}) {
+    return this._request('/api/operator/portfolio/status', {
       query: {
-        prefix,
-        limit,
+        project_id: cleanText(project_id) || cleanText(projectId),
       },
     });
   }
 
-  async getDatabaseBackup({ backupId } = {}) {
-    return this._request(`/api/operator/database/backups/${encodeURIComponent(backupId)}`);
+  async getPortfolioBundle() {
+    return this._request('/api/operator/portfolio/bundle');
   }
 
-  async listDatabaseBackupOperations({ databaseName, operationFilter, limit } = {}) {
-    return this._request('/api/operator/database/backups/operations', {
-      query: {
-        database_name: databaseName,
-        operation_filter: operationFilter,
-        limit,
-      },
-    });
+  async getExternalProjectStatus(projectId) {
+    return this._request(`/api/v1/projects/${projectId}/status`);
   }
 
-  async runAzureSqlBacpacBackup({
-    databaseName,
-    storageAccount,
-    container,
-    resourceGroup,
-    serverName,
-    outputName,
-    adminUser,
-    adminPassword,
-    subscription,
-    storageKey,
-    skipContainerCreate,
-    noWait,
-  } = {}) {
-    return this._request('/api/operator/database/backups/azure-sql-bacpac', {
-      method: 'POST',
-      body: {
-        database_name: databaseName,
-        storage_account: storageAccount,
-        container,
-        resource_group: resourceGroup,
-        server_name: serverName,
-        output_name: outputName,
-        admin_user: adminUser,
-        admin_password: adminPassword,
-        subscription,
-        storage_key: storageKey,
-        skip_container_create: skipContainerCreate,
-        no_wait: noWait,
-      },
-    });
+  async getExternalProjectRoadmapSummary(projectId) {
+    return this._request(`/api/v1/projects/${projectId}/implementation-roadmap/summary`);
   }
 
-  async listAzureSqlBacpacBackups({
-    storageAccount,
-    container,
-    resourceGroup,
-    serverName,
-    subscription,
-    storageKey,
-    prefix,
-    limit,
-  } = {}) {
-    return this._request('/api/operator/database/backups/azure-sql-bacpac', {
-      query: {
-        storage_account: storageAccount,
-        container,
-        resource_group: resourceGroup,
-        server_name: serverName,
-        subscription,
-        storage_key: storageKey,
-        prefix,
-        limit,
-      },
-    });
+  async getExternalProjectRoadmapActiveItem(projectId) {
+    return this._request(`/api/v1/projects/${projectId}/implementation-roadmap/active-item`);
   }
 
-  async listAzureSqlBacpacBackupOperations({
-    databaseName,
-    resourceGroup,
-    serverName,
-    subscription,
-    operationFilter,
-    limit,
-  } = {}) {
-    return this._request('/api/operator/database/backups/azure-sql-bacpac/operations', {
-      query: {
-        database_name: databaseName,
-        resource_group: resourceGroup,
-        server_name: serverName,
-        subscription,
-        operation_filter: operationFilter,
-        limit,
-      },
-    });
+  async listExternalProjectOpenTasks(projectId) {
+    return this._request(`/api/v1/projects/${projectId}/open-tasks`);
   }
 
-  async getDashboard() {
-    return this._request('/api/dashboard');
+  async getExternalProjectStatusBundle(projectId) {
+    return this._request(`/api/v1/projects/${projectId}/status-bundle`);
   }
 
-  async startSessionGovernance({
-    intent,
-    objective,
-    allowedScopes,
-    allowedMutationSurfaces,
-    requiredToolKeys,
-    sessionKey,
-    workflowRunId,
-    workflowId,
-    workflowSlug,
-    governedScope,
-    successCriteria,
-    disallowedSurfaces,
-    ...rest
-  } = {}) {
-    return this._request('/api/v1/session-governance/startup', {
+  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: {
-        ...rest,
-        objective: objective ?? intent,
-        allowed_mutation_surfaces: allowedMutationSurfaces ?? allowedScopes,
-        required_tool_keys: requiredToolKeys,
-        session_key: sessionKey,
-        workflow_run_id: workflowRunId,
-        workflow_id: workflowId,
-        workflow_slug: workflowSlug,
-        governed_scope: governedScope,
-        success_criteria: successCriteria,
-        disallowed_surfaces: disallowedSurfaces,
-      },
+      body: { text, voice, model, speed },
     });
   }
 
-  async startReviewGovernance({
-    intent,
-    objective,
-    readScope,
-    requiredToolKeys,
-    sessionKey,
-    workflowRunId,
-    workflowId,
-    workflowSlug,
-    turnPersisted,
-    ...rest
-  } = {}) {
-    return this._request('/api/v1/session-governance/review/startup', {
-      method: 'POST',
-      body: {
-        ...rest,
-        intent: intent ?? 'review code',
-        objective: objective ?? intent,
-        read_scope: readScope,
-        required_tool_keys: requiredToolKeys,
-        session_key: sessionKey,
-        workflow_run_id: workflowRunId,
-        workflow_id: workflowId,
-        workflow_slug: workflowSlug ?? 'code-review/read-only',
-        turn_persisted: turnPersisted,
-      },
-    });
+  async getExternalAudioRender(audioRenderRunId) {
+    return this._request(`/api/v1/audio-renders/${audioRenderRunId}`);
   }
 
-  async startWork(body = {}) {
-    return this._request('/api/work/start', { method: 'POST', body });
+  async downloadExternalAudioRender(audioRenderRunId) {
+    return this._requestBinary(`/api/v1/audio-renders/${audioRenderRunId}/download`);
   }
 
-  async startClaimedWork({
-    claimName,
-    actorId,
-    intentId,
-    declaredScopeFiles,
-    allowedMutationSurfaces,
-    runtimeSessionId,
-    executionPurpose,
-    successCriteria,
-    mutationAllowed,
-    metadata,
-    ...rest
-  } = {}) {
-    return this._request('/api/governance/claims/start-claimed-work', {
-      method: 'POST',
-      body: {
-        ...rest,
-        claim_name: claimName,
-        actor_id: actorId,
-        intent_id: intentId,
-        declared_scope_files: declaredScopeFiles,
-        allowed_mutation_surfaces: allowedMutationSurfaces,
-        runtime_session_id: runtimeSessionId,
-        execution_purpose: executionPurpose,
-        success_criteria: successCriteria,
-        mutation_allowed: mutationAllowed,
-        metadata: normalizeMetadataTaskBinding(metadata),
-      },
-    });
+  async listExternalWorkflowRunArtifacts(workflowRunId) {
+    return this._request(`/api/v1/runs/${workflowRunId}/artifacts`);
   }
 
-  async claimWorkItem(body = {}) {
-    const normalizedBody = isPlainObject(body)
-      ? {
-          ...body,
-          ...(isPlainObject(body.task_binding)
-            ? { task_binding: normalizeTaskBindingPolicy(body.task_binding) }
-            : {}),
-          metadata: normalizeMetadataTaskBinding(body.metadata),
-        }
-      : body;
-    return this._request('/api/governance/claims/claim-work-item', { method: 'POST', body: normalizedBody });
+  async downloadExternalWorkflowRunArtifact(workflowRunId, artifactType) {
+    return this._requestBinary(`/api/v1/runs/${workflowRunId}/artifacts/${artifactType}/download`);
   }
 
-  async bindClaimedWorkItem({
-    claimId,
-    contextSessionId,
-    workflowRunId,
-    agentSessionId,
-    claimedItemId,
-    claimedItemKey,
-    claimName,
-    actorId,
-    workflowId,
-    workflowSlug,
-    requiredToolKeys,
-    declaredScopeFiles,
-    allowedMutationSurfaces,
-    successCriteria,
-    acknowledgedReminders,
-    intentConfirmation,
-    actorSignature,
-    autoSignoff = true,
-    metadata,
-  } = {}) {
-    const normalizedContextSessionId = contextSessionIdFromInput({
-      contextSessionId,
-      context_session_id: contextSessionId,
-      claim: { context_session_id: contextSessionId },
-    });
-    const normalizedClaimId = cleanText(claimId);
-    const normalizedWorkflowRunId = cleanText(workflowRunId);
-    const normalizedAgentSessionId = cleanText(agentSessionId);
-    const normalizedClaimedItemId = cleanText(claimedItemId);
-    const normalizedClaimedItemKey = cleanText(claimedItemKey);
-    const normalizedClaimedItemRef = normalizedClaimedItemId || normalizedClaimedItemKey;
-    if (!normalizedContextSessionId) throw new Error('contextSessionId is required.');
-    if (!normalizedWorkflowRunId) throw new Error('workflowRunId is required.');
-    if (!normalizedAgentSessionId) throw new Error('agentSessionId is required.');
-    if (!normalizedClaimedItemRef) throw new Error('claimedItemId or claimedItemKey is required.');
-
-    const normalizedWorkflowId = cleanText(workflowId);
-    const normalizedWorkflowSlug = cleanText(workflowSlug);
-    let normalizedRequiredToolKeys = cleanList(requiredToolKeys);
-    let workflowRegistry = null;
-    if (normalizedRequiredToolKeys.length === 0 && (normalizedWorkflowId || normalizedWorkflowSlug)) {
-      workflowRegistry = await this.getWorkflowToolRegistry({
-        workflowId: normalizedWorkflowId,
-        workflowSlug: normalizedWorkflowSlug,
-      });
-      normalizedRequiredToolKeys = activeToolKeysFromRegistry(workflowRegistry);
-    }
+  // ─── Core HTTP ─────────────────────────────────────────────────────────────
 
-    const lockClaimResult = await this.lockContextSessionClaim(normalizedContextSessionId);
-    const lockedContextSession = lockClaimResult?.context_session || lockClaimResult;
-    const lockedContextSessionId = contextSessionIdFromInput(lockedContextSession) || normalizedContextSessionId;
-
-    const claimWorkItemResult = await this.claimWorkItem({
-      context_session_id: lockedContextSessionId,
-      workflow_run_id: normalizedWorkflowRunId,
-      agent_session_id: normalizedAgentSessionId,
-      claimed_item_id: normalizedClaimedItemId,
-      claimed_item_key: normalizedClaimedItemKey,
-      claim_name: claimName,
-      actor_id: actorId,
-      workflow_id: normalizedWorkflowId,
-      workflow_slug: normalizedWorkflowSlug,
-      required_tool_keys: normalizedRequiredToolKeys,
-      declared_scope_files: cleanList(declaredScopeFiles).length > 0
-        ? cleanList(declaredScopeFiles)
-        : [normalizedClaimedItemRef],
-      allowed_mutation_surfaces: cleanList(allowedMutationSurfaces).length > 0
-        ? cleanList(allowedMutationSurfaces)
-        : ['project_roadmap_task'],
-      success_criteria: successCriteria,
-      metadata,
-    });
+  async _resolveAccessToken() {
+    return resolveAccessToken(this);
+  }
 
-    let signedClaim = null;
-    const resolvedClaimId = cleanText(claimWorkItemResult?.claim_id) || normalizedClaimId;
-    if (autoSignoff && resolvedClaimId) {
-      const claimEnvelope = isPlainObject(claimWorkItemResult?.claim) ? claimWorkItemResult.claim : claimWorkItemResult;
-      const reminders = cleanList(acknowledgedReminders).length > 0
-        ? cleanList(acknowledgedReminders)
-        : reminderTokens(claimEnvelope?.required_reminders);
-      if (reminders.length > 0) {
-        signedClaim = await this.signoffClaim(resolvedClaimId, {
-          acknowledged_reminders: reminders,
-          intent_confirmation: cleanText(intentConfirmation) || 'I confirm this governed execution intent and scope.',
-          actor_signature: cleanText(actorSignature) || cleanText(actorId) || this.actorId,
-        });
-      }
-    }
+  async _buildHeaders({ headers, body, accept }) {
+    return buildHeaders(this, { headers, body, accept });
+  }
 
-    return {
-      claim_id: resolvedClaimId,
-      context_session_id: lockedContextSessionId,
-      workflow_run_id: normalizedWorkflowRunId,
-      agent_session_id: normalizedAgentSessionId,
-      required_tool_keys: normalizedRequiredToolKeys,
-      workflow_registry: workflowRegistry,
-      lock_claim_result: lockClaimResult,
-      claim_work_item_result: claimWorkItemResult,
-      signed_claim: signedClaim,
-      approved_tool_keys: cleanList(
-        signedClaim?.approved_tool_keys ||
-        signedClaim?.claim?.approved_tool_keys ||
-        claimWorkItemResult?.approved_tool_keys ||
-        claimWorkItemResult?.claim?.approved_tool_keys
-      ),
-    };
+  async _assertExecutionEligibility(body = {}) {
+    return this.executionEligibility._assertExecutionEligibility(body);
   }
 
-  async getClaim(claimId) {
-    if (!claimId) throw new Error('claimId is required.');
-    return this._request(`/api/governance/claims/${encodeURIComponent(claimId)}`);
+  async _request(path, { method = 'GET', query, headers, body } = {}) {
+    return requestJson(this, path, { method, query, headers, body });
   }
 
-  async claimIsValid(claimId) {
-    const claim = await this.getClaim(claimId);
-    return cleanText(claim?.status) === 'active';
+  async _requestText(path, { method = 'GET', query, headers, body } = {}) {
+    return requestText(this, path, { method, query, headers, body });
   }
 
-  async getExecutionEligibility(body = {}) {
-    return this._request('/api/governance/execution-eligibility', {
-      method: 'POST',
-      body: {
-        required_capabilities: GOVERNED_MUTATION_REQUIRED_CAPABILITIES,
-        verification_required: true,
-        ...body,
-      },
-    });
+  async _requestLogaProjection(path, options = {}) {
+    return requestLogaProjection(this, path, options);
   }
 
-  async signoffClaim(claimId, body = {}) {
-    if (!claimId) throw new Error('claimId is required.');
-    return this._request(`/api/governance/claims/${encodeURIComponent(claimId)}/signoff`, {
-      method: 'POST',
-      body,
-    });
+  async _requestBinary(path, { method = 'GET', query, headers, body } = {}) {
+    return requestBinary(this, path, { method, query, headers, body });
   }
+}
 
-  /**
-   * Promote a governance claim from `missing_promoted_surface` to
-   * `promoted_surface_bound` by binding required tool definitions to the
-   * workflow and recording a completed claim signoff.
-   *
-   * @param {object} params
-   * @param {string} params.claimId           - UUID of the claim to unblock.
-   * @param {string} params.workflowId        - UUID of the target workflow.
-   * @param {string} params.contextSessionId  - Oriented context session UUID.
-   * @param {string} params.actorId           - Caller identity for audit trail.
-   * @param {string[]} params.requiredToolKeys - Tool keys to bind.
-   * @param {string} [params.intentId]         - Default: 'code_mutation'.
-   * @param {string} [params.bindingScope]     - Default: 'required'.
-   * @param {string} [params.usageMode]        - Default: 'manual'.
-   * @param {string} [params.operatorScope]
-   * @param {object} [params.allowedArgumentPolicy]
-   * @returns {Promise<object>} Promotion result envelope.
-   */
-  async promoteClaimSurface({
-    claimId,
-    workflowId,
-    contextSessionId,
-    actorId,
-    requiredToolKeys,
-    intentId,
-    bindingScope,
-    usageMode,
-    operatorScope,
-    allowedArgumentPolicy,
-    ...rest
-  } = {}) {
-    if (!claimId) throw new Error('claimId is required.');
-    if (!workflowId) throw new Error('workflowId is required.');
-    if (!contextSessionId) throw new Error('contextSessionId is required.');
-    if (!actorId) throw new Error('actorId is required.');
-    if (!Array.isArray(requiredToolKeys) || requiredToolKeys.length === 0) {
-      throw new Error('requiredToolKeys must be a non-empty array.');
-    }
-    return this._request('/api/governance/claims/promote-surface', {
-      method: 'POST',
-      body: {
-        ...rest,
-        claim_id: claimId,
-        workflow_id: workflowId,
-        context_session_id: contextSessionId,
-        actor_id: actorId,
-        required_tool_keys: requiredToolKeys,
-        intent_id: intentId,
-        binding_scope: bindingScope,
-        usage_mode: usageMode,
-        operator_scope: operatorScope,
-        allowed_argument_policy: allowedArgumentPolicy,
-      },
-    });
-  }
-
-  /**
-   * Bootstrap/admin surface for creating a governed workflow-tool-binding
-   * approval lane request. This call cannot approve or execute bindings.
-   *
-   * @param {object} params
-   * @param {string} params.operatorActorType
-   * @param {string} params.requesterActor
-   * @param {string[]} params.requestedToolKeys
-   * @param {string} params.blockedReason
-   * @param {string} params.rollbackPlan
-   * @param {string} [params.requesterActorType]
-   * @param {string} [params.operatorActorId]
-   * @param {string} [params.targetWorkflowId]
-   * @param {string} [params.targetWorkflowRunId]
-   * @param {string[]} [params.relatedGapRecordIds]
-   * @param {string} [params.requestedBindingScope]
-   * @param {string} [params.riskClassification]
-   * @param {object} [params.metadata]
-   * @returns {Promise<object>}
-   */
-  async createWorkflowToolBindingApprovalLane({
-    operatorActorType,
-    requesterActor,
-    requestedToolKeys,
-    blockedReason,
-    rollbackPlan,
-    requesterActorType,
-    operatorActorId,
-    targetWorkflowId,
-    targetWorkflowRunId,
-    relatedGapRecordIds,
-    requestedBindingScope,
-    riskClassification,
-    metadata,
-    ...rest
-  } = {}) {
-    if (!operatorActorType) throw new Error('operatorActorType is required.');
-    if (!requesterActor) throw new Error('requesterActor is required.');
-    if (!Array.isArray(requestedToolKeys) || requestedToolKeys.length === 0) {
-      throw new Error('requestedToolKeys must be a non-empty array.');
-    }
-    if (!blockedReason) throw new Error('blockedReason is required.');
-    if (!rollbackPlan) throw new Error('rollbackPlan is required.');
-    return this._request('/api/governance/bootstrap/workflow-tool-binding-approval/create', {
-      method: 'POST',
-      body: {
-        ...rest,
-        operator_actor_type: operatorActorType,
-        requester_actor: requesterActor,
-        requested_tool_keys: requestedToolKeys,
-        blocked_reason: blockedReason,
-        rollback_plan: rollbackPlan,
-        requester_actor_type: requesterActorType,
-        operator_actor_id: operatorActorId,
-        target_workflow_id: targetWorkflowId,
-        target_workflow_run_id: targetWorkflowRunId,
-        related_gap_record_ids: relatedGapRecordIds,
-        requested_binding_scope: requestedBindingScope,
-        risk_classification: riskClassification,
-        metadata,
-      },
-    });
-  }
-
-  async recordWorkflowToolBindingApprovalDecision(approvalRequestId, {
-    operatorActorType,
-    decision,
-    operatorActorId,
-    decisionNotes,
-    decisionConditions,
-    ...rest
-  } = {}) {
-    if (!approvalRequestId) throw new Error('approvalRequestId is required.');
-    if (!operatorActorType) throw new Error('operatorActorType is required.');
-    if (!decision) throw new Error('decision is required.');
-    return this._request(`/api/governance/bootstrap/workflow-tool-binding-approval/${encodeURIComponent(approvalRequestId)}/approval-decision`, {
-      method: 'POST',
-      body: {
-        ...rest,
-        operator_actor_type: operatorActorType,
-        operator_actor_id: operatorActorId,
-        decision,
-        decision_notes: decisionNotes,
-        decision_conditions: decisionConditions,
-      },
-    });
-  }
-
-  async executeWorkflowToolBindingApprovalBinding(approvalRequestId, {
-    operatorActorType,
-    operatorActorId,
-    ...rest
-  } = {}) {
-    if (!approvalRequestId) throw new Error('approvalRequestId is required.');
-    if (!operatorActorType) throw new Error('operatorActorType is required.');
-    return this._request(`/api/governance/bootstrap/workflow-tool-binding-approval/${encodeURIComponent(approvalRequestId)}/binding-execution`, {
-      method: 'POST',
-      body: {
-        ...rest,
-        operator_actor_type: operatorActorType,
-        operator_actor_id: operatorActorId,
-      },
-    });
-  }
-
-  async revalidateWorkflowToolBindingStartup(approvalRequestId, {
-    operatorActorType,
-    operatorActorId,
-    ...rest
-  } = {}) {
-    if (!approvalRequestId) throw new Error('approvalRequestId is required.');
-    if (!operatorActorType) throw new Error('operatorActorType is required.');
-    return this._request(`/api/governance/bootstrap/workflow-tool-binding-approval/${encodeURIComponent(approvalRequestId)}/startup-revalidation`, {
-      method: 'POST',
-      body: {
-        ...rest,
-        operator_actor_type: operatorActorType,
-        operator_actor_id: operatorActorId,
-      },
-    });
-  }
-
-  async completeTurn(body = {}) {
-    return this._request('/api/turns/complete', { method: 'POST', body });
-  }
-
-  async evaluateTurnCompliance(sessionId) {
-    return this._request(`/api/v1/session-governance/${encodeURIComponent(sessionId)}/compliance`);
-  }
-
-  async blockIfNonCompliant(sessionId) {
-    return this._request(`/api/v1/session-governance/${encodeURIComponent(sessionId)}/block-if-non-compliant`, {
-      method: 'POST',
-    });
-  }
-
-  async runCharter(body = {}) {
-    return this._request('/api/charters/run', { method: 'POST', body });
-  }
-
-  async createProjectDelivery(body = {}) {
-    return this.projectChartering.createProjectDelivery(body);
-  }
-
-  async approveProjectCharterIntent(projectId, body = {}) {
-    return this.projectChartering.approveProjectCharterIntent(projectId, body);
-  }
-
-  async approveImplementationRoadmap(projectId, body = {}) {
-    return this.projectChartering.approveImplementationRoadmap(projectId, body);
-  }
-
-  async runProjectCharter(projectId, body = {}) {
-    return this.projectChartering.runProjectCharter(projectId, body);
-  }
-
-  async beginImplementationRoadmap(projectId, body = {}) {
-    return this.projectChartering.beginImplementationRoadmap(projectId, body);
-  }
-
-  async routeImplementationItem(implementationItemId, body = {}) {
-    return this.projectChartering.routeImplementationItem(implementationItemId, body);
-  }
-
-  async persistAssistantTurn(body) {
-    return this._request('/api/v1/assistant-turns', { method: 'POST', body });
-  }
-
-  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`);
-  }
-
-  // ─── Retrieval Wrapper ─────────────────────────────────────────────────────
-
-  async getCommandCard({ commandKey, alias, intentText, requestedBy } = {}) {
-    return this.retrievalWrapper.getCommandCard({ commandKey, alias, intentText, requestedBy });
-  }
-
-  async resolveOperatingProcedure({ procedureKey, intentText, requestedBy } = {}) {
-    return this.retrievalWrapper.resolveOperatingProcedure({ procedureKey, intentText, requestedBy });
-  }
-
-  async getSymbolDefinition({ symbolKey, qualifiedName, symbolName, projectScope, includeCode = true, maxLines = 120, requestedBy } = {}) {
-    return this.retrievalWrapper.getSymbolDefinition({ symbolKey, qualifiedName, symbolName, projectScope, includeCode, maxLines, requestedBy });
-  }
-
-  async getRelatedCode({ symbolKey, qualifiedName, relationshipType, depth = 1, includeCode = false, maxLines = 80, requestedBy } = {}) {
-    return this.retrievalWrapper.getRelatedCode({ symbolKey, qualifiedName, relationshipType, depth, includeCode, maxLines, requestedBy });
-  }
-
-  // ─── Repo Inventory ───────────────────────────────────────────────────────
-
-  async listRepositories({ limit } = {}) {
-    return this.repo.listRepositories({ limit });
-  }
-
-  async getRepository(repositoryId) {
-    return this.repo.getRepository(repositoryId);
-  }
-
-  async listProjects({ repositoryId, repoKey, limit } = {}) {
-    return this.repo.listProjects({ repositoryId, repoKey, limit });
-  }
-
-  async getProject(projectId) {
-    return this.repo.getProject(projectId);
-  }
-
-  async listCodeFiles({ repositoryId, projectId, language, pathPrefix, page = 1, pageSize = 50 } = {}) {
-    return this.repo.listCodeFiles({ repositoryId, projectId, language, pathPrefix, page, pageSize });
-  }
-
-  async getCodeFile(fileId) {
-    return this.repo.getCodeFile(fileId);
-  }
-
-  async getCodeFileContentWindow(fileId, { startLine = 1, endLine } = {}) {
-    return this.repo.getCodeFileContentWindow(fileId, { startLine, endLine });
-  }
-
-  async listCodeSymbolsByFile(fileId, { limit = 500 } = {}) {
-    return this.repo.listCodeSymbolsByFile(fileId, { limit });
-  }
-
-  async getCodeSymbol(symbolId, { includeCode = false, maxLines = 120 } = {}) {
-    return this.repo.getCodeSymbol(symbolId, { includeCode, maxLines });
-  }
-
-  async searchSymbols({ query, projectScope, maxResults = 10 } = {}) {
-    return this.repo.searchSymbols({ query, projectScope, maxResults });
-  }
-
-  async getSymbolRelationships(symbolId, { relationshipType, depth = 1 } = {}) {
-    return this.repo.getSymbolRelationships(symbolId, { relationshipType, depth });
-  }
-
-  async listCodeRelationships({ repositoryId, projectId, relationshipType, limit = 100 } = {}) {
-    return this.repo.listCodeRelationships({ repositoryId, projectId, relationshipType, limit });
-  }
-
-  async listActionObservations({ repositoryId, projectPath, filePath, symbolId, actionKind, limit = 100 } = {}) {
-    return this.repo.listActionObservations({ repositoryId, projectPath, filePath, symbolId, actionKind, limit });
-  }
-
-  async listCodebaseShapeFindings({ repositoryId, projectPath, filePath, severity, status, limit = 100 } = {}) {
-    return this.repo.listCodebaseShapeFindings({ repositoryId, projectPath, filePath, severity, status, limit });
-  }
-
-  async listObjectFlowObservations({ repositoryId, projectPath, filePath, objectKind, boundaryKind, limit = 100 } = {}) {
-    return this.repo.listObjectFlowObservations({ repositoryId, projectPath, filePath, objectKind, boundaryKind, limit });
-  }
-
-  async getChangeAnalysis({ fileId, symbolId, limit = 25 } = {}) {
-    return this.repo.getChangeAnalysis({ fileId, symbolId, limit });
-  }
-
-  async listRefactorCandidates({ repositoryRoot, limit = 10 } = {}) {
-    return this.repo.listRefactorCandidates({ repositoryRoot, limit });
-  }
-
-  async analyzeRefactorCandidate({ filePath, requestedBy, packetId, refactorIntent } = {}) {
-    return this.repo.analyzeRefactorCandidate({ filePath, requestedBy, packetId, refactorIntent });
-  }
-
-  async getRepoRetrievalPacket(retrievalPacketId) {
-    return this.repo.getRepoRetrievalPacket(retrievalPacketId);
-  }
-
-  async getRepoRetrievalPacketFragments(retrievalPacketId) {
-    return this.repo.getRepoRetrievalPacketFragments(retrievalPacketId);
-  }
-
-  async evaluateProposalScope({ filePath, projectId, changeType = 'refactor', requestedBy, refactorIntent } = {}) {
-    return this.repo.evaluateProposalScope({ filePath, projectId, changeType, requestedBy, refactorIntent });
-  }
-
-  // ─── Retrieval Management ──────────────────────────────────────────────────
-
-  async getRetrievalStatus() {
-    return this.retrievalManagement.getRetrievalStatus();
-  }
-
-  async getRetrievalProfileMetrics() {
-    return this.retrievalManagement.getRetrievalProfileMetrics();
-  }
-
-  async getRetrievalFeedbackMetrics() {
-    return this.retrievalManagement.getRetrievalFeedbackMetrics();
-  }
-
-  async getRetrievalQuery(retrievalQueryId) {
-    return this.retrievalManagement.getRetrievalQuery(retrievalQueryId);
-  }
-
-  async getRetrievalPacket(retrievalPacketId) {
-    return this.retrievalManagement.getRetrievalPacket(retrievalPacketId);
-  }
-
-  async generateRetrievalCandidates(body) {
-    return this.retrievalManagement.generateRetrievalCandidates(body);
-  }
-
-  async selectRetrievalPacket(body) {
-    return this.retrievalManagement.selectRetrievalPacket(body);
-  }
-
-  async recordRetrievalFeedback(body) {
-    return this.retrievalManagement.recordRetrievalFeedback(body);
-  }
-
-  async deriveRetrievalOptimizationCandidates(body) {
-    return this.retrievalManagement.deriveRetrievalOptimizationCandidates(body);
-  }
-
-  async validatePromptAssembly(body) {
-    return this.retrievalManagement.validatePromptAssembly(body);
-  }
-
-  // ─── Workflows ─────────────────────────────────────────────────────────────
-
-  async listWorkflows({ status, includeSteps } = {}) {
-    return this.workflows.listWorkflows({ status, includeSteps });
-  }
-
-  async createWorkflow({ name, slug, description, goal, governanceProfile, steps = [] } = {}) {
-    return this.workflows.createWorkflow({ name, slug, description, goal, governanceProfile, steps });
-  }
-
-  async getWorkflow(workflowId) {
-    return this.workflows.getWorkflow(workflowId);
-  }
-
-  async replaceWorkflowSteps(workflowId, steps) {
-    return this.workflows.replaceWorkflowSteps(workflowId, steps);
-  }
-
-  async publishWorkflow(workflowId) {
-    return this.workflows.publishWorkflow(workflowId);
-  }
-
-  async cloneWorkflow(workflowId) {
-    return this.workflows.cloneWorkflow(workflowId);
-  }
-
-  // ─── Workflow Governance ───────────────────────────────────────────────────
-
-  async evaluateWorkflowGovernance(workflowId) {
-    return this.workflows.evaluateWorkflowGovernance(workflowId);
-  }
-
-  async listWorkflowGovernanceDecisions(workflowId) {
-    return this.workflows.listWorkflowGovernanceDecisions(workflowId);
-  }
-
-  async getWorkflowGovernanceSimulation(workflowId) {
-    return this.workflows.getWorkflowGovernanceSimulation(workflowId);
-  }
-
-  async listWorkflowGovernanceBundles(workflowId) {
-    return this.workflows.listWorkflowGovernanceBundles(workflowId);
-  }
-
-  async listWorkflowGovernanceApprovals(workflowId) {
-    return this.workflows.listWorkflowGovernanceApprovals(workflowId);
-  }
-
-  async listWorkflowGovernanceEvents(workflowId) {
-    return this.workflows.listWorkflowGovernanceEvents(workflowId);
-  }
-
-  async getWorkflowGovernanceReview(workflowId) {
-    return this.workflows.getWorkflowGovernanceReview(workflowId);
-  }
-
-  async createWorkflowGovernanceReviewDecision(workflowId, body) {
-    return this.workflows.createWorkflowGovernanceReviewDecision(workflowId, body);
-  }
-
-  // ─── Workflow Runs ─────────────────────────────────────────────────────────
-
-  async createWorkflowRun(body) {
-    return this.workflows.createWorkflowRun(body);
-  }
-
-  async getWorkflowRun(workflowRunId) {
-    return this.workflows.getWorkflowRun(workflowRunId);
-  }
-
-  async listWorkflowArtifacts(workflowRunId) {
-    return this.workflows.listWorkflowArtifacts(workflowRunId);
-  }
-
-  async getWorkflowRunSubstrate(workflowRunId) {
-    return this.workflows.getWorkflowRunSubstrate(workflowRunId);
-  }
-
-  async getWorkflowPlayback(workflowRunId) {
-    return this.workflows.getWorkflowPlayback(workflowRunId);
-  }
-
-  async resumeWorkflowRun(workflowRunId, body = {}) {
-    return this.workflows.resumeWorkflowRun(workflowRunId, body);
-  }
-
-  // ─── Workflow Inspector ────────────────────────────────────────────────────
-
-  async listRecentInspectorRuns({ limit } = {}) {
-    return this.workflows.listRecentInspectorRuns({ limit });
-  }
-
-  async inspectWorkflowRun(workflowRunId) {
-    return this.workflows.inspectWorkflowRun(workflowRunId);
-  }
-
-  // ─── Manual & Approval Tasks ───────────────────────────────────────────────
-
-  async listManualTasks() {
-    return this._request('/api/manual-tasks');
-  }
-
-  async listApprovalTasks() {
-    return this._request('/api/approval-tasks');
-  }
-
-  async completeManualTask(stepRunId, body = {}) {
-    return this._request(`/api/manual-tasks/${stepRunId}/complete`, { method: 'POST', body });
-  }
-
-  async approveTask(stepRunId, body = {}) {
-    return this._request(`/api/approval-tasks/${stepRunId}/approve`, { method: 'POST', body });
-  }
-
-  // ─── Projects & Chartering ─────────────────────────────────────────────────
-
-  async createProjectCharter({
-    projectName,
-    objective,
-    businessContext,
-    successCriteria,
-    priority,
-    constraints = [],
-    inScope = [],
-    outOfScope = [],
-    assumptions = [],
-    linkedWorkflows = [],
-    linkedWorkflowSlug,
-    testingStrategy = {},
-    initialContext = {},
-    requestedBy,
-    ensureTaskSurface = true,
-    assignedTo,
-    createAcceptanceSubtasks = true,
-  } = {}) {
-    return this.projectChartering.createProjectCharter({
-      projectName,
-      objective,
-      businessContext,
-      successCriteria,
-      priority,
-      constraints,
-      inScope,
-      outOfScope,
-      assumptions,
-      linkedWorkflows,
-      linkedWorkflowSlug,
-      testingStrategy,
-      initialContext,
-      requestedBy,
-      ensureTaskSurface,
-      assignedTo,
-      createAcceptanceSubtasks,
-    });
-  }
-
-  async listProjects({ limit, includeInactive, processStatus, charterStatus } = {}) {
-    return this.projects.listProjects({ limit, includeInactive, processStatus, charterStatus });
-  }
-
-  async getProject(projectId) {
-    return this.projects.getProject(projectId);
-  }
-
-  async listProjectWorkflowRuns(projectId, { limit = 25 } = {}) {
-    return this.projects.listProjectWorkflowRuns(projectId, { limit });
-  }
-
-  async closeProject(projectId, options = {}) {
-    return this.projects.closeProject(projectId, options);
-  }
-
-  async closeActiveProject(projectId, options = {}) {
-    return this.projects.closeActiveProject(projectId, options);
-  }
-
-  async getProjectCharterReport(projectId) {
-    return this.projectReports.getProjectCharterReport(projectId);
-  }
-
-  async createProjectMarkdownDownload(projectId, { reportType, includeMarkdown = false } = {}) {
-    return this.projectReports.createProjectMarkdownDownload(projectId, { reportType, includeMarkdown });
-  }
-
-  async downloadProjectMarkdownReport(projectId, reportType) {
-    return this.projectReports.downloadProjectMarkdownReport(projectId, reportType);
-  }
-
-  async downloadProjectCharterReportMarkdown(projectId) {
-    return this.projectReports.downloadProjectCharterReportMarkdown(projectId);
-  }
-
-  async getProjectBundle(projectId) {
-    return this.projects.getProjectBundle(projectId);
-  }
-
-  async listProjectOpenTasks(projectId) {
-    return this.projects.listProjectOpenTasks(projectId);
-  }
-
-  async resumeProjectWork({
-    projectIdentifier,
-    projectId,
-    actorMode,
-    executionIntent,
-    requireClaim,
-    workflowRunLimit,
-  } = {}) {
-    return this.projectResume.resumeProjectWork({
-      projectIdentifier,
-      projectId,
-      actorMode,
-      executionIntent,
-      requireClaim,
-      workflowRunLimit,
-    });
-  }
-
-  async closeRoadmapItemWorkflow(options = {}) {
-    return this.projects.closeRoadmapItemWorkflow(options);
-  }
-
-  // LOGA projections are governed runtime documents, not static reports.
-
-  async getLogaOperatorHomeProjection() {
-    return this._requestLogaProjection('/api/operator/projections/home');
-  }
-
-  async getLogaProjectCatalogProjection() {
-    return this._requestLogaProjection('/api/operator/projections/project-catalog');
-  }
-
-  async getLogaProjectPortfolioProjection() {
-    return this._requestLogaProjection('/api/operator/projections/project-portfolio');
-  }
-
-  async getLogaProjectRoadmapProjection(projectId) {
-    return this._requestLogaProjection(`/api/operator/projections/projects/${projectId}/roadmap.md`);
-  }
-
-  async getLogaRoadmapItemProjection(projectId, itemKey) {
-    return this._requestLogaProjection(`/api/operator/projections/projects/${projectId}/roadmap/items/${itemKey}`);
-  }
-
-  async getLogaWorkflowRunProjection(workflowRunId) {
-    return this._requestLogaProjection(`/api/operator/projections/workflow-runs/${workflowRunId}`);
-  }
-
-  async getLogaEvidencePacketProjection(packetKey) {
-    return this._requestLogaProjection(`/api/operator/projections/evidence-packets/${packetKey}`);
-  }
-
-  async getLogaTransferHomeProjection() {
-    return this._requestLogaProjection('/api/operator/projections/transfers/home');
-  }
-
-  async getLogaTransferInboxProjection({ workflowRunId, recipientAgentSessionId, recipientRoleKey } = {}) {
-    return this._requestLogaProjection('/api/operator/projections/transfers/inbox', {
-      query: {
-        workflow_run_id: workflowRunId,
-        recipient_agent_session_id: recipientAgentSessionId,
-        recipient_role_key: recipientRoleKey,
-      },
-    });
-  }
-
-  async getLogaTransferPacketProjection(workTransferPacketId) {
-    return this._requestLogaProjection(`/api/operator/projections/transfers/${workTransferPacketId}`);
-  }
-
-  async getLogaTransferNegotiationEventsProjection({ workTransferPacketId, workflowRunId } = {}) {
-    const path = workTransferPacketId
-      ? `/api/operator/projections/transfers/${workTransferPacketId}/negotiation-events`
-      : '/api/operator/projections/transfers/negotiation-events';
-    return this._requestLogaProjection(path, {
-      query: { workflow_run_id: workflowRunId },
-    });
-  }
-
-  async getLogaTransferFrictionLaneProjection({ workflowRunId } = {}) {
-    return this._requestLogaProjection('/api/operator/projections/transfers/friction-lane', {
-      query: { workflow_run_id: workflowRunId },
-    });
-  }
-
-  async getLogaTransferReceiptsProjection({ workTransferPacketId, workflowRunId } = {}) {
-    return this._requestLogaProjection('/api/operator/projections/transfers/receipts', {
-      query: {
-        work_transfer_packet_id: workTransferPacketId,
-        workflow_run_id: workflowRunId,
-      },
-    });
-  }
-
-  async getLogaTransferClosureReviewProjection(workTransferPacketId) {
-    return this._requestLogaProjection(`/api/operator/projections/transfers/${workTransferPacketId}/closure-review`);
-  }
-
-  async getLogaTransferChannelThreadProjection(transferChannelId) {
-    const normalizedTransferChannelId = cleanText(transferChannelId);
-    if (!normalizedTransferChannelId) {
-      throw new Error('transferChannelId is required.');
-    }
-    return this._requestLogaProjection(`/api/operator/projections/transfers/channels/${encodeURIComponent(normalizedTransferChannelId)}`);
-  }
-
-  async getTransferChannelProjection(transferChannelId) {
-    return this.getLogaTransferChannelThreadProjection(transferChannelId);
-  }
-
-  async submitUxGateRemediation({
-    projectionType,
-    projectionId,
-    gateRunId,
-    findingIds,
-    remediationPayload,
-    sourceTruth = 'sql',
-    clientEvidence,
-    createdBy,
-  } = {}) {
-    return this._request('/api/loga/ux-gate-remediations', {
-      method: 'POST',
-      body: {
-        projectionType,
-        projectionId,
-        gateRunId,
-        findingIds,
-        remediationPayload,
-        sourceTruth,
-        clientEvidence,
-        createdBy,
-      },
-    });
-  }
-
-  async listUxGateRemediations({ projectionType, status } = {}) {
-    return this._request('/api/loga/ux-gate-remediations', {
-      query: { projectionType, status },
-    });
-  }
-
-  async getUxGateRemediation(remediationId) {
-    return this._request(`/api/loga/ux-gate-remediations/${remediationId}`);
-  }
-
-  async appendUxRemediationTicketNote(remediationId, {
-    noteKind,
-    body,
-    visibility,
-    authorActorId,
-    evidenceRefs,
-    metadata,
-  } = {}) {
-    return this._request(`/api/loga/ux-gate-remediations/${remediationId}/notes`, {
-      method: 'POST',
-      body: {
-        noteKind,
-        body,
-        visibility,
-        authorActorId,
-        evidenceRefs,
-        metadata,
-      },
-    });
-  }
-
-  async listUxRemediationTicketNotes(remediationId) {
-    return this._request(`/api/loga/ux-gate-remediations/${remediationId}/notes`);
-  }
-
-  async promoteUxGateRemediationImplementationCandidate(remediationId, { promotedBy } = {}) {
-    return this._request(`/api/loga/ux-gate-remediations/${remediationId}/implementation-candidate`, {
-      method: 'POST',
-      body: { promotedBy },
-    });
-  }
-
-  async getLogaUxGateRemediationProjection(remediationId) {
-    return this._requestLogaProjection(`/api/operator/projections/ux-gate-remediations/${remediationId}`);
-  }
-
-  async generateScript({
-    claimId,
-    contextSessionId,
-    workflowRunId,
-    intent = {},
-    renderSpec = {},
-    createdBy,
-  } = {}) {
-    return this._request('/api/scripts/generate', {
-      method: 'POST',
-      body: {
-        claimId,
-        contextSessionId,
-        workflowRunId,
-        intent,
-        renderSpec,
-        createdBy,
-      },
-    });
-  }
-
-  async renderScript(scriptId) {
-    return this._request(`/api/scripts/${scriptId}/render`);
-  }
-
-  async submitScriptArtifact(scriptId, {
-    workflowRunId,
-    output = {},
-    observations = [],
-    validation = {},
-    recordedBy,
-  } = {}) {
-    return this._request(`/api/scripts/${scriptId}/artifacts`, {
-      method: 'POST',
-      body: {
-        workflowRunId,
-        output,
-        observations,
-        validation,
-        recordedBy,
-      },
-    });
-  }
-
-  async getScriptRunEvidence({ workflowRunId, scriptId } = {}) {
-    return this._request('/api/scripts/run-evidence', {
-      query: {
-        workflowRunId,
-        scriptId,
-      },
-    });
-  }
-
-  // ─── Roadmaps ──────────────────────────────────────────────────────────────
-
-  async listProjectRoadmaps({ includeInactive } = {}) {
-    return this.roadmaps.listProjectRoadmaps({ includeInactive });
-  }
-
-  async getProjectRoadmap(projectId) {
-    return this.roadmaps.getProjectRoadmap(projectId);
-  }
-
-  async getProjectRoadmapSummary(projectId) {
-    return this.roadmaps.getProjectRoadmapSummary(projectId);
-  }
-
-  async getProjectRoadmapActiveItem(projectId) {
-    return this.roadmaps.getProjectRoadmapActiveItem(projectId);
-  }
-
-  async getProjectImplementationRoadmapReport(projectId) {
-    return this.roadmapReports.getProjectImplementationRoadmapReport(projectId);
-  }
-
-  async downloadProjectImplementationRoadmapReportMarkdown(projectId) {
-    return this.roadmapReports.downloadProjectImplementationRoadmapReportMarkdown(projectId);
-  }
-
-  async ensureProjectRoadmapTaskSurface(projectId, {
-    requestedBy,
-    assignedTo,
-    createAcceptanceSubtasks = true,
-  } = {}) {
-    return this.roadmaps.ensureProjectRoadmapTaskSurface(projectId, {
-      requestedBy,
-      assignedTo,
-      createAcceptanceSubtasks,
-    });
-  }
-
-  async importImplementationPacketAndMaterializeRoadmap(packetPayload, {
-    importedBy,
-    requestedBy,
-    createdBy,
-    workflowId,
-    bindingRole = 'active',
-    assignedTo,
-    notes,
-    createAcceptanceSubtasks = true,
-  } = {}) {
-    return this.implementationPackets.importImplementationPacketAndMaterializeRoadmap(packetPayload, {
-      importedBy,
-      requestedBy,
-      createdBy,
-      workflowId,
-      bindingRole,
-      assignedTo,
-      notes,
-      createAcceptanceSubtasks,
-    });
-  }
-
-  // ─── Implementation Tasks ──────────────────────────────────────────────────
-
-  async createImplementationTask(implementationItemId, {
-    title,
-    implementationPacketId,
-    description,
-    priority,
-    assignedTo,
-    assignedBy,
-    dueAt,
-    sortOrder,
-    notes,
-    createdBy,
-    parentTaskId,
-    claimId,
-    claimProjectId,
-    projectId,
-    claimedItemId,
-    workflowRunId,
-    agentSessionId,
-    allowedMutationSurfaces,
-    acknowledgedReminders,
-    executionIntent,
-    executionType,
-    executionPurpose,
-  } = {}) {
-    return this.implementationTasks.createImplementationTask(implementationItemId, {
-      title,
-      implementationPacketId,
-      description,
-      priority,
-      assignedTo,
-      assignedBy,
-      dueAt,
-      sortOrder,
-      notes,
-      createdBy,
-      parentTaskId,
-      claimId,
-      claimProjectId,
-      projectId,
-      claimedItemId,
-      workflowRunId,
-      agentSessionId,
-      allowedMutationSurfaces,
-      acknowledgedReminders,
-      executionIntent,
-      executionType,
-      executionPurpose,
-    });
-  }
-
-  async listImplementationTasks(implementationItemId) {
-    return this.implementationTasks.listImplementationTasks(implementationItemId);
-  }
-
-  async listImplementationSubtasks(taskId) {
-    return this.implementationTasks.listImplementationSubtasks(taskId);
-  }
-
-  async updateImplementationTask(taskId, updates) {
-    return this.implementationTasks.updateImplementationTask(taskId, updates);
-  }
-
-  async assignImplementationTask(taskId, { assignedTo, assignedBy } = {}) {
-    return this.implementationTasks.assignImplementationTask(taskId, { assignedTo, assignedBy });
-  }
-
-  async completeImplementationTask(taskId, { completedBy } = {}) {
-    return this.implementationTasks.completeImplementationTask(taskId, { completedBy });
-  }
-
-  // ─── Governed Implementation ───────────────────────────────────────────────
-
-  async importImplementationPacket(body) {
-    return this.implementationPackets.importImplementationPacket(body);
-  }
-
-  async listImplementationPackets({ status, packetType } = {}) {
-    return this.implementationPackets.listImplementationPackets({ status, packetType });
-  }
-
-  async getImplementationPacket(packetId) {
-    return this.implementationPackets.getImplementationPacket(packetId);
-  }
-
-  async getImplementationItemAcceptanceChecks(implementationItemId) {
-    return this.implementationChecks.getImplementationItemAcceptanceChecks(implementationItemId);
-  }
-
-  async getArtifactManifest(implementationItemId) {
-    return this.implementationArtifacts.getArtifactManifest(implementationItemId);
-  }
-
-  async getDecisionPacket(implementationItemId) {
-    return this.implementationArtifacts.getDecisionPacket(implementationItemId);
-  }
-
-  async updateImplementationItemStatus(implementationItemId, body) {
-    return this.implementationItems.updateImplementationItemStatus(implementationItemId, body);
-  }
-
-  async addImplementationItemEvidence(implementationItemId, body) {
-    return this.implementationEvidence.addImplementationItemEvidence(implementationItemId, body);
-  }
-
-  async addImplementationItemActivity(implementationItemId, body) {
-    return this.implementationEvidence.addImplementationItemActivity(implementationItemId, body);
-  }
-
-  async listImplementationItemActivity(implementationItemId) {
-    return this.implementationEvidence.listImplementationItemActivity(implementationItemId);
-  }
-
-  async updateAcceptanceCheckStatus(implementationItemId, acceptanceCheckId, body) {
-    return this.implementationChecks.updateAcceptanceCheckStatus(implementationItemId, acceptanceCheckId, body);
-  }
-
-  async createImplementationPacketGateDecision(packetId, body) {
-    return this.implementationGates.createImplementationPacketGateDecision(packetId, body);
-  }
-
-  async bindImplementationPacketToWorkflow(workflowId, body) {
-    return this.implementationPackets.bindImplementationPacketToWorkflow(workflowId, body);
-  }
-
-  async getWorkflowImplementationRoadmap(workflowId) {
-    return this.implementationPackets.getWorkflowImplementationRoadmap(workflowId);
-  }
-
-  async getWorkflowResumeContext(workflowId) {
-    return this.implementationPackets.getWorkflowResumeContext(workflowId);
-  }
-
-  async executeVerifiedMutation({
-    mutationName,
-    mutationFn,
-    verificationFn,
-    expectedState,
-    evidenceLabel,
-  } = {}) {
-    return executeVerifiedMutation({
-      mutationName,
-      mutationFn,
-      verificationFn,
-      expectedState,
-      evidenceLabel,
-    });
-  }
-
-  async updateImplementationItemStatusVerified(implementationItemId, status, body = {}) {
-    return this.implementationItems.updateImplementationItemStatusVerified(implementationItemId, status, body);
-  }
-
-  async updateAcceptanceCheckStatusVerified(implementationItemId, acceptanceCheckId, status, body = {}) {
-    return this.implementationChecks.updateAcceptanceCheckStatusVerified(implementationItemId, acceptanceCheckId, status, body);
-  }
-
-  async verifyImplementationItemArtifacts(implementationItemId, { requiredArtifacts = [] } = {}) {
-    return this.implementationArtifacts.verifyImplementationItemArtifacts(implementationItemId, { requiredArtifacts });
-  }
-
-  // ─── Skills ────────────────────────────────────────────────────────────────
-
-  async currentSkillRegistryStatus() {
-    return this._request('/api/operator/current-skill-registry-status');
-  }
-
-  async getSkillContract({ skillId, skillKey } = {}) {
-    return this._request('/api/skills/contract', { query: { skill_id: skillId, skill_key: skillKey } });
-  }
-
-  async getSkillGovernance({ skillId, skillKey, skillVersionId } = {}) {
-    return this._request('/api/operator/skills/governance', {
-      query: { skill_id: skillId, skill_key: skillKey, skill_version_id: skillVersionId },
-    });
-  }
-
-  async createSkillContractDraft(body) {
-    return this._request('/api/operator/skills/contracts/drafts', { method: 'POST', body });
-  }
-
-  async recordSkillPatternReview(skillVersionId, body) {
-    return this._request(`/api/operator/skills/contracts/${skillVersionId}/pattern-reviews`, {
-      method: 'POST', body,
-    });
-  }
-
-  async approveSkillContract(skillVersionId, body = {}) {
-    return this._request(`/api/operator/skills/contracts/${skillVersionId}/approve`, {
-      method: 'POST', body,
-    });
-  }
-
-  async createWorkflowSkillContract(body) {
-    return this._request('/api/skills/workflow-contracts', { method: 'POST', body });
-  }
-
-  async listWorkflowSkillBindings(workflowId, { workflowStepId } = {}) {
-    return this._request(`/api/workflows/${workflowId}/skill-bindings`, {
-      query: { workflow_step_id: workflowStepId },
-    });
-  }
-
-  async seedFrequentOperationSkills({ createdBy } = {}) {
-    return this._request('/api/operator/skills/seed-frequent-operations', {
-      method: 'POST',
-      body: { created_by: createdBy },
-    });
-  }
-
-  // ─── Skill Governance ──────────────────────────────────────────────────────
-
-  async createSkillGovernanceChange(body) {
-    return this._request('/api/operator/skill-governance/changes', { method: 'POST', body });
-  }
-
-  async listSkillGovernanceChanges({ limit, processStatus, changeStatus } = {}) {
-    return this._request('/api/operator/skill-governance/changes', {
-      query: { limit, process_status: processStatus, change_status: changeStatus },
-    });
-  }
-
-  async getSkillGovernanceChange(governanceChangeId) {
-    return this._request(`/api/operator/skill-governance/changes/${governanceChangeId}`);
-  }
-
-  // ─── Capabilities ──────────────────────────────────────────────────────────
-
-  async listCapabilities() {
-    return this._request('/api/capabilities');
-  }
-
-  async createCapability(body) {
-    return this._request('/api/capabilities', { method: 'POST', body });
-  }
-
-  async testCapability(capabilityId, body = {}) {
-    return this._request(`/api/capabilities/${capabilityId}/test`, { method: 'POST', body });
-  }
-
-  // ─── Tool Registry ─────────────────────────────────────────────────────────
-
-  async currentToolRegistryStatus() {
-    return this._request('/api/operator/current-tool-registry-status');
-  }
-
-  async getWorkflowToolRegistry({ workflowId, workflowSlug } = {}) {
-    return this._request('/api/operator/workflow-tool-registry', {
-      query: { workflow_id: workflowId, workflow_slug: workflowSlug },
-    });
-  }
-
-  async currentAssistantToolContext() {
-    return this._request('/api/operator/current-assistant-tool-context');
-  }
-
-  async getTool(toolKey) {
-    return this._request(`/api/tools/${toolKey}`);
-  }
-
-  async getToolHistory(toolKey) {
-    return this._request(`/api/tools/${toolKey}/history`);
-  }
-
-  async getToolInvocations(toolKey) {
-    return this._request(`/api/tools/${toolKey}/invocations`);
-  }
-
-  async getToolGovernance(toolKey) {
-    return this._request(`/api/tools/${toolKey}/governance`);
-  }
-
-  async getToolEventReplayBundle(toolEventSummaryId) {
-    return this._request(`/api/operator/tool-events/${toolEventSummaryId}/replay-bundle`);
-  }
-
-  async createToolReviewDecision(toolKey, body) {
-    return this._request(`/api/governance/tools/${toolKey}/review-decisions`, {
-      method: 'POST', body,
-    });
-  }
-
-  async createToolGateDecision(toolKey, body) {
-    return this._request(`/api/governance/tools/${toolKey}/gate-decisions`, {
-      method: 'POST', body,
-    });
-  }
-
-  // ─── Context Assembly ──────────────────────────────────────────────────────
-
-  async getContextAssemblyContract(workflowRunId, { stepRunId } = {}) {
-    return this._request(`/api/context-assembly/workflow-runs/${workflowRunId}/contract`, {
-      query: { step_run_id: stepRunId },
-    });
-  }
-
-  async getContextAssemblyStatus(workflowRunId, { stepRunId } = {}) {
-    return this._request(`/api/context-assembly/workflow-runs/${workflowRunId}/status`, {
-      query: { step_run_id: stepRunId },
-    });
-  }
-
-  async getOperatorContext(workflowRunId, { stepRunId } = {}) {
-    return this._request(`/api/operator/runs/${workflowRunId}/context`, {
-      query: { step_run_id: stepRunId },
-    });
-  }
-
-  async getContextFragments(workflowRunId, { stepRunId } = {}) {
-    return this._request(`/api/operator/runs/${workflowRunId}/context/fragments`, {
-      query: { step_run_id: stepRunId },
-    });
-  }
-
-  async getContextReuse(workflowRunId, { stepRunId } = {}) {
-    return this._request(`/api/operator/runs/${workflowRunId}/context/reuse`, {
-      query: { step_run_id: stepRunId },
-    });
-  }
-
-  async listPromptAssemblies(workflowRunId) {
-    return this._request(`/api/operator/workflow-runs/${workflowRunId}/prompt-assemblies`);
-  }
-
-  // ─── Performance ───────────────────────────────────────────────────────────
-
-  async getSessionPerformanceMetrics({ clientType, workflowRunId, sessionId } = {}) {
-    return this._request('/api/operator/performance/sessions', {
-      query: { client_type: clientType, workflow_run_id: workflowRunId, session_id: sessionId },
-    });
-  }
-
-  async captureBenchmarkSnapshot(body) {
-    return this._request('/api/operator/performance/benchmarks', { method: 'POST', body });
-  }
-
-  async listBenchmarks({ benchmarkScope } = {}) {
-    return this._request('/api/operator/performance/benchmarks', {
-      query: { benchmark_scope: benchmarkScope },
-    });
-  }
-
-  async getBenchmarkMetrics(benchmarkName) {
-    return this._request(`/api/operator/performance/benchmarks/${benchmarkName}/metrics`);
-  }
-
-  async getBenchmarkDelta({ baseline, current } = {}) {
-    return this._request('/api/operator/performance/delta', { query: { baseline, current } });
-  }
-
-  async getBenchmarkTrend({ metricKey, dimensionValue, limit } = {}) {
-    return this._request('/api/operator/performance/trend', {
-      query: { metric_key: metricKey, dimension_value: dimensionValue, limit },
-    });
-  }
-
-  async getPerformanceDashboard({ clientType, workflowRunId } = {}) {
-    return this._request('/api/operator/performance/dashboard', {
-      query: { client_type: clientType, workflow_run_id: workflowRunId },
-    });
-  }
-
-  // ─── Portfolio ─────────────────────────────────────────────────────────────
-
-  async getPortfolioStatus({ projectId } = {}) {
-    return this._request('/api/operator/portfolio/status', { query: { project_id: projectId } });
-  }
-
-  async getPortfolioSummary() {
-    return this._request('/api/operator/portfolio/summary');
-  }
-
-  async getPortfolioExceptions() {
-    return this._request('/api/operator/portfolio/exceptions');
-  }
-
-  async getPortfolioProject(projectId) {
-    return this._request(`/api/operator/portfolio/projects/${projectId}`);
-  }
-
-  async getPortfolioReport() {
-    return this._request('/api/operator/portfolio/report');
-  }
-
-  async getPortfolioBundle() {
-    return this._request('/api/operator/portfolio/bundle');
-  }
-
-  async getPortfolioClosureReadiness({
-    projectLimit = 25,
-    includeInactive = false,
-    includeLogaPortfolioProjection = false,
-    includeLogaRoadmapProjections = false,
-  } = {}) {
-    return this.portfolio.getPortfolioClosureReadiness({
-      projectLimit,
-      includeInactive,
-      includeLogaPortfolioProjection,
-      includeLogaRoadmapProjections,
-    });
-  }
-
-  async registerModernizationAsset(request = {}) {
-    return this.workflowComposition.registerModernizationAsset(request);
-  }
-
-  async classifyModernizationAsset(request = {}) {
-    return this.workflowComposition.classifyModernizationAsset(request);
-  }
-
-  async discoverSalvageCandidates(request = {}) {
-    return this.workflowComposition.discoverSalvageCandidates(request);
-  }
-
-  async createModernizationWorkPacket(request = {}) {
-    return this.workflowComposition.createModernizationWorkPacket(request);
-  }
-
-  async requestModernizationWrapperExecution(request = {}) {
-    return this.workflowComposition.requestModernizationWrapperExecution(request);
-  }
-
-  async getModernizationWrapperEvidence(request = {}) {
-    return this.workflowComposition.getModernizationWrapperEvidence(request);
-  }
-
-  async decideModernizationGate(request = {}) {
-    return this.workflowComposition.decideModernizationGate(request);
-  }
-  // ─── Self-Learning ─────────────────────────────────────────────────────────
-
-  async getSelfLearningPosture({ workflowRunId, limit } = {}) {
-    return this._request('/api/operator/self-learning/posture', {
-      query: { workflow_run_id: workflowRunId, limit },
-    });
-  }
-
-  async listLearningRecords({ workflowRunId, learningCategory, promotionReadiness, limit } = {}) {
-    return this._request('/api/operator/self-learning/records', {
-      query: {
-        workflow_run_id: workflowRunId,
-        learning_category: learningCategory,
-        promotion_readiness: promotionReadiness,
-        limit,
-      },
-    });
-  }
-
-  async getLearningRecord(learningRecordId) {
-    return this._request(`/api/operator/self-learning/records/${learningRecordId}`);
-  }
-
-  async listPromotionCandidates({ workflowRunId, learningCategory, promotionReadiness, limit } = {}) {
-    return this._request('/api/operator/self-learning/promotion-candidates', {
-      query: {
-        workflow_run_id: workflowRunId,
-        learning_category: learningCategory,
-        promotion_readiness: promotionReadiness,
-        limit,
-      },
-    });
-  }
-
-  async getPromotionCandidate(candidateKey) {
-    return this._request(`/api/operator/self-learning/promotion-candidates/${candidateKey}`);
-  }
-
-  async listPromotionFlows({ flowStatus, targetType, candidateKey, limit } = {}) {
-    return this._request('/api/operator/self-learning/promotion-flows', {
-      query: {
-        flow_status: flowStatus,
-        target_type: targetType,
-        candidate_key: candidateKey,
-        limit,
-      },
-    });
-  }
-
-  // ─── Self-Optimization ─────────────────────────────────────────────────────
-
-  async getSelfOptimizationDashboard() {
-    return this._request('/api/operator/self-optimization/dashboard');
-  }
-
-  async getSelfOptimizationCandidateQueue({ objectiveCategory, impactPosture, blockedByDefault, limit } = {}) {
-    return this._request('/api/operator/self-optimization/candidate-queue', {
-      query: {
-        objective_category: objectiveCategory,
-        impact_posture: impactPosture,
-        blocked_by_default: blockedByDefault,
-        limit,
-      },
-    });
-  }
-
-  async getSelfOptimizationBacklogPosture({ snapshotKey } = {}) {
-    return this._request('/api/operator/self-optimization/backlog-posture', {
-      query: { snapshot_key: snapshotKey },
-    });
-  }
-
-  async getSelfOptimizationPendingHandoffs({ downstreamLane } = {}) {
-    return this._request('/api/operator/self-optimization/pending-handoffs', {
-      query: { downstream_lane: downstreamLane },
-    });
-  }
-
-  // ─── Design Intelligence ───────────────────────────────────────────────────
-
-  async getDesignIntelligenceDashboard() {
-    return this._request('/api/design-intelligence/dashboard');
-  }
-
-  async listDesignDecisions() {
-    return this._request('/api/design-intelligence/decisions');
-  }
-
-  async getDesignDecision(decisionId) {
-    return this._request(`/api/design-intelligence/decisions/${decisionId}`);
-  }
-
-  async getDesignDecisionVariants(decisionId) {
-    return this._request(`/api/design-intelligence/decisions/${decisionId}/variants`);
-  }
-
-  async getDesignDecisionCritique(decisionId) {
-    return this._request(`/api/design-intelligence/decisions/${decisionId}/critique`);
-  }
-
-  async getDesignDecisionLineage(decisionId) {
-    return this._request(`/api/design-intelligence/decisions/${decisionId}/lineage`);
-  }
-
-  async listDesignPatterns() {
-    return this._request('/api/design-intelligence/patterns');
-  }
-
-  async getDecisionLabCanvas() {
-    return this._request('/api/design-intelligence/decision-lab/canvas');
-  }
-
-  async getDesignRecommendations() {
-    return this._request('/api/design-intelligence/recommendations');
-  }
-
-  async getDesignPromotions() {
-    return this._request('/api/design-intelligence/promotions');
-  }
-
-  async previewDesignPromotion(body) {
-    return this._request('/api/design-intelligence/promotions/preview', { method: 'POST', body });
-  }
-
-  async getDesignIntelligenceMetrics() {
-    return this._request('/api/design-intelligence/metrics');
-  }
-
-  // ─── Script Discovery ──────────────────────────────────────────────────────
-
-  async scanScripts(body = {}) {
-    return this._request('/api/script-discovery/scan', { method: 'POST', body });
-  }
-
-  async listDiscoveredScriptAssets({ limit } = {}) {
-    return this._request('/api/script-discovery/script-assets', { query: { limit } });
-  }
-
-  async listDiscoveredCapabilities({ limit } = {}) {
-    return this._request('/api/script-discovery/discovered-capabilities', { query: { limit } });
-  }
-
-  async listWorkflowCandidates({ limit } = {}) {
-    return this._request('/api/script-discovery/workflow-candidates', { query: { limit } });
-  }
-
-  async promoteWorkflowCandidate(workflowCandidateId, body = {}) {
-    return this._request(`/api/script-discovery/workflow-candidates/${workflowCandidateId}/promote`, {
-      method: 'POST', body,
-    });
-  }
-
-  // ─── Notes Lab ─────────────────────────────────────────────────────────────
-
-  async getNotesLabConfig() {
-    return this._request('/api/notes-lab/config');
-  }
-
-  async submitNote(body) {
-    return this._request('/api/notes-lab/submit', { method: 'POST', body });
-  }
-
-  async approveNoteReview(body) {
-    return this._request('/api/notes-lab/approve-review', { method: 'POST', body });
-  }
-
-  // ─── Search & Contacts ─────────────────────────────────────────────────────
-
-  async search(query) {
-    return this._request('/api/search', { query: { q: query } });
-  }
-
-  async getOrganization(entityId) {
-    return this._request(`/api/organizations/${entityId}`);
-  }
-
-  async getContact(contactId) {
-    return this._request(`/api/contacts/${contactId}`);
-  }
-
-  // ─── Benchmarks ────────────────────────────────────────────────────────────
-
-  async listRecentBenchmarkRuns({ limit } = {}) {
-    return this._request('/api/benchmarks/reasoners/runs/recent', { query: { limit } });
-  }
-
-  async getBenchmarkRun(benchmarkRunId) {
-    return this._request(`/api/benchmarks/reasoners/runs/${benchmarkRunId}`);
-  }
-
-  // ─── Commit Governance ────────────────────────────────────────────────────
-
-  async evaluateCommitGovernance({
-    claimId,
-    contextSessionId,
-    agentId,
-    intentId,
-    changedFiles,
-    declaredScopeFiles,
-    diffSummary,
-    branch,
-    headSha,
-  } = {}) {
-    return this._request('/api/commit-governance/evaluate', {
-      method: 'POST',
-      body: {
-        claim_id: claimId,
-        context_session_id: contextSessionId,
-        agent_id: agentId,
-        intent_id: intentId,
-        changed_files: changedFiles,
-        declared_scope_files: declaredScopeFiles,
-        diff_summary: diffSummary,
-        branch,
-        head_sha: headSha,
-      },
-    });
-  }
-
-  async checkGitShipReadiness({
-    claimId,
-    actorId,
-    targetBranch,
-    shipCommand,
-    packageName,
-    declaredScopeFiles,
-    stagedFiles,
-    dirtyFiles,
-    branch,
-    headSha,
-    packageJsonVersion,
-    facadeMinClientVersion,
-    packageRelease,
-    packageJsonHash,
-    sdkVersionHash,
-  } = {}) {
-    return this._request('/api/commit-governance/ship-readiness', {
-      method: 'POST',
-      body: {
-        claim_id: claimId,
-        actor_id: actorId,
-        target_branch: targetBranch,
-        ship_command: shipCommand,
-        package_name: packageName,
-        declared_scope_files: declaredScopeFiles,
-        staged_files: stagedFiles,
-        dirty_files: dirtyFiles,
-        branch,
-        head_sha: headSha,
-        package_json_version: packageJsonVersion,
-        facade_min_client_version: facadeMinClientVersion,
-        package_release: packageRelease,
-        package_json_hash: packageJsonHash,
-        sdk_version_hash: sdkVersionHash,
-      },
-    });
-  }
-
-  async getCommitGovernanceEvaluation(evaluationId) {
-    return this._request(`/api/commit-governance/evaluations/${encodeURIComponent(evaluationId)}`);
-  }
-
-  async listCommitGovernanceEvaluationsByClaim(claimId, { limit } = {}) {
-    return this._request(`/api/commit-governance/claims/${encodeURIComponent(claimId)}/evaluations`, {
-      query: { limit },
-    });
-  }
-
-  // ─── Context Session Orientation ──────────────────────────────────────────
+export function createAIEngineClient(options) {
+  return new AIEngineClient(options);
+}
 
-  async openContextSession({ agentId, runtimeSessionId, intentId, executionPurpose, notes } = {}) {
-    return this._request('/api/context-session/open', {
-      method: 'POST',
-      body: {
-        agent_id: agentId,
-        runtime_session_id: runtimeSessionId,
-        intent_id: intentId,
-        execution_purpose: executionPurpose,
-        notes,
+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,
     });
   }
+}
 
-  async getOrientationWindow(contextSessionId) {
-    return this._request(`/api/context-session/${encodeURIComponent(contextSessionId)}/window`);
-  }
-
-  async acknowledgeReminder(contextSessionId, { reminderId, agentSignature, understandingSummary } = {}) {
-    return this._request(`/api/context-session/${encodeURIComponent(contextSessionId)}/acknowledge`, {
-      method: 'POST',
-      body: {
-        reminder_id: reminderId,
-        agent_signature: agentSignature,
-        understanding_summary: understandingSummary,
+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,
     });
   }
-
-  async completeOrientation(contextSessionId) {
-    return this._request(`/api/context-session/${encodeURIComponent(contextSessionId)}/complete`, {
-      method: 'POST',
-    });
-  }
-
-  async lockContextSessionClaim(input) {
-    const contextSessionId = contextSessionIdFromInput(input);
-    if (!contextSessionId) throw new Error('contextSessionId is required.');
-    return this._request(`/api/context-session/${encodeURIComponent(contextSessionId)}/lock-claim`, {
-      method: 'POST',
-    });
-  }
-
-  async getContextSessionGateStatus(contextSessionId) {
-    return this._request(`/api/context-session/${encodeURIComponent(contextSessionId)}/gate-status`);
-  }
-
-  async conductOrientation({
-    agentId,
-    runtimeSessionId,
-    intentId,
-    executionPurpose,
-    agentSignature,
-    understandingSummary,
-    lockClaim = true,
-  } = {}) {
-    const { context_session, reminders } = await this.openContextSession({
-      agentId,
-      runtimeSessionId,
-      intentId,
-      executionPurpose,
-    });
-    const sessionId = context_session.context_session_id;
-
-    const required = (reminders || []).filter(r => r.severity === 'required');
-    let acknowledgedCount = 0;
-    for (const reminder of required) {
-      await this.acknowledgeReminder(sessionId, {
-        reminderId: reminder.reminder_id,
-        agentSignature,
-        understandingSummary,
-      });
-      acknowledgedCount++;
-    }
-
-    const completion = await this.completeOrientation(sessionId);
-
-    let claimLockResult = null;
-    if (lockClaim) {
-      claimLockResult = await this.lockContextSessionClaim(sessionId);
-    }
-
-    return {
-      context_session_id: sessionId,
-      intent_id: intentId,
-      context_session: claimLockResult?.context_session || completion.context_session,
-      gate_result: claimLockResult?.gate_result || completion.gate_result,
-      acknowledged_count: acknowledgedCount,
-      claim_locked: lockClaim && !!claimLockResult,
-    };
-  }
-
-  // ─── Core HTTP ─────────────────────────────────────────────────────────────
-
-  async _resolveAccessToken() {
-    return resolveAccessToken(this);
-  }
-
-  async _buildHeaders({ headers, body, accept }) {
-    return buildHeaders(this, { headers, body, accept });
-  }
-
-  async _assertExecutionEligibility(body = {}) {
-    const eligibility = await this.getExecutionEligibility(body);
-    if (eligibility?.execution_eligible && eligibility?.mutation_allowed) {
-      return eligibility;
-    }
-    const remediation = cleanText(eligibility?.remediation_command);
-    const verification = cleanText(eligibility?.verification_command);
-    throw buildEligibilityError(
-      [
-        `Execution eligibility gate blocked mutation${cleanText(body?.requested_mutation_surface) ? ` on ${cleanText(body.requested_mutation_surface)}` : ''}.`,
-        remediation ? `Fix: ${remediation}` : null,
-        verification ? `Then verify: ${verification}` : null,
-      ].filter(Boolean).join(' '),
-      {
-        required_gate: eligibility?.required_gate || 'execution_eligibility.required_gate',
-        execution_eligibility: eligibility ?? null,
-      },
-    );
-  }
-
-  async _request(path, { method = 'GET', query, headers, body } = {}) {
-    return requestJson(this, path, { method, query, headers, body });
-  }
-
-  async _requestText(path, { method = 'GET', query, headers, body } = {}) {
-    return requestText(this, path, { method, query, headers, body });
-  }
-
-  async _requestLogaProjection(path, options = {}) {
-    return requestLogaProjection(this, path, options);
-  }
-
-  async _requestBinary(path, { method = 'GET', query, headers, body } = {}) {
-    return requestBinary(this, path, { method, query, headers, body });
-  }
 }
 
-export function createAIEngineClient(options) {
-  return new AIEngineClient(options);
+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']);
 }
+
+installClientCompatibilityDelegates(AIEngineClient);