@bpmsoftwaresolutions/ai-engine-client 1.1.89 → 1.1.90

package/src/client.js

@@ -345,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,
@@ -2936,301 +2691,140 @@ export class AIEngineClient {
     });
   }
 
-  async currentProjectStatus({ projectId } = {}) {
-    return this._request('/api/operator/current-project-status', {
-      query: { project_id: projectId },
-    });
-  }
-
-  async createDatabaseBackup({ databaseName, outputName, noWait } = {}) {
-    return this._request('/api/operator/database/backups', {
-      method: 'POST',
-      body: {
-        database_name: databaseName,
-        output_name: outputName,
-        no_wait: noWait,
-      },
-    });
-  }
-
-  async listDatabaseBackups({ prefix, limit } = {}) {
-    return this._request('/api/operator/database/backups', {
-      query: {
-        prefix,
-        limit,
-      },
-    });
-  }
-
-  async getDatabaseBackup({ backupId } = {}) {
-    return this._request(`/api/operator/database/backups/${encodeURIComponent(backupId)}`);
-  }
-
-  async listDatabaseBackupOperations({ databaseName, operationFilter, limit } = {}) {
-    return this._request('/api/operator/database/backups/operations', {
-      query: {
-        database_name: databaseName,
-        operation_filter: operationFilter,
-        limit,
-      },
-    });
-  }
-
-  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 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 listAzureSqlBacpacBackupOperations({
-    databaseName,
-    resourceGroup,
-    serverName,
-    subscription,
-    operationFilter,
-    limit,
+  async getPortfolioClosureReadiness({
+    projectLimit = 25,
+    includeInactive = false,
+    includeLogaPortfolioProjection = false,
+    includeLogaRoadmapProjections = false,
   } = {}) {
-    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 getDashboard() {
-    return this._request('/api/dashboard');
-  }
-
-  async startSessionGovernance(request = {}) {
-    return this.sessionGovernance.startSessionGovernance(request);
-  }
-
-  async startReviewGovernance(request = {}) {
-    return this.sessionGovernance.startReviewGovernance(request);
-  }
-
-  async startWork(body = {}) {
-    return this.workStart.startWork(body);
-  }
-
-  async startClaimedWork(request = {}) {
-    return this.workStart.startClaimedWork(request);
-  }
-
-  async claimWorkItem(body = {}) {
-    return this.workStart.claimWorkItem(body);
-  }
-
-  async bindClaimedWorkItem(request = {}) {
-    return this.workStart.bindClaimedWorkItem(request);
-  }
+    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 getClaim(claimId) {
-    return this.claims.getClaim(claimId);
-  }
+    const projectReadiness = [];
+    for (const project of activeProjects) {
+      const projectId = cleanText(project.project_id) || cleanText(project.projectId);
+      if (!projectId) {
+        continue;
+      }
 
-  async claimIsValid(claimId) {
-    return this.claims.claimIsValid(claimId);
-  }
+      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);
+    }
 
-  async getExecutionEligibility(body = {}) {
-    return this.executionEligibility.getExecutionEligibility(body);
-  }
+    const closureReady = projectReadiness.length === 0 || projectReadiness.every((project) => project.closure_ready === true);
+    const blockingProject = projectReadiness.find((project) => project.closure_ready !== true);
 
-  async signoffClaim(claimId, body = {}) {
-    return this.claims.signoffClaim(claimId, body);
+    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,
+    };
   }
 
-  /**
-   * 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
+  async getPortfolioStatus({
+    projectId,
+    project_id,
   } = {}) {
-    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,
+    return this._request('/api/operator/portfolio/status', {
+      query: {
+        project_id: cleanText(project_id) || cleanText(projectId),
       },
     });
   }
 
-  /**
-   * 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(request = {}) {
-    return this.toolBindingApprovals.createWorkflowToolBindingApprovalLane(request);
-  }
-
-  async recordWorkflowToolBindingApprovalDecision(approvalRequestId, request = {}) {
-    return this.toolBindingApprovals.recordWorkflowToolBindingApprovalDecision(approvalRequestId, request);
-  }
-
-  async executeWorkflowToolBindingApprovalBinding(approvalRequestId, request = {}) {
-    return this.toolBindingApprovals.executeWorkflowToolBindingApprovalBinding(approvalRequestId, request);
-  }
-
-  async revalidateWorkflowToolBindingStartup(approvalRequestId, request = {}) {
-    return this.toolBindingApprovals.revalidateWorkflowToolBindingStartup(approvalRequestId, request);
-  }
-
-  async completeTurn(body = {}) {
-    return this.workflowTurns.completeTurn(body);
-  }
-
-  async evaluateTurnCompliance(sessionId) {
-    return this.sessionGovernance.evaluateTurnCompliance(sessionId);
-  }
-
-  async blockIfNonCompliant(sessionId) {
-    return this.sessionGovernance.blockIfNonCompliant(sessionId);
-  }
-
-  async runCharter(body = {}) {
-    return this.charters.runCharter(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.workflowTurns.persistAssistantTurn(body);
+  async getPortfolioBundle() {
+    return this._request('/api/operator/portfolio/bundle');
   }
 
   async getExternalProjectStatus(projectId) {
@@ -3284,1345 +2878,129 @@ export class AIEngineClient {
     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 });
-  }
+  // ─── Core HTTP ─────────────────────────────────────────────────────────────
 
-  async getProject(projectId) {
-    return this.repo.getProject(projectId);
+  async _resolveAccessToken() {
+    return resolveAccessToken(this);
   }
 
-  async listCodeFiles({ repositoryId, projectId, language, pathPrefix, page = 1, pageSize = 50 } = {}) {
-    return this.repo.listCodeFiles({ repositoryId, projectId, language, pathPrefix, page, pageSize });
+  async _buildHeaders({ headers, body, accept }) {
+    return buildHeaders(this, { headers, body, accept });
   }
 
-  async getCodeFile(fileId) {
-    return this.repo.getCodeFile(fileId);
+  async _assertExecutionEligibility(body = {}) {
+    return this.executionEligibility._assertExecutionEligibility(body);
   }
 
-  async getCodeFileContentWindow(fileId, { startLine = 1, endLine } = {}) {
-    return this.repo.getCodeFileContentWindow(fileId, { startLine, endLine });
+  async _request(path, { method = 'GET', query, headers, body } = {}) {
+    return requestJson(this, path, { method, query, headers, body });
   }
 
-  async listCodeSymbolsByFile(fileId, { limit = 500 } = {}) {
-    return this.repo.listCodeSymbolsByFile(fileId, { limit });
+  async _requestText(path, { method = 'GET', query, headers, body } = {}) {
+    return requestText(this, path, { method, query, headers, body });
   }
 
-  async getCodeSymbol(symbolId, { includeCode = false, maxLines = 120 } = {}) {
-    return this.repo.getCodeSymbol(symbolId, { includeCode, maxLines });
+  async _requestLogaProjection(path, options = {}) {
+    return requestLogaProjection(this, path, options);
   }
 
-  async searchSymbols({ query, projectScope, maxResults = 10 } = {}) {
-    return this.repo.searchSymbols({ query, projectScope, maxResults });
+  async _requestBinary(path, { method = 'GET', query, headers, body } = {}) {
+    return requestBinary(this, path, { method, query, headers, body });
   }
+}
 
-  async getSymbolRelationships(symbolId, { relationshipType, depth = 1 } = {}) {
-    return this.repo.getSymbolRelationships(symbolId, { relationshipType, depth });
-  }
+export function createAIEngineClient(options) {
+  return new AIEngineClient(options);
+}
 
-  async listCodeRelationships({ repositoryId, projectId, relationshipType, limit = 100 } = {}) {
-    return this.repo.listCodeRelationships({ repositoryId, projectId, relationshipType, limit });
+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 listActionObservations({ repositoryId, projectPath, filePath, symbolId, actionKind, limit = 100 } = {}) {
-    return this.repo.listActionObservations({ repositoryId, projectPath, filePath, symbolId, actionKind, limit });
+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 listCodebaseShapeFindings({ repositoryId, projectPath, filePath, severity, status, limit = 100 } = {}) {
-    return this.repo.listCodebaseShapeFindings({ repositoryId, projectPath, filePath, severity, status, limit });
-  }
+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']);
+}
 
-  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 this.verifiedMutations.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(request = {}) {
-    return this.commitGovernance.evaluateCommitGovernance(request);
-  }
-
-  async checkGitShipReadiness(request = {}) {
-    return this.commitGovernance.checkGitShipReadiness(request);
-  }
-
-  async getCommitGovernanceEvaluation(evaluationId) {
-    return this.commitGovernance.getCommitGovernanceEvaluation(evaluationId);
-  }
-
-  async listCommitGovernanceEvaluationsByClaim(claimId, { limit } = {}) {
-    return this.commitGovernance.listCommitGovernanceEvaluationsByClaim(claimId, { limit });
-  }
-
-  // ─── Context Session Orientation ──────────────────────────────────────────
-
-  async openContextSession(request = {}) {
-    return this.contextSessions.openContextSession(request);
-  }
-
-  async getOrientationWindow(contextSessionId) {
-    return this.contextSessions.getOrientationWindow(contextSessionId);
-  }
-
-  async acknowledgeReminder(contextSessionId, request = {}) {
-    return this.contextSessions.acknowledgeReminder(contextSessionId, request);
-  }
-
-  async completeOrientation(contextSessionId) {
-    return this.contextSessions.completeOrientation(contextSessionId);
-  }
-
-  async lockContextSessionClaim(input) {
-    return this.contextSessions.lockContextSessionClaim(input);
-  }
-
-  async getContextSessionGateStatus(contextSessionId) {
-    return this.contextSessions.getContextSessionGateStatus(contextSessionId);
-  }
-
-  async conductOrientation(request = {}) {
-    return this.contextOrientation.conductOrientation(request);
-  }
-
-  // ─── Core HTTP ─────────────────────────────────────────────────────────────
-
-  async _resolveAccessToken() {
-    return resolveAccessToken(this);
-  }
-
-  async _buildHeaders({ headers, body, accept }) {
-    return buildHeaders(this, { headers, body, accept });
-  }
-
-  async _assertExecutionEligibility(body = {}) {
-    return this.executionEligibility._assertExecutionEligibility(body);
-  }
-
-  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);
-}
+installClientCompatibilityDelegates(AIEngineClient);