fix: stabilize review detail and collabora loading

app/api/cross-checking/cross-file-result.ts

@@ -2,6 +2,19 @@ import { postgrestGet, postgrestPut } from "../postgrest-client";
 import axios from 'axios';
 import { API_BASE_URL } from '../../config/api-config';
 
+interface ResultEnvelope<T> {
+  code?: number;
+  msg?: string;
+  data?: T;
+}
+
+function unwrapResultEnvelope<T>(payload: unknown): T {
+  if (payload && typeof payload === 'object' && 'data' in (payload as ResultEnvelope<T>)) {
+    return ((payload as ResultEnvelope<T>).data ?? null) as T;
+  }
+  return payload as T;
+}
+
 /**
  * 从不同格式的 API 响应中提取数据
  * @param responseData API 响应数据
@@ -86,8 +99,7 @@ async function safeGetJWT(jwtToken?: string): Promise<string> {
 /**
  * 检查用户是否有权确认完成文档评查
  *
- * 🔥 接口文档: auth_doc/交叉评查接口文档.md 接口11
- * 📍 API地址: GET /api/v2/cross_review/tasks/{task_id}/can-confirm
+ * 📍 API地址: GET /api/v3/cross-review/tasks/{task_id}/can-confirm
  *
  * @param taskId 任务ID
  * @param frontendJWT JWT token
@@ -100,10 +112,8 @@ export async function findIsProposer(taskId: string | number, userId: number | u
       return false;
     }
 
-    // 调用新的接口检查用户是否有权确认完成
-    // GET /api/v2/cross_review/tasks/{task_id}/can-confirm
-    const response = await axios.get(
-      `${API_BASE_URL}/api/v2/cross_review/tasks/${taskId}/can-confirm`,
+    const response = await axios.get<ResultEnvelope<{ canConfirm?: boolean; can_confirm?: boolean }>>(
+      `${API_BASE_URL}/api/v3/cross-review/tasks/${taskId}/can-confirm`,
       {
         headers: {
           'Content-Type': 'application/json',
@@ -112,12 +122,8 @@ export async function findIsProposer(taskId: string | number, userId: number | u
       }
     );
 
-    const data = response.data;
-    // console.log('[findIsProposer] 检查权限响应:', data);
-
-    // 返回 can_confirm 字段，表示是否有权确认完成
-    // 有权限的用户：任务创建者(assigner_id) 或 主要负责人(principal_user_ids)
-    return data?.can_confirm === true;
+    const data = response.data?.data || response.data;
+    return data?.canConfirm === true || data?.can_confirm === true;
   } catch (error) {
     console.error('[findIsProposer] 检查权限失败:', error);
 
@@ -147,26 +153,29 @@ export async function submitCrossCheckingOpinion(
     const token = await safeGetJWT(jwtToken);
 
     const requestData = {
-      document_id: opinionData.documentId,
-      evaluation_point_id: Number(opinionData.evaluationPointId), // 强制转数字
-      proposed_score: opinionData.deductionScore,
-      reason: opinionData.auditOpinion,
-      proposer_id: userInfo?.user_id,
-      evaluation_result_id: opinionData.reviewPointResultId
+      documentId: Number(opinionData.documentId),
+      evaluationPointId: Number(opinionData.evaluationPointId),
+      deductionScore: opinionData.deductionScore,
+      auditOpinion: opinionData.auditOpinion,
+      reviewPointResultId: Number(opinionData.reviewPointResultId)
     };
 
-    const response = await axios.post(`${API_BASE_URL}/api/v2/cross_review/proposals`, requestData, {
+    const response = await axios.post<ResultEnvelope<{ proposalId?: number; createdAt?: string }>>(`${API_BASE_URL}/api/v3/cross-review/proposals`, requestData, {
       headers: {
         'Content-Type': 'application/json',
         'Authorization': `Bearer ${token}`
       }
     });
+    const data = unwrapResultEnvelope<{ proposalId?: number; createdAt?: string }>(response.data);
 
     return {
       data: {
         success: true,
         message: '意见提交成功',
-        data: response.data
+        data: {
+          id: data?.proposalId,
+          created_at: data?.createdAt || new Date().toISOString()
+        }
       }
     };
   } catch (error) {
@@ -213,64 +222,80 @@ export async function getCrossCheckingOpinions(
     // 如果没传userId，默认用1
     const realUserId = userId ?? 1;
     // 实际后端API调用，拼接API_BASE_URL
-    const response = await axios.post(`${API_BASE_URL}/api/v2/cross_review/proposals/document`, {
-      // user_id: realUserId,
-      document_id: documentId, // 如果后端需要document_id可以加上
+    const response = await axios.get<ResultEnvelope<{
+      total: number;
+      page: number;
+      pageSize: number;
+      items: Array<{
+        proposalId: string | number;
+        evaluationPointName: string;
+        proposedScore: number;
+        reason: string;
+        proposer: string;
+        votes?: Array<{ voter: string; voteType: string }>;
+        agreeVoters?: string[];
+        disagreeVoters?: string[];
+        pendingVoters?: string[];
+        canVote?: boolean;
+        problemMessage?: string;
+        proposerId: number;
+        createdAt: string;
+        status: string;
+      }>;
+    }>>(`${API_BASE_URL}/api/v3/cross-review/documents/${documentId}/proposals`, {
+      params: {
         page,
-      page_size: pageSize
-    }, {
+        pageSize
+      },
       headers: {
-        'Content-Type': 'application/json',
         'Authorization': `Bearer ${token}`
       }
     });
 
-    const data = response.data;
-    // console.log('最原始的返回data', data);
-    // 处理新的数据结构，支持分页
-    const responseData = data.data || data;
-    const pagination = data.pagination;
-    
-    // 定义后端返回的数据项类型
-    interface ProposalItem {
-      proposal_id: string | number;
-      evaluation_point_name: string;
-      proposed_score: number;
+    const pageData = unwrapResultEnvelope<{
+      total: number;
+      page: number;
+      pageSize: number;
+      items: Array<{
+        proposalId: string | number;
+        evaluationPointName: string;
+        proposedScore: number;
         reason: string;
         proposer: string;
-      votes?: Array<{ voter: string; vote_type: string }>;
-      agree_voters?: string[];
-      disagree_voters?: string[];
-      pending_voters?: string[];
-      can_vote?: boolean;
-      problem_message?: string;
-      proposer_id: number;
-      created_at: string;
+        votes?: Array<{ voter: string; voteType: string }>;
+        agreeVoters?: string[];
+        disagreeVoters?: string[];
+        pendingVoters?: string[];
+        canVote?: boolean;
+        problemMessage?: string;
+        proposerId: number;
+        createdAt: string;
         status: string;
-    }
+      }>;
+    }>(response.data);
     
-    // 适配后端返回结构，使用新字段
-    const opinions: CrossCheckingOpinion[] = Array.isArray(responseData) ? responseData.map((item: ProposalItem) => ({
-      proposal_id: item.proposal_id,
-      evaluation_point_name: item.evaluation_point_name,
-      proposed_score: item.proposed_score,
+    // 定义后端返回的数据项类型
+    const opinions: CrossCheckingOpinion[] = Array.isArray(pageData?.items) ? pageData.items.map((item) => ({
+      proposal_id: item.proposalId,
+      evaluation_point_name: item.evaluationPointName,
+      proposed_score: item.proposedScore,
       reason: item.reason,
       proposer: item.proposer,
-      votes: item.votes || [],
-      agree_voters: item.agree_voters || [],
-      disagree_voters: item.disagree_voters || [],
-      pending_voters: item.pending_voters || [],
-      can_vote: item.can_vote ?? false,
-      problem_message: item.problem_message || '',
-      proposer_id: item.proposer_id,
-      created_at: item.created_at,
+      votes: (item.votes || []).map((vote) => ({ voter: vote.voter, vote_type: vote.voteType })),
+      agree_voters: item.agreeVoters || [],
+      disagree_voters: item.disagreeVoters || [],
+      pending_voters: item.pendingVoters || [],
+      can_vote: item.canVote ?? false,
+      problem_message: item.problemMessage || '',
+      proposer_id: item.proposerId,
+      created_at: item.createdAt,
       status: item.status
     })) : [];
     
     return {
       data: {
         opinions,
-        total: pagination?.total || opinions.length
+        total: pageData?.total || opinions.length
       }
     };
   } catch (error) {
@@ -335,31 +360,29 @@ export async function performOpinionAction(
     switch (actionData.action) {
       case 'agree':
         message = '已赞同该意见';
-        endpoint = `${API_BASE_URL}/api/v2/cross_review/proposals/${actionData.opinionId}/votes`;
-        requestBody = { vote_type: 'agree', voter_id: userInfo?.user_id };
+        endpoint = `${API_BASE_URL}/api/v3/cross-review/proposals/${actionData.opinionId}/votes`;
+        requestBody = { voteType: 'agree' };
         break;
       case 'disagree':
         message = '已反对该意见';
-        endpoint = `${API_BASE_URL}/api/v2/cross_review/proposals/${actionData.opinionId}/votes`;
-        requestBody = { vote_type: 'disagree', voter_id: userInfo?.user_id };
+        endpoint = `${API_BASE_URL}/api/v3/cross-review/proposals/${actionData.opinionId}/votes`;
+        requestBody = { voteType: 'disagree' };
         break;
       case 'withdraw_vote':
         message = '已撤销投票';
-        // 撤销投票的接口，根据实际API调整
-        endpoint = `${API_BASE_URL}/api/v2/cross_review/proposals/${actionData.opinionId}/votes`;
-        requestBody = { vote_type: 'cancel', voter_id: userInfo?.user_id };
+        endpoint = `${API_BASE_URL}/api/v3/cross-review/proposals/${actionData.opinionId}/votes`;
+        requestBody = { voteType: 'cancel' };
         break;
       case 'withdraw_opinion':
         message = '已撤销意见';
-        // 撤销意见的接口，根据实际API调整
-        endpoint = `${API_BASE_URL}/api/v2/cross_review/proposals/${actionData.opinionId}`;
+        endpoint = `${API_BASE_URL}/api/v3/cross-review/proposals/${actionData.opinionId}`;
         requestBody = {};
         break;
       default:
         throw new Error('无效的操作类型');
     }
 
-    const response = actionData.action === 'withdraw_opinion'
+    await (actionData.action === 'withdraw_opinion'
       ? await axios.delete(endpoint, {
           headers: {
             'Content-Type': 'application/json',
@@ -371,11 +394,7 @@ export async function performOpinionAction(
             'Content-Type': 'application/json',
             'Authorization': `Bearer ${token}`
           }
-        });
-
-    const data = response.data;
-
-    console.log('返回的意见列表数据',data);
+        }));
 
     return {
       data: {
@@ -412,8 +431,7 @@ export async function performOpinionAction(
  * @param frontendJWT JWT token
  * @returns 完成评查结果
  *
- * 🔥 接口文档: auth_doc/交叉评查接口文档(1).md 接口10
- * 📍 API地址: POST /admin/v2/cross_review/tasks/{task_id}/documents/{document_id}/complete
+ * 📍 API地址: POST /api/v3/cross-review/tasks/{task_id}/documents/{document_id}/complete
  */
 export async function confirmReviewResults(
   taskId: string | number,
@@ -428,10 +446,13 @@ export async function confirmReviewResults(
       return { error: '文档ID不能为空', status: 400 };
     }
 
-    // 调用后端API确认文档审核完成
-    // 接口: POST /admin/v2/cross_review/tasks/{task_id}/documents/{document_id}/complete
-    const response = await axios.post(
-      `${API_BASE_URL}/admin/v2/cross_review/tasks/${taskId}/documents/${documentId}/complete`,
+    const response = await axios.post<ResultEnvelope<{
+      taskId?: number;
+      documentId?: number;
+      taskStatus?: string;
+      auditStatus?: number;
+    }>>(
+      `${API_BASE_URL}/api/v3/cross-review/tasks/${taskId}/documents/${documentId}/complete`,
       {}, // 无需请求体
       {
         headers: {
@@ -441,15 +462,16 @@ export async function confirmReviewResults(
       }
     );
 
-    const data = response.data;
+    const data = response.data?.data || response.data;
 
-    // 检查响应是否成功
-    if (data?.success || data?.code === 0) {
+    if (data) {
       return {
         data: {
-          task_id: data.task_id || taskId,
-          document_id: data.document_id || documentId,
-          message: data.message || '文档评查已完成'
+          task_id: data.taskId || taskId,
+          document_id: data.documentId || documentId,
+          task_status: data.taskStatus,
+          audit_status: data.auditStatus,
+          message: '文档评查已完成'
         }
       };
     }
@@ -457,7 +479,7 @@ export async function confirmReviewResults(
     // 数据为空或格式不正确
     console.error('❌ [confirmReviewResults] API响应数据异常:', data);
     return {
-      error: data?.message || '确认文档审核失败',
+      error: '确认文档审核失败',
       status: 500
     };
 
@@ -491,26 +513,30 @@ export async function checkProposalVotes(
     // 获取JWT token
     const token = await safeGetJWT(jwtToken);
 
-    const requestData = {
-        document_id: documentId
-    };
-
-    const response = await axios.post(`${API_BASE_URL}/api/v2/cross_review/proposals/document/check_pending_votes`, requestData, {
+    const response = await axios.get<ResultEnvelope<{
+      hasPendingVotes?: boolean;
+      pendingProposals?: Array<{ evaluationPointName: string; pendingVotersNum: number }>;
+    }>>(`${API_BASE_URL}/api/v3/cross-review/documents/${documentId}/pending-votes`, {
       headers: {
-        'Content-Type': 'application/json',
         'Authorization': `Bearer ${token}`
       }
     });
 
-    const data = response.data;
-
-    console.log("检查投票数据",data);
+    const data = unwrapResultEnvelope<{
+      hasPendingVotes?: boolean;
+      pendingProposals?: Array<{ evaluationPointName: string; pendingVotersNum: number }>;
+    }>(response.data);
 
     return {
       data: {
         success: true,
         message: '检查成功',
-        data: data
+        data: {
+          pending_proposals: (data?.pendingProposals || []).map((item) => ({
+            evaluation_point_name: item.evaluationPointName,
+            pending_voters_num: item.pendingVotersNum
+          }))
+        }
       }
     };
   } catch (error) {
@@ -533,4 +559,3 @@ export async function checkProposalVotes(
     };
   }
 }
-

app/api/cross-checking/cross-files-upload.ts

@@ -116,39 +116,16 @@ export async function uploadCrossCheckingDocument(
   token: string | null = null
 ): Promise<{data: CrossCheckingFileUploadResponse; error?: never} | {data?: never; error: string; status?: number}> {
   try {
-    console.log('【交叉评查上传】开始上传文档:', { fileName, fileSize: binaryData.byteLength, typeId });
-    
-    // 创建FormData对象
     const formData = new FormData();
-    
-    // 将二进制数据转换为Blob并添加到FormData
     const blob = new Blob([binaryData], { type: fileType });
     formData.append('file', blob, fileName);
-    console.log('【交叉评查上传】Blob已创建，文件大小:', blob.size);
+    formData.append('typeId', String(typeId));
+    formData.append('region', 'default');
+    formData.append('fileRole', 'primary');
+    formData.append('autoRun', 'true');
+    formData.append('speed', priority === 'urgent' ? 'urgent' : 'normal');
 
-    // 将信息添加到一个JSON对象中
-    const uploadInfo = {
-      type_id: typeId, 
-      evaluation_level: priority,
-      document_number: documentNumber || null,
-      remark: remark || null,
-      is_test_document: isTestDocument,
-      document_id: documentId || null,
-      is_reupload: isReupload
-    };
-    
-    // 添加JSON字符串到FormData
-    formData.append('upload_info', JSON.stringify(uploadInfo));
-    console.log('【交叉评查上传】FormData准备完成:', JSON.stringify(uploadInfo));
-    
-    // 根据是否有documentId决定使用哪个接口
-    const uploadEndpoint = '/batch_upload';
-    const uploadUrl = UPLOAD_URL + uploadEndpoint;
-    console.log('【交叉评查上传】准备发送请求到服务器:', uploadUrl);
-    
-    // 发送请求
     try {
-      console.log('【交叉评查上传】开始axios请求...');
       const headers: Record<string, string> = {
         'X-File-Name': encodeURIComponent(fileName),
       };
@@ -157,30 +134,43 @@ export async function uploadCrossCheckingDocument(
         headers['Authorization'] = `Bearer ${token}`;
       }
 
-      const response = await axios.post(uploadUrl, formData, {
+      const response = await axios.post(`${API_BASE_URL}/api/upload`, formData, {
         headers
       });
-
-      console.log('【交叉评查上传】收到服务器响应:', { status: response.status, statusText: response.statusText });
-
-      console.log('【交叉评查上传】JSON响应解析成功:', response.data);
-
-      const extractedData = extractApiData<CrossCheckingFileUploadResponse>(response.data);
-      console.log('【交叉评查上传】提取的数据:', extractedData);
-
-      if (!extractedData) {
-        console.error('【交叉评查上传】无法提取数据');
-        return { error: '处理上传响应失败', status: 500 };
+      const uploadData = response.data?.data;
+      if (!uploadData?.documentId) {
+        return { error: response.data?.message || response.data?.msg || '处理上传响应失败', status: response.status };
       }
 
-      console.log('【交叉评查上传】上传成功，返回数据');
-      return { data: extractedData as CrossCheckingFileUploadResponse };
-    } catch (axiosError) {
-      console.error('【交叉评查上传】axios请求失败:', axiosError);
-      if (axios.isAxiosError(axiosError)) {
-        const errorText = axiosError.response?.data || axiosError.message;
       return {
-          error: `上传失败: ${axiosError.response?.status || 500} ${axiosError.response?.statusText || ''} - ${errorText}`,
+        data: {
+          success: true,
+          result: {
+            id: Number(uploadData.documentId),
+            file_name: uploadData.fileName || fileName,
+            file_size: binaryData.byteLength,
+            file_url: uploadData.storagePath || '',
+            type_id: Number(uploadData.typeId || typeId),
+            type_description: uploadData.typeCode || '',
+            document_number: documentNumber || null,
+            storage_type: 'oss',
+            is_test_document: isTestDocument,
+            remark: remark || null,
+            background_processing: true,
+            evaluation_level: priority,
+          },
+          error: null,
+        }
+      };
+    } catch (axiosError) {
+      if (axios.isAxiosError(axiosError)) {
+        const errorText =
+          axiosError.response?.data?.message ||
+          axiosError.response?.data?.msg ||
+          axiosError.response?.data?.detail ||
+          axiosError.message;
+        return {
+          error: `上传失败: ${errorText}`,
           status: axiosError.response?.status || 500
         };
       }
@@ -190,7 +180,6 @@ export async function uploadCrossCheckingDocument(
       };
     }
   } catch (error) {
-    console.error('【交叉评查上传】上传过程中发生错误:', error);
     return { 
       error: error instanceof Error ? error.message : '上传失败',
       status: 500
@@ -199,19 +188,13 @@ export async function uploadCrossCheckingDocument(
 }
 
 /**
- * 批量上传并自动分配交叉评查任务（新接口适配）
- * @param files 文件列表
- * @param typeId 文档类型ID
- * @param priority 优先级
- * @param documentNumber 文档编号
- * @param remark 备注
- * @param isTestDocument 是否为测试文档
- * @param assignUserIds 需要分配的用户ID数组
- * @param taskName 任务名称
- * @param docType 文档类型（如 XZCF、XZXK）
- * @param taskType 任务类型（如 市局间交叉评查、区局间交叉评查）
- * @param token JWT Token
- * @param principalUserIds 负责人ID数组（包含主要负责人和额外负责人）
+ * 旧的一体化“上传并分配任务”接口适配。
+ *
+ * 现在创建交叉评查任务已改为：
+ * 1. 先上传文档
+ * 2. 再调用 `createCrossReviewTask()` 创建 v3 任务
+ *
+ * 这里先保留兼容实现，避免影响可能的旧调用方。
  */
 export async function batchUploadAndAssignCrossCheckingFiles(
   files: CrossCheckingUploadedFile[],
@@ -286,16 +269,15 @@ export async function batchUploadAndAssignCrossCheckingFiles(
 }
 
 /**
- * 创建交叉评查任务
- * @param taskData 任务数据
- * @param token JWT Token
- * @returns 创建结果
+ * 创建交叉评查任务（v3）。
+ * 先由前端完成文档上传，再将上传成功后的 documentIds 挂到任务上。
  */
 export async function createCrossReviewTask(taskData: {
   documentIds: number[];
   userIds: number[];
-  assignerId: number;
+  principalUserIds?: number[];
   taskName: string;
+  docTypeId?: number;
   docType: string;
   taskType?: string;
 }, token: string | null = null): Promise<{
@@ -305,12 +287,13 @@ export async function createCrossReviewTask(taskData: {
 }> {
   try {
     const requestBody = {
-      document_ids: taskData.documentIds,
-      user_ids: taskData.userIds,
-      assigner_id: taskData.assignerId,
-      task_name: taskData.taskName,
-      doc_type: taskData.docType,
-      task_type: taskData.taskType || '市局间交叉评查'
+      documentIds: taskData.documentIds,
+      memberUserIds: taskData.userIds,
+      principalUserIds: taskData.principalUserIds || [],
+      taskName: taskData.taskName,
+      docTypeId: taskData.docTypeId,
+      docTypeCode: taskData.docType,
+      taskType: taskData.taskType || 'CITY'
     };
 
     // console.log('[创建任务] 请求数据:', requestBody);
@@ -323,7 +306,7 @@ export async function createCrossReviewTask(taskData: {
     }
 
     const response = await axios.post(
-      `${API_BASE_URL}/admin/cross_review/tasks/assign`,
+      `${API_BASE_URL}/api/v3/cross-review/tasks`,
       requestBody,
       { headers }
     );
@@ -376,7 +359,7 @@ export function formatFileSize(bytes: number): string {
 /**
  * 向已有任务上传新文档
  *
- * POST /api/v2/cross_review/tasks/{task_id}/upload_documents
+ * POST /api/v3/cross-review/tasks/{task_id}/documents/upload
  *
  * @param params 上传参数
  * @returns 上传结果
@@ -396,10 +379,9 @@ export async function uploadDocumentToTask(params: {
     console.log('[上传文档到任务] 开始上传:', { taskId, fileName: file.name });
 
     const formData = new FormData();
-    // 添加文件（使用 files 字段名）
-    formData.append('files', file, file.name);
+    formData.append('file', file, file.name);
 
-    const uploadEndpoint = `/api/v2/cross_review/tasks/${taskId}/upload_documents`;
+    const uploadEndpoint = `/api/v3/cross-review/tasks/${taskId}/documents/upload`;
     const uploadUrl = API_BASE_URL + uploadEndpoint;
 
     const headers: Record<string, string> = {};
@@ -410,10 +392,9 @@ export async function uploadDocumentToTask(params: {
     const response = await axios.post(uploadUrl, formData, { headers });
     const result = response.data;
 
-    // 新接口响应格式: { code: 0, success: true, message: "...", data: {...} }
     if (result && (result.success || result.code === 0)) {
       console.log('[上传文档到任务] 上传成功:', result.message);
-      return { success: true, data: result.data };
+      return { success: true, data: result.data || result };
     } else {
       console.error('[上传文档到任务] 上传失败:', result.detail || result.message);
       return { success: false, error: result.detail || result.message || '上传失败' };

app/api/cross-checking/cross-files.ts

@@ -76,7 +76,7 @@ export interface UserTaskApiResponse {
   items: UserTaskInfo[];
 }
 
-// 任务文档接口类型定义（旧版，保留兼容）
+// 任务文档接口类型定义（任务详情页兼容结构）
 export interface TaskDocument {
   document_id: number;
   file_name: string;
@@ -289,6 +289,156 @@ export interface ApiResponse<T> {
   status?: number;
 }
 
+interface ResultEnvelope<T> {
+  code?: number;
+  msg?: string;
+  data?: T;
+}
+
+interface V3UserTaskItem {
+  taskId: number;
+  taskName: string;
+  taskType: string;
+  docTypeId?: number | null;
+  docTypeCode?: string | null;
+  status: string;
+  progress?: number;
+  totalDocuments?: number;
+  completedDocuments?: number;
+  createdAt?: string;
+}
+
+interface V3UserTaskPage {
+  total: number;
+  page: number;
+  pageSize: number;
+  items: V3UserTaskItem[];
+}
+
+interface V3TaskDocumentItem {
+  documentId: number;
+  name: string;
+  documentNumber?: string | null;
+  typeId?: number | null;
+  processingStatus?: string | null;
+  versionNo?: number;
+  isLatestVersion?: boolean;
+  auditStatus?: number;
+  createdAt?: string;
+}
+
+interface V3TaskDocumentPage {
+  taskId: number;
+  total: number;
+  page: number;
+  pageSize: number;
+  items: V3TaskDocumentItem[];
+}
+
+function unwrapResultEnvelope<T>(payload: unknown): T {
+  if (payload && typeof payload === 'object' && 'data' in (payload as ResultEnvelope<T>)) {
+    return ((payload as ResultEnvelope<T>).data ?? null) as T;
+  }
+  return payload as T;
+}
+
+function mapProcessingStatus(status?: string | null): CrossReviewDocumentWithVersion['status'] {
+  switch (status) {
+    case 'processed':
+    case 'Processed':
+      return 'Processed';
+    case 'failed':
+    case 'Failed':
+      return 'Failed';
+    case 'cutting':
+    case 'Cutting':
+      return 'Cutting';
+    case 'extracting':
+    case 'Extractioning':
+      return 'Extractioning';
+    case 'evaluating':
+    case 'Evaluationing':
+      return 'Evaluationing';
+    case 'waiting':
+    case 'Waiting':
+    default:
+      return 'Waiting';
+  }
+}
+
+function mapV3TaskToUserTaskInfo(item: V3UserTaskItem): UserTaskInfo {
+  return {
+    task_id: item.taskId,
+    task_name: item.taskName,
+    task_status: item.status,
+    doc_type: item.docTypeCode || undefined,
+    task_created_at: item.createdAt,
+    task_type: item.taskType,
+    progress: item.progress,
+    total_documents: item.totalDocuments
+  };
+}
+
+function mapV3DocumentToTaskDocument(item: V3TaskDocumentItem): TaskDocument {
+  return {
+    document_id: item.documentId,
+    file_name: item.name || '',
+    status: mapProcessingStatus(item.processingStatus),
+    path: '',
+    file_code: item.documentNumber || '',
+    file_type_name: item.typeId ? `类型${item.typeId}` : '',
+    file_type_id: item.typeId || 0,
+    file_size: 0,
+    upload_time: item.createdAt || '',
+    created_at: item.createdAt || '',
+    evaluations_status: 0,
+    audit_status: item.auditStatus || 0,
+    created_by_user_id: 0,
+    issues: [],
+    final_score: 0,
+    score_summary: '',
+    score_percent: null,
+    pass_count: 0,
+    warning_count: 0,
+    fail_count: 0,
+    manual_count: 0
+  };
+}
+
+function mapV3DocumentToVersionedDocument(item: V3TaskDocumentItem): CrossReviewDocumentWithVersion {
+  const typeName = item.typeId ? `类型${item.typeId}` : '未知类型';
+  return {
+    id: item.documentId,
+    name: item.name || '',
+    path: '',
+    version_number: item.versionNo || 1,
+    created_at: item.createdAt || '',
+    status: mapProcessingStatus(item.processingStatus),
+    file_size: 0,
+    document_number: item.documentNumber || null,
+    type_id: item.typeId || 0,
+    type_name: typeName,
+    upload_time: item.createdAt || '',
+    audit_status: (item.auditStatus || 0) as 0 | 1,
+    total_evaluation_points: 0,
+    pass_count: 0,
+    warning_count: 0,
+    error_count: 0,
+    manual_count: 0,
+    issue_count: 0,
+    warning_messages: [],
+    error_messages: [],
+    issue_messages: [],
+    manual_messages: [],
+    final_score: 0,
+    full_score: 100,
+    score_summary: '',
+    score_percent: 0,
+    total_versions: 1,
+    history_versions: []
+  };
+}
+
 // 任务列表查询参数
 export interface TaskListParams {
   page?: number;
@@ -321,10 +471,7 @@ export interface TaskListResponse {
  */
 export async function getCrossCheckingTasks(params: TaskListParams = {}, userInfo?: { user_id?: number; [key: string]: unknown }, jwtToken?: string): Promise<ApiResponse<TaskListResponse>> {
   try {
-    // console.log('开始调用getCrossCheckingTasks，参数:', params);
-    
-    // 调用用户任务API，获取当前用户参与的任务
-    const userTasksResponse = await getUserTaskDocuments(params.page || 1, params.pageSize || 10, jwtToken);
+    const userTasksResponse = await getUserTaskDocuments(params, jwtToken);
     
     // console.log('getUserTaskDocuments响应:', JSON.stringify(userTasksResponse,null,2));
     
@@ -347,7 +494,7 @@ export async function getCrossCheckingTasks(params: TaskListParams = {}, userInf
         startDate: userTask.task_created_at ? new Date(userTask.task_created_at).toISOString().split('T')[0] : new Date().toISOString().split('T')[0],
         taskType: userTask.task_type, // 保持默认任务类型
         docType: userTask.doc_type || '未知类型', // 使用API返回的文档类型
-        evaluationRegion: userTask.evaluation_region || [], // 保持默认评查地区
+        evaluationRegion: userTask.evaluation_region || [],
         progress: userTask.progress || 0, // 使用API返回的进度
         status: userTask.task_status || 'pending', // 使用API返回的任务状态
         score: userTask.task_status === 'completed' ? 85 : 0, // 默认分数
@@ -391,7 +538,7 @@ export async function getCrossCheckingTasks(params: TaskListParams = {}, userInf
       const lowerKeyword = keyword.toLowerCase();
       filteredTasks = filteredTasks.filter(task => 
         task.taskName.toLowerCase().includes(lowerKeyword) ||
-        task.evaluationRegion.toLowerCase().includes(lowerKeyword)
+        task.evaluationRegion.join(',').toLowerCase().includes(lowerKeyword)
       );
     }
 
@@ -525,7 +672,7 @@ export async function getCrossCheckingStats(userInfo?: { user_id?: number; [key:
     console.log('开始调用getCrossCheckingStats');
     
     // 获取用户任务数据来计算统计（默认获取第一页数据进行统计）
-    const userTasksResponse = await getUserTaskDocuments(1, 100, jwtToken); // 获取前100个任务用于统计
+    const userTasksResponse = await getUserTaskDocuments({ page: 1, pageSize: 100 }, jwtToken);
     
     if (!userTasksResponse.success || !userTasksResponse.data) {
       console.error('获取用户任务失败:', userTasksResponse.error);
@@ -568,25 +715,49 @@ export async function getCrossCheckingStats(userInfo?: { user_id?: number; [key:
  * @param jwtToken JWT token
  * @returns 用户任务列表
  */
-export async function getUserTaskDocuments(page: number = 1, pageSize: number = 10, jwtToken?: string): Promise<ApiResponse<UserTaskApiResponse>> {
+export async function getUserTaskDocuments(params: TaskListParams = {}, jwtToken?: string): Promise<ApiResponse<UserTaskApiResponse>> {
   try {
-    // 拼接绝对路径，去除多余斜杠
     const base = API_BASE_URL.endsWith('/') ? API_BASE_URL.slice(0, -1) : API_BASE_URL;
-    const url = `${base}/admin/v2/cross_review/tasks/user_tasks`;
+    const url = `${base}/api/v3/cross-review/tasks/query`;
 
-    const response = await axios.post(url, {
-      page: page,
-      page_size: pageSize
-    }, {
+    const page = params.page || 1;
+    const pageSize = params.pageSize || 10;
+    const requestBody: Record<string, unknown> = {
+      page,
+      pageSize
+    };
+
+    if (params.keyword?.trim()) {
+      requestBody.keyword = params.keyword.trim();
+    }
+    if (params.status && params.status !== 'all') {
+      requestBody.status = params.status;
+    }
+    if (params.taskType && params.taskType !== 'all') {
+      requestBody.taskType = params.taskType;
+    }
+    if (params.docType && params.docType !== 'all') {
+      requestBody.docTypeCode = params.docType;
+    }
+
+    const response = await axios.post<ResultEnvelope<V3UserTaskPage>>(url, requestBody, {
       headers: {
         'Content-Type': 'application/json',
         'Authorization': `Bearer ${jwtToken || ''}`
       }
     });
 
+    const pageData = unwrapResultEnvelope<V3UserTaskPage>(response.data);
+    const items = Array.isArray(pageData?.items) ? pageData.items.map(mapV3TaskToUserTaskInfo) : [];
+
     return {
       success: true,
-      data: response.data
+      data: {
+        total: pageData?.total || 0,
+        page: pageData?.page || page,
+        page_size: pageData?.pageSize || pageSize,
+        items
+      }
     };
   } catch (error) {
     if (axios.isAxiosError(error)) {
@@ -603,7 +774,7 @@ export async function getUserTaskDocuments(page: number = 1, pageSize: number =
 }
 
 /**
- * 获取指定任务的文档列表（旧版接口，保留兼容）
+ * 获取指定任务的文档列表（兼容任务详情使用）
  * @param taskId 任务ID
  * @param page 页码
  * @param pageSize 每页大小
@@ -612,24 +783,30 @@ export async function getUserTaskDocuments(page: number = 1, pageSize: number =
  */
 export async function getTaskDocuments(taskId: number, page: number = 1, pageSize: number = 10, jwtToken?: string): Promise<ApiResponse<TaskDocumentApiResponse>> {
   try {
-    // 拼接绝对路径，去除多余斜杠
     const base = API_BASE_URL.endsWith('/') ? API_BASE_URL.slice(0, -1) : API_BASE_URL;
-    const url = `${base}/admin/v2/cross_review/tasks/${taskId}/documents`;
-    // console.log('最终请求URL:', url);
+    const url = `${base}/api/v3/cross-review/tasks/${taskId}/documents`;
 
-    const response = await axios.post(url, {
-      page: page,
-      page_size: pageSize
-    }, {
+    const response = await axios.get<ResultEnvelope<V3TaskDocumentPage>>(url, {
+      params: {
+        page,
+        pageSize
+      },
       headers: {
-        'Content-Type': 'application/json',
         'Authorization': `Bearer ${jwtToken || ''}`
       }
     });
 
+    const pageData = unwrapResultEnvelope<V3TaskDocumentPage>(response.data);
+    const items = Array.isArray(pageData?.items) ? pageData.items.map(mapV3DocumentToTaskDocument) : [];
+
     return {
       success: true,
-      data: response.data
+      data: {
+        total: pageData?.total || 0,
+        page: pageData?.page || page,
+        page_size: pageData?.pageSize || pageSize,
+        items
+      }
     };
   } catch (error) {
     if (axios.isAxiosError(error)) {
@@ -646,9 +823,9 @@ export async function getTaskDocuments(taskId: number, page: number = 1, pageSiz
 }
 
 /**
- * 获取任务下文档列表（支持版本归纳）- 新版接口
+ * 获取任务下文档列表（支持版本归纳）
  *
- * POST /api/v2/cross_review/tasks/{task_id}/documents
+ * GET /api/v3/cross-review/tasks/{task_id}/documents
  *
  * 同一任务内同名且同类型的文档会被归纳为版本组，最新上传的为当前版本，其余为历史版本。
  *
@@ -661,18 +838,16 @@ export async function getTaskDocumentsWithVersions(
   const { taskId, page = 1, pageSize = 10, keyword, jwtToken } = params;
 
   try {
-    // 拼接绝对路径，去除多余斜杠
     const base = API_BASE_URL.endsWith('/') ? API_BASE_URL.slice(0, -1) : API_BASE_URL;
-    const url = `${base}/api/v2/cross_review/tasks/${taskId}/documents`;
+    const url = `${base}/api/v3/cross-review/tasks/${taskId}/documents`;
 
-    // 构建请求体
     const queryParams: {
       page: number;
-      page_size: number;
+      pageSize: number;
       keyword?: string;
     } = {
       page,
-      page_size: pageSize
+      pageSize
     };
 
     // 只有当 keyword 有值时才添加
@@ -680,16 +855,25 @@ export async function getTaskDocumentsWithVersions(
       queryParams.keyword = keyword.trim();
     }
 
-    const response = await axios.get<CrossReviewDocumentListResponse>(url, {
+    const response = await axios.get<ResultEnvelope<V3TaskDocumentPage>>(url, {
       params: queryParams,
       headers: {
         'Authorization': `Bearer ${jwtToken || ''}`
       }
     });
 
+    const pageData = unwrapResultEnvelope<V3TaskDocumentPage>(response.data);
+    const documents = Array.isArray(pageData?.items) ? pageData.items.map(mapV3DocumentToVersionedDocument) : [];
+
     return {
       success: true,
-      data: response.data
+      data: {
+        total: pageData?.total || 0,
+        page: pageData?.page || page,
+        page_size: pageData?.pageSize || pageSize,
+        total_pages: Math.ceil((pageData?.total || 0) / (pageData?.pageSize || pageSize || 1)),
+        documents
+      }
     };
   } catch (error) {
     if (axios.isAxiosError(error)) {
@@ -762,33 +946,24 @@ export async function updateDocumentAuditStatus(id: string, auditStatus: number,
  */
 export async function getCrossCheckingDocumentTypes(jwtToken?: string): Promise<ApiResponse<DocumentType[]>> {
   try {
-    // console.log('[getCrossCheckingDocumentTypes] 开始获取交叉评查文档类型');
-
-    const response = await postgrestGet<DocumentType>('/api/postgrest/proxy/document_types',{
-      select: 'id,name,code,evaluation_point_groups_ids',
-      filter: {
-        evaluation_point_groups_ids: 'not.is.null'
-      },
-      token: jwtToken
+    const response = await axios.get<{ data?: Array<{
+      id: number;
+      name: string;
+      code: string;
+      isEnabled?: boolean;
+      ruleSetIds?: number[];
+    }> }>(`${API_BASE_URL}/api/document-types`, {
+      headers: jwtToken ? { Authorization: `Bearer ${jwtToken}` } : undefined,
     });
-
-    if (response.error) {
-      console.error('[getCrossCheckingDocumentTypes] 获取失败:', response.error);
-      return {
-        success: false,
-        error: response.error
-      };
-    }
-
-    // 进一步过滤，确保 evaluation_point_groups_ids 是非空数组
-    const dataArray = Array.isArray(response.data) ? response.data : [];
-    const filteredData = dataArray.filter(
-      (item: DocumentType) => item.evaluation_point_groups_ids &&
-              Array.isArray(item.evaluation_point_groups_ids) &&
-              item.evaluation_point_groups_ids.length > 0
-    );
-
-    // console.log('[getCrossCheckingDocumentTypes] 获取成功，共', filteredData.length, '个文档类型');
+    const rawItems = Array.isArray(response.data?.data) ? response.data.data : [];
+    const filteredData = rawItems
+      .filter((item) => item && item.isEnabled !== false)
+      .map((item) => ({
+        id: item.id,
+        name: item.name,
+        code: item.code,
+      }))
+      .sort((a, b) => a.name.localeCompare(b.name, 'zh-CN'));
 
     return {
       success: true,

app/api/dify-chat/chat.ts

@@ -1,82 +1,97 @@
 /**
- * Dify Chat API 模块
+ * 自有 RAG Chat API 模块
  *
- * 提供客户端调用 Dify API 的函数
- * 用于 Remix loader/action 中调用 Dify API
+ * 保持前端 dify-chat 调用面不变，内部转发到新的 /api/v3/rag/* 接口。
  *
- * @module api/dify/chat
+ * @module api/dify-chat/chat
  */
 
 import { difyFetch } from './client.server';
 
-// ============================================================================
-// Dify Chat API 客户端
-// ============================================================================
+function unwrapResult<T>(payload: any): T {
+    if (payload && typeof payload === 'object' && 'data' in payload) {
+        return payload.data as T;
+    }
+    return payload as T;
+}
+
+function toIntAppId(appId?: string): string | undefined {
+    if (!appId) return undefined;
+    const parsed = Number(appId);
+    return Number.isFinite(parsed) ? String(parsed) : undefined;
+}
+
+function normalizeConversationName(name: string): string {
+    const compact = (name || '').replace(/\s+/g, ' ').trim();
+    if (!compact) return '新对话';
+    return compact.length > 20 ? `${compact.slice(0, 20)}...` : compact;
+}
 
-/**
- * Dify Chat API 客户端
- *
- * @param jwt - JWT 认证令牌
- * user 参数由后端自动从 JWT 中提取
- */
 export const difyClient = {
-    /**
-     * 获取应用参数
-     */
-    async getApplicationParameters(jwt?: string): Promise<any> {
-        const response = await difyFetch('parameters', {
+    async getApplicationParameters(jwt?: string, appId?: string): Promise<any> {
+        const response = await difyFetch('chat/parameters', {
             method: 'GET',
+            appId: toIntAppId(appId),
         }, jwt);
-        return response.json();
+        const payload = unwrapResult<any>(await response.json());
+        return {
+            opening_statement: payload?.openingStatement || '',
+            suggested_questions: payload?.suggestedQuestions || [],
+            user_input_form: payload?.userInputForm || [],
+            file_upload: payload?.fileUpload || { enabled: false },
+        };
     },
 
-    /**
-     * 获取会话列表
-     *
-     * @param jwt - JWT 认证令牌
-     * @param appId - 对话应用 ID（可选，用于获取特定应用的会话列表）
-     */
     async getConversations(jwt?: string, appId?: string): Promise<any> {
         const params = new URLSearchParams({
-            limit: '100',
-            first_id: '',
+            page: '1',
+            pageSize: '100',
         });
+        const normalizedAppId = toIntAppId(appId);
+        if (normalizedAppId) {
+            params.set('appId', normalizedAppId);
+        }
 
-        const response = await difyFetch(`conversations?${params}`, {
+        const response = await difyFetch(`chat/conversations?${params.toString()}`, {
             method: 'GET',
-            appId, // 传递应用 ID，会在请求头中添加 X-Dify-App-Id
         }, jwt);
-        return response.json();
+        const payload = unwrapResult<any>(await response.json());
+        return {
+            data: (payload?.data || []).map((item: any) => ({
+                id: item.id,
+                name: item.name,
+                introduction: item.introduction || '',
+                created_at: item.createdAt || 0,
+                updated_at: item.updatedAt || 0,
+            })),
+            has_more: Boolean(payload?.hasMore),
+            limit: payload?.limit || 100,
+        };
     },
 
-    /**
-     * 获取会话消息
-     */
     async getConversationMessages(conversationId: string, jwt?: string): Promise<any> {
         const params = new URLSearchParams({
-            conversation_id: conversationId,
-            limit: '20',
-            last_id: '',
+            page: '1',
+            pageSize: '100',
         });
-
-        const response = await difyFetch(`messages?${params}`, {
+        const response = await difyFetch(`chat/conversations/${conversationId}/messages?${params.toString()}`, {
             method: 'GET',
         }, jwt);
-        return response.json();
+        const payload = unwrapResult<any>(await response.json());
+        return {
+            data: (payload?.data || []).map((item: any) => ({
+                id: item.id,
+                query: item.query,
+                answer: item.answer,
+                feedback: item.feedback || undefined,
+                retriever_resources: item.retrieverResources || [],
+                created_at: item.createdAt || 0,
+            })),
+            has_more: Boolean(payload?.hasMore),
+            limit: payload?.limit || 100,
+        };
     },
 
-    /**
-     * 发送聊天消息
-     *
-     * @param inputs - 输入参数
-     * @param query - 用户问题
-     * @param responseMode - 响应模式 ('streaming' | 'blocking')
-     * @param conversationId - 会话 ID
-     * @param files - 附件文件
-     * @param jwt - JWT 认证令牌
-     * @param appId - 对话应用 ID（可选，用于切换不同的 Dify 应用）
-     * @returns 对于流式响应返回 Response 对象，否则返回 JSON
-     */
     async createChatMessage(
         inputs: Record<string, any>,
         query: string,
@@ -92,99 +107,58 @@ export const difyClient = {
             response_mode: responseMode,
             conversation_id: conversationId,
             files: files || [],
+            appId: toIntAppId(appId) ? Number(appId) : null,
+            conversationId: conversationId || null,
         };
-        const response = await difyFetch('chat-messages', {
+        const response = await difyFetch('chat/messages', {
             method: 'POST',
             body: JSON.stringify(body),
-            appId, // 传递应用 ID，会在请求头中添加 X-Dify-App-Id
         }, jwt);
 
-        // 对于流式响应，直接返回 Response 对象
         if (responseMode === 'streaming') {
             return response;
         }
 
-        console.log('[Dify Chat] 解析 JSON 响应');
         return response.json();
     },
 
-    /**
-     * 重命名会话
-     */
     async renameConversation(
         conversationId: string,
         name: string,
         autoGenerate: boolean = false,
         jwt?: string
     ): Promise<any> {
-        const body = {
-            name,
-            auto_generate: autoGenerate,
-        };
+        let nextName = name?.trim() || '';
 
-        const response = await difyFetch(`conversations/${conversationId}/name`, {
-            method: 'POST',
-            body: JSON.stringify(body),
+        if (autoGenerate || !nextName) {
+            const messages = await this.getConversationMessages(conversationId, jwt);
+            const firstQuestion = messages?.data?.find((item: any) => item?.query)?.query || '';
+            nextName = normalizeConversationName(firstQuestion);
+        }
+
+        const response = await difyFetch(`chat/conversations/${conversationId}`, {
+            method: 'PATCH',
+            body: JSON.stringify({ name: nextName }),
         }, jwt);
-        return response.json();
+        return unwrapResult<any>(await response.json());
     },
 
-    /**
-     * 删除会话
-     */
     async deleteConversation(conversationId: string, jwt?: string): Promise<any> {
-        console.log('[Dify Chat] 删除会话:', conversationId);
-
-        try {
-            const response = await difyFetch(`conversations/${conversationId}`, {
+        const response = await difyFetch(`chat/conversations/${conversationId}`, {
             method: 'DELETE',
-                body: JSON.stringify({}),
         }, jwt);
-
-            // 对于 204 No Content 响应，直接返回成功
-            if (response.status === 204) {
-                console.log('[Dify Chat] 删除会话成功:', conversationId);
-                return { result: 'success' };
-            }
-
-            const contentType = response.headers.get('Content-Type');
-
-            if (contentType && contentType.includes('application/json')) {
-                const data = await response.json();
-                return data;
-            }
-
-            const text = await response.text();
-            console.log('[Dify Chat] 删除会话文本响应:', text);
-
-            return { result: 'success' };
-        } catch (error: any) {
-            // 权限不足等明确错误需要抛出，不能吞掉
-            if (error.message?.includes('403') || error.message?.includes('401')) {
-                throw error;
-            }
-            // 网络超时等不确定错误才降级为成功（Dify 可能已执行删除）
-            console.warn('[Dify Chat] 删除会话请求失败，但可能已成功删除:', error.message);
-            return { result: 'success' };
-        }
+        return unwrapResult<any>(await response.json());
     },
 
-    /**
-     * 更新消息反馈
-     */
     async updateMessageFeedback(
         messageId: string,
         rating: 'like' | 'dislike' | null,
         jwt?: string
     ): Promise<any> {
-        const body = {
-            rating,
-        };
-
-        const response = await difyFetch(`messages/${messageId}/feedbacks`, {
+        const response = await difyFetch(`chat/messages/${messageId}/feedback`, {
             method: 'POST',
-            body: JSON.stringify(body),
+            body: JSON.stringify({ rating }),
         }, jwt);
-        return response.json();
+        return unwrapResult<any>(await response.json());
     },
 };

app/api/dify-chat/client.server.ts

@@ -1,98 +1,71 @@
 /**
- * Dify Chat 服务端 API 模块
+ * RAG Chat 服务端 API 模块
  *
- * 提供 Node.js 服务端调用 FastAPI 后端的基础功能
- * Dify 的 API_KEY 和 APP_ID 由 FastAPI 后端管理，前端只负责转发请求
- *
- * 调用链路：
- * Remix Server → FastAPI /dify_chat/* → Dify
+ * 提供 Node.js 服务端调用 FastAPI 后端的基础功能。
+ * 现已改为走自有 RAG 接口：
+ * Remix Server -> FastAPI /api/v3/rag/*
  *
  * @module api/dify-chat/client.server
  */
 
 import { API_BASE_URL } from '~/config/api-config';
 
-// ============================================================================
-// 配置
-// ============================================================================
+const RAG_API_ROOT = `${API_BASE_URL}/v3/rag`;
 
-/**
- * Dify Chat API 代理地址
- * 通过 FastAPI 后端的 /dify_chat 路由代理访问 Dify
- * Dify 的认证（API_KEY）由 FastAPI 后端处理
- */
-const DIFY_CHAT_API_URL = `${API_BASE_URL}/dify_chat`;
-
-// ============================================================================
-// 基础请求函数
-// ============================================================================
-
-/**
- * Dify Fetch 请求选项
- */
 export interface DifyFetchOptions extends RequestInit {
-    /** 对话应用 ID，用于切换不同的 Dify 应用 */
     appId?: string;
 }
 
-/**
- * Dify Chat API 基础请求函数
- *
- * 使用用户 JWT 认证通过 FastAPI 代理访问 Dify
- * FastAPI 后端会验证 JWT 并添加 Dify API_KEY
- *
- * @param endpoint - API 端点路径
- * @param options - fetch 请求选项（可包含 appId）
- * @param jwt - 用户 JWT 认证令牌
- * @returns Response 对象
- */
-export async function difyFetch(
-    endpoint: string,
-    options: DifyFetchOptions = {},
-    jwt?: string
-): Promise<Response> {
-    const { appId, ...fetchOptions } = options;
-    const url = `${DIFY_CHAT_API_URL}/${endpoint.replace(/^\//, '')}`;
-
+function buildHeaders(fetchOptions: RequestInit, jwt?: string): HeadersInit {
     const headers: HeadersInit = {
         'Content-Type': 'application/json',
         ...fetchOptions.headers,
     };
 
     if (jwt) {
-        (headers as Record<string, string>)['Authorization'] = `Bearer ${jwt}`;
+        (headers as Record<string, string>).Authorization = `Bearer ${jwt}`;
     } else {
-        console.warn('[Dify Chat] 没有提供 JWT，FastAPI 请求可能失败');
+        console.warn('[RAG Chat] 没有提供 JWT，FastAPI 请求可能失败');
     }
 
-    // 如果指定了应用 ID，添加 X-Dify-App-Id 请求头
+    return headers;
+}
+
+export async function difyFetch(
+    endpoint: string,
+    options: DifyFetchOptions = {},
+    jwt?: string
+): Promise<Response> {
+    const { appId, ...fetchOptions } = options;
+    const cleanEndpoint = endpoint.replace(/^\//, '');
+    let url = `${RAG_API_ROOT}/${cleanEndpoint}`;
+
     if (appId) {
-        (headers as Record<string, string>)['X-Dify-App-Id'] = appId;
-        console.log('[Dify Chat] 使用应用 ID:', appId);
+        const separator = url.includes('?') ? '&' : '?';
+        url = `${url}${separator}appId=${encodeURIComponent(appId)}`;
     }
 
     const response = await fetch(url, {
         ...fetchOptions,
-        headers,
+        headers: buildHeaders(fetchOptions, jwt),
     });
 
     if (!response.ok) {
         const errorText = await response.text();
-        console.error('[Dify Chat] API 转发错误:', {
+        console.error('[RAG Chat] API 转发错误:', {
             status: response.status,
             statusText: response.statusText,
-            error: errorText
+            error: errorText,
         });
 
         if (response.status === 401) {
             throw new Error('JWT认证失败，请重新登录');
         }
 
-        throw new Error(`Dify API Error: ${response.status} ${response.statusText}`);
+        throw new Error(`RAG API Error: ${response.status} ${response.statusText}`);
     }
 
     return response;
 }
 
-// 重新导出 chat 模块的 difyClient
 export { difyClient } from './chat';

app/api/login/auth.server.ts

@@ -77,6 +77,26 @@ export interface SsoUser {
   deleted_at?: string;
 }
 
+function compactUserInfoForSession(userInfo?: UserInfo, userRole?: string): UserInfo | undefined {
+  if (!userInfo) {
+    return undefined;
+  }
+
+  // Cookie Session 直接存整份 userInfo 很容易超过浏览器 4KB 限制；
+  // 服务端鉴权实际只依赖这几个核心字段，其余信息交给接口按需取回。
+  return {
+    user_id: userInfo.user_id,
+    sub: userInfo.sub,
+    username: userInfo.username,
+    nick_name: userInfo.nick_name || userInfo.nickname || userInfo.name,
+    ou_id: userInfo.ou_id,
+    ou_name: userInfo.ou_name,
+    is_leader: userInfo.is_leader,
+    area: userInfo.area,
+    user_role: userInfo.user_role || userRole,
+  };
+}
+
 /**
  * 会话存储配置
  * 
@@ -201,7 +221,14 @@ export async function getUserSession(request: Request) {
   const refreshToken = session.get("refreshToken");
   const tokenIssuedAt = session.get("tokenIssuedAt");
   let tokenExpiresIn = session.get("tokenExpiresIn");
-  const userInfo = session.get("userInfo");
+  const storedUserInfo = session.get("userInfo");
+  const userInfo = storedUserInfo
+    ? {
+        ...storedUserInfo,
+        role: storedUserInfo.role || storedUserInfo.user_role || userRole,
+        user_role: storedUserInfo.user_role || userRole,
+      }
+    : storedUserInfo;
   const frontendJWT = session.get("frontendJWT");
 
   // 🔑 检查是否是公共路径（不需要认证的路径）
@@ -369,7 +396,7 @@ export async function createUserSession(params: {
 
   // 用户信息和JWT
   if (params.userInfo) {
-    session.set("userInfo", params.userInfo);
+    session.set("userInfo", compactUserInfoForSession(params.userInfo, params.userRole));
   }
   if (params.frontendJWT) {
     session.set("frontendJWT", params.frontendJWT);

app/api/user/user-management.ts

@@ -62,6 +62,207 @@ export interface ApiResponse<T> {
   status?: number;
 }
 
+type RbacUserRole = {
+  role_id?: number;
+  role_key?: string;
+  role_name?: string;
+};
+
+type RbacUserItem = {
+  id: number;
+  username: string;
+  nick_name: string;
+  area: string;
+  ou_id: string | null;
+  ou_name: string | null;
+  is_leader: boolean;
+  status: number;
+  tenant_name: string | null;
+  dep_name: string | null;
+  dep_short_name?: string | null;
+  email?: string | null;
+  phone_number?: string | null;
+  roles?: RbacUserRole[];
+};
+
+type RbacUsersPayload = {
+  total: number;
+  page: number;
+  page_size: number;
+  items: RbacUserItem[];
+};
+
+let rbacUsersAvailable: boolean | null = null;
+
+function normalizeUser(user: RbacUserItem): UserInfo {
+  return {
+    id: user.id,
+    username: user.username,
+    nick_name: user.nick_name,
+    area: user.area,
+    ou_id: user.ou_id || '',
+    ou_name: user.ou_name || '',
+    is_leader: Boolean(user.is_leader),
+    status: Number(user.status ?? 0),
+    tenant_name: user.tenant_name ?? null,
+    dep_name: user.dep_name ?? null,
+    dep_short_name: user.dep_short_name ?? null,
+    email: user.email ?? undefined,
+    phone_number: user.phone_number ?? undefined,
+    organization_path: {
+      tenant_name: user.tenant_name || '未分组租户',
+      dep_name: user.dep_name || '未分组部门',
+      dep_short_name: user.dep_short_name || user.dep_name || '未分组部门',
+      ou_name: user.ou_name || '未分组组织',
+    },
+  };
+}
+
+async function fetchRbacUsers(
+  jwtToken?: string,
+  search?: string,
+): Promise<ApiResponse<RbacUsersPayload>> {
+  try {
+    const params = new URLSearchParams();
+    params.set('page', '1');
+    params.set('pageSize', '5000');
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+    };
+    if (jwtToken) {
+      headers.Authorization = `Bearer ${jwtToken}`;
+    }
+
+    const response = await axios.get<{ code?: number; message?: string; data?: RbacUsersPayload }>(
+      `${API_BASE_URL}/api/v3/rbac/users?${params.toString()}`,
+      { headers },
+    );
+
+    if (!response.data?.data) {
+      return {
+        success: false,
+        error: response.data?.message || '用户列表返回为空',
+      };
+    }
+
+    const keyword = search?.trim().toLowerCase();
+    const items = keyword
+      ? response.data.data.items.filter((item) => {
+          const haystacks = [
+            item.username,
+            item.nick_name,
+            item.area,
+            item.tenant_name,
+            item.dep_name,
+            item.ou_name,
+          ];
+          return haystacks.some((value) => value?.toLowerCase().includes(keyword));
+        })
+      : response.data.data.items;
+
+    return {
+      success: true,
+      data: {
+        ...response.data.data,
+        total: items.length,
+        items,
+      },
+    };
+  } catch (error) {
+    let errorMessage = '获取用户列表失败';
+    if (axios.isAxiosError(error)) {
+      errorMessage = error.response?.data?.detail || error.response?.data?.message || error.message;
+    } else if (error instanceof Error) {
+      errorMessage = error.message;
+    }
+    return {
+      success: false,
+      error: errorMessage,
+    };
+  }
+}
+
+function buildOrganizationTreeFromUsers(
+  users: UserInfo[],
+  includeUsers: boolean,
+  rootUuid?: string,
+): OrganizationResponse {
+  const tenantMap = new Map<string, OrganizationNode>();
+
+  const ensureChild = (
+    parent: OrganizationNode,
+    key: string,
+    create: () => OrganizationNode,
+  ): OrganizationNode => {
+    const existing = parent.children.find((item) => item.ou_id === key);
+    if (existing) return existing;
+    const next = create();
+    parent.children.push(next);
+    return next;
+  };
+
+  users.forEach((user) => {
+    const tenantName = user.tenant_name || user.area || '未分组租户';
+    const depName = user.dep_name || '未分组部门';
+    const ouId = user.ou_id || `ou_${depName}`;
+    const ouName = user.ou_name || depName || '未分组组织';
+
+    const tenantKey = `tenant:${tenantName}`;
+    let tenantNode = tenantMap.get(tenantKey);
+    if (!tenantNode) {
+      tenantNode = {
+        ou_id: tenantKey,
+        ou_name: tenantName,
+        parent_ou_id: null,
+        level: 1,
+        children: [],
+        users: [],
+      };
+      tenantMap.set(tenantKey, tenantNode);
+    }
+
+    const depKey = `dep:${tenantName}:${depName}`;
+    const depNode = ensureChild(tenantNode, depKey, () => ({
+      ou_id: depKey,
+      ou_name: depName,
+      parent_ou_id: tenantNode!.ou_id,
+      level: 2,
+      children: [],
+      users: [],
+    }));
+
+    const orgKey = ouId.startsWith('ou_') ? `org:${tenantName}:${depName}:${ouName}` : ouId;
+    const orgNode = ensureChild(depNode, orgKey, () => ({
+      ou_id: orgKey,
+      ou_name: ouName,
+      parent_ou_id: depNode.ou_id,
+      level: 3,
+      children: [],
+      users: [],
+    }));
+
+    if (includeUsers) {
+      orgNode.users.push(user);
+    }
+  });
+
+  const organizations = Array.from(tenantMap.values());
+  const pickSubtree = (nodes: OrganizationNode[], target: string): OrganizationNode[] => {
+    for (const node of nodes) {
+      if (node.ou_id === target) return [node];
+      const nested = pickSubtree(node.children || [], target);
+      if (nested.length > 0) return nested;
+    }
+    return [];
+  };
+
+  return {
+    organizations: rootUuid ? pickSubtree(organizations, rootUuid) : organizations,
+    total_organizations: organizations.length,
+    total_users: users.length,
+  };
+}
+
 /**
  * 获取组织架构树（新版接口，支持按需加载）
  * @param includeUsers 是否包含用户信息
@@ -74,17 +275,6 @@ export async function getOrganizationTree(
   jwtToken?: string,
   rootUuid?: string
 ): Promise<ApiResponse<OrganizationResponse>> {
-  try {
-    // console.log('[getOrganizationTree] 开始调用获取组织架构API:', { includeUsers, rootUuid });
-
-    const params: string[] = [];
-    params.push(`include_users=${includeUsers}`);
-    if (rootUuid) {
-      params.push(`root_uuid=${rootUuid}`);
-    }
-
-    const url = `${API_BASE_URL}/api/v2/users/organizations/tree?${params.join('&')}`;
-
   const headers: Record<string, string> = {
     'Content-Type': 'application/json'
   };
@@ -92,18 +282,46 @@ export async function getOrganizationTree(
     headers['Authorization'] = `Bearer ${jwtToken}`;
   }
 
-    const response = await axios.get<OrganizationResponse>(url, { headers });
-    const responseData = response.data;
-
-    // console.log('[getOrganizationTree] API响应:', responseData);
+  try {
+    // 新平台直接基于 RBAC 用户列表构造组织树，避免依赖已下线的旧 v2 接口。
+    const fallbackUsers = await fetchRbacUsers(jwtToken);
+    if (!fallbackUsers.success || !fallbackUsers.data) {
+      throw new Error(fallbackUsers.error || '获取组织架构失败');
+    }
 
+    rbacUsersAvailable = true;
+    const normalizedUsers = fallbackUsers.data.items.map(normalizeUser);
     return {
       success: true,
-      data: responseData
+      data: buildOrganizationTreeFromUsers(normalizedUsers, includeUsers, rootUuid),
+    };
+  } catch (error) {
+    if (rbacUsersAvailable === false) {
+      console.error('[getOrganizationTree] 获取组织架构失败:', error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : '获取组织架构失败',
+      };
+    }
+
+    rbacUsersAvailable = false;
+  }
+
+  try {
+    const params: string[] = [];
+    params.push(`include_users=${includeUsers}`);
+    if (rootUuid) {
+      params.push(`root_uuid=${rootUuid}`);
+    }
+
+    const url = `${API_BASE_URL}/api/v2/users/organizations/tree?${params.join('&')}`;
+    const response = await axios.get<OrganizationResponse>(url, { headers });
+    return {
+      success: true,
+      data: response.data
     };
   } catch (error) {
     console.error('[getOrganizationTree] 获取组织架构失败:', error);
-
     let errorMessage = '获取组织架构失败';
     if (axios.isAxiosError(error)) {
       if (error.response?.data?.detail) {
@@ -139,16 +357,13 @@ export async function searchUsers(
   users: UserInfo[];
   total: number;
 }>> {
-  try {
-    // console.log('[searchUsers] 搜索用户:', { search, page, pageSize });
-
+  const fallbackUsers = await fetchRbacUsers(jwtToken, search);
+  if (!fallbackUsers.success || !fallbackUsers.data) {
     const params: string[] = [];
     if (search) params.push(`search=${encodeURIComponent(search)}`);
     params.push(`page=${page}`);
     params.push(`page_size=${pageSize}`);
 
-    const url = `${API_BASE_URL}/api/v2/users?${params.join('&')}`;
-
     const headers: Record<string, string> = {
       'Content-Type': 'application/json'
     };
@@ -156,19 +371,16 @@ export async function searchUsers(
       headers['Authorization'] = `Bearer ${jwtToken}`;
     }
 
+    try {
+      const url = `${API_BASE_URL}/api/v2/users?${params.join('&')}`;
       const response = await axios.get<{ users: UserInfo[]; total: number }>(url, { headers });
-    const responseData = response.data;
-
-    // console.log('[searchUsers] 搜索结果:', { total: responseData.total, count: responseData.users?.length });
-
       return {
         success: true,
-      data: responseData
+        data: response.data
       };
     } catch (error) {
       console.error('[searchUsers] 搜索用户失败:', error);
-
-    let errorMessage = '搜索用户失败';
+      let errorMessage = fallbackUsers.error || '搜索用户失败';
       if (axios.isAxiosError(error)) {
         if (error.response?.data?.detail) {
           errorMessage = error.response.data.detail;
@@ -184,6 +396,18 @@ export async function searchUsers(
         error: errorMessage
       };
     }
+  }
+
+  const normalized = fallbackUsers.data.items.map(normalizeUser);
+  const start = (page - 1) * pageSize;
+  const paged = normalized.slice(start, start + pageSize);
+  return {
+    success: true,
+    data: {
+      users: paged,
+      total: normalized.length,
+    }
+  };
 }
 
 /**

app/components/collabora/CollaboraViewer.tsx

@@ -106,7 +106,7 @@ export const CollaboraViewer = forwardRef<CollaboraViewerHandle, CollaboraViewer
     const { config, loading, error } = useCollaboraConfig(fileId, mode, userId, userName);
 
     // 2. 监听文档加载状态
-    const { isDocumentLoaded } = useDocumentReady(iframeRef);
+    const { isDocumentLoaded } = useDocumentReady(iframeRef, config?.iframeUrl);
 
     // 2.5. 保存 iframe window 引用并在文档加载时清除所有高亮
     useEffect(() => {
@@ -1194,4 +1194,3 @@ export const CollaboraViewer = forwardRef<CollaboraViewerHandle, CollaboraViewer
 // 导出类型和 hook
 export { useCollaboraUnoCommands };
 export type { CollaboraViewerHandle };
-

app/components/collabora/hooks.ts

@@ -110,35 +110,75 @@ export function useCollaboraConfig(
  * @param iframeRef - iframe 引用
  * @returns 文档加载状态
  */
-export function useDocumentReady(iframeRef: RefObject<HTMLIFrameElement>) {
+export function useDocumentReady(
+  iframeRef: RefObject<HTMLIFrameElement>,
+  iframeUrl?: string
+) {
   const [isDocumentLoaded, setIsDocumentLoaded] = useState(false);
 
   useEffect(() => {
-    const handleMessage = (event: MessageEvent) => {
-      // 验证消息来源
-      const collaboraOrigin = new URL(COLLABORA_URL).origin;
+    setIsDocumentLoaded(false);
 
-      if (event.origin !== collaboraOrigin) {
+    const iframe = iframeRef.current;
+    const expectedOrigin = iframeUrl
+      ? new URL(iframeUrl).origin
+      : new URL(COLLABORA_URL).origin;
+    let fallbackTimer: ReturnType<typeof setTimeout> | null = null;
+
+    const markLoaded = (source: string) => {
+      setIsDocumentLoaded((prev) => {
+        if (!prev) {
+          console.log(`[DocumentReady] 文档已就绪(${source})`);
+        }
+        return true;
+      });
+    };
+
+    const handleIframeLoad = () => {
+      // 某些环境下 Collabora 不一定会抛出 Document_Loaded 消息，
+      // 先在 iframe load 后给一个兜底超时，避免页面一直被遮罩层盖住。
+      fallbackTimer = setTimeout(() => {
+        markLoaded('iframe-load-fallback');
+      }, 1500);
+    };
+
+    const handleMessage = (event: MessageEvent) => {
+      if (event.origin !== expectedOrigin) {
+        return;
+      }
+
+      if (iframeRef.current?.contentWindow && event.source !== iframeRef.current.contentWindow) {
         return;
       }
 
       try {
         const msg = typeof event.data === 'string' ? JSON.parse(event.data) : event.data;
 
-        if (msg.MessageId === 'App_LoadingStatus' && msg.Values?.Status === 'Document_Loaded') {
-          console.log('[DocumentReady] 文档加载完成');
-          setIsDocumentLoaded(true);
+        if (
+          msg?.MessageId === 'App_LoadingStatus' &&
+          ['Document_Loaded', 'Document_Loaded_Editing', 'UI_Loaded'].includes(msg.Values?.Status)
+        ) {
+          if (fallbackTimer) {
+            clearTimeout(fallbackTimer);
+            fallbackTimer = null;
           }
-      } catch (err) {
-        console.warn('[DocumentReady] 解析消息失败:', err);
+          markLoaded(`postmessage:${msg.Values?.Status}`);
+        }
+      } catch {
+        // Collabora 也会发送非 JSON 消息，这里忽略即可。
       }
     };
 
+    iframe?.addEventListener('load', handleIframeLoad);
     window.addEventListener('message', handleMessage);
     return () => {
+      if (fallbackTimer) {
+        clearTimeout(fallbackTimer);
+      }
+      iframe?.removeEventListener('load', handleIframeLoad);
       window.removeEventListener('message', handleMessage);
     };
-  }, [iframeRef]);
+  }, [iframeRef, iframeUrl]);
 
   return { isDocumentLoaded };
 }

app/components/dify-chat/index.tsx

@@ -49,7 +49,7 @@ export default function Chat() {
 
     // 权限检查
     const { hasPermission: checkPerm } = usePermission();
-    const canChat = checkPerm('dify:chat:use');
+    const canChat = checkPerm('rag:chat:use');
 
     // 侧边栏状态
     const [sidebarCollapsed, setSidebarCollapsed] = useState(false);

app/components/dify-chat/sidebar.tsx

@@ -61,7 +61,7 @@ const ChatSidebar = forwardRef<ChatSidebarRef, ChatSidebarProps>(({
     conversationReadOnly = false,
 }, ref) => {
     const { hasPermission } = usePermission();
-    const canDeleteConversation = hasPermission('dify:conversation:delete');
+    const canDeleteConversation = hasPermission('rag:conversation:delete');
     const [searchValue, setSearchValue] = useState('');
     const [renameModalVisible, setRenameModalVisible] = useState(false);
     const [deleteModalVisible, setDeleteModalVisible] = useState(false);

app/components/reviews/ReviewTabs.tsx

@@ -25,15 +25,18 @@ interface ReviewTabsProps {
     auditStatus?: number;
     type?: string;
     comparisonId?: number;
+    backTo?: string;
   };
   onConfirmResults: () => void;
   onExportReport?: () => void;
   jwtToken?: string | null;
+  showConfirmButton?: boolean;
+  showCompareTab?: boolean;
   /** 下载前保存文档的回调，返回 true 表示保存成功可以继续下载 */
   onSaveBeforeDownload?: () => Promise<boolean>;
 }
 
-export function ReviewTabs({ activeTab, onTabChange, children, fileInfo, onConfirmResults, onExportReport, jwtToken, onSaveBeforeDownload }: ReviewTabsProps) {
+export function ReviewTabs({ activeTab, onTabChange, children, fileInfo, onConfirmResults, onExportReport, jwtToken, showConfirmButton = true, showCompareTab = true, onSaveBeforeDownload }: ReviewTabsProps) {
   const [isNavigating, setIsNavigating] = useState(false);
   const [isReuploadModalOpen, setIsReuploadModalOpen] = useState(false);
   const [selectedTemplateFiles, setSelectedTemplateFiles] = useState<File[]>([]);
@@ -54,11 +57,15 @@ export function ReviewTabs({ activeTab, onTabChange, children, fileInfo, onConfi
 
     // 根据来源页面返回
     const previousRoute = fileInfo.previousRoute || 'documents';
-    const returnTo = previousRoute === 'documents'
+    const returnTo = fileInfo.backTo || (
+      previousRoute === 'documents'
         ? "/documents/list"
         : previousRoute === 'filesUpload'
           ? "/files/upload"
-        : "/rules-files";
+          : previousRoute === 'crossChecking'
+            ? "/cross-checking"
+            : "/rules-files"
+    );
     navigate(returnTo);
     setTimeout(() => {
       revalidator.revalidate();
@@ -266,7 +273,7 @@ export function ReviewTabs({ activeTab, onTabChange, children, fileInfo, onConfi
           >
             <i className="ri-lightbulb-line"></i> AI智能分析
           </button> */}
-          {fileInfo.type?.toString().includes('1')  && (
+          {showCompareTab && fileInfo.type?.toString().includes('1')  && (
             <button 
               className={`tab-nav-item ${activeTab === 'filecompare' ? 'active' : ''}`}
               onClick={() => onTabChange('filecompare')}
@@ -328,12 +335,22 @@ export function ReviewTabs({ activeTab, onTabChange, children, fileInfo, onConfi
               <i className="ri-file-copy-line mr-1"></i> 导出评查报告
             </button>
           )}
+          {showConfirmButton && (
             <button
               className={`ant-btn ant-btn-primary my-2 flex items-center ${fileInfo.auditStatus === 1 ? 'hidden' : ''}`}
               onClick={onConfirmResults}
             >
               <i className="ri-check-double-line mr-1"></i> 确认评查结果
             </button>
+          )}
+          {showConfirmButton && (
+            <button
+              className={`ant-btn ant-btn-primary my-2 flex items-center ${fileInfo.auditStatus === 1 ? 'hidden' : ''}`}
+              onClick={onConfirmResults}
+            >
+              <i className="ri-check-double-line mr-1"></i> 确认评查结果
+            </button>
+          )}
         </div>
       </div>
 

app/config/api-config.ts

@@ -180,7 +180,7 @@ const configs: Record<string, ApiConfig> = {
     // documentUrl: 'http://172.16.0.84:8073/docauditai/',
     // uploadUrl: 'http://172.16.0.84:8073/api/v2/documents',
 
-    // 公网访问 reviewsTest 时，iframe 不能再直连内网 Collabora，否则浏览器会拦截。
+    // 从公网页面发起到 172.16.* 的 iframe 请求会触发浏览器私网访问拦截，联调环境必须走公网可达地址。
     collaboraUrl: 'http://nas.7bm.co:9980',
     appUrl: 'http://nas.7bm.co:5173',
 

app/routes/api.parameters.tsx

@@ -23,7 +23,9 @@ export async function loader({ request }: LoaderFunctionArgs) {
             );
         }
 
-        const data = await difyClient.getApplicationParameters(frontendJWT);
+        const url = new URL(request.url);
+        const appId = url.searchParams.get('app_id') || undefined;
+        const data = await difyClient.getApplicationParameters(frontendJWT, appId);
 
         return json(data, {
             headers: {

app/routes/api.v3.dify.chat-apps.default.tsx

@@ -1,14 +1,21 @@
-/**
- * GET /api/v3/dify/chat-apps/default - 获取默认对话应用
- *
- * 转发请求到后端 API，后端从配置文件读取默认对话应用
- * 参考文档：docs/new-dify/dify_api_doc.md - 对话应用多实例支持
- */
-
 import { LoaderFunctionArgs, json } from '@remix-run/node';
 import { API_BASE_URL } from '~/config/api-config';
 import { getUserSession } from '~/api/login/auth.server';
 
+function normalizeApp(payload: any) {
+    const app = payload?.data?.data || payload?.data || null;
+    if (!app) return null;
+    return {
+        app_id: String(app.appId),
+        app_name: app.appName,
+        description: app.description || '',
+        is_default: Boolean(app.isDefault),
+        type: 'rag',
+        created_at: '',
+        updated_at: '',
+    };
+}
+
 export async function loader({ request }: LoaderFunctionArgs) {
     try {
         const { frontendJWT } = await getUserSession(request);
@@ -20,23 +27,16 @@ export async function loader({ request }: LoaderFunctionArgs) {
             );
         }
 
-        console.log('[API] Get Default Chat App - Forwarding to backend');
-
-        // 转发请求到后端
-        const apiUrl = `${API_BASE_URL}/v3/dify/chat-apps/default`;
-        const response = await fetch(apiUrl, {
+        const response = await fetch(`${API_BASE_URL}/v3/rag/apps/default`, {
             method: 'GET',
             headers: {
                 'Content-Type': 'application/json',
-                'Authorization': `Bearer ${frontendJWT}`,
+                Authorization: `Bearer ${frontendJWT}`,
             },
         });
 
         const data = await response.json();
-        console.log('[API] Get Default Chat App - Backend response:', data);
-
-        return json(data, { status: response.status });
-
+        return json({ data: normalizeApp(data) }, { status: response.status });
     } catch (error: any) {
         console.error('[API] Get Default Chat App - Error:', error.message);
         return json(

app/routes/api.v3.dify.chat-apps.my.tsx

@@ -1,14 +1,27 @@
-/**
- * GET /api/v3/dify/chat-apps/my - 获取当前用户可访问的对话应用列表
- *
- * 转发请求到后端 API，后端从配置文件读取对话应用列表
- * 参考文档：docs/new-dify/dify_api_doc.md - 对话应用多实例支持
- */
-
 import { LoaderFunctionArgs, json } from '@remix-run/node';
 import { API_BASE_URL } from '~/config/api-config';
 import { getUserSession } from '~/api/login/auth.server';
 
+function normalizeApps(payload: any) {
+    const apps = payload?.data?.data || payload?.data || [];
+    return {
+        data: Array.isArray(apps)
+            ? apps.map((app: any) => ({
+                app_id: String(app.appId),
+                app_name: app.appName,
+                description: app.description || '',
+                is_default: Boolean(app.isDefault),
+                type: 'rag',
+                created_at: '',
+                updated_at: '',
+            }))
+            : [],
+        total: Array.isArray(apps) ? apps.length : 0,
+        page: 1,
+        page_size: Array.isArray(apps) ? apps.length : 0,
+    };
+}
+
 export async function loader({ request }: LoaderFunctionArgs) {
     try {
         const { frontendJWT } = await getUserSession(request);
@@ -20,24 +33,17 @@ export async function loader({ request }: LoaderFunctionArgs) {
             );
         }
 
-        console.log('[API] Get My Chat Apps - Forwarding to backend');
-
-        // 转发请求到后端 - 使用正确的接口路径
-        // 根据文档：GET /api/v3/dify/chat-apps
-        const apiUrl = `${API_BASE_URL}/v3/dify/chat-apps`;
-        const response = await fetch(apiUrl, {
+        const response = await fetch(`${API_BASE_URL}/v3/rag/apps`, {
             method: 'GET',
             headers: {
                 'Content-Type': 'application/json',
-                'Authorization': `Bearer ${frontendJWT}`,
+                Authorization: `Bearer ${frontendJWT}`,
             },
         });
 
         const data = await response.json();
-        console.log('[API] Get My Chat Apps - Backend response:', data);
-
-        return json(data, { status: response.status });
-
+        const normalized = normalizeApps(data);
+        return json(normalized, { status: response.status });
     } catch (error: any) {
         console.error('[API] Get My Chat Apps - Error:', error.message);
         return json(

app/routes/cross-checking.result.tsx

@@ -25,24 +25,26 @@
 import { type MetaFunction, type LoaderFunctionArgs, type ActionFunctionArgs } from "@remix-run/node";
 import React, { useState, useEffect, useCallback, useRef, useMemo } from "react";
 import { useNavigate, useLoaderData } from "@remix-run/react";
-import crossCheckingStyles from "~/styles/cross-checking-result.css?url";
-import { getReviewPoints, updateReviewResult, getReviewPoints_fromApi} from "~/api/evaluation_points/reviews";
+import reviewsStyles from "~/styles/reviews.css?url";
+import { updateReviewResult, getReviewPoints_fromApi, getUnifiedEvaluationResults } from "~/api/evaluation_points/reviews";
+import { postgrestGet } from "~/api/postgrest-client";
 import { toastService } from "~/components/ui/Toast";
 import { confirmReviewResults, checkProposalVotes, findIsProposer } from "~/api/cross-checking/cross-file-result";
 import { usePermission } from "~/hooks/usePermission";
 
-// 导入交叉评查详情页面组件
+// 复用新版评查详情页外壳，保留交叉评查提案面板
 import {
-  FileInfo,
+  ReviewTabs,
   FilePreview,
-  ReviewPointsList
-} from "~/components/cross-checking";
+  FileDetails,
+} from "~/components/reviews";
+import { ReviewPointsList, type CharPosition } from "~/components/cross-checking";
 
 // 导入文档对比组件
 import { ComparePreview } from "~/components/reviews/previewComponents/ComparePreview";
 
-// 从ReviewPointsList组件中导入ReviewPoint类型和CharPosition类型
-import { type ReviewPoint, type CharPosition } from '~/components/cross-checking';
+// 从ReviewPointsList组件中导入ReviewPoint类型
+import { type ReviewPoint } from '~/components/cross-checking';
 import { messageService } from "~/components/ui/MessageModal";
 import { loadingBarService } from "~/components/ui/LoadingBar";
 import { Breadcrumb } from "~/components/layout/Breadcrumb";
@@ -177,7 +179,7 @@ export const meta: MetaFunction = () => {
 };
 
 export function links() {
-  return [{ rel: "stylesheet", href: crossCheckingStyles }];
+  return [{ rel: "stylesheet", href: reviewsStyles }];
 }
 
 export const handle = {
@@ -229,15 +231,102 @@ export async function loader({ request }: LoaderFunctionArgs) {
 
     // console.log(`✅ [Loader] 用户 ${userInfo.user_id} (${accessCheck.userRole}) 访问文档 ${id} - 权限验证通过`);
 
+    async function patchPointCodes(points: Array<Record<string, any>>, jwt: string) {
+      try {
+        const pointIds = points.map((point) => point.pointId).filter(Boolean);
+        if (pointIds.length === 0) return;
+
+        const response = await postgrestGet<any>('/api/postgrest/proxy/evaluation_points', {
+          select: 'id,code',
+          filter: { id: `in.(${[...new Set(pointIds)].join(',')})` },
+          token: jwt,
+        });
+
+        const raw = response.data;
+        const pointList = Array.isArray(raw) ? raw : (raw?.data && Array.isArray(raw.data) ? raw.data : []);
+        const codeMap: Record<string, string> = {};
+
+        pointList.forEach((point: any) => {
+          if (point.code) {
+            codeMap[String(point.id)] = point.code;
+          }
+        });
+
+        points.forEach((point) => {
+          point.pointCode = codeMap[String(point.pointId)] || point.pointCode || '';
+        });
+      } catch (error) {
+        console.error('[CrossChecking Loader] patchPointCodes error:', error);
+      }
+    }
+
+    const isProposer = await findIsProposer(taskId, userInfo?.user_id, frontendJWT);
+    const unifiedData = await getUnifiedEvaluationResults(id, request);
+
+    if (!('error' in unifiedData) && unifiedData.flow_type === 'graphrag') {
+      const reviewData = await getReviewPoints_fromApi(id, request);
+      const existingPoints = ('data' in reviewData && !('error' in reviewData)) ? reviewData.data : [];
+      const notApplicablePoints = (unifiedData.results || [])
+        .filter((result: any) => result.result_type === 'not_applicable')
+        .map((result: any) => ({
+          id: `na-${result.evaluation_point_id}`,
+          documentId: id,
+          pointId: result.evaluation_point_id,
+          editAuditStatusId: '',
+          editAuditStatus: '',
+          editAuditStatusMessage: '',
+          title: '该评查点未涉及',
+          pointName: result.name || '',
+          pointCode: result.code || '',
+          groupName: '',
+          status: 'notApplicable',
+          content: {},
+          contentPage: {},
+          suggestion: result.ai_suggestion || '该评查点未涉及',
+          result: null,
+          score: result.score || 0,
+          finalScore: null,
+          machineScore: 0,
+          postAction: '',
+        }));
+      const allReviewPoints = [...existingPoints, ...notApplicablePoints];
+      await patchPointCodes(allReviewPoints as Array<Record<string, any>>, frontendJWT);
+
+      return Response.json({
+        previousRoute,
+        document: ('document' in reviewData && !('error' in reviewData)) ? reviewData.document : null,
+        reviewPoints: allReviewPoints,
+        reviewInfo: {
+          reviewTime: unifiedData.evaluated_at,
+          reviewModel: 'GraphRAG',
+          ruleGroup: '',
+          result: '',
+          issueCount: unifiedData.summary?.total_points || 0
+        },
+        statistics: {
+          total: unifiedData.summary?.total_points || 0,
+          success: unifiedData.summary?.passed_count || 0,
+          warning: unifiedData.summary?.failed_count || 0,
+          error: 0,
+          score: unifiedData.summary?.total_score || 0
+        },
+        comparison_document: ('comparison_document' in reviewData && !('error' in reviewData)) ? reviewData.comparison_document : null,
+        scoring_proposals: ('scoring_proposals' in reviewData && !('error' in reviewData)) ? (reviewData.scoring_proposals || []) : [],
+        userInfo,
+        jwtToken: frontendJWT,
+        isProposer,
+        taskId,
+        taskName,
+        flowType: 'graphrag'
+      });
+    }
+
     // 对接接口，新的获取评查点结果的方法
-    const reviewData = await getReviewPoints_fromApi(id, request)
+    const reviewData = await getReviewPoints_fromApi(id, request);
 
     // 获取评查点数据，传递request对象 旧获取评查点结果的方法
     // const reviewData = await getReviewPoints(id, request);
 
-    // 获取当前登录用户是否是负责人
-    const isProposer = await findIsProposer(taskId, userInfo?.user_id, frontendJWT);
-
     // console.log("documentData-------",JSON.stringify(documentData.data,null,2));
     // console.log("reviewData-------",JSON.stringify('data' in reviewData ? reviewData.data : '',null,2));
     // console.log("reviewData-------",JSON.stringify(reviewData,null,2));
@@ -249,6 +338,7 @@ export async function loader({ request }: LoaderFunctionArgs) {
 
     // 确保reviewData有效且具有预期的属性
     if ('document' in reviewData && 'data' in reviewData && 'reviewInfo' in reviewData && 'stats' in reviewData) {
+      await patchPointCodes(reviewData.data as Array<Record<string, any>>, frontendJWT);
       // console.log("reviewData-------",JSON.stringify(reviewData.data));
       return Response.json({
         previousRoute: previousRoute,
@@ -262,7 +352,8 @@ export async function loader({ request }: LoaderFunctionArgs) {
         jwtToken: frontendJWT, // 传递JWT token
         isProposer: isProposer,
         taskId: taskId, // 传递任务ID
-        taskName: taskName // 传递任务名称
+        taskName: taskName, // 传递任务名称
+        flowType: 'legacy'
       });
     } else {
       console.error("返回的评查数据格式不正确",JSON.stringify(reviewData,null,2));
@@ -338,12 +429,7 @@ export default function CrossCheckingResult() {
   const { document, reviewPoints, statistics, reviewInfo, comparison_document, scoring_proposals, jwtToken, userInfo, isProposer, taskId, taskName } = loaderData;
   const [isLoading, setIsLoading] = useState(false); // 已经通过loader加载了数据，不需要再显示加载状态
 
-  // 视图切换状态：'review' = 评查结果视图, 'compare' = 结构比对视图
-  const [viewMode, setViewMode] = useState<'review' | 'compare'>('review');
-
-
-  // 判断是否有模板可以进行结构比对
-  const hasTemplateForCompare = Boolean(comparison_document?.template_contract_path?.trim());
+  const [activeTab, setActiveTab] = useState<string>('preview');
 
   // 权限控制
   const { hasPermission } = usePermission();
@@ -377,6 +463,12 @@ export default function CrossCheckingResult() {
     setLocalScoringProposals(scoring_proposals || []);
   }, [scoring_proposals]);
 
+  useEffect(() => {
+    if (!comparison_document?.template_contract_path?.trim() && activeTab === 'filecompare') {
+      setActiveTab('preview');
+    }
+  }, [activeTab, comparison_document?.template_contract_path]);
+
   // 处理意见提交成功的回调
   const handleOpinionSubmitted = useCallback((newProposal: ScoringProposal) => {
     setLocalScoringProposals(prev => [...prev, newProposal]);
@@ -697,7 +789,7 @@ export default function CrossCheckingResult() {
       isProcessingRef.current = false;
       toastService.error(`确认评查结果失败: ${error instanceof Error ? error.message : '未知错误'}`);
     }
-  }, [document, jwtToken, navigate]);
+  }, [document, jwtToken, navigate, taskId, taskName]);
   
   // 构建自定义面包屑项 - 使用 useMemo 缓存
   const breadcrumbItems = useMemo(() => {
@@ -716,7 +808,7 @@ export default function CrossCheckingResult() {
   }, [document?.id, loaderData.previousRoute]);
   
   return (
-    <div className="cross-checking-result-container">
+    <div className="review-container">
       {isLoading ? (
         <div className="flex justify-center items-center p-12">
           <div className="loading-spinner"></div>
@@ -753,90 +845,35 @@ export default function CrossCheckingResult() {
                 )}
               </div>
             </div>
+          </div>
 
-            {/* 返回按钮 */}
-            <button
-              type="button"
-              onClick={() => {
-                // 返回到交叉评查列表页，并带上任务信息以自动打开模态框
-                const params = new URLSearchParams({
+          <ReviewTabs
+            activeTab={activeTab}
+            onTabChange={setActiveTab}
+            fileInfo={{
+              id: document?.id,
+              previousRoute: loaderData.previousRoute,
+              path: document?.path,
+              auditStatus: document?.auditStatus,
+              type: document?.type || document?.type_id,
+              comparisonId: comparison_document?.id ? Number(comparison_document.id) : undefined,
+              backTo: `/cross-checking?${new URLSearchParams({
                 openModal: 'true',
                 taskId: taskId || '',
                 taskName: taskName || '任务详情'
-                });
-                navigate(`/cross-checking?${params.toString()}`);
+              }).toString()}`
             }}
-              className="inline-flex items-center px-3 py-1.5 text-sm font-medium text-gray-600 border border-gray-400 rounded-md hover:bg-gray-100 hover:text-gray-800 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-gray-300 mr-3"
-            >
-              <i className="ri-arrow-left-line mr-1.5"></i>
-              返回任务
-            </button>
-
-            {/* 结构比对/查看评查结果按钮 - 仅当文档类型包含"合同"且有模板时显示 */}
-            {hasTemplateForCompare && (
-              <button
-                type="button"
-                onClick={() => setViewMode(viewMode === 'review' ? 'compare' : 'review')}
-                className="inline-flex items-center px-3 py-1.5 text-sm font-medium text-white bg-blue-600 border border-transparent rounded-md hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-blue-500 mr-2"
-              >
-                {viewMode === 'review' ? (
-                  <>
-                    <i className="ri-file-copy-2-line mr-1.5"></i>
-                    结构比对
-                  </>
-                ) : (
-                  <>
-                    <i className="ri-file-list-3-line mr-1.5"></i>
-                    查看评查结果
-                  </>
-                )}
-              </button>
-            )}
-
-            {/* 完成评查按钮 - 需要 isProposer 且拥有 cross_review:document:complete 权限 */}
-            {isProposer && canCompleteDocument && (
-              <button
-                type="button"
-                onClick={(event) => {
-                  // 立即阻止所有默认行为
-                  event.preventDefault();
-                  event.stopPropagation();
-                  // 异步调用处理函数
-                  void handleConfirmResults(event);
+            onConfirmResults={() => {
+              void handleConfirmResults();
             }}
-                disabled={isLoading}
-                className="inline-flex items-center px-3 py-1.5 text-sm font-medium text-white bg-green-800 border border-transparent rounded-md hover:bg-green-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-green-800 disabled:opacity-50 disabled:cursor-not-allowed"
+            jwtToken={jwtToken}
+            showConfirmButton={Boolean(isProposer && canCompleteDocument)}
+            showCompareTab={Boolean(comparison_document?.template_contract_path?.trim())}
           >
-                {isLoading ? (
-                  <>
-                    <i className="ri-loader-4-line ri-spin animate-spin mr-1.5"></i>
-                    处理中...
-                  </>
-                ) : (
-                  <>
-                    <i className="ri-check-double-line mr-1.5"></i>
-                    完成评查
-                  </>
-                )}
-              </button>
-            )}
-          </div>
-
-          {/* 文件信息和操作按钮 */}
-          {/* <FileInfo 
-            fileInfo={{
-              ...reviewData.fileInfo,
-              previousRoute: loaderData.previousRoute
-            }}
-            onConfirmResults={handleConfirmResults}
-          /> */}
-
-          {/* 根据视图模式切换内容 */}
-          {viewMode === 'review' ? (
-            /* 评查结果视图 */
-            <div className="flex flex-col lg:flex-row space-y-4 lg:space-y-0 lg:space-x-4 lg:justify-between">
+            {activeTab === 'preview' && (
+              <div className="flex flex-col lg:flex-row space-y-4 lg:space-y-0 lg:space-x-4">
               {/* 左侧：文件预览 */}
-              <div className="w-full lg:w-[62%]">
+              <div className="w-full lg:w-[65%]">
                 <FilePreview
                   fileContent={document}
                   reviewPoints={reviewData.reviewPoints}
@@ -845,6 +882,7 @@ export default function CrossCheckingResult() {
                   charPositions={charPositions}
                   highlightValue={highlightValue}
                   aiSuggestionReplace={aiSuggestionReplace}
+                  userInfo={loaderData.userInfo}
                 />
               </div>
 
@@ -869,8 +907,9 @@ export default function CrossCheckingResult() {
                 />
               </div>
               </div>
-          ) : (
-            /* 结构比对视图 */
+            )}
+
+            {activeTab === 'filecompare' && (
               <div className="w-full" style={{
               height: 'calc(100vh - 120px)',
               minHeight: '600px',
@@ -883,6 +922,15 @@ export default function CrossCheckingResult() {
               />
               </div>
             )}
+
+            {activeTab === 'fileinfo' && (
+              <FileDetails
+                fileInfo={reviewData.fileInfo}
+                contractInfo={reviewData.contractInfo}
+                reviewInfo={reviewData.reviewInfo}
+              />
+            )}
+          </ReviewTabs>
         </>
       )}
     </div>

app/routes/cross-checking.upload.tsx

@@ -14,7 +14,7 @@ import {
   type CrossCheckingUploadedFile,
   generateFileId,
   formatFileSize,
-  batchUploadAndAssignCrossCheckingFiles,
+  uploadCrossCheckingDocument,
   createCrossReviewTask
 } from "~/api/cross-checking/cross-files-upload";
 import {
@@ -302,8 +302,7 @@ export default function CrossCheckingUpload() {
                 return;
             }
 
-            // 第一步：上传文件并自动分配任务（新接口）
-            // console.log("开始批量上传文件并分配任务:", filesToUpload.length, "个，案卷类型:", selectedDocType.name);
+            // 第一步：先上传文档到平台，再用 v3 接口创建交叉评查任务
 
             // 提取用户ID（从选中的组织架构中获取用户）
             const userIds = groupChecked.filter(id => {
@@ -316,23 +315,6 @@ export default function CrossCheckingUpload() {
                 return;
             }
 
-            // const requireParam = {
-            //     filesToUpload: filesToUpload,
-            //     selectedDocTypeId: selectedDocTypeId, 
-            //     priority: priority,
-            //     documentNumber: documentNumber,
-            //     remark: remark,
-            //     isTestDocument: isTestDocument,
-            //     userIds: userIds,
-            //     taskInfo_name: taskInfo.name,
-            //     selectedDocType_name: selectedDocType.code, 
-            //     taskInfo_type: taskInfo.type,
-            //     frontendJWT
-            // }
-
-            // // console.log("requireParam", requireParam)
-            // return;
-
             // 构建负责人ID数组：当前用户（主要负责人）+ 额外负责人
             const principalUserIds: number[] = [];
             // 添加当前用户作为主要负责人
@@ -347,37 +329,63 @@ export default function CrossCheckingUpload() {
                 }
             });
 
-            // 使用文档类型名称作为 doc_type
-            const uploadResult = await batchUploadAndAssignCrossCheckingFiles(
-                filesToUpload,
-                selectedDocTypeId, // 使用选中的文档类型ID
+            const uploadSuccesses: Array<{ file: CrossCheckingUploadedFile; documentId: number }> = [];
+            const uploadFailures: Array<{ file: CrossCheckingUploadedFile; error: string }> = [];
+
+            for (const fileInfo of filesToUpload) {
+                const binaryData = await fileInfo.file.arrayBuffer();
+                const uploadResponse = await uploadCrossCheckingDocument(
+                    binaryData,
+                    fileInfo.name,
+                    fileInfo.type,
+                    selectedDocTypeId,
                     priority,
                     documentNumber,
                     remark,
                     isTestDocument,
-                userIds,
-                taskInfo.name,
-                selectedDocType.code, // 使用文档类型code
-                taskInfo.type, // 使用任务类型（市局间交叉评查 或 区局间交叉评查）
-                frontendJWT,
-                principalUserIds, // 负责人ID数组
-                attributeType // 合同类型
+                    null,
+                    false,
+                    frontendJWT
                 );
 
+                if (uploadResponse.error || !uploadResponse.data?.result?.id) {
+                    uploadFailures.push({
+                        file: fileInfo,
+                        error: uploadResponse.error || '上传后未返回文档ID'
+                    });
+                    continue;
+                }
 
-            // return;
+                uploadSuccesses.push({
+                    file: fileInfo,
+                    documentId: uploadResponse.data.result.id
+                });
+            }
 
-            const { successes, failures } = uploadResult;
+            if (uploadFailures.length > 0) {
+                toastService.error(`文件上传失败：${uploadFailures[0].error}`);
+                return;
+            }
 
-            if (failures.length > 0) {
-                toastService.error(`文件上传或任务分配失败：${failures[0].error}`);
+            const createTaskResult = await createCrossReviewTask({
+                documentIds: uploadSuccesses.map(item => item.documentId),
+                userIds,
+                principalUserIds,
+                taskName: taskInfo.name,
+                docTypeId: selectedDocTypeId,
+                docType: selectedDocType.code,
+                taskType: taskInfo.type
+            }, frontendJWT);
+
+            if (!createTaskResult.success) {
+                toastService.error(createTaskResult.error || '创建交叉评查任务失败');
                 return;
             }
 
             // 任务创建成功
             toastService.success("交叉评查任务创建成功！");
             messageService.success(
-                `任务创建完成！\n任务名称：${taskInfo.name}\n上传文件：${successes.length} 个\n评查人员：${userIds.length} 人`,
+                `任务创建完成！\n任务名称：${taskInfo.name}\n上传文件：${uploadSuccesses.length} 个\n评查人员：${userIds.length} 人`,
                 {
                     title: '任务创建成功',
                     confirmText: '确定',

app/routes/document-types._index.tsx

@@ -28,8 +28,9 @@ export async function loader({ request }: LoaderFunctionArgs) {
     const { getUserSession } = await import("~/api/login/auth.server");
     const { frontendJWT, userInfo } = await getUserSession(request);
     const { requireRoutePermission } = await import("~/api/auth/check-route-permission.server");
+    const userRole = userInfo?.role || userInfo?.user_role || "";
 
-    await requireRoutePermission("/document-types", userInfo?.role || "", frontendJWT || undefined);
+    await requireRoutePermission("/document-types", userRole, frontendJWT || undefined);
     const rootsRes = await getDocumentTypeRoots({}, frontendJWT);
 
     return {

app/routes/document-types.new.tsx

@@ -35,7 +35,8 @@ export async function loader({ request }: LoaderFunctionArgs) {
   const { getUserSession } = await import("~/api/login/auth.server");
   const { frontendJWT, userInfo } = await getUserSession(request);
   const { requireRoutePermission } = await import("~/api/auth/check-route-permission.server");
-  await requireRoutePermission("/document-types/new", userInfo?.role || "", frontendJWT || undefined);
+  const userRole = userInfo?.role || userInfo?.user_role || "";
+  await requireRoutePermission("/document-types/new", userRole, frontendJWT || undefined);
   const url = new URL(request.url);
   const editId = url.searchParams.get("id");
 

app/routes/reviewsTest.tsx

@@ -356,12 +356,13 @@ export async function loader({ request }: LoaderFunctionArgs): Promise<Response>
 
     const { getUserSession } = await import("~/api/login/auth.server");
     const { userInfo, frontendJWT } = await getUserSession(request);
-    if (!frontendJWT || !userInfo?.role) {
+    const userRole = userInfo?.role || userInfo?.user_role || '';
+    if (!frontendJWT || !userRole) {
       throw redirect('/login');
     }
 
     const { requireRoutePermission } = await import("~/api/auth/check-route-permission.server");
-    await requireRoutePermission('/reviewsTest', userInfo.role, frontendJWT);
+    await requireRoutePermission('/reviewsTest', userRole, frontendJWT);
 
     const reviewData = await getReviewPoints_fromApi(id, request);
 

app/routes/rule-groups._index.tsx

@@ -148,8 +148,9 @@ export async function loader({ request }: LoaderFunctionArgs) {
   const { getUserSession } = await import("~/api/login/auth.server");
   const { frontendJWT, userInfo } = await getUserSession(request);
   const { requireRoutePermission } = await import("~/api/auth/check-route-permission.server");
+  const userRole = userInfo?.role || userInfo?.user_role || "";
 
-  await requireRoutePermission("/rule-groups", userInfo?.role || "", frontendJWT || undefined);
+  await requireRoutePermission("/rule-groups", userRole, frontendJWT || undefined);
 
   try {
     const [groups, docTypesRes, entryModulesRes, ruleSetsRes] = await Promise.all([

app/routes/rules.list.tsx

@@ -240,7 +240,8 @@ export async function loader({ request }: LoaderFunctionArgs) {
   const { getUserSession } = await import("~/api/login/auth.server");
   const { frontendJWT, userInfo } = await getUserSession(request);
   const { requireRoutePermission } = await import("~/api/auth/check-route-permission.server");
-  await requireRoutePermission("/rules/list", userInfo?.role || "", frontendJWT || undefined);
+  const userRole = userInfo?.role || userInfo?.user_role || "";
+  await requireRoutePermission("/rules/list", userRole, frontendJWT || undefined);
 
   // 从 URL 参数中提取查询条件
   const params = {
@@ -287,7 +288,8 @@ export async function action({ request }: LoaderFunctionArgs) {
   const { getUserSession } = await import("~/api/login/auth.server");
   const { frontendJWT, userInfo } = await getUserSession(request);
   const { requireRoutePermission } = await import("~/api/auth/check-route-permission.server");
-  await requireRoutePermission("/rules/list", userInfo?.role || "", frontendJWT || undefined);
+  const userRole = userInfo?.role || userInfo?.user_role || "";
+  await requireRoutePermission("/rules/list", userRole, frontendJWT || undefined);
   const formData = await request.formData();
   const _action = formData.get('_action');
   const ruleId = formData.get('ruleId');

app/routes/rules.tsx

@@ -21,8 +21,9 @@ export async function loader({ request }: LoaderFunctionArgs) {
   const { getUserSession } = await import("~/api/login/auth.server");
   const { frontendJWT, userInfo } = await getUserSession(request);
   const { requireRoutePermission } = await import("~/api/auth/check-route-permission.server");
+  const userRole = userInfo?.role || userInfo?.user_role || "";
 
-  await requireRoutePermission("/rules", userInfo?.role || "", frontendJWT || undefined);
+  await requireRoutePermission("/rules", userRole, frontendJWT || undefined);
 
   if (url.pathname === '/rules') {
     const query = url.searchParams.toString();

app/routes/rulesTest.detail.tsx

@@ -185,6 +185,28 @@ function fallbackDependencyOption(value: string, optionMap?: Map<string, Depende
   };
 }
 
+function resolveRuleDependencies(
+  rule: RuleSummary | undefined,
+  rulesById: Map<string, RuleSummary>,
+  visited = new Set<string>(),
+): string[] {
+  if (!rule) return [];
+  const key = rule.ruleId || rule.id;
+  if (visited.has(key)) return [];
+  visited.add(key);
+
+  const merged = new Set<string>((rule.dependencies || []).filter(Boolean));
+
+  (rule.subRuleIds || []).forEach((ruleId) => {
+    const referenced = rulesById.get(ruleId);
+    resolveRuleDependencies(referenced, rulesById, visited).forEach((dependency) => {
+      if (dependency) merged.add(dependency);
+    });
+  });
+
+  return Array.from(merged);
+}
+
 function makeId(prefix: string): string {
   return `${prefix}-${Date.now()}`;
 }
@@ -424,7 +446,8 @@ export async function loader({ request }: LoaderFunctionArgs) {
 export async function action({ request }: ActionFunctionArgs) {
   const { frontendJWT, userInfo } = await getUserSession(request);
   const { requireRoutePermission } = await import('~/api/auth/check-route-permission.server');
-  await requireRoutePermission('/rulesTest/detail', userInfo?.role || '', frontendJWT || undefined);
+  const userRole = userInfo?.role || userInfo?.user_role || '';
+  await requireRoutePermission('/rulesTest/detail', userRole, frontendJWT || undefined);
   if (!frontendJWT) {
     return json<ActionData>({ success: false, intent: 'save', message: '登录已失效，请重新登录后再保存。' }, { status: 401 });
   }
@@ -571,29 +594,36 @@ export default function RulesTestDetail() {
     'ai_rule',
     'rule_group'
   ]), [rules]);
+  const rulesById = useMemo(() => new Map(rules.map(rule => [rule.ruleId || rule.id, rule])), [rules]);
   const selectedDependencyOptions = useMemo(() => {
     return ruleDraft.dependencies.map(value => dependencyOptionMap.get(value) || fallbackDependencyOption(value, dependencyOptionMap));
   }, [dependencyOptionMap, ruleDraft.dependencies]);
+  const resolvedCurrentDependencies = useMemo(() => {
+    return resolveRuleDependencies(currentRule, rulesById);
+  }, [currentRule, rulesById]);
+  const currentRuleWithResolvedDependencies = useMemo(() => (
+    currentRule ? { ...currentRule, dependencies: resolvedCurrentDependencies } : undefined
+  ), [currentRule, resolvedCurrentDependencies]);
   const currentDependencyRows = useMemo(() => {
-    return (currentRule?.dependencies || []).map(value => dependencyOptionMap.get(value) || fallbackDependencyOption(value, dependencyOptionMap));
-  }, [currentRule, dependencyOptionMap]);
+    return resolvedCurrentDependencies.map(value => dependencyOptionMap.get(value) || fallbackDependencyOption(value, dependencyOptionMap));
+  }, [dependencyOptionMap, resolvedCurrentDependencies]);
   const currentRuleFields = useMemo(
-    () => fields.filter((field) => matchesCurrentRuleDependency(currentRule, [field.name])),
-    [currentRule, fields],
+    () => fields.filter((field) => matchesCurrentRuleDependency(currentRuleWithResolvedDependencies, [field.name])),
+    [currentRuleWithResolvedDependencies, fields],
   );
   const currentRuleSubDocuments = useMemo(
-    () => subDocuments.filter((document) => matchesCurrentRuleDependency(currentRule, [document.name, document.id])),
-    [currentRule, subDocuments],
+    () => subDocuments.filter((document) => matchesCurrentRuleDependency(currentRuleWithResolvedDependencies, [document.name, document.id])),
+    [currentRuleWithResolvedDependencies, subDocuments],
   );
   const currentRuleVisualElements = useMemo(
-    () => visualElements.filter((item) => matchesCurrentRuleDependency(currentRule, [
+    () => visualElements.filter((item) => matchesCurrentRuleDependency(currentRuleWithResolvedDependencies, [
       item.id,
       item.name,
       `visual.${item.id}`,
       `visual.${item.name || item.id}`,
       item.type,
     ])),
-    [currentRule, visualElements],
+    [currentRuleWithResolvedDependencies, visualElements],
   );
   const dialogDependencyOptions = useMemo(() => {
     const selectedValues = new Set(ruleDraft.dependencies);
@@ -644,7 +674,6 @@ export default function RulesTestDetail() {
   const fullYamlText = serializedYamlResult.yamlText;
   const isSmartRuleDraft = ruleDraft.type === 'ai_rule' || ruleDraft.checkTypes.includes('ai');
   const isRuleGroupDraft = ruleDraft.type === 'rule_group';
-  const rulesById = useMemo(() => new Map(rules.map(rule => [rule.ruleId || rule.id, rule])), [rules]);
   const saveButtonBusy = saveFetcher.state !== 'idle';
   const latestDraftVersion = useMemo(
     () => versionItems.find((item) => !['published', 'rollback'].includes(item.status)),
@@ -1362,7 +1391,7 @@ export default function RulesTestDetail() {
 
             <Card
               className="ant-card"
-              title={`依赖字段 (${currentRule.dependencies.length}项)`}
+              title={`依赖字段 (${resolvedCurrentDependencies.length}项)`}
             >
               <Table
                 className="rules-test-table"

app/routes/rulesTest.list.tsx

@@ -88,7 +88,7 @@ export async function loader({ request }: LoaderFunctionArgs) {
   const requestedSubtype = url.searchParams.get('subtype') || url.searchParams.get('documentAttributeType') || '';
   const requestedRuleGroup = url.searchParams.get('ruleGroup') || url.searchParams.getAll('ruleGroups')[0] || '';
   const requestedPage = Number(url.searchParams.get('page') || '1');
-  const requestedPageSize = Number(url.searchParams.get('pageSize') || '10');
+  const requestedPageSize = Number(url.searchParams.get('pageSize') || '50');
   const requestedFilters = {
     documentType: url.searchParams.get('documentType') || '',
     mainType: requestedMainType,
@@ -96,7 +96,7 @@ export async function loader({ request }: LoaderFunctionArgs) {
     ruleGroup: requestedRuleGroup,
     keyword: url.searchParams.get('keyword') || '',
     page: Number.isFinite(requestedPage) && requestedPage > 0 ? requestedPage : 1,
-    pageSize: [10, 20, 30, 50].includes(requestedPageSize) ? requestedPageSize : 10
+    pageSize: [10, 20, 30, 50].includes(requestedPageSize) ? requestedPageSize : 50
   };
 
   const packs = await loadRuleConfigPackSummaries(request);
@@ -422,13 +422,13 @@ export default function RulesTestList() {
           />
         </FilterPanel>
 
-        <Card className="ant-card">
+        <Card className="ant-card rules-test-table-card">
           <Table
             className="rules-test-table rules-table"
             columns={columns}
             dataSource={rows}
             rowKey="rowId"
-            scroll={{ y: 700 }}
+            scroll={{ y: 'calc(100vh - 340px)' }}
             emptyText={<div className="empty-state">暂无规则。当前类型的规则列表流程已保留，可进入配置页查看空 YAML 模板。</div>}
           />
           {totalCount > 0 && (

app/services/collabora.config.server.ts

@@ -87,9 +87,8 @@ function buildCollaboraIframeUrl(params: {
 }): string {
     const { collaboraUrl, wopiSrc, accessToken, mode } = params;
 
-    // Collabora iframe 基础 URL
-    // fa80579 是 Collabora 的版本号标识，实际部署时可能需要调整
-    const baseUrl = `${collaboraUrl}/browser/fa80579/cool.html`;
+    // 使用稳定的 dist 入口，避免 Collabora 升级后版本号路径失效。
+    const baseUrl = `${collaboraUrl}/browser/dist/cool.html`;
 
     const url = new URL(baseUrl);
 

app/styles/pages/rules_test.css

@@ -184,8 +184,8 @@
 }
 
 .rules-test-page .rules-test-table td {
-  padding-top: 18px;
-  padding-bottom: 18px;
+  padding-top: 14px;
+  padding-bottom: 14px;
   padding-right: 12px;
   vertical-align: top;
 }
@@ -216,9 +216,7 @@
 .rules-test-page .rule-name {
   display: flex;
   flex-direction: column;
-  gap: 6px;
-  min-height: 54px;
-  justify-content: center;
+  gap: 4px;
 }
 
 .rules-test-page .rule-name strong {
@@ -235,9 +233,29 @@
   display: flex;
   flex-direction: column;
   align-items: flex-start;
-  gap: 6px;
-  min-height: 54px;
-  justify-content: center;
+  gap: 4px;
+}
+
+.rules-test-page .rules-test-table-card {
+  min-height: calc(100vh - 250px);
+  display: flex;
+  flex-direction: column;
+}
+
+.rules-test-page .rules-test-table-card .card-body {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+}
+
+.rules-test-page .rules-test-table-card .ant-table-wrapper {
+  flex: 1;
+  min-height: 0;
+}
+
+.rules-test-page .rules-test-table-card .pagination,
+.rules-test-page .rules-test-table-card .ant-pagination {
+  margin-top: auto;
 }
 
 .rules-test-page .rule-check-type span:last-child {

app/utils/rules-config-editor.ts

@@ -330,7 +330,7 @@ function normalizeBooleanText(value: string | boolean | undefined): boolean {
 }
 
 function rewriteExtractNodes(fields: ExtractFieldSummary[]): Array<Record<string, unknown>> {
-  const topLevelFields = fields.filter((field) => !field.name.includes('[*].'));
+  const topLevelFields = fields.filter((field) => field.group !== '派生字段' && !field.name.includes('[*].'));
   return Array.from(groupBy(topLevelFields, (field) => field.group || '未分组').entries()).map(([group, items]) => ({
     group,
     fields: items.map((field) => ({
@@ -343,6 +343,46 @@ function rewriteExtractNodes(fields: ExtractFieldSummary[]): Array<Record<string
   }));
 }
 
+function rewriteDerivedFieldNodes(
+  fields: ExtractFieldSummary[],
+  existingNodes: unknown,
+): Array<Record<string, unknown>> {
+  const derivedFields = fields.filter((field) => field.group === '派生字段');
+  if (derivedFields.length === 0) {
+    return [];
+  }
+
+  const existingMap = new Map<string, Record<string, unknown>>();
+  if (Array.isArray(existingNodes)) {
+    existingNodes.forEach((node) => {
+      if (!node || typeof node !== 'object') return;
+      const record = deepClone(node as Record<string, unknown>);
+      const name = String(record.name || '').trim();
+      if (name) {
+        existingMap.set(name, record);
+      }
+    });
+  }
+
+  return derivedFields.map((field) => {
+    const existing = existingMap.get(field.name) || {};
+    const nextNode: Record<string, unknown> = {
+      ...existing,
+      name: field.name,
+      type: field.type || String(existing.type || 'computed'),
+    };
+    const nextCompute = field.description && field.description !== '由其他字段计算得出'
+      ? field.description
+      : String(existing.compute || '').trim();
+    if (nextCompute) {
+      nextNode.compute = nextCompute;
+    } else {
+      delete nextNode.compute;
+    }
+    return nextNode;
+  });
+}
+
 function rewriteSubDocumentNodes(subDocuments: SubDocumentSummary[]): Array<Record<string, unknown>> {
   return subDocuments.map((document) => ({
     id: document.id,
@@ -474,7 +514,6 @@ function rewriteRuleNode(baseRule: Record<string, unknown> | undefined, rule: Ru
   }
 
   delete nextRule.rules;
-  delete nextRule.logic;
 
   const existingStages = Array.isArray(nextRule.stages) ? (nextRule.stages as Array<Record<string, unknown>>) : [];
   const stages = existingStages.length > 0 ? deepClone(existingStages) : (buildMinimalRuleNode(rule).stages as Array<Record<string, unknown>>);
@@ -494,6 +533,8 @@ function rewriteRuleNode(baseRule: Record<string, unknown> | undefined, rule: Ru
   }
 
   nextRule.stages = stages;
+  if (rule.logic?.trim()) nextRule.logic = rule.logic.trim();
+  else if (typeof nextRule.logic === 'string' && !String(nextRule.logic).trim()) delete nextRule.logic;
   return nextRule;
 }
 
@@ -512,6 +553,7 @@ export function serializeEditableRuleConfig(config: EditableRuleConfig): string
   if (Array.isArray(config.metadata.inheritsFrom) && config.metadata.inheritsFrom.length > 0) metadata.inherits_from = [...config.metadata.inheritsFrom];
   root.metadata = metadata;
   root.extract = rewriteExtractNodes(config.fields);
+  root.derived_fields = rewriteDerivedFieldNodes(config.fields, root.derived_fields);
   root.sub_documents = rewriteSubDocumentNodes(config.subDocuments);
   root.visual_elements = rewriteVisualElementNodes(config.visualElements);
 

app/utils/rules-yaml-mock.server.ts

@@ -288,7 +288,7 @@ function parseRules(source: string): RuleSummary[] {
     for (let index = start + 1; index < lines.length; index += 1) {
       const line = lines[index];
       const lineIndent = line.match(/^\s*/)?.[0].length || 0;
-      if (line.trim() && lineIndent <= baseIndent) {
+      if (line.trim() && lineIndent <= baseIndent && !/^\s*-\s+/.test(line)) {
         break;
       }
       const match = line.match(/^\s*-\s+(.+)$/);
@@ -313,7 +313,7 @@ function parseRules(source: string): RuleSummary[] {
         values.push(stripYamlValue(match[1]));
         continue;
       }
-      if (line.trim() && lineIndent <= indent) break;
+      if (line.trim() && lineIndent <= indent && !/^\s*-\s+/.test(line)) break;
     }
 
     return values;
@@ -331,7 +331,7 @@ function parseRules(source: string): RuleSummary[] {
     for (let index = start + 1; index < lines.length; index += 1) {
       const line = lines[index];
       const lineIndent = line.match(/^\s*/)?.[0].length || 0;
-      if (line.trim() && lineIndent <= baseIndent) {
+      if (line.trim() && lineIndent <= baseIndent && !/^\s*-\s+/.test(line)) {
         break;
       }
       const match = line.match(/^\s*-\s+(.+)$/);
@@ -342,6 +342,19 @@ function parseRules(source: string): RuleSummary[] {
     return values;
   };
   const readStageScalar = (block: string, key: string): string => stripYamlValue(block.match(new RegExp(`^\\s+${key}:\\s*(.+)$`, 'm'))?.[1] || '');
+  const readStagePairValues = (block: string): string[] => {
+    const lines = block.split('\n');
+    const values: string[] = [];
+
+    for (let index = 0; index < lines.length; index += 1) {
+      const match = lines[index].match(/^\s+(?:source|target|ref_field):\s*(.+)$/);
+      if (match) {
+        values.push(stripYamlValue(match[1]));
+      }
+    }
+
+    return values;
+  };
   const summarizeStage = (stageBlock: string): string => {
     const fields = readStageList(stageBlock, 'fields');
     const field = readStageScalar(stageBlock, 'field');
@@ -376,11 +389,22 @@ function parseRules(source: string): RuleSummary[] {
       const ruleId = stripYamlValue(ruleBlock.match(/^\s*-\s+rule_id:\s*(.+)$/m)?.[1] || '');
       const name = stripYamlValue(ruleBlock.match(/^\s+name:\s*(.+)$/m)?.[1] || '未命名规则');
       const checkTypes = Array.from(new Set(Array.from(ruleBlock.matchAll(/^\s+(?:check|type):\s*(.+)$/gm)).map(match => stripYamlValue(match[1]))));
-      const stageDependencies = Array.from(ruleBlock.matchAll(/^\s+(?:field|number|chinese|left|right|left_field|right_field|target|element|seal_id|signature_id):\s*(.+)$/gm))
+      const stageDependencies = Array.from(ruleBlock.matchAll(/^\s+(?:field|number|chinese|left|right|left_field|right_field|target|element|seal_id|signature_id|ref_field):\s*(.+)$/gm))
         .map(match => normalizeDependency(match[1]));
+      const stageFieldDependencies = splitBlocks(ruleBlock, /^\s{4,}-\s+id:\s*/)
+        .flatMap(stageBlock => [
+          ...readStageList(stageBlock, 'fields'),
+          ...readStagePairValues(stageBlock),
+        ])
+        .map(normalizeDependency);
       const prompts = readPrompts(ruleBlock);
       const promptDependencies = readPromptDependencies(prompts).map(normalizeDependency);
-      const dependencies = Array.from(new Set([...readExplicitDependencies(ruleBlock), ...stageDependencies, ...promptDependencies]));
+      const dependencies = Array.from(new Set([
+        ...readExplicitDependencies(ruleBlock),
+        ...stageDependencies,
+        ...stageFieldDependencies,
+        ...promptDependencies,
+      ]));
       const scope = Array.from(new Set(Array.from(ruleBlock.matchAll(/^\s{4,}-\s*([^:\n]+)$/gm)).map(match => stripYamlValue(match[1])).filter(value => !/^\d+$/.test(value))));
       const subRules = readSubRules(ruleBlock);
 
@@ -391,9 +415,9 @@ function parseRules(source: string): RuleSummary[] {
         group,
         risk: stripYamlValue(ruleBlock.match(/^\s+risk:\s*(.+)$/m)?.[1] || 'medium'),
         score: stripYamlValue(ruleBlock.match(/^\s+score:\s*(.+)$/m)?.[1] || '-'),
-        type: stripYamlValue(ruleBlock.match(/^\s+type:\s*(.+)$/m)?.[1] || 'deterministic'),
+        type: stripYamlValue(ruleBlock.match(/^\s{4}type:\s*(.+)$/m)?.[1] || 'deterministic'),
         checkTypes,
-        logic: stripYamlValue(ruleBlock.match(/^\s+logic:\s*(.+)$/m)?.[1] || ''),
+        logic: stripYamlValue(ruleBlock.match(/^\s{4}logic:\s*(.+)$/m)?.[1] || ''),
         subRules,
         subRuleIds: readList(ruleBlock, 'rules'),
         scope: scope.slice(0, 8),
@@ -401,7 +425,7 @@ function parseRules(source: string): RuleSummary[] {
         stageCount: subRules.length,
         appliesIn: readFlexibleList(ruleBlock, 'applies_in'),
         prompt: prompts.join('\n\n'),
-        description: stripYamlValue(ruleBlock.match(/^\s+desc:\s*(.+)$/m)?.[1] || '')
+        description: stripYamlValue(ruleBlock.match(/^\s{4}desc:\s*(.+)$/m)?.[1] || '')
       };
     });
   });

docs/cross-checking-v3-migration-status.md

@@ -0,0 +1,179 @@
+# 交叉评查 v3 迁移收口说明
+
+## 当前主链路状态
+
+目前交叉评查的主流程已经切到新版本链路：
+
+1. 创建任务页先上传文档，再调用 `POST /api/v3/cross-review/tasks` 创建任务
+2. 任务列表走 `POST /api/v3/cross-review/tasks/query`
+3. 任务文档列表走 `GET /api/v3/cross-review/tasks/{taskId}/documents`
+4. 交叉评查详情页使用新版评查详情页外壳
+5. 提案、投票、待投票检查走 `v3 cross-review` 接口
+6. 完成评查走 `POST /api/v3/cross-review/tasks/{taskId}/documents/{documentId}/complete`
+
+## 本次已完成的前端收口
+
+### 1. 创建任务
+
+文件：
+
+- `app/routes/cross-checking.upload.tsx`
+- `app/api/cross-checking/cross-files-upload.ts`
+
+现状：
+
+- 不再把“上传文件 + 自动分配任务”作为主链路
+- 改为先上传文档，再使用上传成功返回的 `documentId` 创建任务
+- 创建任务请求体已经对齐后端 `v3` DTO：
+  - `taskName`
+  - `taskType`
+  - `docTypeId`
+  - `docTypeCode`
+  - `memberUserIds`
+  - `principalUserIds`
+  - `documentIds`
+
+### 2. 任务页
+
+文件：
+
+- `app/api/cross-checking/cross-files.ts`
+- `app/routes/cross-checking._index.tsx`
+
+现状：
+
+- 任务列表、统计、文档列表均已接新接口
+- 返回任务页后仍保留 `openModal + taskId + taskName` 的 reopen 机制
+
+### 3. 详情页
+
+文件：
+
+- `app/routes/cross-checking.result.tsx`
+- `app/components/reviews/ReviewTabs.tsx`
+
+现状：
+
+- 页面外壳切到新版评查详情页
+- 优先复用新版预览、tab、文件信息组件
+- 交叉评查特有的提案面板仍保留，作为业务差异层
+
+### 4. 提案与投票
+
+文件：
+
+- `app/api/cross-checking/cross-file-result.ts`
+
+现状：
+
+- 已切到以下新接口：
+  - `POST /api/v3/cross-review/proposals`
+  - `POST /api/v3/cross-review/proposals/{proposalId}/votes`
+  - `DELETE /api/v3/cross-review/proposals/{proposalId}`
+  - `GET /api/v3/cross-review/documents/{documentId}/proposals`
+  - `GET /api/v3/cross-review/documents/{documentId}/pending-votes`
+
+## 边支能力迁移状态
+
+结合最新后端实现，交叉评查的边支能力里，“向已有任务补传文档”也已经切到新版本链路。
+
+### 1. 向已有任务补传文档
+
+文件：
+
+- `app/api/cross-checking/cross-files-upload.ts`
+
+接口：
+
+- `POST /api/v3/cross-review/tasks/{taskId}/documents/upload`
+
+调用位置：
+
+- `app/components/cross-checking/DocumentListModal.tsx`
+
+当前实现：
+
+- 前端改为直接上传 `file`
+- 后端不再走旧 `cross_review` 边支上传逻辑
+- 改为复用 `leaudit` 文档上传与抽取链路，再把新文档挂到交叉评查任务下
+- 上传成功后任务状态会回到 `in_progress`
+
+说明：
+
+- 这条能力已经不再依赖旧版 `v2 cross_review upload_documents`
+- 文档抽取、后续评查点生成与新版主链路保持一致
+
+## 仍保留旧接口的支链路
+
+以下能力当前仍是旧接口，尚未迁到 `v3`：
+
+### 1. 任务文档追加附件
+
+文件：
+
+- `app/api/cross-checking/cross-files.ts`
+
+接口：
+
+- `POST /api/v2/cross_review/tasks/{task_id}/documents/{document_id}/append_attachments`
+
+调用位置：
+
+- `app/components/cross-checking/DocumentListModal.tsx`
+
+说明：
+
+- 该能力主要服务合同场景的版本追加
+- 当前仍可继续保留旧接口，等后端 `v3` 能力明确后再迁
+
+### 2. 合同模板上传
+
+文件：
+
+- `app/api/cross-checking/cross-files.ts`
+
+接口：
+
+- 复用上传服务 `/upload_contract_template`
+
+调用位置：
+
+- `app/components/cross-checking/DocumentListModal.tsx`
+
+说明：
+
+- 该能力不属于 `cross-review` 专属接口，暂不要求迁到 `v3 cross-review`
+
+## 建议的后续迁移优先级
+
+### P1
+
+- 追加附件：`appendTaskDocumentAttachments()`
+
+原因：
+
+- 业务价值高，但更多是合同场景增强功能
+- 可以在主链路稳定后迁
+
+### P2
+
+- 历史兼容 helper 清理
+- 旧注释、旧命名继续清理
+
+原因：
+
+- 不影响业务，但能减少后续误接老接口的概率
+
+## 当前结论
+
+可以认为交叉评查的核心业务链路已经完成 `v3` 迁移：
+
+- 创建任务
+- 任务列表
+- 文档列表
+- 详情展示
+- 提案投票
+- 完成评查
+- 已有任务补传文档
+
+剩余工作主要集中在“追加附件”这条旧边支能力，以及后续兼容代码清理。

public/min-maps/vs/loader.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "file": "loader.js",
+  "sources": [],
+  "names": [],
+  "mappings": ""
+}