@bpmsoftwaresolutions/ai-engine-client 1.1.87 → 1.1.88

package/src/client.js

@@ -16,10 +16,14 @@ import { createHealthDomain } from './domains/health.js';
 import { createLogaDomain } from './domains/loga.js';
 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 { createProjectionsDomain } from './domains/projections.js';
 import { createReportsDomain } from './domains/reports.js';
+import { createRoadmapReportsDomain } from './domains/roadmap-reports.js';
 import { createPerformanceDomain } from './domains/performance.js';
 import { createImplementationArtifactsDomain } from './domains/implementation-artifacts.js';
+import { createImplementationChecksDomain } from './domains/implementation-checks.js';
 import { createImplementationEvidenceDomain } from './domains/implementation-evidence.js';
 import { createImplementationGatesDomain } from './domains/implementation-gates.js';
 import { createImplementationPacketsDomain } from './domains/implementation-packets.js';
@@ -51,6 +55,8 @@ 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', {
@@ -219,37 +225,6 @@ function compareSemanticVersions(left, right) {
   return 0;
 }
 
-function looksLikeUuid(value) {
-  const text = cleanText(value);
-  return Boolean(text && /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(text));
-}
-
-function countRoadmapProjectionLines(markdown) {
-  const lines = [];
-  let inSummary = false;
-  for (const line of String(markdown || '').split(/\r?\n/)) {
-    if (line.startsWith('## Roadmap Summary')) {
-      inSummary = true;
-      continue;
-    }
-    if (inSummary && line.startsWith('## ')) {
-      break;
-    }
-    if (inSummary && line.startsWith('- ')) {
-      lines.push(line);
-    }
-  }
-  const wanted = [
-    'Total Items',
-    'Total Tasks',
-    'Total Subtasks',
-    'Total Acceptance Checks',
-    'Open Acceptance Checks',
-    'Completion Percentage',
-  ];
-  return lines.filter((line) => wanted.some((label) => line.startsWith(`- ${label}:`)));
-}
-
 function cleanList(value) {
   if (!Array.isArray(value)) return [];
   return value.map((item) => cleanText(item)).filter(Boolean);
@@ -259,35 +234,6 @@ function isPlainObject(value) {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 
-function normalizeTaskBindingPolicy(taskBinding, { expectedAction = null } = {}) {
-  if (!isPlainObject(taskBinding)) return taskBinding;
-  const taskId = cleanText(taskBinding.task_id || taskBinding.implementation_item_task_id);
-  const roadmapItemId = cleanText(taskBinding.roadmap_item_id || taskBinding.implementation_item_id);
-  const taskStatus = cleanText(taskBinding.task_status || taskBinding.status);
-  const allowedActions = cleanList(taskBinding.allowed_actions);
-  const substrateAction = cleanText(taskBinding.substrate_action) || cleanText(expectedAction);
-  return {
-    ...taskBinding,
-    ...(taskId ? { task_id: taskId } : {}),
-    ...(roadmapItemId ? { roadmap_item_id: roadmapItemId, implementation_item_id: roadmapItemId } : {}),
-    ...(taskStatus ? { task_status: taskStatus } : {}),
-    ...(allowedActions.length > 0 ? { allowed_actions: allowedActions } : {}),
-    ...(substrateAction ? { substrate_action: substrateAction } : {}),
-    policy_key: cleanText(taskBinding.policy_key) || 'task_bound_substrate_execution',
-    policy_version: cleanText(taskBinding.policy_version) || 'v1',
-    policy_identifier: cleanText(taskBinding.policy_identifier) || TASK_BOUND_SUBSTRATE_EXECUTION_POLICY,
-  };
-}
-
-function normalizeMetadataTaskBinding(metadata, { expectedAction = null } = {}) {
-  if (!isPlainObject(metadata)) return metadata;
-  if (!isPlainObject(metadata.task_binding)) return metadata;
-  return {
-    ...metadata,
-    task_binding: normalizeTaskBindingPolicy(metadata.task_binding, { expectedAction }),
-  };
-}
-
 function isActiveBinding(binding) {
   return isPlainObject(binding) && (
     binding.is_active === true ||
@@ -333,28 +279,6 @@ function contextSessionIdFromInput(input) {
   return cleanText(input);
 }
 
-function matchesExpectedState(actual, expected) {
-  if (typeof expected === 'function') {
-    throw new Error('matchesExpectedState does not support function expectations.');
-  }
-  if (Array.isArray(expected)) {
-    if (!Array.isArray(actual) || actual.length < expected.length) return false;
-    return expected.every((item, index) => matchesExpectedState(actual[index], item));
-  }
-  if (isPlainObject(expected)) {
-    if (!isPlainObject(actual)) return false;
-    return Object.entries(expected).every(([key, value]) => matchesExpectedState(actual[key], value));
-  }
-  return Object.is(actual, expected);
-}
-
-function buildVerificationError(message, details = {}) {
-  const error = new Error(message);
-  error.code = 'POST_CONDITION_VERIFICATION_FAILED';
-  error.details = details;
-  return error;
-}
-
 function buildEligibilityError(message, details = {}) {
   const error = new Error(message);
   error.code = 'EXECUTION_ELIGIBILITY_FAILED';
@@ -388,10 +312,14 @@ export class AIEngineClient {
     this.database = createDatabaseDomain(this);
     this.projects = createProjectsDomain(this);
     this.projectChartering = createProjectCharteringDomain(this);
+    this.projectReports = createProjectReportsDomain(this);
+    this.projectResume = createProjectResumeDomain(this);
     this.roadmaps = createRoadmapsDomain(this);
+    this.roadmapReports = createRoadmapReportsDomain(this);
     this.implementationPackets = createImplementationPacketsDomain(this);
     this.implementationItems = createImplementationItemsDomain(this);
     this.implementationArtifacts = createImplementationArtifactsDomain(this);
+    this.implementationChecks = createImplementationChecksDomain(this);
     this.implementationEvidence = createImplementationEvidenceDomain(this);
     this.implementationGates = createImplementationGatesDomain(this);
     this.implementationTasks = createImplementationTasksDomain(this);
@@ -3624,19 +3552,7 @@ export class AIEngineClient {
   }
 
   async routeImplementationItem(implementationItemId, body = {}) {
-    if (!implementationItemId) throw new Error('implementationItemId is required.');
-    const normalizedBody = isPlainObject(body)
-      ? {
-          ...body,
-          ...(isPlainObject(body.task_binding)
-            ? { task_binding: normalizeTaskBindingPolicy(body.task_binding) }
-            : {}),
-        }
-      : body;
-    return this._request(`/api/governed-implementation/items/${encodeURIComponent(implementationItemId)}/routing`, {
-      method: 'PATCH',
-      body: normalizedBody,
-    });
+    return this.projectChartering.routeImplementationItem(implementationItemId, body);
   }
 
   async persistAssistantTurn(body) {
@@ -4008,93 +3924,38 @@ export class AIEngineClient {
     return this.projects.listProjectWorkflowRuns(projectId, { limit });
   }
 
-  async closeProject(projectId, {
-    workflowId,
-    workflowRunIds,
-    reason,
-    operatorIdentity,
-    runTerminalStatus = 'failed',
-  } = {}) {
-    const normalizedProjectId = cleanText(projectId);
-    if (!normalizedProjectId) {
-      throw new Error('projectId is required.');
-    }
-    const normalizedReason = cleanText(reason) || 'close active project';
-    const normalizedOperatorIdentity = cleanText(operatorIdentity) || this.actorId;
-    const resolvedRuns = Array.isArray(workflowRunIds) ? cleanList(workflowRunIds) : [];
-    let resolvedWorkflowId = cleanText(workflowId);
-
-    if (!resolvedWorkflowId || resolvedRuns.length === 0) {
-      const projectPayload = await this.getProject(normalizedProjectId);
-      const summary = isPlainObject(projectPayload?.summary) ? projectPayload.summary : {};
-      if (!resolvedWorkflowId) {
-        resolvedWorkflowId = cleanText(summary.workflow_id) || cleanText(summary.workflowId);
-      }
-      if (resolvedRuns.length === 0) {
-        const workflowRuns = await this.listProjectWorkflowRuns(normalizedProjectId, { limit: 100 });
-        const activeStatuses = new Set(['queued', 'running', 'blocked', 'open', 'active', 'ping-review']);
-        const activeRuns = Array.isArray(workflowRuns)
-          ? workflowRuns.filter((run) => activeStatuses.has(String(run?.status || '').trim().toLowerCase()))
-          : [];
-        for (const run of activeRuns) {
-          const runId = cleanText(run.workflow_run_id || run.workflowRunId);
-          if (runId && !resolvedRuns.includes(runId)) {
-            resolvedRuns.push(runId);
-          }
-          if (!resolvedWorkflowId) {
-            resolvedWorkflowId = cleanText(run.workflow_id || run.workflowId) || resolvedWorkflowId;
-          }
-        }
-      }
-    }
-
-    if (resolvedRuns.length > 0 && !resolvedWorkflowId) {
-      throw new Error('workflowId could not be resolved for project cleanup.');
-    }
-
-    const cleanupPayload = {
-      project_id: normalizedProjectId,
-      reason: normalizedReason,
-      operator_identity: normalizedOperatorIdentity,
-      run_terminal_status: cleanText(runTerminalStatus) || 'failed',
-    };
-    if (resolvedWorkflowId) {
-      cleanupPayload.workflow_id = resolvedWorkflowId;
-    }
-    if (resolvedRuns.length > 0) {
-      cleanupPayload.workflow_run_ids = resolvedRuns;
-    }
-
-    return this._request('/api/operator/cleanup', {
-      method: 'POST',
-      body: cleanupPayload,
-    });
+  async closeProject(projectId, options = {}) {
+    return this.projects.closeProject(projectId, options);
   }
 
   async closeActiveProject(projectId, options = {}) {
-    return this.closeProject(projectId, options);
+    return this.projects.closeActiveProject(projectId, options);
   }
 
   async getProjectCharterReport(projectId) {
-    return this.projects.getProjectCharterReport(projectId);
+    return this.projectReports.getProjectCharterReport(projectId);
   }
 
   async createProjectMarkdownDownload(projectId, { reportType, includeMarkdown = false } = {}) {
-    return this.projects.createProjectMarkdownDownload(projectId, { reportType, includeMarkdown });
+    return this.projectReports.createProjectMarkdownDownload(projectId, { reportType, includeMarkdown });
   }
 
   async downloadProjectMarkdownReport(projectId, reportType) {
-    return this.projects.downloadProjectMarkdownReport(projectId, reportType);
+    return this.projectReports.downloadProjectMarkdownReport(projectId, reportType);
   }
 
   async downloadProjectCharterReportMarkdown(projectId) {
-    return this.projects.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,
@@ -4103,7 +3964,7 @@ export class AIEngineClient {
     requireClaim,
     workflowRunLimit,
   } = {}) {
-    return this.projects.resumeProjectWork({
+    return this.projectResume.resumeProjectWork({
       projectIdentifier,
       projectId,
       actorMode,
@@ -4113,283 +3974,8 @@ export class AIEngineClient {
     });
   }
 
-  async closeRoadmapItemWorkflow({
-    projectIdentifier,
-    projectId,
-    claimId,
-    claimName,
-    actorId,
-    actorMode = 'operator',
-    executionIntent = 'close roadmap item workflow',
-    workflowRunLimit = 5,
-    declaredScopeFiles,
-    allowedMutationSurfaces,
-    requiredArtifacts,
-    requiredAcceptanceCheckStatus = 'verified',
-    terminalItemStatus = 'accepted',
-    gateType = 'roadmap_closure',
-    gateDecision = 'pass',
-    gateRationale,
-    gateEvidenceRefs,
-    remediationActions = [],
-    closureEvidenceType = 'roadmap_closure',
-    closureEvidenceRef,
-    closureEvidenceTitle,
-    closeProjectIfNoRemainingOpenItems = true,
-    closeProjectReason,
-  } = {}) {
-    const normalizedProjectReference = cleanText(projectIdentifier) || cleanText(projectId);
-    if (!normalizedProjectReference) {
-      throw new Error('projectIdentifier is required.');
-    }
-
-    const normalizedActorId = cleanText(actorId) || this.actorId;
-    const continuation = await this.resumeProjectWork({
-      projectIdentifier: normalizedProjectReference,
-      projectId: normalizedProjectReference,
-      actorMode,
-      executionIntent,
-      requireClaim: false,
-      workflowRunLimit,
-    });
-
-    const projectSummary = isPlainObject(continuation?.project) ? continuation.project : {};
-    const resolvedProjectId = cleanText(projectSummary.project_id) || cleanText(projectSummary.projectId) || normalizedProjectReference;
-    const resolvedWorkflowId = cleanText(projectSummary.workflow_id) || cleanText(projectSummary.workflowId);
-    const resolvedWorkflowRunId = cleanText(projectSummary.workflow_run_id) || cleanText(projectSummary.workflowRunId) || null;
-    const activeItem = await this.getProjectRoadmapActiveItem(resolvedProjectId);
-    const normalizedActiveItem = isPlainObject(activeItem) ? activeItem : {};
-    const implementationItemId = cleanText(normalizedActiveItem.implementation_item_id) || cleanText(normalizedActiveItem.implementationItemId);
-    const itemKey = cleanText(normalizedActiveItem.item_key) || cleanText(normalizedActiveItem.itemKey) || implementationItemId;
-    const itemStatus = cleanText(normalizedActiveItem.item_status) || cleanText(normalizedActiveItem.status);
-    const packetId = cleanText(normalizedActiveItem.implementation_packet_id) || cleanText(normalizedActiveItem.implementationPacketId);
-
-    if (!implementationItemId || !resolvedWorkflowId || !packetId) {
-      throw new Error('project closure state is ambiguous.');
-    }
-
-    let effectiveClaimId = cleanText(claimId);
-    let claimSource = 'provided';
-    if (effectiveClaimId) {
-      const claimStillValid = await this.claimIsValid(effectiveClaimId).catch(() => false);
-      if (!claimStillValid) {
-        effectiveClaimId = null;
-        claimSource = 'fresh';
-      }
-    } else {
-      claimSource = 'fresh';
-    }
-
-    let freshClaim = null;
-    if (!effectiveClaimId) {
-      const declaredScope = cleanList(declaredScopeFiles);
-      const surfaces = cleanList(allowedMutationSurfaces);
-      const fallbackDeclaredScope = declaredScope.length > 0 ? declaredScope : [
-        `${resolvedProjectId}`,
-        itemKey || implementationItemId,
-      ].filter(Boolean);
-      const fallbackSurfaces = surfaces.length > 0 ? surfaces : [
-        'project_roadmap_task',
-        'implementation_acceptance_check',
-        'implementation_evidence',
-        'implementation_gate',
-        'project_close',
-      ];
-      const closureTaskStatus = itemStatus && !new Set(['done', 'completed', 'complete', 'blocked', 'failed', 'rejected', 'cancelled']).has(itemStatus.toLowerCase())
-        ? itemStatus
-        : 'in_progress';
-      const closureTaskBinding = {
-        task_id: implementationItemId || itemKey || resolvedProjectId,
-        roadmap_item_id: implementationItemId || itemKey || resolvedProjectId,
-        task_status: closureTaskStatus,
-        allowed_actions: ['claim_work_item'],
-        substrate_action: 'claim_work_item',
-        task_type: 'roadmap_closure',
-      };
-      try {
-        freshClaim = await this.startClaimedWork({
-          claimName: cleanText(claimName) || `closeRoadmapItemWorkflow:${resolvedProjectId}:${itemKey || implementationItemId}`,
-          actorId: normalizedActorId,
-          intentId: 'code_mutation',
-          declaredScopeFiles: fallbackDeclaredScope,
-          allowedMutationSurfaces: fallbackSurfaces,
-          runtimeSessionId: resolvedWorkflowRunId || resolvedProjectId,
-          executionPurpose: cleanText(executionIntent) || `Close roadmap item ${itemKey || implementationItemId}`,
-          successCriteria: 'Active roadmap item closed with verified acceptance checks, artifacts, gate decision, and claim signoff.',
-          mutationAllowed: true,
-          metadata: {
-            source: 'closeRoadmapItemWorkflow',
-            project_id: resolvedProjectId,
-            workflow_id: resolvedWorkflowId,
-            workflow_run_id: resolvedWorkflowRunId,
-            task_binding: closureTaskBinding,
-          },
-        });
-      } catch (error) {
-        throw new Error(`claim cannot be established: ${error.message}`);
-      }
-      effectiveClaimId = cleanText(freshClaim?.claim_id) || cleanText(freshClaim?.claim?.claim_id);
-      if (!effectiveClaimId) {
-        throw new Error('claim cannot be established.');
-      }
-    }
-
-    const acceptanceCheckResult = await this.getImplementationItemAcceptanceChecks(implementationItemId);
-    const acceptanceChecks = Array.isArray(acceptanceCheckResult?.acceptance_checks)
-      ? acceptanceCheckResult.acceptance_checks.filter((check) => isPlainObject(check))
-      : [];
-    if (acceptanceChecks.length === 0) {
-      throw new Error('acceptance checks are incomplete.');
-    }
-
-    const normalizedAcceptanceStatus = cleanText(requiredAcceptanceCheckStatus) || 'verified';
-    const verifiedAcceptanceChecks = [];
-    for (const check of acceptanceChecks) {
-      const acceptanceCheckId = cleanText(check.acceptance_check_id) || cleanText(check.acceptanceCheckId);
-      if (!acceptanceCheckId) {
-        throw new Error('acceptance checks are incomplete.');
-      }
-      const status = cleanText(check.status).toLowerCase();
-      if (status !== normalizedAcceptanceStatus.toLowerCase()) {
-        try {
-          const verification = await this.updateAcceptanceCheckStatusVerified(
-            implementationItemId,
-            acceptanceCheckId,
-            normalizedAcceptanceStatus,
-            {
-              updated_by: normalizedActorId,
-              workflowId: resolvedWorkflowId,
-              claim_id: effectiveClaimId,
-              status_reason: 'Roadmap closure workflow verified the required acceptance check.',
-            },
-          );
-          verifiedAcceptanceChecks.push({
-            acceptance_check_id: acceptanceCheckId,
-            status: normalizedAcceptanceStatus,
-            verification,
-          });
-        } catch (error) {
-          throw new Error(`acceptance checks are incomplete: ${error.message}`);
-        }
-        continue;
-      }
-      verifiedAcceptanceChecks.push({
-        acceptance_check_id: acceptanceCheckId,
-        status,
-        existing: true,
-      });
-    }
-
-    const artifacts = await this.verifyImplementationItemArtifacts(implementationItemId, {
-      requiredArtifacts: cleanList(requiredArtifacts).length > 0
-        ? cleanList(requiredArtifacts)
-        : ['artifact_manifest', 'decision_packet'],
-    });
-
-    const evidenceRefs = cleanList(gateEvidenceRefs);
-    if (evidenceRefs.length === 0) {
-      evidenceRefs.push(closureEvidenceRef || `roadmap-closure:${resolvedProjectId}:${itemKey || implementationItemId}`);
-    }
-
-    const gateDecisionResult = await this.createImplementationPacketGateDecision(packetId, {
-      gate_type: cleanText(gateType) || 'roadmap_closure',
-      decision: cleanText(gateDecision) || 'pass',
-      rationale: cleanText(gateRationale) || `Roadmap item ${itemKey || implementationItemId} satisfied all closure checks.`,
-      evidence_refs: evidenceRefs,
-      remediation_actions: cleanList(remediationActions),
-      decided_by: normalizedActorId,
-      claim_id: effectiveClaimId,
-      workflow_id: resolvedWorkflowId,
-      workflow_run_id: resolvedWorkflowRunId,
-    });
-
-    const itemStatusResult = await this.updateImplementationItemStatusVerified(
-      implementationItemId,
-      cleanText(terminalItemStatus) || 'accepted',
-      {
-        workflowId: resolvedWorkflowId,
-        updated_by: normalizedActorId,
-        claim_id: effectiveClaimId,
-        status_reason: cleanText(closeProjectReason) || `Roadmap closure workflow advanced ${itemKey || implementationItemId} to terminal status.`,
-      },
-    );
-
-    const closureEvidenceRefValue = cleanText(closureEvidenceRef) || `roadmap-closure:${resolvedProjectId}:${itemKey || implementationItemId}`;
-    const closureEvidence = await this.addImplementationItemEvidence(implementationItemId, {
-      evidence_type: cleanText(closureEvidenceType) || 'roadmap_closure',
-      evidence_ref: closureEvidenceRefValue,
-      title: cleanText(closureEvidenceTitle) || `Closure evidence for ${itemKey || implementationItemId}`,
-      recorded_by: normalizedActorId,
-      metadata: {
-        project_id: resolvedProjectId,
-        workflow_id: resolvedWorkflowId,
-        workflow_run_id: resolvedWorkflowRunId,
-        claim_id: effectiveClaimId,
-        gate_decision_id: cleanText(gateDecisionResult?.implementation_gate_decision_id) || cleanText(gateDecisionResult?.gate_decision_id),
-        gate_type: cleanText(gateType) || 'roadmap_closure',
-      },
-    });
-
-    const signedClaim = await this.signoffClaim(effectiveClaimId, {
-      actor_signature: normalizedActorId,
-      intent_confirmation: cleanText(executionIntent) || 'I confirm this governed roadmap closure workflow.',
-    });
-
-    const reloadedActiveItem = await this.getProjectRoadmapActiveItem(resolvedProjectId);
-    const remainingOpenTasksPayload = await this.listProjectOpenTasks(resolvedProjectId);
-    const remainingOpenTasks = Array.isArray(remainingOpenTasksPayload?.tasks)
-      ? remainingOpenTasksPayload.tasks.filter((task) => isPlainObject(task))
-      : Array.isArray(remainingOpenTasksPayload)
-        ? remainingOpenTasksPayload.filter((task) => isPlainObject(task))
-        : [];
-    const reloadedItemStatus = cleanText(reloadedActiveItem?.item_status) || cleanText(reloadedActiveItem?.status) || null;
-    const terminalStatuses = new Set([
-      cleanText(terminalItemStatus) || 'accepted',
-      'accepted',
-      'verified',
-      'done',
-      'completed',
-      'closed',
-    ].map((value) => String(value || '').toLowerCase()));
-    const activeItemClosed = !reloadedActiveItem || terminalStatuses.has(String(reloadedItemStatus || '').toLowerCase());
-    if (!activeItemClosed) {
-      throw new Error('project closure state is ambiguous.');
-    }
-
-    let closeProjectResult = null;
-    if (closeProjectIfNoRemainingOpenItems && remainingOpenTasks.length === 0) {
-      closeProjectResult = await this.closeActiveProject(resolvedProjectId, {
-        workflowId: resolvedWorkflowId,
-        workflowRunIds: resolvedWorkflowRunId ? [resolvedWorkflowRunId] : undefined,
-        reason: cleanText(closeProjectReason) || `Roadmap item ${itemKey || implementationItemId} closed.`,
-        operatorIdentity: normalizedActorId,
-        runTerminalStatus: cleanText(terminalItemStatus) || 'accepted',
-      });
-    }
-
-    return {
-      status: closeProjectResult ? 'closed' : 'item_closed',
-      project_id: resolvedProjectId,
-      workflow_id: resolvedWorkflowId,
-      workflow_run_id: resolvedWorkflowRunId,
-      claim_id: effectiveClaimId,
-      claim_source: claimSource,
-      continuation_brief: continuation,
-      project: projectSummary,
-      active_item_before: normalizedActiveItem,
-      active_item_after: reloadedActiveItem,
-      acceptance_checks: {
-        loaded: acceptanceChecks,
-        verified: verifiedAcceptanceChecks,
-      },
-      artifact_verification: artifacts,
-      gate_decision: gateDecisionResult,
-      implementation_item_status: itemStatusResult,
-      closure_evidence: closureEvidence,
-      claim_signoff: signedClaim,
-      remaining_open_task_count: remainingOpenTasks.length,
-      close_project: closeProjectResult,
-    };
+  async closeRoadmapItemWorkflow(options = {}) {
+    return this.projects.closeRoadmapItemWorkflow(options);
   }
 
   // LOGA projections are governed runtime documents, not static reports.
@@ -4623,11 +4209,11 @@ export class AIEngineClient {
   }
 
   async getProjectImplementationRoadmapReport(projectId) {
-    return this.roadmaps.getProjectImplementationRoadmapReport(projectId);
+    return this.roadmapReports.getProjectImplementationRoadmapReport(projectId);
   }
 
   async downloadProjectImplementationRoadmapReportMarkdown(projectId) {
-    return this.roadmaps.downloadProjectImplementationRoadmapReportMarkdown(projectId);
+    return this.roadmapReports.downloadProjectImplementationRoadmapReportMarkdown(projectId);
   }
 
   async ensureProjectRoadmapTaskSurface(projectId, {
@@ -4652,148 +4238,16 @@ export class AIEngineClient {
     notes,
     createAcceptanceSubtasks = true,
   } = {}) {
-    if (!isPlainObject(packetPayload)) {
-      throw new Error('packetPayload must be a JSON object.');
-    }
-
-    const normalizedImportedBy = cleanText(importedBy) || cleanText(requestedBy) || this.actorId;
-    const normalizedRequestedBy = cleanText(requestedBy) || normalizedImportedBy;
-    const normalizedCreatedBy = cleanText(createdBy) || normalizedRequestedBy;
-
-    const importedPacket = await this.importImplementationPacket({
-      ...packetPayload,
-      imported_by: normalizedImportedBy,
-    });
-    const packetId = cleanText(importedPacket?.packet_id || importedPacket?.packetId || importedPacket?.implementation_packet_key || importedPacket?.implementationPacketKey || packetPayload.packetId || packetPayload.packet_id);
-    const implementationPacketId = cleanText(importedPacket?.implementation_packet_id || importedPacket?.implementationPacketId);
-    if (!implementationPacketId) {
-      throw new Error('Imported implementation packet response must include implementation_packet_id.');
-    }
-    if (!looksLikeUuid(implementationPacketId)) {
-      throw new Error('Imported implementation packet response returned a non-UUID implementation_packet_id.');
-    }
-    const projectReference = this._resolveImplementationPacketProjectReference(packetPayload);
-    if (!projectReference) {
-      throw new Error('Could not resolve a project reference from the packet payload.');
-    }
-    const projectPayload = await this.getProject(projectReference);
-    const projectSummary = isPlainObject(projectPayload?.summary) ? projectPayload.summary : {};
-    const projectId = cleanText(projectSummary.project_id);
-    if (!projectId) {
-      throw new Error('Project id could not be resolved.');
-    }
-
-    const workflowReference = this._resolveImplementationPacketWorkflowReference(packetPayload, {
-      projectSummary,
-      workflowIdOverride: cleanText(workflowId),
-    });
-    if (!workflowReference) {
-      throw new Error('Could not resolve a workflow reference from the packet payload or project summary.');
-    }
-    const resolvedWorkflowId = await this._resolveImplementationPacketWorkflowId(workflowReference);
-    const workflowSlug = cleanText(projectSummary.workflow_slug);
-
-    const binding = await this.bindImplementationPacketToWorkflow(resolvedWorkflowId, {
-      packet_id: packetId,
-      binding_role: cleanText(bindingRole) || 'active',
-      created_by: normalizedCreatedBy,
-      notes: cleanText(notes),
-    });
-
-    const taskSurface = await this.ensureProjectRoadmapTaskSurface(projectId, {
-      requestedBy: normalizedRequestedBy,
+    return this.implementationPackets.importImplementationPacketAndMaterializeRoadmap(packetPayload, {
+      importedBy,
+      requestedBy,
+      createdBy,
+      workflowId,
+      bindingRole,
       assignedTo,
+      notes,
       createAcceptanceSubtasks,
     });
-
-    const roadmapReport = await this.getProjectImplementationRoadmapReport(projectId);
-    const roadmapMarkdown = await this.downloadProjectImplementationRoadmapReportMarkdown(projectId);
-    const phases = Array.isArray(packetPayload.phases) ? packetPayload.phases.filter(isPlainObject) : [];
-    const roadmapItems = phases.flatMap((phase) => (
-      Array.isArray(phase.items) ? phase.items.filter(isPlainObject) : []
-    ));
-    const taskRows = Array.isArray(taskSurface?.task_surfaces) ? taskSurface.task_surfaces.filter(isPlainObject) : [];
-    const subtaskRows = taskRows.filter((task) => cleanText(task.parent_task_id) !== null);
-    const acceptanceCheckCount = roadmapItems.reduce(
-      (total, item) => total + (Array.isArray(item.acceptanceChecks) ? item.acceptanceChecks.filter(Boolean).length : 0),
-      0,
-    );
-
-    return {
-      status: 'materialized',
-      project_id: projectId,
-      project_slug: cleanText(projectSummary.project_slug),
-      workflow_id: resolvedWorkflowId,
-      workflow_slug: workflowSlug,
-      implementation_packet_id: implementationPacketId,
-      implementation_packet_key: packetId,
-      binding,
-      task_surface: taskSurface,
-      roadmap_projection: {
-        report: roadmapReport,
-        markdown: roadmapMarkdown,
-        count_lines: countRoadmapProjectionLines(roadmapMarkdown),
-        phase_count: phases.length,
-        roadmap_item_count: roadmapItems.length,
-        task_count: taskRows.length,
-        subtask_count: subtaskRows.length,
-        acceptance_check_count: acceptanceCheckCount,
-      },
-    };
-  }
-
-  async listProjectOpenTasks(projectId) {
-    return this.projects.listProjectOpenTasks(projectId);
-  }
-
-  async getProjectPerformanceMetrics(projectId, { workflowId, workflowRunId, sinceUtc } = {}) {
-    return this.projects.getProjectPerformanceMetrics(projectId, { workflowId, workflowRunId, sinceUtc });
-  }
-
-  _resolveImplementationPacketProjectReference(packetPayload) {
-    return cleanText(packetPayload.projectId)
-      || cleanText(packetPayload.project_id)
-      || cleanText(packetPayload.projectSlug)
-      || cleanText(packetPayload.project_slug)
-      || cleanText(packetPayload?.scope?.projectId)
-      || cleanText(packetPayload?.scope?.project_id)
-      || cleanText(packetPayload?.scope?.projectSlug)
-      || cleanText(packetPayload?.scope?.project_slug)
-      || cleanText(packetPayload?.system?.slug);
-  }
-
-  _resolveImplementationPacketWorkflowReference(packetPayload, { projectSummary, workflowIdOverride } = {}) {
-    if (workflowIdOverride) return workflowIdOverride;
-    return cleanText(packetPayload.workflowId)
-      || cleanText(packetPayload.workflow_id)
-      || cleanText(packetPayload.workflowSlug)
-      || cleanText(packetPayload.workflow_slug)
-      || cleanText(packetPayload?.scope?.workflowId)
-      || cleanText(packetPayload?.scope?.workflow_id)
-      || cleanText(packetPayload?.scope?.workflowSlug)
-      || cleanText(packetPayload?.scope?.workflow_slug)
-      || cleanText(projectSummary?.workflow_id)
-      || cleanText(projectSummary?.workflow_slug);
-  }
-
-  async _resolveImplementationPacketWorkflowId(workflowReference) {
-    const normalized = cleanText(workflowReference);
-    if (!normalized) {
-      throw new Error('workflow reference is required.');
-    }
-    const workflow = await this.getWorkflow(normalized);
-    if (workflow) {
-      return cleanText(workflow.workflow_id) || cleanText(workflow.workflowId) || normalized;
-    }
-    const workflowList = await this.listWorkflows();
-    const workflows = Array.isArray(workflowList) ? workflowList : workflowList?.workflows;
-    const matches = Array.isArray(workflows)
-      ? workflows.filter((item) => cleanText(item?.slug) === normalized)
-      : [];
-    if (matches.length === 1) {
-      return cleanText(matches[0].workflow_id) || cleanText(matches[0].workflowId) || normalized;
-    }
-    throw new Error(`Workflow not found: ${normalized}`);
   }
 
   // ─── Implementation Tasks ──────────────────────────────────────────────────
@@ -4822,7 +4276,7 @@ export class AIEngineClient {
     executionType,
     executionPurpose,
   } = {}) {
-    return this.implementationItems.createImplementationTask(implementationItemId, {
+    return this.implementationTasks.createImplementationTask(implementationItemId, {
       title,
       implementationPacketId,
       description,
@@ -4849,23 +4303,23 @@ export class AIEngineClient {
   }
 
   async listImplementationTasks(implementationItemId) {
-    return this.implementationItems.listImplementationTasks(implementationItemId);
+    return this.implementationTasks.listImplementationTasks(implementationItemId);
   }
 
   async listImplementationSubtasks(taskId) {
-    return this.implementationItems.listImplementationSubtasks(taskId);
+    return this.implementationTasks.listImplementationSubtasks(taskId);
   }
 
   async updateImplementationTask(taskId, updates) {
-    return this.implementationItems.updateImplementationTask(taskId, updates);
+    return this.implementationTasks.updateImplementationTask(taskId, updates);
   }
 
   async assignImplementationTask(taskId, { assignedTo, assignedBy } = {}) {
-    return this.implementationItems.assignImplementationTask(taskId, { assignedTo, assignedBy });
+    return this.implementationTasks.assignImplementationTask(taskId, { assignedTo, assignedBy });
   }
 
   async completeImplementationTask(taskId, { completedBy } = {}) {
-    return this.implementationItems.completeImplementationTask(taskId, { completedBy });
+    return this.implementationTasks.completeImplementationTask(taskId, { completedBy });
   }
 
   // ─── Governed Implementation ───────────────────────────────────────────────
@@ -4883,7 +4337,7 @@ export class AIEngineClient {
   }
 
   async getImplementationItemAcceptanceChecks(implementationItemId) {
-    return this.implementationGates.getImplementationItemAcceptanceChecks(implementationItemId);
+    return this.implementationChecks.getImplementationItemAcceptanceChecks(implementationItemId);
   }
 
   async getArtifactManifest(implementationItemId) {
@@ -4895,46 +4349,7 @@ export class AIEngineClient {
   }
 
   async updateImplementationItemStatus(implementationItemId, body) {
-    await this._assertExecutionEligibility({
-      ...(body || {}),
-      claimed_item_id: body?.claimed_item_id || implementationItemId,
-      requested_mutation_surface: body?.requested_mutation_surface || 'implementation_packet_item',
-      verification_required: true,
-    });
-    const result = await this._request(`/api/governed-implementation/items/${implementationItemId}/status`, {
-      method: 'PATCH', body,
-    });
-    const expectedStatus = cleanText(body?.status);
-    const authoritativeItem = isPlainObject(result?.implementation_item) ? result.implementation_item : null;
-    const actualStatus = cleanText(authoritativeItem?.status);
-    if (expectedStatus && !authoritativeItem) {
-      throw buildVerificationError(
-        `updateImplementationItemStatus did not return authoritative item state for ${implementationItemId}.`,
-        {
-          mutation_name: 'updateImplementationItemStatus',
-          mutation_attempted: true,
-          authoritative_read_performed: false,
-          post_condition_verified: false,
-          expected_state: { status: expectedStatus },
-          mutation_result: result ?? null,
-        },
-      );
-    }
-    if (expectedStatus && actualStatus !== expectedStatus) {
-      throw buildVerificationError(
-        `updateImplementationItemStatus returned ${actualStatus ?? 'unknown'} instead of ${expectedStatus}.`,
-        {
-          mutation_name: 'updateImplementationItemStatus',
-          mutation_attempted: true,
-          authoritative_read_performed: true,
-          post_condition_verified: false,
-          expected_state: { status: expectedStatus },
-          verified_current_state: authoritativeItem ?? result ?? null,
-          mutation_result: result ?? null,
-        },
-      );
-    }
-    return result;
+    return this.implementationItems.updateImplementationItemStatus(implementationItemId, body);
   }
 
   async addImplementationItemEvidence(implementationItemId, body) {
@@ -4950,16 +4365,7 @@ export class AIEngineClient {
   }
 
   async updateAcceptanceCheckStatus(implementationItemId, acceptanceCheckId, body) {
-    await this._assertExecutionEligibility({
-      ...(body || {}),
-      claimed_item_id: body?.claimed_item_id || implementationItemId,
-      requested_mutation_surface: body?.requested_mutation_surface || 'implementation_acceptance_check',
-      verification_required: true,
-    });
-    return this._request(
-      `/api/governed-implementation/items/${implementationItemId}/acceptance-checks/${acceptanceCheckId}/status`,
-      { method: 'PATCH', body }
-    );
+    return this.implementationChecks.updateAcceptanceCheckStatus(implementationItemId, acceptanceCheckId, body);
   }
 
   async createImplementationPacketGateDecision(packetId, body) {
@@ -4985,223 +4391,25 @@ export class AIEngineClient {
     expectedState,
     evidenceLabel,
   } = {}) {
-    if (typeof mutationFn !== 'function') throw new Error('mutationFn is required.');
-    if (typeof verificationFn !== 'function') throw new Error('verificationFn is required.');
-    const normalizedMutationName = cleanText(mutationName) || 'verifiedMutation';
-    const normalizedEvidenceLabel = cleanText(evidenceLabel) || normalizedMutationName;
-
-    let mutationResult;
-    try {
-      mutationResult = await mutationFn();
-    } catch (error) {
-      throw buildVerificationError(
-        `${normalizedMutationName} mutation failed before post-condition verification.`,
-        {
-          mutation_name: normalizedMutationName,
-          evidence_label: normalizedEvidenceLabel,
-          mutation_attempted: true,
-          authoritative_read_performed: false,
-          post_condition_verified: false,
-          expected_state: expectedState ?? null,
-          mutation_error: {
-            message: error?.message || String(error),
-            status: error?.status || null,
-            payload: error?.payload || null,
-          },
-        },
-      );
-    }
-
-    let verificationResult;
-    try {
-      verificationResult = await verificationFn(mutationResult);
-    } catch (error) {
-      throw buildVerificationError(
-        `${normalizedMutationName} authoritative read failed after mutation attempt.`,
-        {
-          mutation_name: normalizedMutationName,
-          evidence_label: normalizedEvidenceLabel,
-          mutation_attempted: true,
-          authoritative_read_performed: false,
-          post_condition_verified: false,
-          expected_state: expectedState ?? null,
-          mutation_result: mutationResult ?? null,
-          verification_error: {
-            message: error?.message || String(error),
-            status: error?.status || null,
-            payload: error?.payload || null,
-          },
-        },
-      );
-    }
-
-    let evaluation;
-    if (typeof expectedState === 'function') {
-      evaluation = expectedState(verificationResult, mutationResult);
-    } else {
-      evaluation = {
-        ok: matchesExpectedState(verificationResult, expectedState),
-        verifiedCurrentState: verificationResult,
-      };
-    }
-    if (typeof evaluation === 'boolean') {
-      evaluation = { ok: evaluation, verifiedCurrentState: verificationResult };
-    }
-    if (!isPlainObject(evaluation) || typeof evaluation.ok !== 'boolean') {
-      throw new Error('expectedState must resolve to a boolean or an object with an ok field.');
-    }
-
-    const evidence = {
-      mutation_name: normalizedMutationName,
-      evidence_label: normalizedEvidenceLabel,
-      mutation_attempted: true,
-      authoritative_read_performed: true,
-      post_condition_verified: evaluation.ok,
-      expected_state: expectedState ?? null,
-      verified_current_state: evaluation.verifiedCurrentState ?? verificationResult ?? null,
-      mutation_result: mutationResult ?? null,
-      verification_result: verificationResult ?? null,
-      verification_message: cleanText(evaluation.message) || null,
-    };
-
-    if (!evaluation.ok) {
-      throw buildVerificationError(
-        cleanText(evaluation.message) || `${normalizedMutationName} post-condition verification failed.`,
-        evidence,
-      );
-    }
-
-    return {
-      mutationName: normalizedMutationName,
-      evidenceLabel: normalizedEvidenceLabel,
-      mutationResult,
-      verificationResult,
-      verifiedCurrentState: evidence.verified_current_state,
-      mutationVerificationEvidence: evidence,
-    };
+    return executeVerifiedMutation({
+      mutationName,
+      mutationFn,
+      verificationFn,
+      expectedState,
+      evidenceLabel,
+    });
   }
 
   async updateImplementationItemStatusVerified(implementationItemId, status, body = {}) {
-    return this.executeVerifiedMutation({
-      mutationName: 'updateImplementationItemStatus',
-      evidenceLabel: `implementation-item-status:${implementationItemId}`,
-      mutationFn: () => this.updateImplementationItemStatus(implementationItemId, { ...body, status }),
-      verificationFn: async (mutationResult) => {
-        const workflowId = cleanText(body.workflowId)
-          || cleanText(body.workflow_id)
-          || cleanText(mutationResult?.workflow_id);
-        if (!workflowId) {
-          throw new Error('workflowId is required to verify implementation item status.');
-        }
-        const roadmap = await this.getWorkflowImplementationRoadmap(workflowId);
-        const items = Array.isArray(roadmap?.items) ? roadmap.items : [];
-        const matchedItem = items.find((item) => item?.implementation_item_id === implementationItemId) || null;
-        return {
-          workflow_id: workflowId,
-          item: matchedItem,
-          roadmap,
-        };
-      },
-      expectedState: (verificationResult) => {
-        const item = verificationResult?.item || null;
-        if (!item) {
-          return {
-            ok: false,
-            message: `Implementation item ${implementationItemId} was not present in the authoritative roadmap read.`,
-            verifiedCurrentState: verificationResult,
-          };
-        }
-        return {
-          ok: item.status === status,
-          message: `Implementation item ${implementationItemId} status remained ${item.status ?? 'unknown'} after mutation attempt.`,
-          verifiedCurrentState: item,
-        };
-      },
-    });
+    return this.implementationItems.updateImplementationItemStatusVerified(implementationItemId, status, body);
   }
 
   async updateAcceptanceCheckStatusVerified(implementationItemId, acceptanceCheckId, status, body = {}) {
-    return this.executeVerifiedMutation({
-      mutationName: 'updateAcceptanceCheckStatus',
-      evidenceLabel: `acceptance-check-status:${implementationItemId}:${acceptanceCheckId}`,
-      mutationFn: () => this.updateAcceptanceCheckStatus(implementationItemId, acceptanceCheckId, { ...body, status }),
-      verificationFn: async () => this.getImplementationItemAcceptanceChecks(implementationItemId),
-      expectedState: (verificationResult) => {
-        const checks = Array.isArray(verificationResult?.acceptance_checks) ? verificationResult.acceptance_checks : [];
-        const targetCheck = checks.find((check) => check?.acceptance_check_id === acceptanceCheckId) || null;
-        if (!targetCheck) {
-          return {
-            ok: false,
-            message: `Acceptance check ${acceptanceCheckId} was not returned by the authoritative read.`,
-            verifiedCurrentState: verificationResult,
-          };
-        }
-        return {
-          ok: targetCheck.status === status,
-          message: `Acceptance check ${acceptanceCheckId} status remained ${targetCheck.status ?? 'unknown'} after mutation attempt.`,
-          verifiedCurrentState: targetCheck,
-        };
-      },
-    });
+    return this.implementationChecks.updateAcceptanceCheckStatusVerified(implementationItemId, acceptanceCheckId, status, body);
   }
 
   async verifyImplementationItemArtifacts(implementationItemId, { requiredArtifacts = [] } = {}) {
-    const requiredKinds = Array.isArray(requiredArtifacts) ? requiredArtifacts : [];
-    const verifications = [];
-    const artifactReaders = {
-      artifact_manifest: async () => this.getArtifactManifest(implementationItemId),
-      decision_packet: async () => this.getDecisionPacket(implementationItemId),
-    };
-
-    for (const kind of requiredKinds) {
-      const reader = artifactReaders[kind];
-      if (typeof reader !== 'function') {
-        throw new Error(`Unsupported required artifact: ${kind}`);
-      }
-      const payload = await reader();
-      if (payload?.source_truth !== 'sql') {
-        throw buildVerificationError(`Artifact ${kind} did not declare SQL as source_truth.`, {
-          artifact_kind: kind,
-          verified_current_state: payload ?? null,
-        });
-      }
-      if (payload?.item_id !== implementationItemId) {
-        throw buildVerificationError(`Artifact ${kind} returned item_id ${payload?.item_id ?? 'unknown'} instead of ${implementationItemId}.`, {
-          artifact_kind: kind,
-          verified_current_state: payload ?? null,
-        });
-      }
-      const dataKey = kind === 'artifact_manifest' ? 'artifact_manifest' : 'decision_packet';
-      if (!isPlainObject(payload?.[dataKey])) {
-        throw buildVerificationError(`Artifact ${kind} did not include required ${dataKey} data.`, {
-          artifact_kind: kind,
-          verified_current_state: payload ?? null,
-        });
-      }
-      verifications.push({
-        artifact_kind: kind,
-        http_status: 200,
-        source_truth: payload.source_truth,
-        item_id: payload.item_id,
-        verified_current_state: payload[dataKey],
-      });
-    }
-
-    return {
-      itemId: implementationItemId,
-      requiredArtifacts: requiredKinds,
-      verified: true,
-      mutationVerificationEvidence: {
-        mutation_name: 'verifyImplementationItemArtifacts',
-        evidence_label: `implementation-item-artifacts:${implementationItemId}`,
-        mutation_attempted: false,
-        authoritative_read_performed: true,
-        post_condition_verified: true,
-        expected_state: { required_artifacts: requiredKinds },
-        verified_current_state: verifications,
-      },
-      artifacts: verifications,
-    };
+    return this.implementationArtifacts.verifyImplementationItemArtifacts(implementationItemId, { requiredArtifacts });
   }
 
   // ─── Skills ────────────────────────────────────────────────────────────────
@@ -5437,3495 +4645,41 @@ export class AIEngineClient {
     includeLogaPortfolioProjection = false,
     includeLogaRoadmapProjections = false,
   } = {}) {
-    const portfolioBundle = await this.getPortfolioBundle();
-    const projectListPayload = await this.listProjects({
-      limit: projectLimit,
+    return this.portfolio.getPortfolioClosureReadiness({
+      projectLimit,
       includeInactive,
+      includeLogaPortfolioProjection,
+      includeLogaRoadmapProjections,
     });
+  }
 
-    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 registerModernizationAsset(request = {}) {
+    return this.workflowComposition.registerModernizationAsset(request);
+  }
 
-    const projectReadiness = [];
-    for (const project of activeProjects) {
-      const projectId = cleanText(project.project_id) || cleanText(project.projectId);
-      if (!projectId) {
-        continue;
-      }
+  async classifyModernizationAsset(request = {}) {
+    return this.workflowComposition.classifyModernizationAsset(request);
+  }
 
-      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 discoverSalvageCandidates(request = {}) {
+    return this.workflowComposition.discoverSalvageCandidates(request);
+  }
 
-    const closureReady = projectReadiness.length === 0 || projectReadiness.every((project) => project.closure_ready === true);
-    const blockingProject = projectReadiness.find((project) => project.closure_ready !== true);
+  async createModernizationWorkPacket(request = {}) {
+    return this.workflowComposition.createModernizationWorkPacket(request);
+  }
 
-    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 requestModernizationWrapperExecution(request = {}) {
+    return this.workflowComposition.requestModernizationWrapperExecution(request);
   }
 
-  async registerModernizationAsset({
-    projectIdentifier,
-    projectId,
-    relatedProjectId,
-    related_project_id,
-    startWorkBody = {},
-    startWorkRequest = {},
-    resumeProjectWorkOptions = {},
-    asset = {},
-    modernizationAsset = {},
-    assetName,
-    asset_name,
-    assetType,
-    asset_type,
-    sourceRef,
-    source_ref,
-    originSystem,
-    origin_system,
-    businessContext,
-    business_context,
-    suspectedValue,
-    suspected_value,
-    knownRisks = [],
-    known_risks = [],
-    evidenceRefs = [],
-    evidence_refs = [],
-    handoffNotes,
-    handoff_notes,
-    assignedClassifier,
-    assigned_classifier,
-    classificationRequired,
-    classification_required,
-    submittedBy,
-    submitted_by,
-    includePortfolioBundle = true,
-    includeProjectRoadmap = true,
-    includeProjectActiveItem = true,
-    metadata = {},
-  } = {}) {
-    const missingSurfaces = [];
-    const normalizedMetadata = isPlainObject(metadata) ? metadata : {};
-    const normalizedAsset = isPlainObject(modernizationAsset)
-      ? modernizationAsset
-      : (isPlainObject(asset) ? asset : {});
-    const normalizedProjectReference = cleanText(projectIdentifier)
-      || cleanText(projectId)
-      || cleanText(relatedProjectId)
-      || cleanText(related_project_id)
-      || cleanText(normalizedAsset.related_project_id)
-      || cleanText(normalizedAsset.relatedProjectId);
-    const normalizedAssetName = cleanText(asset_name) || cleanText(assetName) || cleanText(normalizedAsset.asset_name) || cleanText(normalizedAsset.assetName);
-    const normalizedAssetType = cleanText(asset_type) || cleanText(assetType) || cleanText(normalizedAsset.asset_type) || cleanText(normalizedAsset.assetType) || 'unknown';
-    const normalizedSourceRef = cleanText(source_ref) || cleanText(sourceRef) || cleanText(normalizedAsset.source_ref) || cleanText(normalizedAsset.sourceRef) || normalizedAssetName;
-    if (!normalizedAssetName && !normalizedSourceRef) {
-      throw new Error('asset_name or source_ref is required.');
-    }
-    const normalizedOriginSystem = cleanText(origin_system) || cleanText(originSystem) || cleanText(normalizedAsset.origin_system) || cleanText(normalizedAsset.originSystem);
-    const normalizedBusinessContext = cleanText(business_context) || cleanText(businessContext) || cleanText(normalizedAsset.business_context) || cleanText(normalizedAsset.businessContext);
-    const normalizedSuspectedValue = cleanText(suspected_value) || cleanText(suspectedValue) || cleanText(normalizedAsset.suspected_value) || cleanText(normalizedAsset.suspectedValue);
-    const normalizedKnownRisks = Array.isArray(known_risks)
-      ? known_risks
-      : (Array.isArray(knownRisks) ? knownRisks : normalizedAsset.known_risks || normalizedAsset.knownRisks || []);
-    const normalizedEvidenceRefs = Array.isArray(evidence_refs)
-      ? evidence_refs
-      : (Array.isArray(evidenceRefs) ? evidenceRefs : normalizedAsset.evidence_refs || normalizedAsset.evidenceRefs || []);
-    const normalizedHandoffNotes = cleanText(handoff_notes) || cleanText(handoffNotes) || cleanText(normalizedAsset.handoff_notes) || cleanText(normalizedAsset.handoffNotes);
-    const normalizedAssignedClassifier = cleanText(assigned_classifier)
-      || cleanText(assignedClassifier)
-      || cleanText(normalizedAsset.assigned_classifier)
-      || cleanText(normalizedAsset.assignedClassifier);
-    const normalizedSubmittedBy = cleanText(submitted_by)
-      || cleanText(submittedBy)
-      || this.agentSessionId
-      || this.actorId
-      || null;
-    const normalizedClassificationRequired = classification_required ?? classificationRequired ?? true;
+  async getModernizationWrapperEvidence(request = {}) {
+    return this.workflowComposition.getModernizationWrapperEvidence(request);
+  }
 
-    let continuation = null;
-    let startWorkResult = null;
-    if (normalizedProjectReference) {
-      if (typeof this.resumeProjectWork === 'function') {
-        continuation = await this.resumeProjectWork({
-          projectIdentifier: normalizedProjectReference,
-          projectId: normalizedProjectReference,
-          requireClaim: false,
-          ...resumeProjectWorkOptions,
-        });
-      } else {
-        missingSurfaces.push('resumeProjectWork');
-      }
-    } else if (Object.keys(isPlainObject(startWorkRequest) ? startWorkRequest : {}).length > 0 || Object.keys(isPlainObject(startWorkBody) ? startWorkBody : {}).length > 0) {
-      if (typeof this.startWork === 'function') {
-        startWorkResult = await this.startWork({
-          ...(isPlainObject(startWorkBody) ? startWorkBody : {}),
-          ...(isPlainObject(startWorkRequest) ? startWorkRequest : {}),
-        });
-      } else {
-        missingSurfaces.push('startWork');
-      }
-    } else {
-      throw new Error('projectIdentifier is required.');
-    }
-
-    const projectPayload = isPlainObject(continuation?.project)
-      ? continuation.project
-      : isPlainObject(startWorkResult?.project)
-        ? startWorkResult.project
-        : isPlainObject(continuation?.summary)
-          ? continuation.summary
-          : {};
-    const resolvedProjectId = cleanText(projectPayload.project_id)
-      || cleanText(projectPayload.projectId)
-      || normalizedProjectReference;
-    const resolvedWorkflowId = cleanText(projectPayload.workflow_id)
-      || cleanText(projectPayload.workflowId)
-      || cleanText(continuation?.workflow_id)
-      || cleanText(startWorkResult?.workflow_id);
-    const resolvedWorkflowRunId = cleanText(projectPayload.workflow_run_id)
-      || cleanText(projectPayload.workflowRunId)
-      || cleanText(continuation?.workflow_run_id)
-      || cleanText(startWorkResult?.workflow_run_id)
-      || cleanText(startWorkResult?.workflowRunId);
-
-    const portfolioBundle = includePortfolioBundle && typeof this.getPortfolioBundle === 'function'
-      ? await this.getPortfolioBundle().catch(() => null)
-      : null;
-    const projectRoadmapSummary = resolvedProjectId && includeProjectRoadmap && typeof this.getProjectRoadmapSummary === 'function'
-      ? await this.getProjectRoadmapSummary(resolvedProjectId).catch(() => null)
-      : null;
-    const projectActiveItem = resolvedProjectId && includeProjectActiveItem && typeof this.getProjectRoadmapActiveItem === 'function'
-      ? await this.getProjectRoadmapActiveItem(resolvedProjectId).catch(() => null)
-      : null;
-
-    let assetIntakeRecord = null;
-    const assetIntakeSurface = typeof this.createModernizationAssetIntakeRecord === 'function'
-      ? this.createModernizationAssetIntakeRecord.bind(this)
-      : null;
-    if (!assetIntakeSurface) {
-      missingSurfaces.push('createModernizationAssetIntakeRecord');
-    } else {
-      assetIntakeRecord = await assetIntakeSurface({
-        projectId: resolvedProjectId,
-        workflowId: resolvedWorkflowId,
-        workflowRunId: resolvedWorkflowRunId,
-        assetName: normalizedAssetName,
-        assetType: normalizedAssetType,
-        sourceRef: normalizedSourceRef,
-        originSystem: normalizedOriginSystem,
-        businessContext: normalizedBusinessContext,
-        suspectedValue: normalizedSuspectedValue,
-        knownRisks: normalizedKnownRisks,
-        relatedProjectId: resolvedProjectId,
-        evidenceRefs: normalizedEvidenceRefs,
-        handoffNotes: normalizedHandoffNotes,
-        submittedBy: normalizedSubmittedBy,
-        metadata: {
-          ...normalizedMetadata,
-          source: 'registerModernizationAsset',
-        },
-      });
-    }
-
-    let intakeObservation = null;
-    const observationSurface = typeof this.submitModernizationAssetObservation === 'function'
-      ? this.submitModernizationAssetObservation.bind(this)
-      : null;
-    if (!observationSurface) {
-      missingSurfaces.push('submitModernizationAssetObservation');
-    } else {
-      intakeObservation = await observationSurface({
-        projectId: resolvedProjectId,
-        workflowId: resolvedWorkflowId,
-        workflowRunId: resolvedWorkflowRunId,
-        assetName: normalizedAssetName,
-        assetType: normalizedAssetType,
-        sourceRef: normalizedSourceRef,
-        submittedBy: normalizedSubmittedBy,
-        observationKind: 'asset_intake',
-        observationState: 'registered',
-        observationSummary: normalizedBusinessContext || normalizedHandoffNotes || normalizedAssetName || normalizedSourceRef,
-        evidenceRefs: normalizedEvidenceRefs,
-        metadata: {
-          ...normalizedMetadata,
-          source: 'registerModernizationAsset',
-        },
-      });
-    }
-
-    let transferResult = null;
-    let watchResult = null;
-    const classifierTransferNeeded = Boolean(normalizedClassificationRequired && normalizedAssignedClassifier);
-    if (classifierTransferNeeded) {
-      const transferSurface = typeof this.transferWorkPacket === 'function'
-        ? this.transferWorkPacket.bind(this)
-        : null;
-      if (!transferSurface) {
-        missingSurfaces.push('transferWorkPacket');
-      } else {
-        transferResult = await transferSurface({
-          workflowRunId: resolvedWorkflowRunId,
-          transferKind: 'upstream_remediation',
-          objective: `Classify modernization asset ${normalizedAssetName || normalizedSourceRef}`,
-          requestedOutcome: 'Review and classify the modernization asset intake.',
-          target: {
-            intent: 'upstream_remediation',
-            recipient_mode: 'agent_session',
-            preferred_agent_session_id: normalizedAssignedClassifier,
-            preferred_role_key: normalizedAssignedClassifier,
-          },
-          artifacts: normalizedSourceRef ? [normalizedSourceRef] : [],
-          issues: normalizedKnownRisks,
-          expected_evidence: normalizedEvidenceRefs,
-          preferred_modes: ['bundle', 'artifact_refs', 'inline_payload'],
-          capabilities: {},
-          sender_agent_session_id: normalizedSubmittedBy,
-          sender_actor_session_id: null,
-          message_kind: 'handoff',
-          subject: normalizedAssetName || normalizedSourceRef || 'Modernization asset intake',
-          body_markdown: normalizedHandoffNotes || normalizedBusinessContext || normalizedSuspectedValue,
-          metadata: {
-            ...normalizedMetadata,
-            source: 'registerModernizationAsset',
-            asset_name: normalizedAssetName,
-            asset_type: normalizedAssetType,
-            source_ref: normalizedSourceRef,
-            origin_system: normalizedOriginSystem,
-          },
-        });
-      }
-    }
-
-    const transferPayload = isPlainObject(transferResult) ? transferResult : {};
-    const transferPacketId = cleanText(transferPayload.work_transfer_packet?.work_transfer_packet_id)
-      || cleanText(transferPayload.work_transfer_packet_id)
-      || cleanText(transferPayload.transfer_packet_id)
-      || cleanText(transferPayload.packet_id)
-      || null;
-    const transferChannelId = cleanText(transferPayload.communication_transfer_channel?.transfer_channel_id)
-      || cleanText(transferPayload.communication_transfer_channel?.channel_id)
-      || cleanText(transferPayload.transfer_channel?.transfer_channel_id)
-      || cleanText(transferPayload.transfer_channel_id)
-      || cleanText(transferPayload.channel_id)
-      || null;
-
-    if (classifierTransferNeeded && transferChannelId && transferPacketId) {
-      const watchSurface = typeof this.startMessageWatch === 'function'
-        ? this.startMessageWatch.bind(this)
-        : null;
-      if (!watchSurface) {
-        missingSurfaces.push('startMessageWatch');
-      } else {
-        watchResult = await watchSurface({
-          transferChannelId,
-          workTransferPacketId: transferPacketId,
-          workflowRunId: resolvedWorkflowRunId,
-          watchingAgentRole: normalizedSubmittedBy,
-          expectedFromRole: normalizedAssignedClassifier,
-          expectedMessageKind: 'response',
-          watchType: 'expected_peer_message',
-          watchingAgentSessionId: normalizedSubmittedBy,
-          expectedPayload: {
-            source_ref: normalizedSourceRef,
-            asset_type: normalizedAssetType,
-            classification_required: Boolean(normalizedClassificationRequired),
-          },
-          currentStatus: 'watching',
-          operatorNudge: normalizedHandoffNotes || normalizedBusinessContext || normalizedSuspectedValue,
-          metadata: {
-            ...normalizedMetadata,
-            source: 'registerModernizationAsset',
-          },
-        });
-      }
-    }
-
-    const watchPayload = isPlainObject(watchResult) ? watchResult : {};
-    const watchId = cleanText(watchPayload.message_watch_id)
-      || cleanText(watchPayload.watch_id)
-      || cleanText(watchPayload.message_watch?.message_watch_id)
-      || cleanText(watchPayload.message_watch?.watch_id)
-      || null;
-    const assetId = cleanText(assetIntakeRecord?.asset_id)
-      || cleanText(assetIntakeRecord?.assetId)
-      || cleanText(assetIntakeRecord?.intake_record_id)
-      || cleanText(assetIntakeRecord?.intakeRecordId)
-      || cleanText(assetIntakeRecord?.modernization_asset_id)
-      || cleanText(assetIntakeRecord?.modernizationAssetId)
-      || null;
-    const intakeRecordId = cleanText(assetIntakeRecord?.intake_record_id)
-      || cleanText(assetIntakeRecord?.intakeRecordId)
-      || cleanText(assetIntakeRecord?.asset_id)
-      || cleanText(assetIntakeRecord?.assetId)
-      || null;
-
-    return {
-      status: missingSurfaces.length > 0 ? 'partial' : 'ready',
-      project_id: resolvedProjectId || null,
-      asset_id: assetId,
-      intake_record_id: intakeRecordId,
-      asset_type: normalizedAssetType,
-      source_ref: normalizedSourceRef,
-      submitted_by: normalizedSubmittedBy,
-      classification_required: Boolean(normalizedClassificationRequired),
-      assigned_classifier: normalizedAssignedClassifier || null,
-      transfer_packet_id: transferPacketId,
-      watch_id: watchId,
-      operator_projection_metadata: {
-        portfolio_bundle: portfolioBundle,
-        project_roadmap_summary: projectRoadmapSummary,
-        project_roadmap_active_item: projectActiveItem,
-        asset_intake_record: assetIntakeRecord,
-        intake_observation: intakeObservation,
-        transfer: transferPayload,
-        message_watch: watchPayload,
-      },
-      missing_surfaces: [...new Set(missingSurfaces)],
-      project: projectPayload,
-      transfer: transferPayload,
-      asset_intake_record: assetIntakeRecord,
-      intake_observation: intakeObservation,
-      message_watch: watchPayload,
-    };
-  }
-
-  async classifyModernizationAsset({
-    projectIdentifier,
-    projectId,
-    relatedProjectId,
-    related_project_id,
-    startWorkBody = {},
-    startWorkRequest = {},
-    resumeProjectWorkOptions = {},
-    asset = {},
-    modernizationAsset = {},
-    classification = {},
-    modernizationClassification = {},
-    assetId,
-    asset_id,
-    intakeRecordId,
-    intake_record_id,
-    assetType,
-    asset_type,
-    sourceRef,
-    source_ref,
-    classificationCategory,
-    classification_category,
-    domainArea,
-    domain_area,
-    reusePotential,
-    reuse_potential,
-    modernizationNeed,
-    modernization_need,
-    knownRisks = [],
-    known_risks = [],
-    evidenceRefs = [],
-    evidence_refs = [],
-    recommendedNextStep,
-    recommended_next_step,
-    classificationConfidence,
-    classification_confidence,
-    reviewRequired,
-    review_required,
-    assignedReviewer,
-    assigned_reviewer,
-    handoffNotes,
-    handoff_notes,
-    submittedBy,
-    submitted_by,
-    includePortfolioBundle = true,
-    includeProjectRoadmap = true,
-    includeProjectActiveItem = true,
-    metadata = {},
-  } = {}) {
-    const missingSurfaces = [];
-    const normalizedMetadata = isPlainObject(metadata) ? metadata : {};
-    const normalizedAsset = isPlainObject(modernizationAsset)
-      ? modernizationAsset
-      : (isPlainObject(asset) ? asset : {});
-    const normalizedClassification = isPlainObject(modernizationClassification)
-      ? modernizationClassification
-      : (isPlainObject(classification) ? classification : {});
-    const normalizedProjectReference = cleanText(projectIdentifier)
-      || cleanText(projectId)
-      || cleanText(relatedProjectId)
-      || cleanText(related_project_id)
-      || cleanText(normalizedAsset.related_project_id)
-      || cleanText(normalizedAsset.relatedProjectId)
-      || cleanText(normalizedClassification.related_project_id)
-      || cleanText(normalizedClassification.relatedProjectId);
-    const normalizedAssetId = cleanText(asset_id)
-      || cleanText(assetId)
-      || cleanText(intake_record_id)
-      || cleanText(intakeRecordId)
-      || cleanText(normalizedAsset.asset_id)
-      || cleanText(normalizedAsset.assetId)
-      || cleanText(normalizedAsset.intake_record_id)
-      || cleanText(normalizedAsset.intakeRecordId);
-    const normalizedSourceRef = cleanText(source_ref)
-      || cleanText(sourceRef)
-      || cleanText(normalizedAsset.source_ref)
-      || cleanText(normalizedAsset.sourceRef)
-      || normalizedAssetId;
-    if (!normalizedAssetId && !normalizedSourceRef) {
-      throw new Error('asset_id, intake_record_id, or source_ref is required.');
-    }
-    const normalizedAssetType = cleanText(asset_type)
-      || cleanText(assetType)
-      || cleanText(normalizedAsset.asset_type)
-      || cleanText(normalizedAsset.assetType)
-      || 'unknown';
-    const normalizedClassificationCategory = cleanText(classification_category)
-      || cleanText(classificationCategory)
-      || cleanText(normalizedClassification.classification_category)
-      || cleanText(normalizedClassification.classificationCategory)
-      || 'uncategorized';
-    const normalizedDomainArea = cleanText(domain_area)
-      || cleanText(domainArea)
-      || cleanText(normalizedClassification.domain_area)
-      || cleanText(normalizedClassification.domainArea);
-    const normalizedReusePotential = cleanText(reuse_potential)
-      || cleanText(reusePotential)
-      || cleanText(normalizedClassification.reuse_potential)
-      || cleanText(normalizedClassification.reusePotential);
-    const normalizedModernizationNeed = cleanText(modernization_need)
-      || cleanText(modernizationNeed)
-      || cleanText(normalizedClassification.modernization_need)
-      || cleanText(normalizedClassification.modernizationNeed);
-    const normalizedRecommendedNextStep = cleanText(recommended_next_step)
-      || cleanText(recommendedNextStep)
-      || cleanText(normalizedClassification.recommended_next_step)
-      || cleanText(normalizedClassification.recommendedNextStep);
-    const normalizedClassificationConfidence = cleanText(classification_confidence)
-      || cleanText(classificationConfidence)
-      || cleanText(normalizedClassification.classification_confidence)
-      || cleanText(normalizedClassification.classificationConfidence);
-    const normalizedKnownRisks = Array.isArray(known_risks)
-      ? known_risks
-      : (Array.isArray(knownRisks) ? knownRisks : normalizedAsset.known_risks || normalizedAsset.knownRisks || []);
-    const normalizedEvidenceRefs = Array.isArray(evidence_refs)
-      ? evidence_refs
-      : (Array.isArray(evidenceRefs) ? evidenceRefs : normalizedAsset.evidence_refs || normalizedAsset.evidenceRefs || []);
-    const normalizedHandoffNotes = cleanText(handoff_notes)
-      || cleanText(handoffNotes)
-      || cleanText(normalizedClassification.handoff_notes)
-      || cleanText(normalizedClassification.handoffNotes)
-      || cleanText(normalizedAsset.handoff_notes)
-      || cleanText(normalizedAsset.handoffNotes);
-    const normalizedAssignedReviewer = cleanText(assigned_reviewer)
-      || cleanText(assignedReviewer)
-      || cleanText(normalizedClassification.assigned_reviewer)
-      || cleanText(normalizedClassification.assignedReviewer);
-    const normalizedSubmittedBy = cleanText(submitted_by)
-      || cleanText(submittedBy)
-      || this.agentSessionId
-      || this.actorId
-      || null;
-    const normalizedReviewRequired = review_required ?? reviewRequired ?? true;
-
-    let continuation = null;
-    let startWorkResult = null;
-    if (normalizedProjectReference) {
-      if (typeof this.resumeProjectWork === 'function') {
-        continuation = await this.resumeProjectWork({
-          projectIdentifier: normalizedProjectReference,
-          projectId: normalizedProjectReference,
-          requireClaim: false,
-          ...resumeProjectWorkOptions,
-        });
-      } else {
-        missingSurfaces.push('resumeProjectWork');
-      }
-    } else if (Object.keys(isPlainObject(startWorkRequest) ? startWorkRequest : {}).length > 0 || Object.keys(isPlainObject(startWorkBody) ? startWorkBody : {}).length > 0) {
-      if (typeof this.startWork === 'function') {
-        startWorkResult = await this.startWork({
-          ...(isPlainObject(startWorkBody) ? startWorkBody : {}),
-          ...(isPlainObject(startWorkRequest) ? startWorkRequest : {}),
-        });
-      } else {
-        missingSurfaces.push('startWork');
-      }
-    }
-
-    const projectPayload = isPlainObject(continuation?.project)
-      ? continuation.project
-      : isPlainObject(startWorkResult?.project)
-        ? startWorkResult.project
-        : isPlainObject(continuation?.summary)
-          ? continuation.summary
-          : {};
-    const resolvedProjectId = cleanText(projectPayload.project_id)
-      || cleanText(projectPayload.projectId)
-      || normalizedProjectReference;
-    const resolvedWorkflowId = cleanText(projectPayload.workflow_id)
-      || cleanText(projectPayload.workflowId)
-      || cleanText(continuation?.workflow_id)
-      || cleanText(startWorkResult?.workflow_id);
-    const resolvedWorkflowRunId = cleanText(projectPayload.workflow_run_id)
-      || cleanText(projectPayload.workflowRunId)
-      || cleanText(continuation?.workflow_run_id)
-      || cleanText(startWorkResult?.workflow_run_id)
-      || cleanText(startWorkResult?.workflowRunId);
-
-    const portfolioBundle = includePortfolioBundle && typeof this.getPortfolioBundle === 'function'
-      ? await this.getPortfolioBundle().catch(() => null)
-      : null;
-    const projectRoadmapSummary = resolvedProjectId && includeProjectRoadmap && typeof this.getProjectRoadmapSummary === 'function'
-      ? await this.getProjectRoadmapSummary(resolvedProjectId).catch(() => null)
-      : null;
-    const projectActiveItem = resolvedProjectId && includeProjectActiveItem && typeof this.getProjectRoadmapActiveItem === 'function'
-      ? await this.getProjectRoadmapActiveItem(resolvedProjectId).catch(() => null)
-      : null;
-
-    let registeredAssetRecord = null;
-    const intakeLookupSurface = typeof this.getModernizationAssetIntakeRecord === 'function'
-      ? this.getModernizationAssetIntakeRecord.bind(this)
-      : null;
-    if (!intakeLookupSurface) {
-      missingSurfaces.push('getModernizationAssetIntakeRecord');
-    } else {
-      registeredAssetRecord = await intakeLookupSurface({
-        projectId: resolvedProjectId,
-        workflowId: resolvedWorkflowId,
-        workflowRunId: resolvedWorkflowRunId,
-        assetId: normalizedAssetId,
-        intakeRecordId: cleanText(intake_record_id) || cleanText(intakeRecordId),
-        sourceRef: normalizedSourceRef,
-        metadata: {
-          ...normalizedMetadata,
-          source: 'classifyModernizationAsset',
-        },
-      });
-    }
-
-    let classificationRecord = null;
-    const classificationSurface = typeof this.createModernizationAssetClassificationRecord === 'function'
-      ? this.createModernizationAssetClassificationRecord.bind(this)
-      : null;
-    if (!classificationSurface) {
-      missingSurfaces.push('createModernizationAssetClassificationRecord');
-    } else {
-      classificationRecord = await classificationSurface({
-        projectId: resolvedProjectId,
-        workflowId: resolvedWorkflowId,
-        workflowRunId: resolvedWorkflowRunId,
-        assetId: normalizedAssetId,
-        intakeRecordId: cleanText(intake_record_id) || cleanText(intakeRecordId),
-        assetType: normalizedAssetType,
-        sourceRef: normalizedSourceRef,
-        classificationCategory: normalizedClassificationCategory,
-        domainArea: normalizedDomainArea,
-        reusePotential: normalizedReusePotential,
-        modernizationNeed: normalizedModernizationNeed,
-        knownRisks: normalizedKnownRisks,
-        recommendedNextStep: normalizedRecommendedNextStep,
-        classificationConfidence: normalizedClassificationConfidence,
-        evidenceRefs: normalizedEvidenceRefs,
-        reviewRequired: Boolean(normalizedReviewRequired),
-        assignedReviewer: normalizedAssignedReviewer,
-        submittedBy: normalizedSubmittedBy,
-        handoffNotes: normalizedHandoffNotes,
-        metadata: {
-          ...normalizedMetadata,
-          source: 'classifyModernizationAsset',
-        },
-      });
-    }
-
-    let classificationObservation = null;
-    const observationSurface = typeof this.submitModernizationAssetClassificationObservation === 'function'
-      ? this.submitModernizationAssetClassificationObservation.bind(this)
-      : null;
-    if (!observationSurface) {
-      missingSurfaces.push('submitModernizationAssetClassificationObservation');
-    } else {
-      classificationObservation = await observationSurface({
-        projectId: resolvedProjectId,
-        workflowId: resolvedWorkflowId,
-        workflowRunId: resolvedWorkflowRunId,
-        assetId: normalizedAssetId,
-        intakeRecordId: cleanText(intake_record_id) || cleanText(intakeRecordId),
-        assetType: normalizedAssetType,
-        sourceRef: normalizedSourceRef,
-        classificationCategory: normalizedClassificationCategory,
-        classificationConfidence: normalizedClassificationConfidence,
-        evidenceRefs: normalizedEvidenceRefs,
-        submittedBy: normalizedSubmittedBy,
-        observationKind: 'asset_classification',
-        observationState: 'prepared',
-        observationSummary: normalizedClassificationCategory || normalizedDomainArea || normalizedAssetType || normalizedSourceRef,
-        metadata: {
-          ...normalizedMetadata,
-          source: 'classifyModernizationAsset',
-        },
-      });
-    }
-
-    let transferResult = null;
-    let watchResult = null;
-    let heartbeatResult = null;
-    const reviewTransferNeeded = Boolean(normalizedReviewRequired && normalizedAssignedReviewer);
-    if (reviewTransferNeeded) {
-      const transferSurface = typeof this.transferWorkPacket === 'function'
-        ? this.transferWorkPacket.bind(this)
-        : null;
-      if (!transferSurface) {
-        missingSurfaces.push('transferWorkPacket');
-      } else {
-        transferResult = await transferSurface({
-          workflowRunId: resolvedWorkflowRunId,
-          transferKind: 'upstream_remediation',
-          objective: `Review modernization asset classification ${normalizedSourceRef || normalizedAssetId}`,
-          requestedOutcome: 'Review and enrich the modernization asset classification.',
-          target: {
-            intent: 'upstream_remediation',
-            recipient_mode: 'agent_session',
-            preferred_agent_session_id: normalizedAssignedReviewer,
-            preferred_role_key: normalizedAssignedReviewer,
-          },
-          artifacts: normalizedSourceRef ? [normalizedSourceRef] : [],
-          issues: normalizedKnownRisks,
-          expected_evidence: normalizedEvidenceRefs,
-          preferred_modes: ['bundle', 'artifact_refs', 'inline_payload'],
-          capabilities: {},
-          sender_agent_session_id: normalizedSubmittedBy,
-          sender_actor_session_id: null,
-          message_kind: 'handoff',
-          subject: normalizedClassificationCategory || normalizedSourceRef || 'Modernization asset classification',
-          body_markdown: normalizedHandoffNotes || normalizedRecommendedNextStep || normalizedClassificationCategory,
-          metadata: {
-            ...normalizedMetadata,
-            source: 'classifyModernizationAsset',
-            asset_id: normalizedAssetId,
-            intake_record_id: cleanText(intake_record_id) || cleanText(intakeRecordId),
-            asset_type: normalizedAssetType,
-            classification_category: normalizedClassificationCategory,
-            domain_area: normalizedDomainArea,
-          },
-        });
-      }
-    }
-
-    const transferPayload = isPlainObject(transferResult) ? transferResult : {};
-    const transferPacketId = cleanText(transferPayload.work_transfer_packet?.work_transfer_packet_id)
-      || cleanText(transferPayload.work_transfer_packet_id)
-      || cleanText(transferPayload.transfer_packet_id)
-      || cleanText(transferPayload.packet_id)
-      || null;
-    const transferChannelId = cleanText(transferPayload.communication_transfer_channel?.transfer_channel_id)
-      || cleanText(transferPayload.communication_transfer_channel?.channel_id)
-      || cleanText(transferPayload.transfer_channel?.transfer_channel_id)
-      || cleanText(transferPayload.transfer_channel_id)
-      || cleanText(transferPayload.channel_id)
-      || null;
-
-    if (reviewTransferNeeded && transferChannelId && transferPacketId) {
-      const watchSurface = typeof this.startMessageWatch === 'function'
-        ? this.startMessageWatch.bind(this)
-        : null;
-      if (!watchSurface) {
-        missingSurfaces.push('startMessageWatch');
-      } else {
-        watchResult = await watchSurface({
-          transferChannelId,
-          workTransferPacketId: transferPacketId,
-          workflowRunId: resolvedWorkflowRunId,
-          watchingAgentRole: normalizedSubmittedBy,
-          expectedFromRole: normalizedAssignedReviewer,
-          expectedMessageKind: 'response',
-          watchType: 'expected_peer_message',
-          watchingAgentSessionId: normalizedSubmittedBy,
-          expectedPayload: {
-            asset_id: normalizedAssetId,
-            classification_category: normalizedClassificationCategory,
-            review_required: Boolean(normalizedReviewRequired),
-          },
-          currentStatus: 'watching',
-          operatorNudge: normalizedHandoffNotes || normalizedRecommendedNextStep || normalizedClassificationCategory,
-          metadata: {
-            ...normalizedMetadata,
-            source: 'classifyModernizationAsset',
-          },
-        });
-      }
-    }
-
-    const watchPayload = isPlainObject(watchResult) ? watchResult : {};
-    const watchId = cleanText(watchPayload.message_watch_id)
-      || cleanText(watchPayload.watch_id)
-      || cleanText(watchPayload.message_watch?.message_watch_id)
-      || cleanText(watchPayload.message_watch?.watch_id)
-      || null;
-
-    if ((classificationRecord || classificationObservation || transferResult) && typeof this.postCollaborationHeartbeat === 'function') {
-      try {
-        heartbeatResult = await this.postCollaborationHeartbeat({
-          transferChannelId: transferChannelId || undefined,
-          workTransferPacketId: transferPacketId || undefined,
-          workflowRunId: resolvedWorkflowRunId,
-          participantRole: normalizedReviewRequired && normalizedAssignedReviewer ? 'classifier' : 'warehouse',
-          currentPhase: reviewTransferNeeded ? 'review_pending' : 'classification_prepared',
-          currentTaskSummary: normalizedClassificationCategory || normalizedSourceRef || 'Modernization asset classification',
-        });
-      } catch (error) {
-        void error;
-      }
-    }
-
-    const heartbeatPayload = isPlainObject(heartbeatResult) ? heartbeatResult : {};
-    const classificationId = cleanText(classificationRecord?.classification_id)
-      || cleanText(classificationRecord?.classificationId)
-      || cleanText(classificationRecord?.intake_classification_id)
-      || cleanText(classificationRecord?.intakeClassificationId)
-      || null;
-    const assetRecordId = cleanText(registeredAssetRecord?.asset_id)
-      || cleanText(registeredAssetRecord?.assetId)
-      || cleanText(registeredAssetRecord?.intake_record_id)
-      || cleanText(registeredAssetRecord?.intakeRecordId)
-      || cleanText(normalizedAssetId)
-      || null;
-    const intakeRecordResolvedId = cleanText(registeredAssetRecord?.intake_record_id)
-      || cleanText(registeredAssetRecord?.intakeRecordId)
-      || cleanText(registeredAssetRecord?.asset_id)
-      || cleanText(registeredAssetRecord?.assetId)
-      || cleanText(intake_record_id)
-      || cleanText(intakeRecordId)
-      || null;
-
-    return {
-      status: missingSurfaces.length > 0 ? 'partial' : 'ready',
-      project_id: resolvedProjectId || null,
-      asset_id: assetRecordId,
-      intake_record_id: intakeRecordResolvedId,
-      classification_id: classificationId,
-      asset_type: normalizedAssetType,
-      classification_category: normalizedClassificationCategory,
-      reuse_potential: normalizedReusePotential || null,
-      risk_level: normalizedClassification.risk_level || normalizedClassification.riskLevel || normalizedKnownRisks[0] || null,
-      classification_confidence: normalizedClassificationConfidence || null,
-      assigned_reviewer: normalizedAssignedReviewer || null,
-      source_ref: normalizedSourceRef,
-      submitted_by: normalizedSubmittedBy,
-      review_required: Boolean(normalizedReviewRequired),
-      transfer_packet_id: transferPacketId,
-      watch_id: watchId,
-      heartbeat_status: cleanText(heartbeatPayload.activity_state)
-        || cleanText(heartbeatPayload.collaboration_heartbeat?.activity_state)
-        || cleanText(heartbeatPayload.status)
-        || cleanText(heartbeatPayload.heartbeat_status)
-        || null,
-      operator_projection_metadata: {
-        portfolio_bundle: portfolioBundle,
-        project_roadmap_summary: projectRoadmapSummary,
-        project_roadmap_active_item: projectActiveItem,
-        registered_asset_record: registeredAssetRecord,
-        classification_record: classificationRecord,
-        classification_observation: classificationObservation,
-        review_transfer: transferPayload,
-        message_watch: watchPayload,
-        heartbeat: heartbeatPayload,
-      },
-      missing_surfaces: [...new Set(missingSurfaces)],
-      project: projectPayload,
-      registered_asset_record: registeredAssetRecord,
-      classification_record: classificationRecord,
-      classification_observation: classificationObservation,
-      transfer: transferPayload,
-      message_watch: watchPayload,
-      heartbeat: heartbeatPayload,
-    };
-  }
-
-  async discoverSalvageCandidates({
-    projectIdentifier,
-    projectId,
-    relatedProjectId,
-    related_project_id,
-    startWorkBody = {},
-    startWorkRequest = {},
-    resumeProjectWorkOptions = {},
-    asset = {},
-    modernizationAsset = {},
-    classification = {},
-    modernizationClassification = {},
-    assetId,
-    asset_id,
-    intakeRecordId,
-    intake_record_id,
-    classificationId,
-    classification_id,
-    sourceRef,
-    source_ref,
-    assetType,
-    asset_type,
-    classificationCategory,
-    classification_category,
-    domainArea,
-    domain_area,
-    reusePotential,
-    reuse_potential,
-    modernizationNeed,
-    modernization_need,
-    riskLevel,
-    risk_level,
-    knownRisks = [],
-    known_risks = [],
-    evidenceRefs = [],
-    evidence_refs = [],
-    recommendedNextStep,
-    recommended_next_step,
-    reviewRequired,
-    review_required,
-    assignedReviewer,
-    assigned_reviewer,
-    candidateSearchIntent,
-    candidate_search_intent,
-    candidateSearchQuery,
-    candidate_search_query,
-    relatedSymbols = [],
-    related_symbols = [],
-    relatedQualifiedNames = [],
-    related_qualified_names = [],
-    relatedFilePaths = [],
-    related_file_paths = [],
-    maxCandidates = 10,
-    submittedBy,
-    submitted_by,
-    includePortfolioBundle = true,
-    includeProjectRoadmap = true,
-    includeProjectActiveItem = true,
-    metadata = {},
-  } = {}) {
-    const missingSurfaces = [];
-    const normalizedMetadata = isPlainObject(metadata) ? metadata : {};
-    const normalizedAsset = isPlainObject(modernizationAsset)
-      ? modernizationAsset
-      : (isPlainObject(asset) ? asset : {});
-    const normalizedClassification = isPlainObject(modernizationClassification)
-      ? modernizationClassification
-      : (isPlainObject(classification) ? classification : {});
-    const normalizedProjectReference = cleanText(projectIdentifier)
-      || cleanText(projectId)
-      || cleanText(relatedProjectId)
-      || cleanText(related_project_id)
-      || cleanText(normalizedAsset.related_project_id)
-      || cleanText(normalizedAsset.relatedProjectId)
-      || cleanText(normalizedClassification.related_project_id)
-      || cleanText(normalizedClassification.relatedProjectId);
-    const normalizedAssetId = cleanText(asset_id)
-      || cleanText(assetId)
-      || cleanText(intake_record_id)
-      || cleanText(intakeRecordId)
-      || cleanText(normalizedAsset.asset_id)
-      || cleanText(normalizedAsset.assetId)
-      || cleanText(normalizedAsset.intake_record_id)
-      || cleanText(normalizedAsset.intakeRecordId);
-    const normalizedClassificationId = cleanText(classification_id)
-      || cleanText(classificationId)
-      || cleanText(normalizedClassification.classification_id)
-      || cleanText(normalizedClassification.classificationId);
-    const normalizedSourceRef = cleanText(source_ref)
-      || cleanText(sourceRef)
-      || cleanText(normalizedAsset.source_ref)
-      || cleanText(normalizedAsset.sourceRef)
-      || normalizedAssetId;
-    if (!normalizedAssetId && !normalizedSourceRef && !normalizedClassificationId) {
-      throw new Error('asset_id, intake_record_id, classification_id, or source_ref is required.');
-    }
-    const normalizedAssetType = cleanText(asset_type)
-      || cleanText(assetType)
-      || cleanText(normalizedAsset.asset_type)
-      || cleanText(normalizedAsset.assetType)
-      || 'unknown';
-    const normalizedClassificationCategory = cleanText(classification_category)
-      || cleanText(classificationCategory)
-      || cleanText(normalizedClassification.classification_category)
-      || cleanText(normalizedClassification.classificationCategory)
-      || 'uncategorized';
-    const normalizedDomainArea = cleanText(domain_area)
-      || cleanText(domainArea)
-      || cleanText(normalizedClassification.domain_area)
-      || cleanText(normalizedClassification.domainArea);
-    const normalizedReusePotential = cleanText(reuse_potential)
-      || cleanText(reusePotential)
-      || cleanText(normalizedClassification.reuse_potential)
-      || cleanText(normalizedClassification.reusePotential);
-    const normalizedModernizationNeed = cleanText(modernization_need)
-      || cleanText(modernizationNeed)
-      || cleanText(normalizedClassification.modernization_need)
-      || cleanText(normalizedClassification.modernizationNeed);
-    const normalizedRiskLevel = cleanText(risk_level)
-      || cleanText(riskLevel)
-      || cleanText(normalizedClassification.risk_level)
-      || cleanText(normalizedClassification.riskLevel)
-      || null;
-    const normalizedRecommendedNextStep = cleanText(recommended_next_step)
-      || cleanText(recommendedNextStep)
-      || cleanText(normalizedClassification.recommended_next_step)
-      || cleanText(normalizedClassification.recommendedNextStep);
-    const normalizedKnownRisks = Array.isArray(known_risks)
-      ? known_risks
-      : (Array.isArray(knownRisks) ? knownRisks : normalizedAsset.known_risks || normalizedAsset.knownRisks || []);
-    const normalizedEvidenceRefs = Array.isArray(evidence_refs)
-      ? evidence_refs
-      : (Array.isArray(evidenceRefs) ? evidenceRefs : normalizedAsset.evidence_refs || normalizedAsset.evidenceRefs || []);
-    const normalizedAssignedReviewer = cleanText(assigned_reviewer)
-      || cleanText(assignedReviewer)
-      || cleanText(normalizedClassification.assigned_reviewer)
-      || cleanText(normalizedClassification.assignedReviewer);
-    const normalizedSubmittedBy = cleanText(submitted_by)
-      || cleanText(submittedBy)
-      || this.agentSessionId
-      || this.actorId
-      || null;
-    const normalizedReviewRequired = review_required ?? reviewRequired ?? true;
-    const normalizedCandidateSearchIntent = cleanText(candidate_search_intent)
-      || cleanText(candidateSearchIntent)
-      || normalizedClassificationCategory
-      || normalizedDomainArea
-      || normalizedSourceRef
-      || normalizedAssetType;
-    const normalizedCandidateSearchQuery = cleanText(candidate_search_query)
-      || cleanText(candidateSearchQuery)
-      || [
-          normalizedClassificationCategory,
-          normalizedDomainArea,
-          normalizedModernizationNeed,
-          normalizedSourceRef,
-          normalizedAssetType,
-        ].filter(Boolean).join(' ');
-    const normalizedRelatedSymbols = cleanList(related_symbols.length > 0 ? related_symbols : relatedSymbols);
-    const normalizedRelatedQualifiedNames = cleanList(related_qualified_names.length > 0 ? related_qualified_names : relatedQualifiedNames);
-    const normalizedRelatedFilePaths = cleanList(related_file_paths.length > 0 ? related_file_paths : relatedFilePaths);
-    const normalizedMaxCandidates = Number.isFinite(Number(maxCandidates)) && Number(maxCandidates) > 0
-      ? Number(maxCandidates)
-      : 10;
-
-    let continuation = null;
-    let startWorkResult = null;
-    if (normalizedProjectReference) {
-      if (typeof this.resumeProjectWork === 'function') {
-        continuation = await this.resumeProjectWork({
-          projectIdentifier: normalizedProjectReference,
-          projectId: normalizedProjectReference,
-          requireClaim: false,
-          ...resumeProjectWorkOptions,
-        });
-      } else {
-        missingSurfaces.push('resumeProjectWork');
-      }
-    } else if (Object.keys(isPlainObject(startWorkRequest) ? startWorkRequest : {}).length > 0 || Object.keys(isPlainObject(startWorkBody) ? startWorkBody : {}).length > 0) {
-      if (typeof this.startWork === 'function') {
-        startWorkResult = await this.startWork({
-          ...(isPlainObject(startWorkBody) ? startWorkBody : {}),
-          ...(isPlainObject(startWorkRequest) ? startWorkRequest : {}),
-        });
-      } else {
-        missingSurfaces.push('startWork');
-      }
-    }
-
-    const projectPayload = isPlainObject(continuation?.project)
-      ? continuation.project
-      : isPlainObject(startWorkResult?.project)
-        ? startWorkResult.project
-        : isPlainObject(continuation?.summary)
-          ? continuation.summary
-          : {};
-    const resolvedProjectId = cleanText(projectPayload.project_id)
-      || cleanText(projectPayload.projectId)
-      || normalizedProjectReference;
-    const resolvedWorkflowId = cleanText(projectPayload.workflow_id)
-      || cleanText(projectPayload.workflowId)
-      || cleanText(continuation?.workflow_id)
-      || cleanText(startWorkResult?.workflow_id);
-    const resolvedWorkflowRunId = cleanText(projectPayload.workflow_run_id)
-      || cleanText(projectPayload.workflowRunId)
-      || cleanText(continuation?.workflow_run_id)
-      || cleanText(startWorkResult?.workflow_run_id)
-      || cleanText(startWorkResult?.workflowRunId);
-
-    const portfolioBundle = includePortfolioBundle && typeof this.getPortfolioBundle === 'function'
-      ? await this.getPortfolioBundle().catch(() => null)
-      : null;
-    const projectRoadmapSummary = resolvedProjectId && includeProjectRoadmap && typeof this.getProjectRoadmapSummary === 'function'
-      ? await this.getProjectRoadmapSummary(resolvedProjectId).catch(() => null)
-      : null;
-    const projectActiveItem = resolvedProjectId && includeProjectActiveItem && typeof this.getProjectRoadmapActiveItem === 'function'
-      ? await this.getProjectRoadmapActiveItem(resolvedProjectId).catch(() => null)
-      : null;
-
-    let assetIntakeRecord = null;
-    const intakeLookupSurface = typeof this.getModernizationAssetIntakeRecord === 'function'
-      ? this.getModernizationAssetIntakeRecord.bind(this)
-      : null;
-    if (!intakeLookupSurface) {
-      missingSurfaces.push('getModernizationAssetIntakeRecord');
-    } else {
-      assetIntakeRecord = await intakeLookupSurface({
-        projectId: resolvedProjectId,
-        workflowId: resolvedWorkflowId,
-        workflowRunId: resolvedWorkflowRunId,
-        assetId: normalizedAssetId,
-        intakeRecordId: cleanText(intake_record_id) || cleanText(intakeRecordId),
-        sourceRef: normalizedSourceRef,
-        metadata: {
-          ...normalizedMetadata,
-          source: 'discoverSalvageCandidates',
-        },
-      });
-    }
-
-    let classificationRecord = null;
-    const classificationLookupSurface = typeof this.getModernizationAssetClassificationRecord === 'function'
-      ? this.getModernizationAssetClassificationRecord.bind(this)
-      : null;
-    if (!classificationLookupSurface) {
-      missingSurfaces.push('getModernizationAssetClassificationRecord');
-    } else {
-      classificationRecord = await classificationLookupSurface({
-        projectId: resolvedProjectId,
-        workflowId: resolvedWorkflowId,
-        workflowRunId: resolvedWorkflowRunId,
-        assetId: normalizedAssetId,
-        classificationId: normalizedClassificationId,
-        sourceRef: normalizedSourceRef,
-        metadata: {
-          ...normalizedMetadata,
-          source: 'discoverSalvageCandidates',
-        },
-      });
-    }
-
-    let codeIntentResult = null;
-    if (typeof this.searchCodeByIntent === 'function') {
-      codeIntentResult = await this.searchCodeByIntent({
-        intentText: normalizedCandidateSearchIntent,
-        repoKey: normalizedProjectReference || undefined,
-        refName: normalizedSourceRef || undefined,
-        maxCandidates: normalizedMaxCandidates,
-      });
-    } else {
-      missingSurfaces.push('searchCodeByIntent');
-    }
-
-    if (typeof this.getCodeContextForIntent === 'function') {
-      await this.getCodeContextForIntent({
-        intentText: normalizedCandidateSearchIntent,
-        candidatePolicy: 'top_ranked',
-      }).catch(() => null);
-    } else {
-      missingSurfaces.push('getCodeContextForIntent');
-    }
-
-    let symbolSearchResult = null;
-    if (typeof this.searchSymbols === 'function') {
-      symbolSearchResult = await this.searchSymbols({
-        query: normalizedCandidateSearchQuery,
-        projectScope: resolvedProjectId || undefined,
-        maxResults: normalizedMaxCandidates,
-      }).catch(() => null);
-    } else {
-      missingSurfaces.push('searchSymbols');
-    }
-
-    const relatedCodeResults = [];
-    if (typeof this.getRelatedCode === 'function') {
-      for (const qualifiedName of normalizedRelatedQualifiedNames) {
-        relatedCodeResults.push(await this.getRelatedCode({
-          qualifiedName,
-          relationshipType: 'salvage_candidate',
-          depth: 2,
-          includeCode: false,
-          requestedBy: normalizedSubmittedBy,
-        }).catch(() => null));
-      }
-      for (const symbolKey of normalizedRelatedSymbols) {
-        relatedCodeResults.push(await this.getRelatedCode({
-          symbolKey,
-          relationshipType: 'salvage_candidate',
-          depth: 2,
-          includeCode: false,
-          requestedBy: normalizedSubmittedBy,
-        }).catch(() => null));
-      }
-    } else if (normalizedRelatedSymbols.length > 0 || normalizedRelatedQualifiedNames.length > 0) {
-      missingSurfaces.push('getRelatedCode');
-    }
-
-    const toArray = (value) => {
-      if (Array.isArray(value)) return value;
-      if (isPlainObject(value)) {
-        const candidates = value.candidates || value.results || value.items || value.symbols || value.related_code || value.relatedCode;
-        if (Array.isArray(candidates)) return candidates;
-      }
-      return [];
-    };
-
-    const mapCandidate = (entry, candidateType, fallbackRankReason) => {
-      if (!isPlainObject(entry)) return null;
-      const sourceRefValue = cleanText(entry.source_ref)
-        || cleanText(entry.sourceRef)
-        || cleanText(entry.qualified_name)
-        || cleanText(entry.qualifiedName)
-        || cleanText(entry.file_path)
-        || cleanText(entry.filePath)
-        || cleanText(entry.symbol_key)
-        || cleanText(entry.symbolKey)
-        || cleanText(entry.symbol_id)
-        || cleanText(entry.symbolId)
-        || null;
-      const candidate = {
-        candidate_type: cleanText(entry.candidate_type) || cleanText(entry.candidateType) || candidateType,
-        source_ref: sourceRefValue,
-        file_path: cleanText(entry.file_path) || cleanText(entry.filePath) || null,
-        qualified_name: cleanText(entry.qualified_name) || cleanText(entry.qualifiedName) || null,
-        responsibility_area: cleanText(entry.responsibility_area) || cleanText(entry.responsibilityArea) || normalizedDomainArea || normalizedClassificationCategory || null,
-        reuse_potential: cleanText(entry.reuse_potential) || cleanText(entry.reusePotential) || normalizedReusePotential || null,
-        modernization_need: cleanText(entry.modernization_need) || cleanText(entry.modernizationNeed) || normalizedModernizationNeed || null,
-        risk_level: cleanText(entry.risk_level) || cleanText(entry.riskLevel) || normalizedRiskLevel || null,
-        rank_reason: cleanText(entry.rank_reason) || cleanText(entry.rankReason) || fallbackRankReason,
-        evidence_refs: Array.isArray(entry.evidence_refs) ? entry.evidence_refs : (Array.isArray(entry.evidenceRefs) ? entry.evidenceRefs : [...normalizedEvidenceRefs]),
-        recommended_next_step: cleanText(entry.recommended_next_step) || cleanText(entry.recommendedNextStep) || normalizedRecommendedNextStep || null,
-      };
-      return candidate.source_ref || candidate.file_path || candidate.qualified_name ? candidate : null;
-    };
-
-    const candidateMap = new Map();
-    const addCandidates = (entries, candidateType, fallbackRankReason) => {
-      for (const entry of entries) {
-        const candidate = mapCandidate(entry, candidateType, fallbackRankReason);
-        if (!candidate) continue;
-        const key = candidate.source_ref || candidate.file_path || candidate.qualified_name;
-        if (!candidateMap.has(key)) {
-          candidateMap.set(key, candidate);
-        }
-      }
-    };
-
-    addCandidates(toArray(codeIntentResult), 'intent_search_match', 'ranked by intent search');
-    addCandidates(toArray(symbolSearchResult), 'symbol_search_match', 'ranked by inventory symbol search');
-    for (const relatedCodeResult of relatedCodeResults) {
-      addCandidates(toArray(relatedCodeResult), 'related_code_match', 'related code lookup');
-    }
-
-    const candidates = [...candidateMap.values()].slice(0, normalizedMaxCandidates);
-    const candidateCount = candidates.length;
-
-    let discoveryObservation = null;
-    const discoveryObservationSurface = typeof this.submitModernizationSalvageDiscoveryObservation === 'function'
-      ? this.submitModernizationSalvageDiscoveryObservation.bind(this)
-      : null;
-    if (!discoveryObservationSurface) {
-      missingSurfaces.push('submitModernizationSalvageDiscoveryObservation');
-    } else {
-      discoveryObservation = await discoveryObservationSurface({
-        projectId: resolvedProjectId,
-        workflowId: resolvedWorkflowId,
-        workflowRunId: resolvedWorkflowRunId,
-        assetId: normalizedAssetId,
-        intakeRecordId: cleanText(intake_record_id) || cleanText(intakeRecordId),
-        classificationId: normalizedClassificationId,
-        candidateCount,
-        candidates,
-        evidenceRefs: normalizedEvidenceRefs,
-        observationKind: 'salvage_candidate_discovery',
-        observationState: 'prepared',
-        observationSummary: normalizedCandidateSearchIntent || normalizedClassificationCategory || normalizedSourceRef || 'salvage candidate discovery',
-        metadata: {
-          ...normalizedMetadata,
-          source: 'discoverSalvageCandidates',
-        },
-      });
-    }
-
-    let transferResult = null;
-    let watchResult = null;
-    let heartbeatResult = null;
-    const reviewTransferNeeded = Boolean(normalizedReviewRequired && normalizedAssignedReviewer);
-    if (reviewTransferNeeded) {
-      const transferSurface = typeof this.transferWorkPacket === 'function'
-        ? this.transferWorkPacket.bind(this)
-        : null;
-      if (!transferSurface) {
-        missingSurfaces.push('transferWorkPacket');
-      } else {
-        transferResult = await transferSurface({
-          workflowRunId: resolvedWorkflowRunId,
-          transferKind: 'upstream_remediation',
-          objective: `Review salvage candidates for ${normalizedSourceRef || normalizedAssetId}`,
-          requestedOutcome: 'Review and rank salvage candidates from governed inventory.',
-          target: {
-            intent: 'upstream_remediation',
-            recipient_mode: 'agent_session',
-            preferred_agent_session_id: normalizedAssignedReviewer,
-            preferred_role_key: normalizedAssignedReviewer,
-          },
-          artifacts: normalizedSourceRef ? [normalizedSourceRef] : [],
-          issues: normalizedKnownRisks,
-          expected_evidence: normalizedEvidenceRefs,
-          preferred_modes: ['bundle', 'artifact_refs', 'inline_payload'],
-          capabilities: {},
-          sender_agent_session_id: normalizedSubmittedBy,
-          sender_actor_session_id: null,
-          message_kind: 'handoff',
-          subject: normalizedCandidateSearchIntent || normalizedSourceRef || 'Salvage candidate discovery',
-          body_markdown: normalizedRecommendedNextStep || normalizedClassificationCategory || normalizedSourceRef,
-          metadata: {
-            ...normalizedMetadata,
-            source: 'discoverSalvageCandidates',
-            asset_id: normalizedAssetId,
-            classification_id: normalizedClassificationId,
-            classification_category: normalizedClassificationCategory,
-            domain_area: normalizedDomainArea,
-          },
-        });
-      }
-    }
-
-    const transferPayload = isPlainObject(transferResult) ? transferResult : {};
-    const transferPacketId = cleanText(transferPayload.work_transfer_packet?.work_transfer_packet_id)
-      || cleanText(transferPayload.work_transfer_packet_id)
-      || cleanText(transferPayload.transfer_packet_id)
-      || cleanText(transferPayload.packet_id)
-      || null;
-    const transferChannelId = cleanText(transferPayload.communication_transfer_channel?.transfer_channel_id)
-      || cleanText(transferPayload.communication_transfer_channel?.channel_id)
-      || cleanText(transferPayload.transfer_channel?.transfer_channel_id)
-      || cleanText(transferPayload.transfer_channel_id)
-      || cleanText(transferPayload.channel_id)
-      || null;
-
-    if (reviewTransferNeeded && transferChannelId && transferPacketId) {
-      const watchSurface = typeof this.startMessageWatch === 'function'
-        ? this.startMessageWatch.bind(this)
-        : null;
-      if (!watchSurface) {
-        missingSurfaces.push('startMessageWatch');
-      } else {
-        watchResult = await watchSurface({
-          transferChannelId,
-          workTransferPacketId: transferPacketId,
-          workflowRunId: resolvedWorkflowRunId,
-          watchingAgentRole: normalizedSubmittedBy,
-          expectedFromRole: normalizedAssignedReviewer,
-          expectedMessageKind: 'response',
-          watchType: 'expected_peer_message',
-          watchingAgentSessionId: normalizedSubmittedBy,
-          expectedPayload: {
-            asset_id: normalizedAssetId,
-            classification_id: normalizedClassificationId,
-            candidate_count: candidateCount,
-          },
-          currentStatus: 'watching',
-          operatorNudge: normalizedRecommendedNextStep || normalizedClassificationCategory || normalizedSourceRef,
-          metadata: {
-            ...normalizedMetadata,
-            source: 'discoverSalvageCandidates',
-          },
-        });
-      }
-    }
-
-    const watchPayload = isPlainObject(watchResult) ? watchResult : {};
-    const watchId = cleanText(watchPayload.message_watch_id)
-      || cleanText(watchPayload.watch_id)
-      || cleanText(watchPayload.message_watch?.message_watch_id)
-      || cleanText(watchPayload.message_watch?.watch_id)
-      || null;
-
-    if ((discoveryObservation || transferResult) && typeof this.postCollaborationHeartbeat === 'function') {
-      try {
-        heartbeatResult = await this.postCollaborationHeartbeat({
-          transferChannelId: transferChannelId || undefined,
-          workTransferPacketId: transferPacketId || undefined,
-          workflowRunId: resolvedWorkflowRunId,
-          participantRole: reviewTransferNeeded ? 'salvage_reviewer' : 'salvage_discovery',
-          currentPhase: reviewTransferNeeded ? 'review_pending' : 'discovery_complete',
-          currentTaskSummary: normalizedCandidateSearchIntent || normalizedSourceRef || 'Salvage candidate discovery',
-        });
-      } catch (error) {
-        void error;
-      }
-    }
-
-    const heartbeatPayload = isPlainObject(heartbeatResult) ? heartbeatResult : {};
-    const heartbeatStatus = cleanText(heartbeatPayload.activity_state)
-      || cleanText(heartbeatPayload.collaboration_heartbeat?.activity_state)
-      || cleanText(heartbeatPayload.status)
-      || cleanText(heartbeatPayload.heartbeat_status)
-      || null;
-
-    return {
-      status: missingSurfaces.length > 0 ? 'partial' : 'ready',
-      project_id: resolvedProjectId || null,
-      asset_id: cleanText(assetIntakeRecord?.asset_id)
-        || cleanText(assetIntakeRecord?.assetId)
-        || normalizedAssetId
-        || null,
-      intake_record_id: cleanText(assetIntakeRecord?.intake_record_id)
-        || cleanText(assetIntakeRecord?.intakeRecordId)
-        || cleanText(intake_record_id)
-        || cleanText(intakeRecordId)
-        || null,
-      classification_id: cleanText(classificationRecord?.classification_id)
-        || cleanText(classificationRecord?.classificationId)
-        || normalizedClassificationId
-        || null,
-      candidate_count: candidateCount,
-      candidates,
-      review_required: Boolean(normalizedReviewRequired),
-      assigned_reviewer: normalizedAssignedReviewer || null,
-      transfer_packet_id: transferPacketId,
-      watch_id: watchId,
-      heartbeat_status: heartbeatStatus,
-      operator_projection_metadata: {
-        portfolio_bundle: portfolioBundle,
-        project_roadmap_summary: projectRoadmapSummary,
-        project_roadmap_active_item: projectActiveItem,
-        asset_intake_record: assetIntakeRecord,
-        classification_record: classificationRecord,
-        code_intent_search: codeIntentResult,
-        symbol_search: symbolSearchResult,
-        related_code: relatedCodeResults,
-        discovery_observation: discoveryObservation,
-        transfer: transferPayload,
-        message_watch: watchPayload,
-        heartbeat: heartbeatPayload,
-      },
-      missing_surfaces: [...new Set(missingSurfaces)],
-      project: projectPayload,
-      asset_intake_record: assetIntakeRecord,
-      classification_record: classificationRecord,
-      code_intent_search: codeIntentResult,
-      symbol_search: symbolSearchResult,
-      related_code: relatedCodeResults,
-      discovery_observation: discoveryObservation,
-      transfer: transferPayload,
-      message_watch: watchPayload,
-      heartbeat: heartbeatPayload,
-    };
-  }
-
-  async createModernizationWorkPacket({
-    projectIdentifier,
-    projectId,
-    relatedProjectId,
-    related_project_id,
-    startWorkBody = {},
-    startWorkRequest = {},
-    resumeProjectWorkOptions = {},
-    asset = {},
-    modernizationAsset = {},
-    classification = {},
-    modernizationClassification = {},
-    assetId,
-    asset_id,
-    intakeRecordId,
-    intake_record_id,
-    classificationId,
-    classification_id,
-    selectedCandidates = [],
-    selected_candidates = [],
-    candidateIds = [],
-    candidate_ids = [],
-    candidateObjects = [],
-    candidate_objects = [],
-    sourceRef,
-    source_ref,
-    packetTitle,
-    packet_title,
-    problemStatement,
-    problem_statement,
-    recommendedModernization,
-    recommended_modernization,
-    affectedFilesOrSymbols = [],
-    affected_files_or_symbols = [],
-    acceptanceCriteria = [],
-    acceptance_criteria = [],
-    riskLevel,
-    risk_level,
-    evidenceRefs = [],
-    evidence_refs = [],
-    wrapperExecutionRequired,
-    wrapper_execution_required,
-    handoffNotes,
-    handoff_notes,
-    targetAgent,
-    target_agent,
-    assignedOwner,
-    assigned_owner,
-    collaborationRequired,
-    collaboration_required,
-    channelId,
-    channel_id,
-    transferChannelId,
-    transfer_channel_id,
-    submittedBy,
-    submitted_by,
-    includePortfolioBundle = true,
-    includeProjectRoadmap = true,
-    includeProjectActiveItem = true,
-    includeTransferChannelProjection = true,
-    metadata = {},
-  } = {}) {
-    const missingSurfaces = [];
-    const normalizedMetadata = isPlainObject(metadata) ? metadata : {};
-    const normalizedAsset = isPlainObject(modernizationAsset)
-      ? modernizationAsset
-      : (isPlainObject(asset) ? asset : {});
-    const normalizedClassification = isPlainObject(modernizationClassification)
-      ? modernizationClassification
-      : (isPlainObject(classification) ? classification : {});
-    const normalizedProjectReference = cleanText(projectIdentifier)
-      || cleanText(projectId)
-      || cleanText(relatedProjectId)
-      || cleanText(related_project_id)
-      || cleanText(normalizedAsset.related_project_id)
-      || cleanText(normalizedAsset.relatedProjectId)
-      || cleanText(normalizedClassification.related_project_id)
-      || cleanText(normalizedClassification.relatedProjectId);
-    const normalizedAssetId = cleanText(asset_id)
-      || cleanText(assetId)
-      || cleanText(intake_record_id)
-      || cleanText(intakeRecordId)
-      || cleanText(normalizedAsset.asset_id)
-      || cleanText(normalizedAsset.assetId)
-      || cleanText(normalizedAsset.intake_record_id)
-      || cleanText(normalizedAsset.intakeRecordId);
-    const normalizedClassificationId = cleanText(classification_id)
-      || cleanText(classificationId)
-      || cleanText(normalizedClassification.classification_id)
-      || cleanText(normalizedClassification.classificationId);
-    const normalizedSourceRef = cleanText(source_ref)
-      || cleanText(sourceRef)
-      || cleanText(normalizedAsset.source_ref)
-      || cleanText(normalizedAsset.sourceRef)
-      || normalizedAssetId;
-    const normalizedPacketTitle = cleanText(packet_title) || cleanText(packetTitle);
-    const normalizedProblemStatement = cleanText(problem_statement)
-      || cleanText(problemStatement)
-      || normalizedPacketTitle
-      || normalizedSourceRef
-      || 'Modernization work packet';
-    const normalizedRecommendedModernization = cleanText(recommended_modernization)
-      || cleanText(recommendedModernization)
-      || cleanText(normalizedClassification.recommended_modernization)
-      || cleanText(normalizedClassification.recommendedModernization);
-    const normalizedRiskLevel = cleanText(risk_level)
-      || cleanText(riskLevel)
-      || cleanText(normalizedClassification.risk_level)
-      || cleanText(normalizedClassification.riskLevel)
-      || null;
-    const normalizedHandoffNotes = cleanText(handoff_notes) || cleanText(handoffNotes);
-    const normalizedSubmittedBy = cleanText(submitted_by)
-      || cleanText(submittedBy)
-      || this.agentSessionId
-      || this.actorId
-      || null;
-    const normalizedTargetAgent = cleanText(target_agent) || cleanText(targetAgent) || cleanText(assigned_owner) || cleanText(assignedOwner) || null;
-    const normalizedWrapperExecutionRequired = wrapper_execution_required ?? wrapperExecutionRequired ?? true;
-    const normalizedCollaborationRequired = collaboration_required ?? collaborationRequired ?? Boolean(normalizedTargetAgent);
-    const normalizedAffectedFilesOrSymbols = cleanList(affected_files_or_symbols.length > 0 ? affected_files_or_symbols : affectedFilesOrSymbols);
-    const normalizedAcceptanceCriteria = cleanList(acceptance_criteria.length > 0 ? acceptance_criteria : acceptanceCriteria);
-    const normalizedEvidenceRefs = cleanList(evidence_refs.length > 0 ? evidence_refs : evidenceRefs);
-
-    const candidateEntries = [
-      ...(Array.isArray(selected_candidates) && selected_candidates.length > 0 ? selected_candidates : selectedCandidates),
-      ...(Array.isArray(candidate_objects) && candidate_objects.length > 0 ? candidate_objects : candidateObjects),
-    ];
-    const normalizedCandidateIds = [];
-    const normalizedCandidateRecords = [];
-    for (const entry of candidateEntries) {
-      if (typeof entry === 'string') {
-        const candidateId = cleanText(entry);
-        if (candidateId) normalizedCandidateIds.push(candidateId);
-        continue;
-      }
-      if (!isPlainObject(entry)) continue;
-      const candidateId = cleanText(entry.candidate_id)
-        || cleanText(entry.candidateId)
-        || cleanText(entry.salvage_candidate_id)
-        || cleanText(entry.salvageCandidateId)
-        || cleanText(entry.work_packet_candidate_id)
-        || cleanText(entry.workPacketCandidateId)
-        || cleanText(entry.source_ref)
-        || cleanText(entry.sourceRef)
-        || cleanText(entry.qualified_name)
-        || cleanText(entry.qualifiedName);
-      if (candidateId) normalizedCandidateIds.push(candidateId);
-      normalizedCandidateRecords.push(entry);
-    }
-    for (const candidateId of Array.isArray(candidate_ids) && candidate_ids.length > 0 ? candidate_ids : candidateIds) {
-      const normalizedCandidateId = cleanText(candidateId);
-      if (normalizedCandidateId) normalizedCandidateIds.push(normalizedCandidateId);
-    }
-    const uniqueCandidateIds = [...new Set(normalizedCandidateIds)].filter(Boolean);
-    if (uniqueCandidateIds.length === 0) {
-      throw new Error('candidate_ids or selected_candidates is required.');
-    }
-
-    let continuation = null;
-    let startWorkResult = null;
-    if (normalizedProjectReference) {
-      if (typeof this.resumeProjectWork === 'function') {
-        continuation = await this.resumeProjectWork({
-          projectIdentifier: normalizedProjectReference,
-          projectId: normalizedProjectReference,
-          requireClaim: false,
-          ...resumeProjectWorkOptions,
-        });
-      } else {
-        missingSurfaces.push('resumeProjectWork');
-      }
-    } else if (Object.keys(isPlainObject(startWorkRequest) ? startWorkRequest : {}).length > 0 || Object.keys(isPlainObject(startWorkBody) ? startWorkBody : {}).length > 0) {
-      if (typeof this.startWork === 'function') {
-        startWorkResult = await this.startWork({
-          ...(isPlainObject(startWorkBody) ? startWorkBody : {}),
-          ...(isPlainObject(startWorkRequest) ? startWorkRequest : {}),
-        });
-      } else {
-        missingSurfaces.push('startWork');
-      }
-    }
-
-    const projectPayload = isPlainObject(continuation?.project)
-      ? continuation.project
-      : isPlainObject(startWorkResult?.project)
-        ? startWorkResult.project
-        : isPlainObject(continuation?.summary)
-          ? continuation.summary
-          : {};
-    const resolvedProjectId = cleanText(projectPayload.project_id)
-      || cleanText(projectPayload.projectId)
-      || normalizedProjectReference;
-    const resolvedWorkflowId = cleanText(projectPayload.workflow_id)
-      || cleanText(projectPayload.workflowId)
-      || cleanText(continuation?.workflow_id)
-      || cleanText(startWorkResult?.workflow_id);
-    const resolvedWorkflowRunId = cleanText(projectPayload.workflow_run_id)
-      || cleanText(projectPayload.workflowRunId)
-      || cleanText(continuation?.workflow_run_id)
-      || cleanText(startWorkResult?.workflow_run_id)
-      || cleanText(startWorkResult?.workflowRunId);
-
-    const portfolioBundle = includePortfolioBundle && typeof this.getPortfolioBundle === 'function'
-      ? await this.getPortfolioBundle().catch(() => null)
-      : null;
-    const projectRoadmapSummary = resolvedProjectId && includeProjectRoadmap && typeof this.getProjectRoadmapSummary === 'function'
-      ? await this.getProjectRoadmapSummary(resolvedProjectId).catch(() => null)
-      : null;
-    const projectActiveItem = resolvedProjectId && includeProjectActiveItem && typeof this.getProjectRoadmapActiveItem === 'function'
-      ? await this.getProjectRoadmapActiveItem(resolvedProjectId).catch(() => null)
-      : null;
-
-    let assetIntakeRecord = null;
-    const intakeLookupSurface = typeof this.getModernizationAssetIntakeRecord === 'function'
-      ? this.getModernizationAssetIntakeRecord.bind(this)
-      : null;
-    if (!intakeLookupSurface) {
-      missingSurfaces.push('getModernizationAssetIntakeRecord');
-    } else {
-      assetIntakeRecord = await intakeLookupSurface({
-        projectId: resolvedProjectId,
-        workflowId: resolvedWorkflowId,
-        workflowRunId: resolvedWorkflowRunId,
-        assetId: normalizedAssetId,
-        intakeRecordId: cleanText(intake_record_id) || cleanText(intakeRecordId),
-        sourceRef: normalizedSourceRef,
-        metadata: {
-          ...normalizedMetadata,
-          source: 'createModernizationWorkPacket',
-        },
-      });
-    }
-
-    let classificationRecord = null;
-    const classificationLookupSurface = typeof this.getModernizationAssetClassificationRecord === 'function'
-      ? this.getModernizationAssetClassificationRecord.bind(this)
-      : null;
-    if (!classificationLookupSurface) {
-      missingSurfaces.push('getModernizationAssetClassificationRecord');
-    } else {
-      classificationRecord = await classificationLookupSurface({
-        projectId: resolvedProjectId,
-        workflowId: resolvedWorkflowId,
-        workflowRunId: resolvedWorkflowRunId,
-        assetId: normalizedAssetId,
-        classificationId: normalizedClassificationId,
-        sourceRef: normalizedSourceRef,
-        metadata: {
-          ...normalizedMetadata,
-          source: 'createModernizationWorkPacket',
-        },
-      });
-    }
-
-    let candidateRecords = [];
-    const candidateLookupSurface = typeof this.getModernizationSalvageCandidateRecord === 'function'
-      ? this.getModernizationSalvageCandidateRecord.bind(this)
-      : typeof this.getModernizationWorkPacketCandidateRecord === 'function'
-        ? this.getModernizationWorkPacketCandidateRecord.bind(this)
-        : null;
-    if (!candidateLookupSurface) {
-      missingSurfaces.push('getModernizationSalvageCandidateRecord');
-      missingSurfaces.push('getModernizationWorkPacketCandidateRecord');
-    } else {
-      candidateRecords = await Promise.all(uniqueCandidateIds.map(async (candidateId) => {
-        try {
-          return await candidateLookupSurface({
-            projectId: resolvedProjectId,
-            workflowId: resolvedWorkflowId,
-            workflowRunId: resolvedWorkflowRunId,
-            candidateId,
-            sourceRef: normalizedSourceRef,
-            metadata: {
-              ...normalizedMetadata,
-              source: 'createModernizationWorkPacket',
-            },
-          });
-        } catch (error) {
-          void error;
-          return null;
-        }
-      }));
-    }
-
-    let packetRecord = null;
-    const packetCreationSurface = typeof this.createModernizationWorkPacketRecord === 'function'
-      ? this.createModernizationWorkPacketRecord.bind(this)
-      : null;
-    if (!packetCreationSurface) {
-      missingSurfaces.push('createModernizationWorkPacketRecord');
-    } else {
-      packetRecord = await packetCreationSurface({
-        projectId: resolvedProjectId,
-        workflowId: resolvedWorkflowId,
-        workflowRunId: resolvedWorkflowRunId,
-        assetId: normalizedAssetId,
-        classificationId: normalizedClassificationId,
-        candidateIds: uniqueCandidateIds,
-        packetTitle: normalizedPacketTitle || normalizedProblemStatement,
-        sourceRef: normalizedSourceRef,
-        problemStatement: normalizedProblemStatement,
-        recommendedModernization: normalizedRecommendedModernization,
-        affectedFilesOrSymbols: normalizedAffectedFilesOrSymbols,
-        acceptanceCriteria: normalizedAcceptanceCriteria,
-        riskLevel: normalizedRiskLevel,
-        evidenceRefs: normalizedEvidenceRefs,
-        wrapperExecutionRequired: Boolean(normalizedWrapperExecutionRequired),
-        handoffNotes: normalizedHandoffNotes,
-        metadata: {
-          ...normalizedMetadata,
-          source: 'createModernizationWorkPacket',
-        },
-      });
-    }
-
-    const transferSurface = typeof this.transferWorkPacket === 'function'
-      ? this.transferWorkPacket.bind(this)
-      : null;
-    if (!transferSurface) missingSurfaces.push('transferWorkPacket');
-    const transferResult = transferSurface
-      ? await transferSurface({
-          workflowRunId: resolvedWorkflowRunId,
-          transferKind: 'upstream_remediation',
-          objective: normalizedProblemStatement || normalizedRecommendedModernization || 'Modernization work packet',
-          requestedOutcome: normalizedRecommendedModernization || normalizedProblemStatement || 'Prepare modernization handoff.',
-          target: normalizedTargetAgent
-            ? {
-                intent: 'upstream_remediation',
-                recipient_mode: 'agent_session',
-                preferred_agent_session_id: normalizedTargetAgent,
-                preferred_role_key: normalizedTargetAgent,
-              }
-            : {
-                intent: 'upstream_remediation',
-                recipient_mode: 'role',
-                preferred_role_key: 'modernization_execution',
-              },
-          artifacts: normalizedAffectedFilesOrSymbols,
-          issues: [],
-          expectedEvidence: normalizedAcceptanceCriteria,
-          preferredModes: ['bundle', 'artifact_refs', 'inline_payload'],
-          capabilities: {
-            wrapper_execution_required: Boolean(normalizedWrapperExecutionRequired),
-            selected_candidate_count: uniqueCandidateIds.length,
-          },
-          senderAgentSessionId: normalizedSubmittedBy,
-          senderActorSessionId: null,
-          messageKind: 'handoff',
-          subject: normalizedPacketTitle || normalizedProblemStatement || 'Modernization work packet',
-          bodyMarkdown: normalizedHandoffNotes || normalizedRecommendedModernization || normalizedProblemStatement,
-          metadata: {
-            ...normalizedMetadata,
-            source: 'createModernizationWorkPacket',
-            asset_id: normalizedAssetId,
-            classification_id: normalizedClassificationId,
-            source_ref: normalizedSourceRef,
-            candidate_ids: uniqueCandidateIds,
-            selected_candidates: normalizedCandidateRecords,
-            wrapper_execution_required: Boolean(normalizedWrapperExecutionRequired),
-          },
-        })
-      : null;
-
-    const transferPayload = isPlainObject(transferResult) ? transferResult : {};
-    let transferPacketId = cleanText(transferPayload.work_transfer_packet?.work_transfer_packet_id)
-      || cleanText(transferPayload.work_transfer_packet_id)
-      || cleanText(transferPayload.transfer_packet_id)
-      || cleanText(transferPayload.packet_id)
-      || null;
-
-    const transferChannelInputId = cleanText(transfer_channel_id)
-      || cleanText(transferChannelId)
-      || cleanText(channel_id)
-      || cleanText(channelId);
-    const transferChannelSurface = transferChannelInputId
-      ? (typeof this.resumeTransferChannel === 'function'
-        ? this.resumeTransferChannel.bind(this)
-        : null)
-      : (transferPacketId && typeof this.openTransferChannel === 'function'
-        ? this.openTransferChannel.bind(this)
-        : null);
-    if (!transferChannelSurface && (transferChannelInputId || transferPacketId)) {
-      missingSurfaces.push(transferChannelInputId ? 'resumeTransferChannel' : 'openTransferChannel');
-    }
-    const channelResult = transferChannelSurface && transferPacketId
-      ? await transferChannelSurface({
-          transferChannelId: transferChannelInputId || undefined,
-          workTransferPacketId: transferPacketId,
-          workflowRunId: resolvedWorkflowRunId,
-          channelKind: 'bidirectional',
-          upstreamAgentSessionId: normalizedSubmittedBy,
-          downstreamAgentSessionId: normalizedTargetAgent || undefined,
-          evidenceRequiredForClosure: true,
-          metadata: {
-            ...normalizedMetadata,
-            source: 'createModernizationWorkPacket',
-          },
-        })
-      : null;
-    const channelPayload = isPlainObject(channelResult) ? channelResult : {};
-    const resolvedChannelId = cleanText(channelPayload.transfer_channel_id)
-      || cleanText(channelPayload.channel_id)
-      || cleanText(channelPayload.transfer_channel?.transfer_channel_id)
-      || cleanText(channelPayload.communication_transfer_channel?.transfer_channel_id)
-      || transferChannelInputId
-      || null;
-
-    const ownershipSurface = normalizedTargetAgent && resolvedChannelId && typeof this.assignCollaborationOwnership === 'function'
-      ? this.assignCollaborationOwnership.bind(this)
-      : null;
-    if (normalizedTargetAgent && !ownershipSurface) missingSurfaces.push('assignCollaborationOwnership');
-    const ownershipResult = ownershipSurface
-      ? await ownershipSurface({
-          transferChannelId: resolvedChannelId,
-          workTransferPacketId: transferPacketId,
-          workflowRunId: resolvedWorkflowRunId,
-          participantRole: 'modernization_owner',
-          ownerAgentSessionId: normalizedTargetAgent,
-          ownerActorSessionId: null,
-          ownerLabel: normalizedTargetAgent,
-          assignmentState: 'assigned',
-          assignmentReason: normalizedProblemStatement || normalizedRecommendedModernization,
-          currentPhase: 'modernization_work_packet',
-          assignedByAgentSessionId: normalizedSubmittedBy,
-          assignedByActorSessionId: null,
-          metadata: {
-            ...normalizedMetadata,
-            source: 'createModernizationWorkPacket',
-          },
-        })
-      : null;
-    const ownershipPayload = isPlainObject(ownershipResult) ? ownershipResult : {};
-
-    const proposalSurface = resolvedChannelId && typeof this.postCollaborationProposal === 'function'
-      ? this.postCollaborationProposal.bind(this)
-      : null;
-    if (resolvedChannelId && !proposalSurface) missingSurfaces.push('postCollaborationProposal');
-    const proposalResult = proposalSurface
-      ? await proposalSurface({
-          transferChannelId: resolvedChannelId,
-          workTransferPacketId: transferPacketId,
-          workflowRunId: resolvedWorkflowRunId,
-          proposalKind: 'modernization_work_packet',
-          proposalState: 'proposed',
-          participantRole: normalizedTargetAgent ? 'modernization_owner' : 'modernization_planner',
-          proposalSummary: normalizedProblemStatement || normalizedRecommendedModernization || 'Modernization work packet',
-          currentPhase: 'modernization_work_packet',
-          expectedNextUpdate: normalizedAcceptanceCriteria.join('; ') || normalizedRecommendedModernization || normalizedProblemStatement,
-          requiredEvidence: normalizedAcceptanceCriteria,
-          responseSchema: {
-            source_ref: normalizedSourceRef,
-            risk_level: normalizedRiskLevel,
-            candidate_ids: uniqueCandidateIds,
-            wrapper_execution_required: Boolean(normalizedWrapperExecutionRequired),
-          },
-          blockerSummary: normalizedProblemStatement || normalizedRecommendedModernization,
-          revisionNumber: 1,
-          proposerAgentSessionId: normalizedSubmittedBy,
-          proposerActorSessionId: null,
-          metadata: {
-            ...normalizedMetadata,
-            source: 'createModernizationWorkPacket',
-          },
-        })
-      : null;
-    const proposalPayload = isPlainObject(proposalResult) ? proposalResult : {};
-
-    const watchSurface = resolvedChannelId && typeof this.startMessageWatch === 'function'
-      ? this.startMessageWatch.bind(this)
-      : null;
-    if (resolvedChannelId && !watchSurface) missingSurfaces.push('startMessageWatch');
-    const watchResult = watchSurface
-      ? await watchSurface({
-          transferChannelId: resolvedChannelId,
-          workTransferPacketId: transferPacketId,
-          workflowRunId: resolvedWorkflowRunId,
-          watchingAgentRole: normalizedSubmittedBy,
-          expectedFromRole: normalizedTargetAgent || 'modernization_owner',
-          expectedMessageKind: 'response',
-          watchType: 'expected_peer_message',
-          watchingAgentSessionId: normalizedSubmittedBy,
-          expectedPayload: {
-            source_ref: normalizedSourceRef,
-            candidate_ids: uniqueCandidateIds,
-            expected_acknowledgement: 'modernization work packet received',
-          },
-          currentStatus: 'watching',
-          operatorNudge: normalizedHandoffNotes || normalizedRecommendedModernization || normalizedProblemStatement,
-          metadata: {
-            ...normalizedMetadata,
-            source: 'createModernizationWorkPacket',
-          },
-        })
-      : null;
-    const watchPayload = isPlainObject(watchResult) ? watchResult : {};
-
-    const heartbeatSurface = resolvedChannelId && typeof this.postCollaborationHeartbeat === 'function'
-      ? this.postCollaborationHeartbeat.bind(this)
-      : null;
-    if (resolvedChannelId && !heartbeatSurface) missingSurfaces.push('postCollaborationHeartbeat');
-    const heartbeatResult = heartbeatSurface
-      ? await heartbeatSurface({
-          transferChannelId: resolvedChannelId,
-          workTransferPacketId: transferPacketId,
-          workflowRunId: resolvedWorkflowRunId,
-          participantRole: normalizedTargetAgent ? 'modernization_owner' : 'modernization_planner',
-          currentPhase: 'modernization_work_packet',
-          currentTaskSummary: normalizedProblemStatement || normalizedRecommendedModernization || 'Modernization work packet',
-          metadata: {
-            ...normalizedMetadata,
-            source: 'createModernizationWorkPacket',
-          },
-        }).catch(() => null)
-      : null;
-    const heartbeatPayload = isPlainObject(heartbeatResult) ? heartbeatResult : {};
-
-    const transferChannelProjectionSurface = includeTransferChannelProjection && resolvedChannelId
-      ? (typeof this.getTransferChannelProjection === 'function'
-        ? this.getTransferChannelProjection.bind(this)
-        : typeof this.getLogaTransferChannelThreadProjection === 'function'
-          ? this.getLogaTransferChannelThreadProjection.bind(this)
-          : null)
-      : null;
-    if (includeTransferChannelProjection && resolvedChannelId && !transferChannelProjectionSurface) missingSurfaces.push('getTransferChannelProjection');
-    const transferChannelProjection = transferChannelProjectionSurface && resolvedChannelId
-      ? await transferChannelProjectionSurface(resolvedChannelId).catch(() => null)
-      : null;
-
-    const modernizationPacketId = cleanText(packetRecord?.modernization_packet_id)
-      || cleanText(packetRecord?.modernizationPacketId)
-      || cleanText(packetRecord?.work_packet_id)
-      || cleanText(packetRecord?.workPacketId)
-      || null;
-    const candidateCount = uniqueCandidateIds.length;
-    const proposalId = cleanText(proposalPayload.collaboration_proposal_id)
-      || cleanText(proposalPayload.proposal_id)
-      || cleanText(proposalPayload.collaboration_proposal?.collaboration_proposal_id)
-      || cleanText(proposalPayload.collaboration_proposal?.proposal_id)
-      || null;
-    const watchId = cleanText(watchPayload.message_watch_id)
-      || cleanText(watchPayload.watch_id)
-      || cleanText(watchPayload.message_watch?.message_watch_id)
-      || cleanText(watchPayload.message_watch?.watch_id)
-      || null;
-    const expectedAcknowledgement = cleanText(watchPayload.expected_message_kind)
-      || cleanText(watchPayload.message_watch?.expected_message_kind)
-      || cleanText(watchPayload.message_watch?.expected_acknowledgement)
-      || (normalizedTargetAgent ? 'acknowledgement' : null);
-    const assignedOwnerResolved = cleanText(ownershipPayload.owner_agent_session_id)
-      || cleanText(ownershipPayload.ownerAgentSessionId)
-      || normalizedTargetAgent
-      || null;
-    const heartbeatStatus = cleanText(heartbeatPayload.collaboration_heartbeat?.activity_state)
-      || cleanText(heartbeatPayload.activity_state)
-      || cleanText(heartbeatPayload.status)
-      || cleanText(heartbeatPayload.collaboration_heartbeat?.status)
-      || null;
-    const transferPacketResolvedId = transferPacketId
-      || cleanText(transferPayload.work_transfer_packet?.work_transfer_packet_id)
-      || cleanText(transferPayload.work_transfer_packet_id)
-      || cleanText(transferPayload.transfer_packet_id)
-      || cleanText(transferPayload.packet_id)
-      || null;
-
-    return {
-      status: missingSurfaces.length > 0 ? 'partial' : 'ready',
-      project_id: resolvedProjectId || null,
-      asset_id: cleanText(assetIntakeRecord?.asset_id)
-        || cleanText(assetIntakeRecord?.assetId)
-        || normalizedAssetId
-        || null,
-      intake_record_id: cleanText(assetIntakeRecord?.intake_record_id)
-        || cleanText(assetIntakeRecord?.intakeRecordId)
-        || cleanText(intake_record_id)
-        || cleanText(intakeRecordId)
-        || null,
-      classification_id: cleanText(classificationRecord?.classification_id)
-        || cleanText(classificationRecord?.classificationId)
-        || normalizedClassificationId
-        || null,
-      candidate_ids: uniqueCandidateIds,
-      candidate_count: candidateCount,
-      modernization_packet_id: modernizationPacketId,
-      transfer_packet_id: transferPacketResolvedId,
-      channel_id: resolvedChannelId,
-      proposal_id: proposalId,
-      assigned_owner: assignedOwnerResolved,
-      watch_id: watchId,
-      expected_acknowledgement: expectedAcknowledgement,
-      heartbeat_status: heartbeatStatus,
-      operator_projection_metadata: {
-        portfolio_bundle: portfolioBundle,
-        project_roadmap_summary: projectRoadmapSummary,
-        project_roadmap_active_item: projectActiveItem,
-        asset_intake_record: assetIntakeRecord,
-        classification_record: classificationRecord,
-        candidate_records: candidateRecords,
-        modernization_packet_record: packetRecord,
-        transfer: transferPayload,
-        channel: channelPayload,
-        ownership_assignment: ownershipPayload,
-        proposal: proposalPayload,
-        message_watch: watchPayload,
-        heartbeat: heartbeatPayload,
-        transfer_channel_projection: transferChannelProjection,
-      },
-      missing_surfaces: [...new Set(missingSurfaces)],
-      project: projectPayload,
-      asset_intake_record: assetIntakeRecord,
-      classification_record: classificationRecord,
-      candidate_records: candidateRecords,
-      modernization_packet_record: packetRecord,
-      transfer: transferPayload,
-      channel: channelPayload,
-      ownership_assignment: ownershipPayload,
-      proposal: proposalPayload,
-      message_watch: watchPayload,
-      heartbeat: heartbeatPayload,
-      selected_candidates: normalizedCandidateRecords,
-    };
-  }
-
-  async requestModernizationWrapperExecution({
-    projectIdentifier,
-    projectId,
-    relatedProjectId,
-    related_project_id,
-    startWorkBody = {},
-    startWorkRequest = {},
-    resumeProjectWorkOptions = {},
-    modernizationPacket = {},
-    modernization_packet = {},
-    modernizationPacketId,
-    modernization_packet_id,
-    packetId,
-    packet_id,
-    sourceRef,
-    source_ref,
-    wrapperName,
-    wrapper_name,
-    wrapperContractRef,
-    wrapper_contract_ref,
-    executionScope = [],
-    execution_scope = [],
-    allowedBlastRadius = [],
-    allowed_blast_radius = [],
-    requiredEvidence = [],
-    required_evidence = [],
-    acceptanceCriteria = [],
-    acceptance_criteria = [],
-    riskLevel,
-    risk_level,
-    targetAgent,
-    target_agent,
-    handoffNotes,
-    handoff_notes,
-    collaborationRequired,
-    collaboration_required,
-    channelId,
-    channel_id,
-    transferChannelId,
-    transfer_channel_id,
-    assignedOwner,
-    assigned_owner,
-    wrapperExecutionRequired,
-    wrapper_execution_required,
-    submittedBy,
-    submitted_by,
-    includePortfolioBundle = true,
-    includeProjectRoadmap = true,
-    includeProjectActiveItem = true,
-    includeTransferChannelProjection = true,
-    metadata = {},
-  } = {}) {
-    const missingSurfaces = [];
-    const normalizedMetadata = isPlainObject(metadata) ? metadata : {};
-    const normalizedPacket = isPlainObject(modernization_packet)
-      ? modernization_packet
-      : (isPlainObject(modernizationPacket) ? modernizationPacket : {});
-    const normalizedProjectReference = cleanText(projectIdentifier)
-      || cleanText(projectId)
-      || cleanText(relatedProjectId)
-      || cleanText(related_project_id)
-      || cleanText(normalizedPacket.project_id)
-      || cleanText(normalizedPacket.projectId)
-      || cleanText(normalizedPacket.related_project_id)
-      || cleanText(normalizedPacket.relatedProjectId);
-    const normalizedPacketId = cleanText(modernization_packet_id)
-      || cleanText(modernizationPacketId)
-      || cleanText(packet_id)
-      || cleanText(packetId)
-      || cleanText(normalizedPacket.modernization_packet_id)
-      || cleanText(normalizedPacket.modernizationPacketId)
-      || cleanText(normalizedPacket.packet_id)
-      || cleanText(normalizedPacket.packetId);
-    const normalizedSourceRef = cleanText(source_ref)
-      || cleanText(sourceRef)
-      || cleanText(normalizedPacket.source_ref)
-      || cleanText(normalizedPacket.sourceRef)
-      || normalizedPacketId;
-    const normalizedWrapperName = cleanText(wrapper_name) || cleanText(wrapperName);
-    const normalizedWrapperContractRef = cleanText(wrapper_contract_ref) || cleanText(wrapperContractRef);
-    const normalizedExecutionScope = cleanList(execution_scope.length > 0 ? execution_scope : executionScope);
-    const normalizedAllowedBlastRadius = cleanList(allowed_blast_radius.length > 0 ? allowed_blast_radius : allowedBlastRadius);
-    const normalizedRequiredEvidence = cleanList(required_evidence.length > 0 ? required_evidence : requiredEvidence);
-    const normalizedAcceptanceCriteria = cleanList(acceptance_criteria.length > 0 ? acceptance_criteria : acceptanceCriteria);
-    const normalizedRiskLevel = cleanText(risk_level)
-      || cleanText(riskLevel)
-      || cleanText(normalizedPacket.risk_level)
-      || cleanText(normalizedPacket.riskLevel)
-      || null;
-    const normalizedHandoffNotes = cleanText(handoff_notes) || cleanText(handoffNotes);
-    const normalizedSubmittedBy = cleanText(submitted_by)
-      || cleanText(submittedBy)
-      || this.agentSessionId
-      || this.actorId
-      || null;
-    const normalizedTargetAgent = cleanText(target_agent) || cleanText(targetAgent) || cleanText(assigned_owner) || cleanText(assignedOwner) || null;
-    const normalizedWrapperExecutionRequired = wrapper_execution_required ?? wrapperExecutionRequired ?? true;
-    const normalizedCollaborationRequired = collaboration_required ?? collaborationRequired ?? Boolean(normalizedTargetAgent || channelId || channel_id || transferChannelId || transfer_channel_id);
-
-    let continuation = null;
-    let startWorkResult = null;
-    if (normalizedProjectReference) {
-      if (typeof this.resumeProjectWork === 'function') {
-        continuation = await this.resumeProjectWork({
-          projectIdentifier: normalizedProjectReference,
-          projectId: normalizedProjectReference,
-          requireClaim: false,
-          ...resumeProjectWorkOptions,
-        });
-      } else {
-        missingSurfaces.push('resumeProjectWork');
-      }
-    } else if (Object.keys(isPlainObject(startWorkRequest) ? startWorkRequest : {}).length > 0 || Object.keys(isPlainObject(startWorkBody) ? startWorkBody : {}).length > 0) {
-      if (typeof this.startWork === 'function') {
-        startWorkResult = await this.startWork({
-          ...(isPlainObject(startWorkBody) ? startWorkBody : {}),
-          ...(isPlainObject(startWorkRequest) ? startWorkRequest : {}),
-        });
-      } else {
-        missingSurfaces.push('startWork');
-      }
-    }
-
-    const projectPayload = isPlainObject(continuation?.project)
-      ? continuation.project
-      : isPlainObject(startWorkResult?.project)
-        ? startWorkResult.project
-        : isPlainObject(continuation?.summary)
-          ? continuation.summary
-          : {};
-    const resolvedProjectId = cleanText(projectPayload.project_id)
-      || cleanText(projectPayload.projectId)
-      || normalizedProjectReference;
-    const resolvedWorkflowId = cleanText(projectPayload.workflow_id)
-      || cleanText(projectPayload.workflowId)
-      || cleanText(continuation?.workflow_id)
-      || cleanText(startWorkResult?.workflow_id);
-    const resolvedWorkflowRunId = cleanText(projectPayload.workflow_run_id)
-      || cleanText(projectPayload.workflowRunId)
-      || cleanText(continuation?.workflow_run_id)
-      || cleanText(startWorkResult?.workflow_run_id)
-      || cleanText(startWorkResult?.workflowRunId);
-
-    const portfolioBundle = includePortfolioBundle && typeof this.getPortfolioBundle === 'function'
-      ? await this.getPortfolioBundle().catch(() => null)
-      : null;
-    const projectRoadmapSummary = resolvedProjectId && includeProjectRoadmap && typeof this.getProjectRoadmapSummary === 'function'
-      ? await this.getProjectRoadmapSummary(resolvedProjectId).catch(() => null)
-      : null;
-    const projectActiveItem = resolvedProjectId && includeProjectActiveItem && typeof this.getProjectRoadmapActiveItem === 'function'
-      ? await this.getProjectRoadmapActiveItem(resolvedProjectId).catch(() => null)
-      : null;
-
-    let packetRecord = null;
-    const packetLookupSurface = typeof this.getModernizationWorkPacketRecord === 'function'
-      ? this.getModernizationWorkPacketRecord.bind(this)
-      : typeof this.getModernizationPacketRecord === 'function'
-        ? this.getModernizationPacketRecord.bind(this)
-        : null;
-    if (!packetLookupSurface) {
-      missingSurfaces.push('getModernizationWorkPacketRecord');
-      missingSurfaces.push('getModernizationPacketRecord');
-    } else {
-      packetRecord = await packetLookupSurface({
-        projectId: resolvedProjectId,
-        workflowId: resolvedWorkflowId,
-        workflowRunId: resolvedWorkflowRunId,
-        modernizationPacketId: normalizedPacketId,
-        packetId: normalizedPacketId,
-        sourceRef: normalizedSourceRef,
-        metadata: {
-          ...normalizedMetadata,
-          source: 'requestModernizationWrapperExecution',
-        },
-      }).catch(() => null);
-    }
-
-    const packetRecordPayload = isPlainObject(packetRecord) ? packetRecord : {};
-    const resolvedModernizationPacketId = cleanText(packetRecordPayload.modernization_packet_id)
-      || cleanText(packetRecordPayload.modernizationPacketId)
-      || cleanText(packetRecordPayload.work_packet_id)
-      || cleanText(packetRecordPayload.workPacketId)
-      || normalizedPacketId
-      || null;
-
-    let wrapperRequestRecord = null;
-    const wrapperRequestSurface = typeof this.createModernizationWrapperExecutionRequestRecord === 'function'
-      ? this.createModernizationWrapperExecutionRequestRecord.bind(this)
-      : typeof this.submitModernizationWrapperExecutionRequest === 'function'
-        ? this.submitModernizationWrapperExecutionRequest.bind(this)
-        : null;
-    if (!wrapperRequestSurface) {
-      missingSurfaces.push('createModernizationWrapperExecutionRequestRecord');
-      missingSurfaces.push('submitModernizationWrapperExecutionRequest');
-    } else {
-      wrapperRequestRecord = await wrapperRequestSurface({
-        projectId: resolvedProjectId,
-        workflowId: resolvedWorkflowId,
-        workflowRunId: resolvedWorkflowRunId,
-        modernizationPacketId: resolvedModernizationPacketId,
-        wrapperName: normalizedWrapperName,
-        wrapperContractRef: normalizedWrapperContractRef,
-        sourceRef: normalizedSourceRef,
-        executionScope: normalizedExecutionScope,
-        allowedBlastRadius: normalizedAllowedBlastRadius,
-        requiredEvidence: normalizedRequiredEvidence,
-        acceptanceCriteria: normalizedAcceptanceCriteria,
-        riskLevel: normalizedRiskLevel,
-        targetAgent: normalizedTargetAgent,
-        handoffNotes: normalizedHandoffNotes,
-        wrapperExecutionRequired: Boolean(normalizedWrapperExecutionRequired),
-        metadata: {
-          ...normalizedMetadata,
-          source: 'requestModernizationWrapperExecution',
-        },
-      }).catch(() => null);
-    }
-
-    let transferResult = null;
-    const transferSurface = typeof this.transferWorkPacket === 'function'
-      ? this.transferWorkPacket.bind(this)
-      : null;
-    if (!transferSurface) missingSurfaces.push('transferWorkPacket');
-    if (transferSurface && (!wrapperRequestRecord || !wrapperRequestRecord.wrapper_execution_request_id) && (normalizedWrapperExecutionRequired || normalizedTargetAgent || normalizedCollaborationRequired)) {
-      transferResult = await transferSurface({
-        workflowRunId: resolvedWorkflowRunId,
-        transferKind: 'upstream_remediation',
-        objective: normalizedWrapperName || normalizedWrapperContractRef || 'Wrapper execution request',
-        requestedOutcome: normalizedHandoffNotes || normalizedWrapperContractRef || 'Prepare wrapper execution request.',
-        target: normalizedTargetAgent
-          ? {
-              intent: 'upstream_remediation',
-              recipient_mode: 'agent_session',
-              preferred_agent_session_id: normalizedTargetAgent,
-              preferred_role_key: normalizedTargetAgent,
-            }
-          : {
-              intent: 'upstream_remediation',
-              recipient_mode: 'role',
-              preferred_role_key: 'wrapper_execution',
-            },
-        artifacts: normalizedExecutionScope,
-        issues: normalizedAllowedBlastRadius,
-        expectedEvidence: normalizedRequiredEvidence,
-        preferredModes: ['bundle', 'artifact_refs', 'inline_payload'],
-        capabilities: {
-          wrapper_execution_required: Boolean(normalizedWrapperExecutionRequired),
-          allowed_blast_radius: normalizedAllowedBlastRadius,
-        },
-        senderAgentSessionId: normalizedSubmittedBy,
-        senderActorSessionId: null,
-        messageKind: 'handoff',
-        subject: normalizedWrapperName || normalizedWrapperContractRef || 'Wrapper execution request',
-        bodyMarkdown: normalizedHandoffNotes || normalizedWrapperContractRef || normalizedWrapperName,
-        metadata: {
-          ...normalizedMetadata,
-          source: 'requestModernizationWrapperExecution',
-          modernization_packet_id: resolvedModernizationPacketId,
-          wrapper_execution_required: Boolean(normalizedWrapperExecutionRequired),
-        },
-      });
-    }
-    const transferPayload = isPlainObject(transferResult) ? transferResult : {};
-
-    const transferPacketId = cleanText(wrapperRequestRecord?.transfer_packet_id)
-      || cleanText(wrapperRequestRecord?.work_transfer_packet_id)
-      || cleanText(wrapperRequestRecord?.workTransferPacketId)
-      || cleanText(transferPayload.work_transfer_packet?.work_transfer_packet_id)
-      || cleanText(transferPayload.work_transfer_packet_id)
-      || cleanText(transferPayload.transfer_packet_id)
-      || cleanText(transferPayload.packet_id)
-      || null;
-
-    const transferChannelInputId = cleanText(transfer_channel_id)
-      || cleanText(transferChannelId)
-      || cleanText(channel_id)
-      || cleanText(channelId);
-    const channelSurface = transferChannelInputId
-      ? (typeof this.resumeTransferChannel === 'function'
-        ? this.resumeTransferChannel.bind(this)
-        : null)
-      : (transferPacketId && typeof this.openTransferChannel === 'function'
-        ? this.openTransferChannel.bind(this)
-        : null);
-    if (!channelSurface && (transferChannelInputId || transferPacketId)) {
-      missingSurfaces.push(transferChannelInputId ? 'resumeTransferChannel' : 'openTransferChannel');
-    }
-    const channelResult = channelSurface && transferPacketId
-      ? await channelSurface({
-          transferChannelId: transferChannelInputId || undefined,
-          workTransferPacketId: transferPacketId,
-          workflowRunId: resolvedWorkflowRunId,
-          channelKind: 'bidirectional',
-          upstreamAgentSessionId: normalizedSubmittedBy,
-          downstreamAgentSessionId: normalizedTargetAgent || undefined,
-          evidenceRequiredForClosure: true,
-          metadata: {
-            ...normalizedMetadata,
-            source: 'requestModernizationWrapperExecution',
-          },
-        })
-      : null;
-    const channelPayload = isPlainObject(channelResult) ? channelResult : {};
-    const resolvedChannelId = cleanText(channelPayload.transfer_channel_id)
-      || cleanText(channelPayload.channel_id)
-      || cleanText(channelPayload.transfer_channel?.transfer_channel_id)
-      || cleanText(channelPayload.communication_transfer_channel?.transfer_channel_id)
-      || transferChannelInputId
-      || null;
-
-    const ownershipSurface = normalizedTargetAgent && resolvedChannelId && typeof this.assignCollaborationOwnership === 'function'
-      ? this.assignCollaborationOwnership.bind(this)
-      : null;
-    if (normalizedTargetAgent && !ownershipSurface) missingSurfaces.push('assignCollaborationOwnership');
-    const ownershipResult = ownershipSurface
-      ? await ownershipSurface({
-          transferChannelId: resolvedChannelId,
-          workTransferPacketId: transferPacketId,
-          workflowRunId: resolvedWorkflowRunId,
-          participantRole: 'wrapper_executor',
-          ownerAgentSessionId: normalizedTargetAgent,
-          ownerActorSessionId: null,
-          ownerLabel: normalizedTargetAgent,
-          assignmentState: 'assigned',
-          assignmentReason: normalizedWrapperName || normalizedWrapperContractRef || normalizedHandoffNotes,
-          currentPhase: 'wrapper_execution_request',
-          assignedByAgentSessionId: normalizedSubmittedBy,
-          assignedByActorSessionId: null,
-          metadata: {
-            ...normalizedMetadata,
-            source: 'requestModernizationWrapperExecution',
-          },
-        })
-      : null;
-    const ownershipPayload = isPlainObject(ownershipResult) ? ownershipResult : {};
-
-    const watchSurface = resolvedChannelId && typeof this.startMessageWatch === 'function'
-      ? this.startMessageWatch.bind(this)
-      : null;
-    if (resolvedChannelId && !watchSurface) missingSurfaces.push('startMessageWatch');
-    const watchResult = watchSurface
-      ? await watchSurface({
-          transferChannelId: resolvedChannelId,
-          workTransferPacketId: transferPacketId,
-          workflowRunId: resolvedWorkflowRunId,
-          watchingAgentRole: normalizedSubmittedBy,
-          expectedFromRole: normalizedTargetAgent || 'wrapper_executor',
-          expectedMessageKind: 'response',
-          watchType: 'expected_peer_message',
-          watchingAgentSessionId: normalizedSubmittedBy,
-          expectedPayload: {
-            modernization_packet_id: resolvedModernizationPacketId,
-            expected_acknowledgement: 'wrapper execution request received',
-          },
-          currentStatus: 'watching',
-          operatorNudge: normalizedHandoffNotes || normalizedWrapperContractRef || normalizedWrapperName,
-          metadata: {
-            ...normalizedMetadata,
-            source: 'requestModernizationWrapperExecution',
-          },
-        })
-      : null;
-    const watchPayload = isPlainObject(watchResult) ? watchResult : {};
-
-    const heartbeatSurface = resolvedChannelId && typeof this.postCollaborationHeartbeat === 'function'
-      ? this.postCollaborationHeartbeat.bind(this)
-      : null;
-    if (resolvedChannelId && !heartbeatSurface) missingSurfaces.push('postCollaborationHeartbeat');
-    const heartbeatResult = heartbeatSurface
-      ? await heartbeatSurface({
-          transferChannelId: resolvedChannelId,
-          workTransferPacketId: transferPacketId,
-          workflowRunId: resolvedWorkflowRunId,
-          participantRole: normalizedTargetAgent ? 'wrapper_executor' : 'wrapper_planner',
-          currentPhase: 'wrapper_execution_request',
-          currentTaskSummary: normalizedWrapperName || normalizedWrapperContractRef || 'Wrapper execution request',
-          metadata: {
-            ...normalizedMetadata,
-            source: 'requestModernizationWrapperExecution',
-          },
-        }).catch(() => null)
-      : null;
-    const heartbeatPayload = isPlainObject(heartbeatResult) ? heartbeatResult : {};
-
-    const transferChannelProjectionSurface = includeTransferChannelProjection && resolvedChannelId
-      ? (typeof this.getTransferChannelProjection === 'function'
-        ? this.getTransferChannelProjection.bind(this)
-        : typeof this.getLogaTransferChannelThreadProjection === 'function'
-          ? this.getLogaTransferChannelThreadProjection.bind(this)
-          : null)
-      : null;
-    if (includeTransferChannelProjection && resolvedChannelId && !transferChannelProjectionSurface) missingSurfaces.push('getTransferChannelProjection');
-    const transferChannelProjection = transferChannelProjectionSurface && resolvedChannelId
-      ? await transferChannelProjectionSurface(resolvedChannelId).catch(() => null)
-      : null;
-
-    const wrapperExecutionRequestId = cleanText(wrapperRequestRecord?.wrapper_execution_request_id)
-      || cleanText(wrapperRequestRecord?.wrapperExecutionRequestId)
-      || cleanText(wrapperRequestRecord?.execution_request_id)
-      || cleanText(wrapperRequestRecord?.executionRequestId)
-      || null;
-    const expectedAcknowledgement = cleanText(watchPayload.expected_message_kind)
-      || cleanText(watchPayload.message_watch?.expected_message_kind)
-      || cleanText(watchPayload.message_watch?.expected_acknowledgement)
-      || (normalizedTargetAgent ? 'acknowledgement' : null);
-    const ownershipAssignmentId = cleanText(ownershipPayload.collaboration_ownership_assignment_id)
-      || cleanText(ownershipPayload.ownership_assignment_id)
-      || cleanText(ownershipPayload.collaboration_ownership_assignment?.collaboration_ownership_assignment_id)
-      || cleanText(ownershipPayload.collaboration_ownership_assignment?.ownership_assignment_id)
-      || null;
-    const watchId = cleanText(watchPayload.message_watch_id)
-      || cleanText(watchPayload.watch_id)
-      || cleanText(watchPayload.message_watch?.message_watch_id)
-      || cleanText(watchPayload.message_watch?.watch_id)
-      || null;
-    const heartbeatStatus = cleanText(heartbeatPayload.collaboration_heartbeat?.activity_state)
-      || cleanText(heartbeatPayload.activity_state)
-      || cleanText(heartbeatPayload.status)
-      || cleanText(heartbeatPayload.collaboration_heartbeat?.status)
-      || null;
-    const wrapperExecutionRequiredResolved = Boolean(normalizedWrapperExecutionRequired);
-
-    return {
-      status: missingSurfaces.length > 0 ? 'partial' : 'ready',
-      project_id: resolvedProjectId || null,
-      modernization_packet_id: resolvedModernizationPacketId,
-      wrapper_execution_request_id: wrapperExecutionRequestId || null,
-      transfer_packet_id: transferPacketId,
-      target_agent: normalizedTargetAgent || null,
-      channel_id: resolvedChannelId,
-      ownership_assignment_id: ownershipAssignmentId,
-      watch_id: watchId,
-      expected_acknowledgement: expectedAcknowledgement,
-      wrapper_execution_required: wrapperExecutionRequiredResolved,
-      heartbeat_status: heartbeatStatus,
-      operator_projection_metadata: {
-        portfolio_bundle: portfolioBundle,
-        project_roadmap_summary: projectRoadmapSummary,
-        project_roadmap_active_item: projectActiveItem,
-        modernization_packet_record: packetRecordPayload,
-        wrapper_execution_request_record: wrapperRequestRecord,
-        transfer: transferPayload,
-        channel: channelPayload,
-        ownership_assignment: ownershipPayload,
-        message_watch: watchPayload,
-        heartbeat: heartbeatPayload,
-        transfer_channel_projection: transferChannelProjection,
-      },
-      missing_surfaces: [...new Set(missingSurfaces)],
-      project: projectPayload,
-      modernization_packet_record: packetRecordPayload,
-      wrapper_execution_request_record: wrapperRequestRecord,
-      transfer: transferPayload,
-      channel: channelPayload,
-      ownership_assignment: ownershipPayload,
-      message_watch: watchPayload,
-      heartbeat: heartbeatPayload,
-    };
-  }
-
-  async getModernizationWrapperEvidence({
-    projectIdentifier,
-    projectId,
-    relatedProjectId,
-    related_project_id,
-    startWorkBody = {},
-    startWorkRequest = {},
-    resumeProjectWorkOptions = {},
-    modernizationPacket = {},
-    modernization_packet = {},
-    modernizationPacketId,
-    modernization_packet_id,
-    packetId,
-    packet_id,
-    wrapperExecutionRequest = {},
-    wrapper_execution_request = {},
-    wrapperExecutionRequestId,
-    wrapper_execution_request_id,
-    wrapperExecutionId,
-    wrapper_execution_id,
-    sourceRef,
-    source_ref,
-    includeOperations = true,
-    include_operations = true,
-    includeFileManifest = true,
-    include_file_manifest = true,
-    includeVerificationSummary = true,
-    include_verification_summary = true,
-    includeProjection = true,
-    include_projection = true,
-    includePortfolioBundle = true,
-    includeProjectRoadmap = true,
-    includeProjectActiveItem = true,
-    metadata = {},
-  } = {}) {
-    const missingSurfaces = [];
-    const normalizedMetadata = isPlainObject(metadata) ? metadata : {};
-    const normalizedPacket = isPlainObject(modernization_packet)
-      ? modernization_packet
-      : (isPlainObject(modernizationPacket) ? modernizationPacket : {});
-    const normalizedWrapperExecutionRequest = isPlainObject(wrapper_execution_request)
-      ? wrapper_execution_request
-      : (isPlainObject(wrapperExecutionRequest) ? wrapperExecutionRequest : {});
-    const normalizedProjectReference = cleanText(projectIdentifier)
-      || cleanText(projectId)
-      || cleanText(relatedProjectId)
-      || cleanText(related_project_id)
-      || cleanText(normalizedPacket.project_id)
-      || cleanText(normalizedPacket.projectId)
-      || cleanText(normalizedPacket.related_project_id)
-      || cleanText(normalizedPacket.relatedProjectId)
-      || cleanText(normalizedWrapperExecutionRequest.project_id)
-      || cleanText(normalizedWrapperExecutionRequest.projectId)
-      || cleanText(normalizedWrapperExecutionRequest.related_project_id)
-      || cleanText(normalizedWrapperExecutionRequest.relatedProjectId);
-    const normalizedModernizationPacketId = cleanText(modernization_packet_id)
-      || cleanText(modernizationPacketId)
-      || cleanText(packet_id)
-      || cleanText(packetId)
-      || cleanText(normalizedPacket.modernization_packet_id)
-      || cleanText(normalizedPacket.modernizationPacketId)
-      || cleanText(normalizedPacket.packet_id)
-      || cleanText(normalizedPacket.packetId)
-      || cleanText(normalizedWrapperExecutionRequest.modernization_packet_id)
-      || cleanText(normalizedWrapperExecutionRequest.modernizationPacketId)
-      || cleanText(normalizedWrapperExecutionRequest.packet_id)
-      || cleanText(normalizedWrapperExecutionRequest.packetId);
-    const normalizedWrapperExecutionRequestId = cleanText(wrapper_execution_request_id)
-      || cleanText(wrapperExecutionRequestId)
-      || cleanText(normalizedWrapperExecutionRequest.wrapper_execution_request_id)
-      || cleanText(normalizedWrapperExecutionRequest.wrapperExecutionRequestId)
-      || cleanText(normalizedWrapperExecutionRequest.execution_request_id)
-      || cleanText(normalizedWrapperExecutionRequest.executionRequestId);
-    const normalizedWrapperExecutionId = cleanText(wrapper_execution_id)
-      || cleanText(wrapperExecutionId)
-      || cleanText(normalizedWrapperExecutionRequest.wrapper_execution_id)
-      || cleanText(normalizedWrapperExecutionRequest.wrapperExecutionId)
-      || cleanText(normalizedWrapperExecutionRequest.execution_id)
-      || cleanText(normalizedWrapperExecutionRequest.executionId)
-      || cleanText(normalizedWrapperExecutionRequest.wrapper_execution_record_id)
-      || cleanText(normalizedWrapperExecutionRequest.wrapperExecutionRecordId);
-    const normalizedSourceRef = cleanText(source_ref)
-      || cleanText(sourceRef)
-      || cleanText(normalizedPacket.source_ref)
-      || cleanText(normalizedPacket.sourceRef)
-      || cleanText(normalizedWrapperExecutionRequest.source_ref)
-      || cleanText(normalizedWrapperExecutionRequest.sourceRef)
-      || normalizedModernizationPacketId
-      || normalizedWrapperExecutionRequestId
-      || normalizedWrapperExecutionId;
-    const normalizedIncludeOperations = include_operations ?? includeOperations ?? true;
-    const normalizedIncludeFileManifest = include_file_manifest ?? includeFileManifest ?? true;
-    const normalizedIncludeVerificationSummary = include_verification_summary ?? includeVerificationSummary ?? true;
-    const normalizedIncludeProjection = include_projection ?? includeProjection ?? true;
-
-    const pickSurface = (candidateNames) => {
-      for (const candidateName of candidateNames) {
-        if (typeof this[candidateName] === 'function') {
-          return this[candidateName].bind(this);
-        }
-      }
-      for (const candidateName of candidateNames) {
-        missingSurfaces.push(candidateName);
-      }
-      return null;
-    };
-
-    let continuation = null;
-    let startWorkResult = null;
-    if (normalizedProjectReference) {
-      if (typeof this.resumeProjectWork === 'function') {
-        continuation = await this.resumeProjectWork({
-          projectIdentifier: normalizedProjectReference,
-          projectId: normalizedProjectReference,
-          requireClaim: false,
-          ...resumeProjectWorkOptions,
-        });
-      } else {
-        missingSurfaces.push('resumeProjectWork');
-      }
-    } else if (Object.keys(isPlainObject(startWorkRequest) ? startWorkRequest : {}).length > 0 || Object.keys(isPlainObject(startWorkBody) ? startWorkBody : {}).length > 0) {
-      if (typeof this.startWork === 'function') {
-        startWorkResult = await this.startWork({
-          ...(isPlainObject(startWorkBody) ? startWorkBody : {}),
-          ...(isPlainObject(startWorkRequest) ? startWorkRequest : {}),
-        });
-      } else {
-        missingSurfaces.push('startWork');
-      }
-    }
-
-    const projectPayload = isPlainObject(continuation?.project)
-      ? continuation.project
-      : isPlainObject(startWorkResult?.project)
-        ? startWorkResult.project
-        : isPlainObject(continuation?.summary)
-          ? continuation.summary
-          : {};
-    const resolvedProjectId = cleanText(projectPayload.project_id)
-      || cleanText(projectPayload.projectId)
-      || normalizedProjectReference;
-    const resolvedWorkflowId = cleanText(projectPayload.workflow_id)
-      || cleanText(projectPayload.workflowId)
-      || cleanText(continuation?.workflow_id)
-      || cleanText(startWorkResult?.workflow_id);
-    const resolvedWorkflowRunId = cleanText(projectPayload.workflow_run_id)
-      || cleanText(projectPayload.workflowRunId)
-      || cleanText(continuation?.workflow_run_id)
-      || cleanText(startWorkResult?.workflow_run_id)
-      || cleanText(startWorkResult?.workflowRunId);
-
-    const portfolioBundle = includePortfolioBundle && typeof this.getPortfolioBundle === 'function'
-      ? await this.getPortfolioBundle().catch(() => null)
-      : null;
-    const projectRoadmapSummary = resolvedProjectId && includeProjectRoadmap && typeof this.getProjectRoadmapSummary === 'function'
-      ? await this.getProjectRoadmapSummary(resolvedProjectId).catch(() => null)
-      : null;
-    const projectActiveItem = resolvedProjectId && includeProjectActiveItem && typeof this.getProjectRoadmapActiveItem === 'function'
-      ? await this.getProjectRoadmapActiveItem(resolvedProjectId).catch(() => null)
-      : null;
-
-    let modernizationPacketRecord = null;
-    const packetLookupSurface = pickSurface(['getModernizationWorkPacketRecord', 'getModernizationPacketRecord']);
-    if (packetLookupSurface) {
-      modernizationPacketRecord = await packetLookupSurface({
-        projectId: resolvedProjectId,
-        workflowId: resolvedWorkflowId,
-        workflowRunId: resolvedWorkflowRunId,
-        modernizationPacketId: normalizedModernizationPacketId,
-        packetId: normalizedModernizationPacketId,
-        sourceRef: normalizedSourceRef,
-        metadata: {
-          ...normalizedMetadata,
-          source: 'getModernizationWrapperEvidence',
-        },
-      }).catch(() => null);
-    }
-
-    const packetRecordPayload = isPlainObject(modernizationPacketRecord) ? modernizationPacketRecord : {};
-    const resolvedModernizationPacketId = cleanText(packetRecordPayload.modernization_packet_id)
-      || cleanText(packetRecordPayload.modernizationPacketId)
-      || cleanText(packetRecordPayload.work_packet_id)
-      || cleanText(packetRecordPayload.workPacketId)
-      || normalizedModernizationPacketId
-      || null;
-    let wrapperExecutionRequestRecord = null;
-    const wrapperRequestLookupSurface = pickSurface([
-      'getModernizationWrapperExecutionRequestRecord',
-      'getWrapperExecutionRequestRecord',
-      'getModernizationWrapperExecutionRequest',
-      'getWrapperExecutionRequest',
-    ]);
-    if (wrapperRequestLookupSurface) {
-      wrapperExecutionRequestRecord = await wrapperRequestLookupSurface({
-        projectId: resolvedProjectId,
-        workflowId: resolvedWorkflowId,
-        workflowRunId: resolvedWorkflowRunId,
-        modernizationPacketId: resolvedModernizationPacketId,
-        wrapperExecutionRequestId: normalizedWrapperExecutionRequestId,
-        wrapperExecutionId: normalizedWrapperExecutionId,
-        sourceRef: normalizedSourceRef,
-        metadata: {
-          ...normalizedMetadata,
-          source: 'getModernizationWrapperEvidence',
-        },
-      }).catch(() => null);
-    }
-
-    const requestRecordPayload = isPlainObject(wrapperExecutionRequestRecord) ? wrapperExecutionRequestRecord : {};
-    const resolvedWrapperExecutionRequestId = cleanText(requestRecordPayload.wrapper_execution_request_id)
-      || cleanText(requestRecordPayload.wrapperExecutionRequestId)
-      || cleanText(requestRecordPayload.execution_request_id)
-      || cleanText(requestRecordPayload.executionRequestId)
-      || normalizedWrapperExecutionRequestId
-      || null;
-
-    let wrapperExecutionEvidenceBundle = null;
-    const wrapperEvidenceLookupSurface = pickSurface([
-      'getWrapperExecutionEvidenceBundle',
-      'getLatestWrapperExecutionEvidenceBundle',
-      'getModernizationWrapperEvidenceBundle',
-      'getModernizationWrapperExecutionEvidenceBundle',
-    ]);
-    if (wrapperEvidenceLookupSurface) {
-      wrapperExecutionEvidenceBundle = await wrapperEvidenceLookupSurface({
-        projectId: resolvedProjectId,
-        workflowId: resolvedWorkflowId,
-        workflowRunId: resolvedWorkflowRunId,
-        modernizationPacketId: resolvedModernizationPacketId,
-        wrapperExecutionRequestId: resolvedWrapperExecutionRequestId,
-        wrapperExecutionId: normalizedWrapperExecutionId,
-        includeOperations: Boolean(normalizedIncludeOperations),
-        includeFileManifest: Boolean(normalizedIncludeFileManifest),
-        includeVerificationSummary: Boolean(normalizedIncludeVerificationSummary),
-        includeProjection: Boolean(normalizedIncludeProjection),
-        metadata: {
-          ...normalizedMetadata,
-          source: 'getModernizationWrapperEvidence',
-        },
-      }).catch(() => null);
-    }
-
-    const bundlePayload = isPlainObject(wrapperExecutionEvidenceBundle) ? wrapperExecutionEvidenceBundle : {};
-    let wrapperExecutionRecord = isPlainObject(bundlePayload.wrapper_execution_record)
-      ? bundlePayload.wrapper_execution_record
-      : isPlainObject(bundlePayload.wrapperExecutionRecord)
-        ? bundlePayload.wrapperExecutionRecord
-        : null;
-    let wrapperOperationRecords = Array.isArray(bundlePayload.wrapper_operation_records)
-      ? bundlePayload.wrapper_operation_records.filter((record) => isPlainObject(record))
-      : Array.isArray(bundlePayload.wrapperOperationRecords)
-        ? bundlePayload.wrapperOperationRecords.filter((record) => isPlainObject(record))
-        : [];
-    let wrapperFileManifest = isPlainObject(bundlePayload.wrapper_file_manifest)
-      ? bundlePayload.wrapper_file_manifest
-      : isPlainObject(bundlePayload.wrapperFileManifest)
-        ? bundlePayload.wrapperFileManifest
-        : null;
-    let wrapperVerificationSummary = isPlainObject(bundlePayload.wrapper_verification_summary)
-      ? bundlePayload.wrapper_verification_summary
-      : isPlainObject(bundlePayload.wrapperVerificationSummary)
-        ? bundlePayload.wrapperVerificationSummary
-        : null;
-
-    if (!wrapperExecutionEvidenceBundle) {
-      if (!wrapperExecutionRecord) {
-        const wrapperRecordSurface = pickSurface([
-          'getWrapperExecutionRecord',
-          'getModernizationWrapperExecutionRecord',
-        ]);
-        if (wrapperRecordSurface) {
-          const wrapperRecordResult = await wrapperRecordSurface({
-            projectId: resolvedProjectId,
-            workflowId: resolvedWorkflowId,
-            workflowRunId: resolvedWorkflowRunId,
-            modernizationPacketId: resolvedModernizationPacketId,
-            wrapperExecutionRequestId: resolvedWrapperExecutionRequestId,
-            wrapperExecutionId: normalizedWrapperExecutionId,
-            sourceRef: normalizedSourceRef,
-            metadata: {
-              ...normalizedMetadata,
-              source: 'getModernizationWrapperEvidence',
-            },
-          }).catch(() => null);
-          if (isPlainObject(wrapperRecordResult)) {
-            wrapperExecutionRecord = wrapperRecordResult;
-          }
-        }
-      }
-
-      if (normalizedIncludeOperations && wrapperOperationRecords.length === 0) {
-        const wrapperOperationSurface = pickSurface([
-          'getWrapperExecutionOperationLog',
-          'getModernizationWrapperExecutionOperationLog',
-          'listWrapperExecutionOperations',
-        ]);
-        if (wrapperOperationSurface) {
-          const wrapperOperationResult = await wrapperOperationSurface({
-            projectId: resolvedProjectId,
-            workflowId: resolvedWorkflowId,
-            workflowRunId: resolvedWorkflowRunId,
-            modernizationPacketId: resolvedModernizationPacketId,
-            wrapperExecutionRequestId: resolvedWrapperExecutionRequestId,
-            wrapperExecutionId: normalizedWrapperExecutionId,
-            includeProjection: Boolean(normalizedIncludeProjection),
-            metadata: {
-              ...normalizedMetadata,
-              source: 'getModernizationWrapperEvidence',
-            },
-          }).catch(() => null);
-          if (Array.isArray(wrapperOperationResult)) {
-            wrapperOperationRecords = wrapperOperationResult.filter((record) => isPlainObject(record));
-          } else if (isPlainObject(wrapperOperationResult)) {
-            const maybeRecords = Array.isArray(wrapperOperationResult.wrapper_operation_records)
-              ? wrapperOperationResult.wrapper_operation_records
-              : Array.isArray(wrapperOperationResult.operation_records)
-                ? wrapperOperationResult.operation_records
-                : [];
-            wrapperOperationRecords = maybeRecords.filter((record) => isPlainObject(record));
-          }
-        }
-      }
-
-      if (normalizedIncludeFileManifest && !wrapperFileManifest) {
-        const wrapperFileManifestSurface = pickSurface([
-          'getWrapperExecutionFileManifest',
-          'getModernizationWrapperExecutionFileManifest',
-        ]);
-        if (wrapperFileManifestSurface) {
-          const wrapperFileManifestResult = await wrapperFileManifestSurface({
-            projectId: resolvedProjectId,
-            workflowId: resolvedWorkflowId,
-            workflowRunId: resolvedWorkflowRunId,
-            modernizationPacketId: resolvedModernizationPacketId,
-            wrapperExecutionRequestId: resolvedWrapperExecutionRequestId,
-            wrapperExecutionId: normalizedWrapperExecutionId,
-            metadata: {
-              ...normalizedMetadata,
-              source: 'getModernizationWrapperEvidence',
-            },
-          }).catch(() => null);
-          if (isPlainObject(wrapperFileManifestResult)) {
-            wrapperFileManifest = wrapperFileManifestResult;
-          }
-        }
-      }
-
-      if (normalizedIncludeVerificationSummary && !wrapperVerificationSummary) {
-        const wrapperVerificationSurface = pickSurface([
-          'getWrapperExecutionVerificationSummary',
-          'getModernizationWrapperExecutionVerificationSummary',
-        ]);
-        if (wrapperVerificationSurface) {
-          const wrapperVerificationResult = await wrapperVerificationSurface({
-            projectId: resolvedProjectId,
-            workflowId: resolvedWorkflowId,
-            workflowRunId: resolvedWorkflowRunId,
-            modernizationPacketId: resolvedModernizationPacketId,
-            wrapperExecutionRequestId: resolvedWrapperExecutionRequestId,
-            wrapperExecutionId: normalizedWrapperExecutionId,
-            metadata: {
-              ...normalizedMetadata,
-              source: 'getModernizationWrapperEvidence',
-            },
-          }).catch(() => null);
-          if (isPlainObject(wrapperVerificationResult)) {
-            wrapperVerificationSummary = wrapperVerificationResult;
-          }
-        }
-      }
-    }
-
-    const wrapperExecutionIdResolved = cleanText(wrapperExecutionRecord?.execution_id)
-      || cleanText(wrapperExecutionRecord?.executionId)
-      || cleanText(bundlePayload.wrapper_execution_persistence?.wrapper_execution_record_id)
-      || cleanText(bundlePayload.wrapper_execution_persistence?.wrapperExecutionRecordId)
-      || normalizedWrapperExecutionId
-      || null;
-    const executionStatus = cleanText(wrapperExecutionRecord?.status)
-      || cleanText(bundlePayload.wrapper_execution_record?.status)
-      || cleanText(bundlePayload.wrapperExecutionRecord?.status)
-      || null;
-    const verificationStatus = cleanText(wrapperVerificationSummary?.verification_status)
-      || cleanText(wrapperVerificationSummary?.verificationStatus)
-      || cleanText(bundlePayload.wrapper_verification_summary?.verification_status)
-      || cleanText(bundlePayload.wrapperVerificationSummary?.verificationStatus)
-      || null;
-
-    const filesCreated = Array.isArray(wrapperFileManifest?.files_created)
-      ? wrapperFileManifest.files_created
-      : Array.isArray(wrapperFileManifest?.filesCreated)
-        ? wrapperFileManifest.filesCreated
-        : [];
-    const filesModified = Array.isArray(wrapperFileManifest?.files_modified)
-      ? wrapperFileManifest.files_modified
-      : Array.isArray(wrapperFileManifest?.filesModified)
-        ? wrapperFileManifest.filesModified
-        : [];
-    const filesCreatedOrModified = cleanList([...filesCreated, ...filesModified]);
-
-    const collectedEvidenceRefs = [];
-    const collectEvidenceRefs = (value) => {
-      if (Array.isArray(value)) {
-        for (const item of value) {
-          if (item !== null && item !== undefined && item !== '') {
-            collectedEvidenceRefs.push(item);
-          }
-        }
-        return;
-      }
-      if (value !== null && value !== undefined && value !== '') {
-        collectedEvidenceRefs.push(value);
-      }
-    };
-    collectEvidenceRefs(bundlePayload.evidence_refs);
-    collectEvidenceRefs(bundlePayload.evidenceRefs);
-    collectEvidenceRefs(wrapperExecutionRecord?.evidence_refs);
-    collectEvidenceRefs(wrapperExecutionRecord?.evidenceRefs);
-    collectEvidenceRefs(wrapperVerificationSummary?.evidence_refs);
-    collectEvidenceRefs(wrapperVerificationSummary?.evidenceRefs);
-    collectEvidenceRefs(requestRecordPayload.evidence_refs);
-    collectEvidenceRefs(requestRecordPayload.evidenceRefs);
-    collectEvidenceRefs(packetRecordPayload.evidence_refs);
-    collectEvidenceRefs(packetRecordPayload.evidenceRefs);
-    if (Array.isArray(wrapperOperationRecords)) {
-      for (const record of wrapperOperationRecords) {
-        collectEvidenceRefs(record?.evidence_ref);
-        collectEvidenceRefs(record?.evidenceRefs);
-        collectEvidenceRefs(record?.evidence_refs);
-      }
-    }
-    const uniqueEvidenceRefs = [];
-    const seenEvidenceRefKeys = new Set();
-    for (const evidenceRef of collectedEvidenceRefs) {
-      const key = typeof evidenceRef === 'string'
-        ? evidenceRef.trim()
-        : JSON.stringify(evidenceRef);
-      if (!key || seenEvidenceRefKeys.has(key)) continue;
-      seenEvidenceRefKeys.add(key);
-      uniqueEvidenceRefs.push(evidenceRef);
-    }
-
-    const transferPacketId = cleanText(wrapperExecutionRequestRecord?.transfer_packet_id)
-      || cleanText(wrapperExecutionRequestRecord?.work_transfer_packet_id)
-      || cleanText(wrapperExecutionRequestRecord?.workTransferPacketId)
-      || cleanText(bundlePayload.transfer_packet_id)
-      || cleanText(bundlePayload.transferPacketId)
-      || null;
-    const transferChannelId = cleanText(wrapperExecutionRequestRecord?.transfer_channel_id)
-      || cleanText(wrapperExecutionRequestRecord?.channel_id)
-      || cleanText(wrapperExecutionRequestRecord?.channelId)
-      || cleanText(bundlePayload.transfer_channel_id)
-      || cleanText(bundlePayload.transferChannelId)
-      || null;
-
-    let transferPacketProjection = null;
-    if (normalizedIncludeProjection && transferPacketId) {
-      if (typeof this.getTransferPacketProjection === 'function') {
-        transferPacketProjection = await this.getTransferPacketProjection(transferPacketId).catch(() => null);
-      } else {
-        missingSurfaces.push('getTransferPacketProjection');
-      }
-    }
-    let transferChannelProjection = null;
-    if (normalizedIncludeProjection && transferChannelId) {
-      const transferChannelProjectionSurface = typeof this.getTransferChannelProjection === 'function'
-        ? this.getTransferChannelProjection.bind(this)
-        : typeof this.getLogaTransferChannelThreadProjection === 'function'
-          ? this.getLogaTransferChannelThreadProjection.bind(this)
-          : null;
-      if (!transferChannelProjectionSurface) {
-        missingSurfaces.push('getTransferChannelProjection');
-      } else {
-        transferChannelProjection = await transferChannelProjectionSurface(transferChannelId).catch(() => null);
-      }
-    }
-
-    const operationCount = wrapperOperationRecords.length;
-    const gateReady = Boolean(
-      wrapperExecutionRecord
-      && executionStatus === 'completed'
-      && verificationStatus === 'pass'
-      && operationCount > 0
-      && filesCreatedOrModified.length > 0
-    );
-
-    return {
-      status: missingSurfaces.length > 0 ? 'partial' : 'ready',
-      project_id: resolvedProjectId || null,
-      modernization_packet_id: resolvedModernizationPacketId,
-      wrapper_execution_request_id: resolvedWrapperExecutionRequestId || null,
-      wrapper_execution_id: wrapperExecutionIdResolved,
-      execution_status: executionStatus,
-      operation_count: operationCount,
-      files_created_or_modified: filesCreatedOrModified,
-      verification_status: verificationStatus,
-      gate_ready: gateReady,
-      evidence_refs: uniqueEvidenceRefs,
-      operator_projection_metadata: {
-        portfolio_bundle: portfolioBundle,
-        project_roadmap_summary: projectRoadmapSummary,
-        project_roadmap_active_item: projectActiveItem,
-        modernization_packet_record: modernizationPacketRecord,
-        wrapper_execution_request_record: wrapperExecutionRequestRecord,
-        wrapper_execution_record: wrapperExecutionRecord,
-        wrapper_execution_evidence_bundle: wrapperExecutionEvidenceBundle,
-        wrapper_operation_records: wrapperOperationRecords,
-        wrapper_file_manifest: wrapperFileManifest,
-        wrapper_verification_summary: wrapperVerificationSummary,
-        transfer_packet_projection: transferPacketProjection,
-        transfer_channel_projection: transferChannelProjection,
-      },
-      missing_surfaces: [...new Set(missingSurfaces)],
-      project: projectPayload,
-      modernization_packet_record: modernizationPacketRecord,
-      wrapper_execution_request_record: wrapperExecutionRequestRecord,
-      wrapper_execution_record: wrapperExecutionRecord,
-      wrapper_execution_evidence_bundle: wrapperExecutionEvidenceBundle,
-      wrapper_operation_records: wrapperOperationRecords,
-      wrapper_file_manifest: wrapperFileManifest,
-      wrapper_verification_summary: wrapperVerificationSummary,
-      transfer_packet_projection: transferPacketProjection,
-      transfer_channel_projection: transferChannelProjection,
-    };
-  }
-
-  async decideModernizationGate({
-    projectIdentifier,
-    projectId,
-    relatedProjectId,
-    related_project_id,
-    startWorkBody = {},
-    startWorkRequest = {},
-    resumeProjectWorkOptions = {},
-    modernizationPacket = {},
-    modernization_packet = {},
-    modernizationPacketId,
-    modernization_packet_id,
-    packetId,
-    packet_id,
-    wrapperExecutionRequestId,
-    wrapper_execution_request_id,
-    wrapperExecutionId,
-    wrapper_execution_id,
-    sourceRef,
-    source_ref,
-    requiredEvidence = [],
-    required_evidence = [],
-    acceptanceCriteria = [],
-    acceptance_criteria = [],
-    decisionMode,
-    decision_mode,
-    decisionBand,
-    decision_band,
-    reviewer,
-    reviewer_id,
-    assignedReviewer,
-    assigned_reviewer,
-    reviewRequired,
-    review_required,
-    riskLevel,
-    risk_level,
-    rationale,
-    rationaleText,
-    decisionRationale,
-    decision_rationale,
-    recordDecision,
-    record_decision,
-    reviewChannelId,
-    review_channel_id,
-    channelId,
-    channel_id,
-    transferChannelId,
-    transfer_channel_id,
-    implementationItemId,
-    implementation_item_id,
-    submittedBy,
-    submitted_by,
-    includeProjection = true,
-    include_projection = true,
-    metadata = {},
-  } = {}) {
-    const missingSurfaces = [];
-    const normalizedMetadata = isPlainObject(metadata) ? metadata : {};
-    const normalizedPacket = isPlainObject(modernization_packet)
-      ? modernization_packet
-      : (isPlainObject(modernizationPacket) ? modernizationPacket : {});
-    const normalizedProjectReference = cleanText(projectIdentifier)
-      || cleanText(projectId)
-      || cleanText(relatedProjectId)
-      || cleanText(related_project_id)
-      || cleanText(normalizedPacket.project_id)
-      || cleanText(normalizedPacket.projectId)
-      || cleanText(normalizedPacket.related_project_id)
-      || cleanText(normalizedPacket.relatedProjectId);
-    const normalizedModernizationPacketId = cleanText(modernization_packet_id)
-      || cleanText(modernizationPacketId)
-      || cleanText(packet_id)
-      || cleanText(packetId)
-      || cleanText(normalizedPacket.modernization_packet_id)
-      || cleanText(normalizedPacket.modernizationPacketId)
-      || cleanText(normalizedPacket.packet_id)
-      || cleanText(normalizedPacket.packetId);
-    const normalizedWrapperExecutionRequestId = cleanText(wrapper_execution_request_id)
-      || cleanText(wrapperExecutionRequestId);
-    const normalizedWrapperExecutionId = cleanText(wrapper_execution_id)
-      || cleanText(wrapperExecutionId);
-    const normalizedSourceRef = cleanText(source_ref)
-      || cleanText(sourceRef)
-      || cleanText(normalizedPacket.source_ref)
-      || cleanText(normalizedPacket.sourceRef)
-      || normalizedModernizationPacketId
-      || normalizedWrapperExecutionRequestId
-      || normalizedWrapperExecutionId;
-    const normalizedRequiredEvidence = cleanList(required_evidence.length > 0 ? required_evidence : requiredEvidence);
-    const normalizedAcceptanceCriteria = cleanList(acceptance_criteria.length > 0 ? acceptance_criteria : acceptanceCriteria);
-    const normalizedDecisionMode = cleanText(decision_mode) || cleanText(decisionMode) || 'recommend_only';
-    const normalizedDecisionBand = cleanText(decision_band) || cleanText(decisionBand) || null;
-    const normalizedReviewer = cleanText(reviewer_id)
-      || cleanText(reviewer)
-      || cleanText(assigned_reviewer)
-      || cleanText(assignedReviewer)
-      || null;
-    const normalizedReviewRequired = review_required ?? reviewRequired ?? Boolean(normalizedReviewer);
-    const normalizedRiskLevel = cleanText(risk_level) || cleanText(riskLevel) || cleanText(normalizedPacket.risk_level) || cleanText(normalizedPacket.riskLevel) || null;
-    const normalizedRationale = cleanText(decision_rationale)
-      || cleanText(decisionRationale)
-      || cleanText(rationaleText)
-      || cleanText(rationale)
-      || null;
-    const normalizedRecordDecision = record_decision ?? recordDecision ?? normalizedDecisionMode === 'record_decision';
-    const normalizedSubmittedBy = cleanText(submitted_by)
-      || cleanText(submittedBy)
-      || this.agentSessionId
-      || this.actorId
-      || null;
-    const normalizedReviewChannelId = cleanText(review_channel_id)
-      || cleanText(reviewChannelId)
-      || cleanText(channel_id)
-      || cleanText(channelId)
-      || cleanText(transfer_channel_id)
-      || cleanText(transferChannelId)
-      || null;
-
-    const pickSurface = (candidateNames) => {
-      for (const candidateName of candidateNames) {
-        if (typeof this[candidateName] === 'function') {
-          return this[candidateName].bind(this);
-        }
-      }
-      for (const candidateName of candidateNames) {
-        missingSurfaces.push(candidateName);
-      }
-      return null;
-    };
-
-    let continuation = null;
-    let startWorkResult = null;
-    if (normalizedProjectReference) {
-      if (typeof this.resumeProjectWork === 'function') {
-        continuation = await this.resumeProjectWork({
-          projectIdentifier: normalizedProjectReference,
-          projectId: normalizedProjectReference,
-          requireClaim: false,
-          ...resumeProjectWorkOptions,
-        });
-      } else {
-        missingSurfaces.push('resumeProjectWork');
-      }
-    } else if (Object.keys(isPlainObject(startWorkRequest) ? startWorkRequest : {}).length > 0 || Object.keys(isPlainObject(startWorkBody) ? startWorkBody : {}).length > 0) {
-      if (typeof this.startWork === 'function') {
-        startWorkResult = await this.startWork({
-          ...(isPlainObject(startWorkBody) ? startWorkBody : {}),
-          ...(isPlainObject(startWorkRequest) ? startWorkRequest : {}),
-        });
-      } else {
-        missingSurfaces.push('startWork');
-      }
-    }
-
-    const projectPayload = isPlainObject(continuation?.project)
-      ? continuation.project
-      : isPlainObject(startWorkResult?.project)
-        ? startWorkResult.project
-        : isPlainObject(continuation?.summary)
-          ? continuation.summary
-          : {};
-    const resolvedProjectId = cleanText(projectPayload.project_id)
-      || cleanText(projectPayload.projectId)
-      || normalizedProjectReference;
-    const resolvedWorkflowId = cleanText(projectPayload.workflow_id)
-      || cleanText(projectPayload.workflowId)
-      || cleanText(continuation?.workflow_id)
-      || cleanText(startWorkResult?.workflow_id);
-    const resolvedWorkflowRunId = cleanText(projectPayload.workflow_run_id)
-      || cleanText(projectPayload.workflowRunId)
-      || cleanText(continuation?.workflow_run_id)
-      || cleanText(startWorkResult?.workflow_run_id)
-      || cleanText(startWorkResult?.workflowRunId);
-
-    const wrapperEvidence = await this.getModernizationWrapperEvidence({
-      projectIdentifier: resolvedProjectId || normalizedProjectReference,
-      modernizationPacketId: normalizedModernizationPacketId,
-      wrapperExecutionRequestId: normalizedWrapperExecutionRequestId,
-      wrapperExecutionId: normalizedWrapperExecutionId,
-      sourceRef: normalizedSourceRef,
-      includeOperations: true,
-      includeFileManifest: true,
-      includeVerificationSummary: true,
-      includeProjection: Boolean(include_projection ?? includeProjection ?? true),
-      metadata: {
-        ...normalizedMetadata,
-        source: 'decideModernizationGate',
-      },
-    }).catch(() => null);
-    const wrapperEvidencePayload = isPlainObject(wrapperEvidence) ? wrapperEvidence : {};
-
-    let modernizationPacketRecord = isPlainObject(wrapperEvidencePayload.modernization_packet_record)
-      ? wrapperEvidencePayload.modernization_packet_record
-      : null;
-    const packetLookupSurface = typeof this.getModernizationWorkPacketRecord === 'function'
-      ? this.getModernizationWorkPacketRecord.bind(this)
-      : typeof this.getModernizationPacketRecord === 'function'
-        ? this.getModernizationPacketRecord.bind(this)
-        : null;
-    if (!modernizationPacketRecord && packetLookupSurface) {
-      modernizationPacketRecord = await packetLookupSurface({
-        projectId: resolvedProjectId,
-        workflowId: resolvedWorkflowId,
-        workflowRunId: resolvedWorkflowRunId,
-        modernizationPacketId: normalizedModernizationPacketId,
-        packetId: normalizedModernizationPacketId,
-        sourceRef: normalizedSourceRef,
-        metadata: {
-          ...normalizedMetadata,
-          source: 'decideModernizationGate',
-        },
-      }).catch(() => null);
-    }
-    if (!packetLookupSurface) {
-      missingSurfaces.push('getModernizationWorkPacketRecord');
-      missingSurfaces.push('getModernizationPacketRecord');
-    }
-
-    const packetRecordPayload = isPlainObject(modernizationPacketRecord) ? modernizationPacketRecord : {};
-    const resolvedModernizationPacketId = cleanText(packetRecordPayload.modernization_packet_id)
-      || cleanText(packetRecordPayload.modernizationPacketId)
-      || cleanText(packetRecordPayload.work_packet_id)
-      || cleanText(packetRecordPayload.workPacketId)
-      || normalizedModernizationPacketId
-      || null;
-    const resolvedImplementationItemId = cleanText(packetRecordPayload.implementation_item_id)
-      || cleanText(packetRecordPayload.implementationItemId)
-      || cleanText(packetRecordPayload.roadmap_item_id)
-      || cleanText(packetRecordPayload.roadmapItemId)
-      || cleanText(implementation_item_id)
-      || cleanText(implementationItemId)
-      || null;
-
-    const acceptanceCriteriaResolved = normalizedAcceptanceCriteria.length > 0
-      ? normalizedAcceptanceCriteria
-      : cleanList(packetRecordPayload.acceptance_criteria || packetRecordPayload.acceptanceCriteria || []);
-    const evidenceRefs = cleanList([
-      ...(Array.isArray(wrapperEvidencePayload.evidence_refs) ? wrapperEvidencePayload.evidence_refs : []),
-      ...(Array.isArray(wrapperEvidencePayload.evidenceRefs) ? wrapperEvidencePayload.evidenceRefs : []),
-    ]);
-    const requiredEvidenceMissing = normalizedRequiredEvidence.filter((evidenceRef) => !evidenceRefs.includes(evidenceRef));
-    const evidenceStatus = wrapperEvidencePayload.wrapper_execution_record
-      ? (wrapperEvidencePayload.gate_ready === true ? 'complete' : 'incomplete')
-      : 'absent';
-    const verificationStatus = cleanText(wrapperEvidencePayload.verification_status)
-      || cleanText(wrapperEvidencePayload.wrapper_verification_summary?.verification_status)
-      || cleanText(wrapperEvidencePayload.wrapper_verification_summary?.verificationStatus)
-      || null;
-    const evidenceComplete = evidenceStatus === 'complete' && verificationStatus === 'pass' && requiredEvidenceMissing.length === 0;
-    const reviewChannelPresent = Boolean(normalizedReviewChannelId);
-    const reviewRequiredResolved = Boolean(normalizedReviewRequired || evidenceStatus !== 'complete' || verificationStatus !== 'pass' || requiredEvidenceMissing.length > 0 || acceptanceCriteriaResolved.length === 0);
-    const recommendedDecision = evidenceComplete ? 'pass' : (reviewRequiredResolved ? 'pending' : 'block');
-    const gateDecisionRequested = normalizedRecordDecision && evidenceComplete;
-
-    let gateDecisionResult = null;
-    const gateDecisionSurface = typeof this.createImplementationPacketGateDecision === 'function'
-      ? this.createImplementationPacketGateDecision.bind(this)
-      : null;
-    if (normalizedRecordDecision && !gateDecisionSurface) {
-      missingSurfaces.push('createImplementationPacketGateDecision');
-    }
-    if (normalizedRecordDecision && gateDecisionSurface) {
-      gateDecisionResult = await gateDecisionSurface(resolvedModernizationPacketId, {
-        gate_type: cleanText(normalizedDecisionBand) || 'modernization_gate',
-        decision: evidenceComplete ? 'pass' : 'block',
-        rationale: normalizedRationale
-          || (evidenceComplete
-            ? 'Wrapper evidence satisfies the modernization gate.'
-            : 'Wrapper evidence is incomplete or unavailable; the gate cannot be marked as pass.'),
-        evidence_refs: evidenceRefs,
-        remediation_actions: evidenceComplete ? [] : ['Review wrapper evidence and missing modernization surfaces.'],
-        decided_by: normalizedReviewer || normalizedSubmittedBy || this.agentSessionId || this.actorId || null,
-      }).catch(() => null);
-    }
-
-    let gateDecisionId = cleanText(gateDecisionResult?.implementation_gate_decision_id)
-      || cleanText(gateDecisionResult?.gate_decision_id)
-      || null;
-
-    let evidenceLinkResult = null;
-    if (gateDecisionId && typeof this.addImplementationItemEvidence === 'function' && resolvedImplementationItemId) {
-      evidenceLinkResult = await this.addImplementationItemEvidence(
-        resolvedImplementationItemId,
-        {
-          evidence_type: 'modernization_gate_decision',
-          evidence_ref: gateDecisionId,
-          title: `Modernization gate decision for ${resolvedModernizationPacketId}`,
-          recorded_by: normalizedReviewer || normalizedSubmittedBy || this.agentSessionId || this.actorId || null,
-          metadata: {
-            ...normalizedMetadata,
-            source: 'decideModernizationGate',
-            modernization_packet_id: resolvedModernizationPacketId,
-            wrapper_execution_id: cleanText(wrapperEvidencePayload.wrapper_execution_id) || cleanText(wrapperEvidencePayload.wrapper_execution_record?.execution_id) || null,
-            decision: gateDecisionResult?.decision || (evidenceComplete ? 'pass' : 'block'),
-          },
-        },
-      ).catch(() => null);
-    } else if (gateDecisionId && !resolvedImplementationItemId) {
-      missingSurfaces.push('addImplementationItemEvidence');
-    }
-
-    let watchResult = null;
-    if (reviewRequiredResolved && reviewChannelPresent) {
-      const watchSurface = typeof this.startMessageWatch === 'function'
-        ? this.startMessageWatch.bind(this)
-        : null;
-      if (!watchSurface) {
-        missingSurfaces.push('startMessageWatch');
-      } else {
-        watchResult = await watchSurface({
-          transferChannelId: normalizedReviewChannelId,
-          workTransferPacketId: cleanText(wrapperEvidencePayload.transfer_packet_id) || cleanText(wrapperEvidencePayload.modernization_packet_id) || resolvedModernizationPacketId,
-          workflowRunId: resolvedWorkflowRunId,
-          watchingAgentRole: normalizedSubmittedBy,
-          expectedFromRole: normalizedReviewer || 'reviewer',
-          expectedMessageKind: 'response',
-          watchType: 'expected_peer_message',
-          watchingAgentSessionId: normalizedSubmittedBy,
-          expectedPayload: {
-            modernization_packet_id: resolvedModernizationPacketId,
-            expected_decision: recommendedDecision,
-          },
-          currentStatus: 'watching',
-          operatorNudge: normalizedRationale || 'Review modernization gate recommendation.',
-          metadata: {
-            ...normalizedMetadata,
-            source: 'decideModernizationGate',
-          },
-        }).catch(() => null);
-      }
-    }
-
-    const watchPayload = isPlainObject(watchResult) ? watchResult : {};
-    const watchId = cleanText(watchPayload.message_watch_id)
-      || cleanText(watchPayload.watch_id)
-      || cleanText(watchPayload.message_watch?.message_watch_id)
-      || cleanText(watchPayload.message_watch?.watch_id)
-      || null;
-
-    let heartbeatResult = null;
-    if (reviewChannelPresent && typeof this.postCollaborationHeartbeat === 'function') {
-      heartbeatResult = await this.postCollaborationHeartbeat({
-        transferChannelId: normalizedReviewChannelId,
-        workTransferPacketId: cleanText(wrapperEvidencePayload.transfer_packet_id) || resolvedModernizationPacketId,
-        workflowRunId: resolvedWorkflowRunId,
-        participantRole: normalizedReviewer ? 'reviewer' : 'gate_reviewer',
-        currentPhase: 'modernization_gate_review',
-        currentTaskSummary: normalizedRationale || `Review modernization gate for ${resolvedModernizationPacketId}`,
-        metadata: {
-          ...normalizedMetadata,
-          source: 'decideModernizationGate',
-        },
-      }).catch(() => null);
-    } else if (reviewChannelPresent) {
-      missingSurfaces.push('postCollaborationHeartbeat');
-    }
-    const heartbeatPayload = isPlainObject(heartbeatResult) ? heartbeatResult : {};
-    const heartbeatStatus = cleanText(heartbeatPayload.collaboration_heartbeat?.activity_state)
-      || cleanText(heartbeatPayload.activity_state)
-      || cleanText(heartbeatPayload.status)
-      || null;
-
-    const projectRoadmapSummary = resolvedProjectId && typeof this.getProjectRoadmapSummary === 'function'
-      ? await this.getProjectRoadmapSummary(resolvedProjectId).catch(() => null)
-      : null;
-    const projectActiveItem = resolvedProjectId && typeof this.getProjectRoadmapActiveItem === 'function'
-      ? await this.getProjectRoadmapActiveItem(resolvedProjectId).catch(() => null)
-      : null;
-    let projectProjection = null;
-    if (include_projection ?? includeProjection ?? true) {
-      const projectProjectionSurface = typeof this.getLogaProjectPortfolioProjection === 'function'
-        ? this.getLogaProjectPortfolioProjection.bind(this)
-        : null;
-      if (projectProjectionSurface) {
-        projectProjection = await projectProjectionSurface().catch(() => null);
-      } else {
-        missingSurfaces.push('getLogaProjectPortfolioProjection');
-      }
-    }
-
-    const operatorProjectionMetadata = {
-      modernization_packet_record: modernizationPacketRecord,
-      wrapper_evidence: wrapperEvidencePayload,
-      gate_decision: gateDecisionResult,
-      gate_decision_evidence_link: evidenceLinkResult,
-      project_roadmap_summary: projectRoadmapSummary,
-      project_roadmap_active_item: projectActiveItem,
-      project_projection: projectProjection,
-      review_watch: watchPayload,
-      review_heartbeat: heartbeatPayload,
-      acceptance_criteria: acceptanceCriteriaResolved,
-    };
-
-    const status = evidenceComplete
-      ? (gateDecisionRequested ? 'ready' : (missingSurfaces.length > 0 ? 'partial' : 'ready'))
-      : (reviewRequiredResolved ? 'review_required' : 'blocked');
-
-    return {
-      status,
-      project_id: resolvedProjectId || null,
-      modernization_packet_id: resolvedModernizationPacketId,
-      wrapper_execution_id: cleanText(wrapperEvidencePayload.wrapper_execution_id) || cleanText(wrapperEvidencePayload.wrapper_execution_record?.execution_id) || normalizedWrapperExecutionId || null,
-      evidence_status: evidenceStatus,
-      verification_status: verificationStatus,
-      recommended_decision: recommendedDecision,
-      gate_decision_id: gateDecisionId || null,
-      review_required: reviewRequiredResolved,
-      watch_id: watchId || null,
-      heartbeat_status: heartbeatStatus,
-      operator_projection_metadata: operatorProjectionMetadata,
-      missing_surfaces: [...new Set(missingSurfaces)],
-      project: projectPayload,
-      modernization_packet_record: modernizationPacketRecord,
-      wrapper_evidence: wrapperEvidencePayload,
-      gate_decision: gateDecisionResult,
-      gate_decision_evidence_link: evidenceLinkResult,
-      review_watch: watchPayload,
-      review_heartbeat: heartbeatPayload,
-    };
+  async decideModernizationGate(request = {}) {
+    return this.workflowComposition.decideModernizationGate(request);
   }
-
   // ─── Self-Learning ─────────────────────────────────────────────────────────
 
   async getSelfLearningPosture({ workflowRunId, limit } = {}) {