@chenchaolong/plugin-trade-compliance-workbench 1.0.6 → 1.0.7

package/dist/lib/workbench.service.js

@@ -1,7 +1,7 @@
 import { __decorate, __metadata, __param } from "tslib";
 import { Injectable, Optional } from '@nestjs/common';
 import { InjectDataSource } from '@nestjs/typeorm';
-import { Brackets, DataSource, In, IsNull } from 'typeorm';
+import { Brackets, DataSource, In, IsNull, Not } from 'typeorm';
 import { Decimal } from 'decimal.js';
 import ExcelJS from 'exceljs';
 import { createWriteStream } from 'node:fs';
@@ -9,20 +9,34 @@ import { mkdtemp, readFile, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { finished } from 'node:stream/promises';
+import { randomUUID } from 'node:crypto';
 import { BankAccountSettings, CompanySanctionMatch, CompanySettings, ControlledCatalogBatch, ControlledCatalogImportIssue, ControlledGoodsRecord, Customer, CustomerContract, CustomerContractAnalysisRun, CustomerContractClause, CustomerContractClauseAnalysis, DerivedSalesOrderManualData, GeneratedSalesFile, ImportTask, ManagedAsset, MonthlySafeExchangeRate, ProductComplianceMatch, ProfitRuleSettings, PurchaseOrder, PurchaseOrderLine, SanctionCatalogBatch, SanctionCatalogImportIssue, SanctionedCompanyRecord, SettingsHistory, Supplier } from './entities/index.js';
 import { CatalogTypes, ClauseTypes, CustomerProfitRateStatuses, DomainError, DomainErrorCodes, RefundValidationMethods, SalesPaymentStatuses, SanctionHitStatuses } from './types.js';
 import { deriveSalesLine, assertReceivedAmount } from './domain/finance.js';
 import { parseCustomerContractNo, parsePurchaseContractNo } from './domain/contract-number.js';
 import { isProductNameMatch, normalizeExactName, normalizeForProductMatch, normalizeHsCode, normalizeSanctionSource } from './domain/normalization.js';
 import { importTaskTimedOut, nextSettingsRevision, normalizeOptionalDecimalInput } from './domain/workflow.js';
-import { renderImportIssuesWorkbook } from './domain/import-issues.js';
+import { importIssueDto, renderImportIssuesWorkbook } from './domain/import-issues.js';
+import { catalogLocalizationInputIssues } from './domain/catalog-localization.js';
 import { BUILTIN_COMPANY_LOGO_STORAGE_ID, DEFAULT_BANKS, DEFAULT_COMPANY, DEFAULT_PROFIT_RULE } from './domain/default-settings.js';
 import { TradeComplianceFileStorage } from './adapters/file-storage.js';
+import { TranslationProvider } from './adapters/translation.provider.js';
 import { parseBankAccountType, parseExchangeRateInput, parseExpectedRevision, validateBankSettingsInput, validateProfitSettingsInput, validatePurchaseLineDiscriminators, validateTaxRates } from './runtime-validation.js';
+import { publicCustomerContractReanalysisDto, publicImportTaskDto } from './public-dto.js';
 const DEFAULT_IMPORT_ISSUE_EXPORT_MAX_ROWS = 50_000;
 const HARD_IMPORT_ISSUE_EXPORT_MAX_ROWS = 100_000;
 const CUSTOMER_REANALYSIS_TIMEOUT_MS = 20 * 60 * 1000;
 const ANALYTICS_EXPORT_MAX_ROWS = 100_000;
+const CONTROLLED_CATALOG_TRANSLATION_CONCURRENCY = 4;
+const CONTROLLED_CATALOG_TRANSLATION_TIMEOUT_MS = 60_000;
+const CONTROLLED_CATALOG_PROCESSING_CLAIM_LEASE_MS = 90_000;
+const CONTROLLED_CATALOG_PROCESSING_HEARTBEAT_MS = 30_000;
+const CONTROLLED_CATALOG_PROCESSING_CLAIM_INITIAL_POLL_MS = 250;
+const CONTROLLED_CATALOG_PROCESSING_CLAIM_MAX_POLL_MS = 1_000;
+const RUNNING_IMPORT_TASK_STATUSES = ['EXTRACTING', 'AI_PARSING', 'VALIDATING', 'PERSISTING'];
+const RECOVERABLE_IMPORT_TASK_STATUSES = ['QUEUED', 'EXTRACTING', 'AI_PARSING', 'VALIDATING', 'PERSISTING'];
+const RECOVERABLE_REANALYSIS_STATUSES = ['PENDING', 'RUNNING'];
+const TERMINAL_IMPORT_TASK_STATUSES = ['AWAITING_REVIEW', 'SUCCEEDED', 'FAILED', 'TIMED_OUT'];
 const CATALOG_RISK_RECOMMENDATIONS = {
     DUAL_USE: '建议核验军民两用物项许可要求，并在出口前完成合规审批',
     OVERSEAS_SANCTION: '建议核验海外制裁限制及交易对手风险，并在交易前完成合规审批'
@@ -44,10 +58,24 @@ export async function writeWorkbookFile(filePath, populate, openOutput = createW
         throw error;
     }
 }
+function controlledGoodsDto(item) {
+    const dto = { ...item };
+    delete dto.originalProductName;
+    delete dto.originalControlDescription;
+    delete dto.translationSource;
+    delete dto.sourceContent;
+    return dto;
+}
+function sanctionedCompanyDto(item) {
+    const dto = { ...item };
+    delete dto.sourceContent;
+    return dto;
+}
 let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
-    constructor(dataSource, storage) {
+    constructor(dataSource, storage, translation) {
         this.dataSource = dataSource;
         this.storage = storage;
+        this.translation = translation;
     }
     async bootstrapSettings(scope) {
         const profitRepo = this.dataSource.getRepository(ProfitRuleSettings);
@@ -93,15 +121,70 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
         return { controlledRiskCount, sanctionRiskCount, unlinkedPurchaseCount, unlinkedCustomerCount };
     }
     async listControlledGoods(scope, query = {}) {
-        return this.pagedCatalogQuery(ControlledGoodsRecord, ControlledCatalogBatch, scope, query, {
+        const page = await this.pagedCatalogQuery(ControlledGoodsRecord, ControlledCatalogBatch, scope, query, {
             exact: { catalogType: query.parameters?.catalogType },
             fuzzy: { productName: query.parameters?.productName, hsCode: query.parameters?.hsCode },
             batchSourceFileName: query.parameters?.sourceFileName
         });
+        return { ...page, items: page.items.map(controlledGoodsDto) };
     }
     async listImportTasks(scope, query = {}) {
         await this.expireStaleImportTasks(scope);
-        return this.pagedQuery(ImportTask, scope, query, ['sourceFileName', 'documentType', 'status', 'errorMessage'], { documentType: query.parameters?.documentType, status: query.parameters?.status });
+        const page = await this.pagedQuery(ImportTask, scope, query, ['sourceFileName', 'documentType', 'status', 'errorMessage'], { documentType: query.parameters?.documentType, status: query.parameters?.status });
+        return { ...page, items: page.items.map(publicImportTaskDto) };
+    }
+    async listActiveCustomerContractReanalyses(scope) {
+        const [contracts, tasks] = await Promise.all([
+            this.dataSource.getRepository(CustomerContract).find({ where: { ...activeScope(scope), currentReanalysisRunId: Not(IsNull()), deletedAt: IsNull() } }),
+            this.dataSource.getRepository(ImportTask).find({ where: { ...activeScope(scope), currentReanalysisRunId: Not(IsNull()) } })
+        ]);
+        const unconsumedIds = new Set([...contracts, ...tasks].map(item => item.currentReanalysisRunId).filter((id) => Boolean(id)));
+        const where = [
+            { ...activeScope(scope), status: In(['PENDING', 'RUNNING']) }
+        ];
+        if (unconsumedIds.size)
+            where.push({ ...activeScope(scope), id: In([...unconsumedIds]), status: 'SUCCEEDED' });
+        const runs = await this.dataSource.getRepository(CustomerContractAnalysisRun).find({
+            where,
+            order: { createdAt: 'DESC', id: 'DESC' }
+        });
+        const recoveries = runs
+            .filter(run => run.status === 'PENDING' || run.status === 'RUNNING' || (run.status === 'SUCCEEDED' && unconsumedIds.has(run.id)))
+            .map(run => ({
+            recoveryType: run.status === 'SUCCEEDED' ? 'SUCCEEDED_RESULT' : 'ACTIVE_POLL',
+            run: publicCustomerContractReanalysisDto(run)
+        }));
+        return { items: recoveries, total: recoveries.length, page: 1, pageSize: 20 };
+    }
+    async consumeCustomerContractReanalysisResult(scope, id) {
+        return this.dataSource.transaction(async (manager) => {
+            const run = await required(manager.getRepository(CustomerContractAnalysisRun).findOne({
+                where: { ...activeScope(scope), id },
+                lock: { mode: 'pessimistic_write' }
+            }), '重新分析任务不存在');
+            if (run.status !== 'SUCCEEDED')
+                throw new DomainError(DomainErrorCodes.INVALID_INPUT, '只有成功的重新分析结果可以确认消费');
+            let consumed = false;
+            if (run.customerContractId) {
+                const repo = manager.getRepository(CustomerContract);
+                const contract = await required(repo.findOne({ where: { ...activeScope(scope), id: run.customerContractId, deletedAt: IsNull() }, lock: { mode: 'pessimistic_write' } }), '客户合同不存在');
+                if (contract.currentReanalysisRunId === run.id) {
+                    contract.currentReanalysisRunId = null;
+                    await repo.save(contract);
+                    consumed = true;
+                }
+            }
+            else {
+                const repo = manager.getRepository(ImportTask);
+                const task = await required(repo.findOne({ where: { ...activeScope(scope), id: run.importTaskId }, lock: { mode: 'pessimistic_write' } }), '解析任务不存在');
+                if (task.currentReanalysisRunId === run.id) {
+                    task.currentReanalysisRunId = null;
+                    await repo.save(task);
+                    consumed = true;
+                }
+            }
+            return { run: publicCustomerContractReanalysisDto(run), consumed };
+        });
     }
     async listControlledBatches(scope, query = {}) { return this.pagedQuery(ControlledCatalogBatch, scope, query, ['sourceFileName'], { catalogType: query.parameters?.catalogType }); }
     async listSanctionBatches(scope, query = {}) { return this.pagedQuery(SanctionCatalogBatch, scope, query, ['sourceFileName']); }
@@ -113,7 +196,7 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
         const duplicate = await repo.findOne({ where: { ...activeScope(scope), catalogType: input.catalogType, normalizedProductName, normalizedHsCode, deletedAt: IsNull() } });
         if (duplicate)
             throw new DomainError(DomainErrorCodes.DUPLICATE_CATALOG_RECORD, '相同目录类型、商品名称和海关编码的记录已存在', { id: duplicate.id });
-        return repo.save(repo.create({ ...auditScope(scope), sourceType: input.sourceType ?? 'MANUAL_ENTRY', catalogType: input.catalogType, productName, normalizedProductName, hsCode: input.hsCode ?? null, normalizedHsCode, controlDescription: input.controlDescription ?? null, sourceLocation: input.sourceLocation ?? null, sourceContent: input.sourceContent ?? null }));
+        return controlledGoodsDto(await repo.save(repo.create({ ...auditScope(scope), sourceType: input.sourceType ?? 'MANUAL_ENTRY', catalogType: input.catalogType, productName, normalizedProductName, hsCode: input.hsCode ?? null, normalizedHsCode, controlDescription: input.controlDescription ?? null, sourceLocation: input.sourceLocation ?? null, sourceContent: input.sourceContent ?? null })));
     }
     async updateControlledGoods(scope, id, input) {
         const repo = this.dataSource.getRepository(ControlledGoodsRecord);
@@ -124,9 +207,133 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
         item.updatedById = scope.userId ?? null;
         const saved = await repo.save(item);
         await this.recalculateProductRisks(scope, 'CATALOG_CHANGED');
-        return saved;
+        return controlledGoodsDto(saved);
     }
     async importControlledCatalog(scope, input) {
+        while (true) {
+            const claim = await this.claimControlledCatalogProcessing(scope, input.importTaskId);
+            if (claim.kind === 'COMPLETED')
+                return this.completeControlledCatalogPostProcessing(scope, claim.batch);
+            if (claim.kind === 'BUSY') {
+                await this.waitForControlledCatalogProcessing(scope, input.importTaskId, claim.claimId, claim.expiresAt);
+                continue;
+            }
+            const heartbeat = this.startControlledCatalogProcessingHeartbeat(scope, input.importTaskId, claim.claimId);
+            try {
+                let result;
+                try {
+                    const localizedRows = await this.localizeControlledCatalogRows(input.rows, claim.deadline, heartbeat.signal);
+                    heartbeat.assertOwned();
+                    result = await this.persistControlledCatalog(scope, input, localizedRows, claim.claimId);
+                }
+                finally {
+                    await heartbeat.stop();
+                }
+                return this.completeControlledCatalogPostProcessing(scope, result);
+            }
+            catch (error) {
+                try {
+                    await this.releaseControlledCatalogProcessing(scope, input.importTaskId, claim.claimId);
+                }
+                catch { }
+                throw error;
+            }
+        }
+    }
+    async claimControlledCatalogProcessing(scope, importTaskId) {
+        return this.dataSource.transaction(async (manager) => {
+            const taskRepo = manager.getRepository(ImportTask);
+            const task = await required(taskRepo.findOne({ where: { ...activeScope(scope), id: importTaskId }, lock: { mode: 'pessimistic_write' } }), '解析任务不存在');
+            if (task.status === 'SUCCEEDED' && task.resultEntityId) {
+                const batch = await required(manager.getRepository(ControlledCatalogBatch).findOne({ where: { ...activeScope(scope), id: task.resultEntityId } }), '已完成导入批次不存在');
+                return { kind: 'COMPLETED', batch };
+            }
+            assertImportTaskResultWritable(task);
+            const now = Date.now();
+            const claimExpiresAt = task.resultProcessingClaimExpiresAt;
+            if (task.resultProcessingClaimId && claimExpiresAt && claimExpiresAt.getTime() > now) {
+                return { kind: 'BUSY', claimId: task.resultProcessingClaimId, expiresAt: claimExpiresAt };
+            }
+            const claimId = randomUUID();
+            const deadline = now + CONTROLLED_CATALOG_TRANSLATION_TIMEOUT_MS;
+            task.resultProcessingClaimId = claimId;
+            task.resultProcessingClaimExpiresAt = new Date(now + CONTROLLED_CATALOG_PROCESSING_CLAIM_LEASE_MS);
+            await taskRepo.save(task);
+            return { kind: 'CLAIMED', claimId, deadline };
+        });
+    }
+    async waitForControlledCatalogProcessing(scope, importTaskId, claimId, expiresAt) {
+        let observedExpiry = expiresAt.getTime();
+        let pollMs = CONTROLLED_CATALOG_PROCESSING_CLAIM_INITIAL_POLL_MS;
+        while (true) {
+            const task = await required(this.dataSource.getRepository(ImportTask).findOne({ where: { ...activeScope(scope), id: importTaskId } }), '解析任务不存在');
+            if (task.status === 'SUCCEEDED')
+                return;
+            if (TERMINAL_IMPORT_TASK_STATUSES.includes(task.status))
+                throwImportTaskTerminalState(task);
+            if (task.resultProcessingClaimId !== claimId)
+                return;
+            observedExpiry = task.resultProcessingClaimExpiresAt?.getTime() ?? observedExpiry;
+            const remaining = observedExpiry - Date.now();
+            if (remaining <= 0)
+                return;
+            await new Promise(resolve => setTimeout(resolve, Math.min(pollMs, remaining)));
+            pollMs = Math.min(pollMs * 2, CONTROLLED_CATALOG_PROCESSING_CLAIM_MAX_POLL_MS);
+        }
+    }
+    startControlledCatalogProcessingHeartbeat(scope, importTaskId, claimId) {
+        const stopController = new AbortController();
+        const ownerController = new AbortController();
+        let lostError = null;
+        const completion = (async () => {
+            while (await cancellableDelay(CONTROLLED_CATALOG_PROCESSING_HEARTBEAT_MS, stopController.signal)) {
+                try {
+                    const renewed = await this.renewControlledCatalogProcessing(scope, importTaskId, claimId);
+                    if (renewed)
+                        continue;
+                    if (stopController.signal.aborted)
+                        return;
+                    lostError = new DomainError(DomainErrorCodes.INVALID_INPUT, '目录导入处理权已失效');
+                }
+                catch (error) {
+                    lostError = error;
+                }
+                ownerController.abort(lostError);
+                return;
+            }
+        })();
+        return {
+            signal: ownerController.signal,
+            assertOwned: () => { if (lostError)
+                throw lostError; },
+            stop: async () => { stopController.abort(); await completion; }
+        };
+    }
+    async renewControlledCatalogProcessing(scope, importTaskId, claimId) {
+        return this.dataSource.transaction(async (manager) => {
+            const taskRepo = manager.getRepository(ImportTask);
+            const task = await required(taskRepo.findOne({ where: { ...activeScope(scope), id: importTaskId }, lock: { mode: 'pessimistic_write' } }), '解析任务不存在');
+            if (task.resultProcessingClaimId !== claimId)
+                return false;
+            if (TERMINAL_IMPORT_TASK_STATUSES.includes(task.status))
+                return false;
+            task.resultProcessingClaimExpiresAt = new Date(Date.now() + CONTROLLED_CATALOG_PROCESSING_CLAIM_LEASE_MS);
+            await taskRepo.save(task);
+            return true;
+        });
+    }
+    async releaseControlledCatalogProcessing(scope, importTaskId, claimId) {
+        await this.dataSource.transaction(async (manager) => {
+            const taskRepo = manager.getRepository(ImportTask);
+            const task = await required(taskRepo.findOne({ where: { ...activeScope(scope), id: importTaskId }, lock: { mode: 'pessimistic_write' } }), '解析任务不存在');
+            if (task.resultProcessingClaimId !== claimId)
+                return;
+            task.resultProcessingClaimId = null;
+            task.resultProcessingClaimExpiresAt = null;
+            await taskRepo.save(task);
+        });
+    }
+    async persistControlledCatalog(scope, input, localizedRows, claimId) {
         return this.dataSource.transaction(async (manager) => {
             const batchRepo = manager.getRepository(ControlledCatalogBatch);
             const recordRepo = manager.getRepository(ControlledGoodsRecord);
@@ -135,6 +342,9 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
             const task = await required(taskRepo.findOne({ where: { ...activeScope(scope), id: input.importTaskId }, lock: { mode: 'pessimistic_write' } }), '解析任务不存在');
             if (task.status === 'SUCCEEDED' && task.resultEntityId)
                 return required(batchRepo.findOne({ where: { ...activeScope(scope), id: task.resultEntityId } }), '已完成导入批次不存在');
+            if (task.resultProcessingClaimId !== claimId)
+                throw new DomainError(DomainErrorCodes.INVALID_INPUT, '目录导入处理权已失效');
+            assertImportTaskResultWritable(task);
             task.status = 'PERSISTING';
             await taskRepo.save(task);
             const now = new Date();
@@ -147,14 +357,15 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
                 await batchRepo.save(old);
                 await recordRepo.update({ ...activeScope(scope), batchId: old.id, deletedAt: IsNull() }, { deletedAt: now, deletedById: scope.userId ?? null, deleteOperation: 'CATALOG_REPLACE' });
             }
-            const batch = await batchRepo.save(batchRepo.create({ ...auditScope(scope), catalogType: input.catalogType, sourceFileId: input.sourceFileId, sourceFileName: input.sourceFileName, importMode: input.replaceBatchId ? 'REPLACE_BATCH' : 'APPEND', replacedBatchId: input.replaceBatchId ?? null, totalCount: input.rows.length, successCount: 0, duplicateCount: 0, invalidCount: 0, importTaskId: input.importTaskId }));
+            const batch = await batchRepo.save(batchRepo.create({ ...auditScope(scope), catalogType: input.catalogType, sourceFileId: task.sourceFileId, sourceFileName: task.sourceFileName, importMode: input.replaceBatchId ? 'REPLACE_BATCH' : 'APPEND', replacedBatchId: input.replaceBatchId ?? null, totalCount: input.rows.length, successCount: 0, duplicateCount: 0, invalidCount: 0, importTaskId: input.importTaskId, riskRecalculatedAt: null }));
             for (let index = 0; index < input.rows.length; index += 1) {
                 const row = input.rows[index];
-                const productName = String(row.productName ?? '').trim();
+                const localized = localizedRows[index];
+                const productName = localized.productName;
                 const normalizedHsCode = String(row.hsCode ?? '').replace(/\s/g, '');
-                if (!productName) {
+                if (localized.error) {
                     batch.invalidCount += 1;
-                    await issueRepo.save(issueRepo.create({ ...createdScope(scope), batchId: batch.id, issueType: 'INVALID', sourceSequence: index + 1, sourceLocation: row.sourceLocation ?? null, sourceContent: row.sourceContent ?? null, parsedPayload: row, message: '商品名称为空' }));
+                    await issueRepo.save(issueRepo.create({ ...createdScope(scope), batchId: batch.id, issueType: 'INVALID', sourceSequence: index + 1, sourceLocation: row.sourceLocation ?? null, sourceContent: row.sourceContent ?? null, parsedPayload: row, message: localized.error }));
                     continue;
                 }
                 const duplicate = await recordRepo.findOne({ where: { ...activeScope(scope), catalogType: input.catalogType, normalizedProductName: productName, normalizedHsCode, deletedAt: IsNull() } });
@@ -163,19 +374,105 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
                     await issueRepo.save(issueRepo.create({ ...createdScope(scope), batchId: batch.id, issueType: 'DUPLICATE', sourceSequence: index + 1, sourceLocation: row.sourceLocation ?? null, sourceContent: row.sourceContent ?? null, parsedPayload: row, message: '目录中已存在相同商品名称和海关编码' }));
                     continue;
                 }
-                await recordRepo.save(recordRepo.create({ ...auditScope(scope), batchId: batch.id, sourceType: 'FILE_IMPORT', catalogType: input.catalogType, productName, normalizedProductName: productName, hsCode: row.hsCode ?? null, normalizedHsCode, controlDescription: row.controlDescription ?? null, sourceLocation: row.sourceLocation ?? null, sourceContent: row.sourceContent ?? null }));
+                await recordRepo.save(recordRepo.create({ ...auditScope(scope), batchId: batch.id, sourceType: 'FILE_IMPORT', catalogType: input.catalogType, productName, normalizedProductName: productName, hsCode: row.hsCode ?? null, normalizedHsCode, controlDescription: localized.controlDescription, originalProductName: localized.originalProductName, originalControlDescription: localized.originalControlDescription, translationSource: localized.translationSource, sourceLocation: row.sourceLocation ?? null, sourceContent: row.sourceContent ?? null }));
                 batch.successCount += 1;
             }
             await batchRepo.save(batch);
             task.status = 'SUCCEEDED';
             task.resultEntityId = batch.id;
             task.completedAt = new Date();
+            task.resultProcessingClaimId = null;
+            task.resultProcessingClaimExpiresAt = null;
             await taskRepo.save(task);
             return batch;
-        }).then(async (batch) => { await this.recalculateProductRisks(scope, 'CATALOG_CHANGED'); return batch; });
+        });
+    }
+    async completeControlledCatalogPostProcessing(scope, batch) {
+        if (batch.riskRecalculatedAt)
+            return batch;
+        const result = await this.recalculateProductRisks(scope, 'CATALOG_CHANGED', batch.id);
+        batch.riskRecalculatedAt = result.riskRecalculatedAt ?? new Date();
+        return batch;
+    }
+    async localizeControlledCatalogRows(rows, deadline = Date.now() + CONTROLLED_CATALOG_TRANSLATION_TIMEOUT_MS, ownerSignal) {
+        const localized = new Array(rows.length);
+        const controller = new AbortController();
+        const abortFromOwner = () => controller.abort(ownerSignal?.reason);
+        ownerSignal?.addEventListener('abort', abortFromOwner, { once: true });
+        if (ownerSignal?.aborted)
+            abortFromOwner();
+        const remaining = Math.max(0, deadline - Date.now());
+        const timeout = setTimeout(() => controller.abort(), remaining);
+        let nextIndex = 0;
+        const worker = async () => {
+            while (nextIndex < rows.length) {
+                const index = nextIndex;
+                nextIndex += 1;
+                localized[index] = await this.localizeControlledCatalogRow(rows[index], deadline, controller.signal);
+            }
+        };
+        try {
+            await Promise.all(Array.from({ length: Math.min(CONTROLLED_CATALOG_TRANSLATION_CONCURRENCY, rows.length) }, worker));
+            return localized;
+        }
+        finally {
+            clearTimeout(timeout);
+            ownerSignal?.removeEventListener('abort', abortFromOwner);
+        }
+    }
+    async localizeControlledCatalogRow(row, deadline, signal) {
+        const originalProductName = String(row.originalProductName ?? '').trim() || null;
+        const originalControlDescription = String(row.originalControlDescription ?? '').trim() || null;
+        let productName = String(row.productName ?? '').trim();
+        let controlDescription = String(row.controlDescription ?? '').trim() || null;
+        let translationSource = row.translationSource ?? null;
+        let serviceTranslated = false;
+        const inputIssue = catalogLocalizationInputIssues(row)[0];
+        if (inputIssue)
+            return { productName, controlDescription, originalProductName, originalControlDescription, translationSource, error: inputIssue.message };
+        if (!productName) {
+            if (!originalProductName)
+                return { productName: '', controlDescription, originalProductName, originalControlDescription, translationSource, error: '商品名称为空' };
+            productName = await this.translateCatalogValue(originalProductName, deadline, signal) ?? '';
+            if (!productName)
+                return { productName: '', controlDescription, originalProductName, originalControlDescription, translationSource, error: '商品名称翻译失败' };
+            serviceTranslated = true;
+        }
+        if (!controlDescription && originalControlDescription) {
+            controlDescription = await this.translateCatalogValue(originalControlDescription, deadline, signal);
+            if (!controlDescription)
+                return { productName, controlDescription: null, originalProductName, originalControlDescription, translationSource, error: '管控说明翻译失败' };
+            serviceTranslated = true;
+        }
+        if (!translationSource)
+            return { productName, controlDescription, originalProductName, originalControlDescription, translationSource, error: '翻译来源为空' };
+        if (serviceTranslated)
+            translationSource = 'SERVICE_TRANSLATED';
+        return { productName, controlDescription, originalProductName, originalControlDescription, translationSource };
+    }
+    async translateCatalogValue(value, deadline, signal) {
+        const remaining = deadline - Date.now();
+        if (!this.translation || remaining <= 0 || signal.aborted)
+            return null;
+        const translated = Promise.resolve(this.translation.toChinese(value, { signal, deadline }))
+            .then(result => String(result ?? '').trim() || null, () => null);
+        let onAbort;
+        try {
+            const aborted = new Promise(resolve => {
+                onAbort = () => resolve(null);
+                signal.addEventListener('abort', onAbort, { once: true });
+                if (signal.aborted)
+                    resolve(null);
+            });
+            return await Promise.race([translated, aborted]);
+        }
+        finally {
+            if (onAbort)
+                signal.removeEventListener('abort', onAbort);
+        }
     }
     async listSanctionedCompanies(scope, query = {}) {
-        return this.pagedCatalogQuery(SanctionedCompanyRecord, SanctionCatalogBatch, scope, query, {
+        const page = await this.pagedCatalogQuery(SanctionedCompanyRecord, SanctionCatalogBatch, scope, query, {
             fuzzy: {
                 companyName: query.parameters?.companyName,
                 countryOrRegion: query.parameters?.countryOrRegion,
@@ -184,22 +481,23 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
             range: { effectiveDate: query.parameters?.effectiveDate },
             batchSourceFileName: query.parameters?.sourceFileName
         });
+        return { ...page, items: page.items.map(sanctionedCompanyDto) };
     }
     async getImportTaskResult(scope, taskId) {
         await this.expireStaleImportTasks(scope);
         const task = await required(this.dataSource.getRepository(ImportTask).findOne({ where: { ...activeScope(scope), id: taskId } }), '解析任务不存在');
-        const execution = { commands: task.executionCommand ? [task.executionCommand] : [], polling: { intervalMs: 2000, timeoutMs: 1200000 } };
+        const publicTask = publicImportTaskDto(task);
         if (!task.resultEntityId)
-            return { task, ...execution };
+            return { task: publicTask };
         if (task.documentType === 'CONTROLLED_CATALOG') {
             const batch = await this.dataSource.getRepository(ControlledCatalogBatch).findOne({ where: { ...activeScope(scope), id: task.resultEntityId } });
-            return { task, batch: batch ?? undefined, ...execution };
+            return { task: publicTask, batch: batch ?? undefined };
         }
         if (task.documentType === 'SANCTION_CATALOG') {
             const batch = await this.dataSource.getRepository(SanctionCatalogBatch).findOne({ where: { ...activeScope(scope), id: task.resultEntityId } });
-            return { task, batch: batch ?? undefined, ...execution };
+            return { task: publicTask, batch: batch ?? undefined };
         }
-        return { task, ...execution };
+        return { task: publicTask };
     }
     async listImportIssues(scope, query) {
         const page = Math.max(1, Number(query.page ?? 1));
@@ -209,7 +507,7 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
             where: { ...activeScope(scope), batchId: query.batchId, issueType: query.issueType },
             order: { sourceSequence: 'ASC' }, skip: (page - 1) * pageSize, take: pageSize
         });
-        return { items, total, page, pageSize };
+        return { items: items.map(importIssueDto), total, page, pageSize };
     }
     async downloadImportIssues(scope, documentType, batchId) {
         const batchEntity = documentType === 'CONTROLLED_CATALOG' ? ControlledCatalogBatch : SanctionCatalogBatch;
@@ -233,7 +531,7 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
             throw new DomainError(DomainErrorCodes.DUPLICATE_CATALOG_RECORD, '相同公司名称和制裁名单来源的记录已存在', { id: duplicate.id });
         const saved = await repo.save(repo.create({ ...auditScope(scope), sourceType: input.sourceType ?? 'MANUAL_ENTRY', companyName, normalizedCompanyName, countryOrRegion: input.countryOrRegion ?? null, sanctionListSource: input.sanctionListSource ?? null, normalizedSanctionListSource, sanctionReason: input.sanctionReason ?? null, effectiveDate: input.effectiveDate ?? null, remarks: input.remarks ?? null, sourceLocation: input.sourceLocation ?? null, sourceContent: input.sourceContent ?? null }));
         await this.recalculateCompanyRisks(scope, 'CATALOG_CHANGED');
-        return saved;
+        return sanctionedCompanyDto(saved);
     }
     async updateSanctionedCompany(scope, id, input) {
         const repo = this.dataSource.getRepository(SanctionedCompanyRecord);
@@ -244,7 +542,7 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
         item.updatedById = scope.userId ?? null;
         const saved = await repo.save(item);
         await this.recalculateCompanyRisks(scope, 'CATALOG_CHANGED');
-        return saved;
+        return sanctionedCompanyDto(saved);
     }
     async importSanctionCatalog(scope, input) {
         const batch = await this.dataSource.transaction(async (manager) => {
@@ -255,6 +553,7 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
             const task = await required(taskRepo.findOne({ where: { ...activeScope(scope), id: input.importTaskId }, lock: { mode: 'pessimistic_write' } }), '解析任务不存在');
             if (task.status === 'SUCCEEDED' && task.resultEntityId)
                 return required(batchRepo.findOne({ where: { ...activeScope(scope), id: task.resultEntityId } }), '已完成导入批次不存在');
+            assertImportTaskResultWritable(task);
             task.status = 'PERSISTING';
             await taskRepo.save(task);
             const now = new Date();
@@ -267,7 +566,7 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
                 await batchRepo.save(old);
                 await recordRepo.update({ ...activeScope(scope), batchId: old.id, deletedAt: IsNull() }, { deletedAt: now, deletedById: scope.userId ?? null, deleteOperation: 'SANCTION_CATALOG_REPLACE' });
             }
-            const result = await batchRepo.save(batchRepo.create({ ...auditScope(scope), sourceFileId: input.sourceFileId, sourceFileName: input.sourceFileName, importMode: input.replaceBatchId ? 'REPLACE_BATCH' : 'APPEND', replacedBatchId: input.replaceBatchId ?? null, totalCount: input.rows.length, successCount: 0, duplicateCount: 0, invalidCount: 0, importTaskId: input.importTaskId }));
+            const result = await batchRepo.save(batchRepo.create({ ...auditScope(scope), sourceFileId: task.sourceFileId, sourceFileName: task.sourceFileName, importMode: input.replaceBatchId ? 'REPLACE_BATCH' : 'APPEND', replacedBatchId: input.replaceBatchId ?? null, totalCount: input.rows.length, successCount: 0, duplicateCount: 0, invalidCount: 0, importTaskId: input.importTaskId }));
             for (let index = 0; index < input.rows.length; index += 1) {
                 const row = input.rows[index];
                 const companyName = String(row.companyName ?? '').trim();
@@ -299,31 +598,360 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
     }
     async createImportTask(scope, input) {
         const repo = this.dataSource.getRepository(ImportTask);
-        return repo.save(repo.create({ ...createdScope(scope), ...input, status: input.status ?? 'QUEUED', queuedAt: new Date(), createdById: scope.userId ?? null }));
+        const targetAssistantId = requiredId(input.targetAssistantId, '目标智能体标识');
+        return repo.save(repo.create({ ...createdScope(scope), ...input, targetAssistantId, status: 'QUEUED', queuedAt: new Date(), createdById: scope.userId ?? null }));
     }
-    async saveImportTaskExecution(scope, id, command) {
-        const repo = this.dataSource.getRepository(ImportTask);
-        const task = await required(repo.findOne({ where: { ...activeScope(scope), id } }), '解析任务不存在');
-        task.executionCommand = command;
-        task.commandDispatchedAt = null;
-        return repo.save(task);
+    async findNextQueuedImportTaskCandidate(scope) {
+        return this.dataSource.getRepository(ImportTask).findOne({
+            where: { ...activeScope(scope), status: 'QUEUED' },
+            order: { queuedAt: 'ASC', id: 'ASC' }
+        });
+    }
+    async claimQueuedImportTaskById(scope, id, claimAttemptToken) {
+        const attemptToken = requiredId(claimAttemptToken, '领取尝试标识');
+        return this.dataSource.transaction(async (manager) => {
+            await lockOrganizationTaskClaim(manager, scope);
+            if (await organizationHasActiveParsing(manager, scope))
+                return null;
+            const repo = manager.getRepository(ImportTask);
+            const task = await repo.findOne({
+                where: { ...activeScope(scope), id, status: 'QUEUED' },
+                lock: { mode: 'pessimistic_write', onLocked: 'skip_locked' }
+            });
+            if (!task)
+                return null;
+            if (!task.targetAssistantId) {
+                task.status = 'FAILED';
+                task.errorCode = 'TARGET_ASSISTANT_MISSING';
+                task.errorMessage = '历史解析任务缺少目标智能体，无法自动恢复';
+                task.completedAt = new Date();
+                await repo.save(task);
+                return null;
+            }
+            task.status = 'EXTRACTING';
+            task.claimAttemptToken = attemptToken;
+            task.startedAt ??= new Date();
+            return repo.save(task);
+        });
+    }
+    async claimNextQueuedImportTask(scope) {
+        return this.dataSource.transaction(async (manager) => {
+            await lockOrganizationTaskClaim(manager, scope);
+            const repo = manager.getRepository(ImportTask);
+            if (await organizationHasActiveParsing(manager, scope))
+                return null;
+            const task = await repo.findOne({
+                where: { ...activeScope(scope), status: 'QUEUED' },
+                order: { queuedAt: 'ASC', id: 'ASC' },
+                lock: { mode: 'pessimistic_write', onLocked: 'skip_locked' }
+            });
+            if (!task)
+                return null;
+            if (!task.targetAssistantId) {
+                task.status = 'FAILED';
+                task.errorCode = 'TARGET_ASSISTANT_MISSING';
+                task.errorMessage = '历史解析任务缺少目标智能体，无法自动恢复';
+                task.completedAt = new Date();
+                await repo.save(task);
+                return null;
+            }
+            task.status = 'EXTRACTING';
+            task.startedAt ??= new Date();
+            return repo.save(task);
+        });
+    }
+    async listOrganizationsWithRecoverableTasks() {
+        const workItems = await this.listRecoverableImportWorkItems();
+        const organizations = new Map();
+        for (const item of workItems) {
+            const organization = { tenantId: item.tenantId, organizationId: item.organizationId };
+            organizations.set(`${organization.tenantId}:${organization.organizationId}`, organization);
+        }
+        return [...organizations.values()];
+    }
+    async listRecoverableImportWorkItems(scope) {
+        const recoveryScope = scope ? activeScope(scope) : {};
+        const [tasks, runs] = await Promise.all([
+            this.dataSource.getRepository(ImportTask).find({
+                where: { ...recoveryScope, status: In([...RECOVERABLE_IMPORT_TASK_STATUSES]) },
+                select: {
+                    id: true, tenantId: true, organizationId: true, targetAssistantId: true,
+                    status: true, claimAttemptToken: true, commandDispatchedAt: true, startedAt: true
+                }
+            }),
+            this.dataSource.getRepository(CustomerContractAnalysisRun).find({
+                where: {
+                    ...recoveryScope,
+                    analysisType: 'REANALYSIS', status: In([...RECOVERABLE_REANALYSIS_STATUSES])
+                },
+                select: {
+                    id: true, importTaskId: true, customerContractId: true,
+                    tenantId: true, organizationId: true, targetAssistantId: true,
+                    status: true, claimAttemptToken: true, commandDispatchedAt: true, startedAt: true, expiresAt: true
+                }
+            })
+        ]);
+        for (const task of tasks.filter(task => !task.targetAssistantId))
+            await this.failRecoverableImportWithoutTarget(task);
+        for (const run of runs.filter(run => !run.targetAssistantId))
+            await this.failRecoverableReanalysisWithoutTarget(run);
+        return [
+            ...tasks.filter(task => task.targetAssistantId).map(task => ({
+                type: 'IMPORT_TASK',
+                importTaskId: task.id,
+                tenantId: task.tenantId,
+                organizationId: task.organizationId,
+                status: task.status,
+                claimAttemptToken: task.claimAttemptToken,
+                commandDispatchedAt: task.commandDispatchedAt,
+                startedAt: task.startedAt
+            })),
+            ...runs.filter(run => run.targetAssistantId).map(run => ({
+                type: 'CUSTOMER_REANALYSIS',
+                importTaskId: run.importTaskId,
+                analysisRunId: run.id,
+                customerContractId: run.customerContractId,
+                tenantId: run.tenantId,
+                organizationId: run.organizationId,
+                status: run.status,
+                claimAttemptToken: run.claimAttemptToken,
+                commandDispatchedAt: run.commandDispatchedAt,
+                startedAt: run.startedAt,
+                expiresAt: run.expiresAt
+            }))
+        ];
+    }
+    async failRecoverableImportWithoutTarget(snapshot) {
+        await this.dataSource.transaction(async (manager) => {
+            const repo = manager.getRepository(ImportTask);
+            const task = await repo.findOne({ where: { ...activeScope(snapshot), id: snapshot.id }, lock: { mode: 'pessimistic_write' } });
+            if (!task || task.targetAssistantId || !RECOVERABLE_IMPORT_TASK_STATUSES.includes(task.status))
+                return;
+            task.status = 'FAILED';
+            task.errorCode = 'TARGET_ASSISTANT_MISSING';
+            task.errorMessage = '历史解析任务缺少目标智能体，无法自动恢复';
+            task.completedAt = new Date();
+            await repo.save(task);
+        });
+    }
+    async failRecoverableReanalysisWithoutTarget(snapshot) {
+        await this.dataSource.transaction(async (manager) => {
+            const repo = manager.getRepository(CustomerContractAnalysisRun);
+            const run = await repo.findOne({ where: { ...activeScope(snapshot), id: snapshot.id }, lock: { mode: 'pessimistic_write' } });
+            if (!run || run.targetAssistantId || !RECOVERABLE_REANALYSIS_STATUSES.includes(run.status))
+                return;
+            run.status = 'FAILED';
+            run.errorCode = 'TARGET_ASSISTANT_MISSING';
+            run.errorMessage = '历史重新分析任务缺少目标智能体，无法自动恢复';
+            run.completedAt = new Date();
+            await repo.save(run);
+        });
+    }
+    async markImportTaskTimedOut(scope, id, claimAttemptToken) {
+        const attemptToken = requiredId(claimAttemptToken, '领取尝试标识');
+        return this.dataSource.transaction(async (manager) => {
+            const repo = manager.getRepository(ImportTask);
+            const task = await required(repo.findOne({
+                where: { ...activeScope(scope), id },
+                lock: { mode: 'pessimistic_write' }
+            }), '解析任务不存在');
+            if (!RUNNING_IMPORT_TASK_STATUSES.includes(task.status))
+                return task;
+            if (task.claimAttemptToken !== attemptToken)
+                return task;
+            task.status = 'TIMED_OUT';
+            task.errorCode = 'AI_PARSING_TIMEOUT';
+            task.errorMessage = '解析任务超过 20 分钟未完成';
+            task.completedAt = new Date();
+            return repo.save(task);
+        });
+    }
+    async findNextPendingReanalysisCandidate(scope) {
+        return this.dataSource.getRepository(CustomerContractAnalysisRun).findOne({
+            where: { ...activeScope(scope), status: 'PENDING' },
+            order: { createdAt: 'ASC', id: 'ASC' }
+        });
+    }
+    async claimPendingReanalysisById(scope, id, claimAttemptToken) {
+        const attemptToken = requiredId(claimAttemptToken, '领取尝试标识');
+        return this.dataSource.transaction(async (manager) => {
+            await lockOrganizationTaskClaim(manager, scope);
+            if (await organizationHasActiveParsing(manager, scope))
+                return null;
+            const locked = await lockCustomerContractReanalysis(manager, scope, id);
+            if (await timeoutCustomerContractReanalysis(manager, locked))
+                return null;
+            const repo = manager.getRepository(CustomerContractAnalysisRun);
+            const run = locked.run;
+            if (run.status !== 'PENDING')
+                return null;
+            if (!run.targetAssistantId) {
+                run.status = 'FAILED';
+                run.errorCode = 'TARGET_ASSISTANT_MISSING';
+                run.errorMessage = '历史重新分析任务缺少目标智能体，无法自动恢复';
+                run.completedAt = new Date();
+                await repo.save(run);
+                return null;
+            }
+            run.status = 'RUNNING';
+            run.claimAttemptToken = attemptToken;
+            run.startedAt ??= new Date();
+            return repo.save(run);
+        });
+    }
+    async expireCustomerContractReanalysisIfNeeded(scope, id) {
+        return this.dataSource.transaction(async (manager) => {
+            const locked = await lockCustomerContractReanalysis(manager, scope, id);
+            await timeoutCustomerContractReanalysis(manager, locked);
+            return locked.run;
+        });
+    }
+    async claimNextPendingReanalysis(scope) {
+        return this.dataSource.transaction(async (manager) => {
+            await lockOrganizationTaskClaim(manager, scope);
+            const repo = manager.getRepository(CustomerContractAnalysisRun);
+            if (await organizationHasActiveParsing(manager, scope))
+                return null;
+            const run = await repo.findOne({
+                where: { ...activeScope(scope), status: 'PENDING' },
+                order: { createdAt: 'ASC', id: 'ASC' },
+                lock: { mode: 'pessimistic_write', onLocked: 'skip_locked' }
+            });
+            if (!run)
+                return null;
+            if (!run.targetAssistantId) {
+                run.status = 'FAILED';
+                run.errorCode = 'TARGET_ASSISTANT_MISSING';
+                run.errorMessage = '历史重新分析任务缺少目标智能体，无法自动恢复';
+                run.completedAt = new Date();
+                await repo.save(run);
+                return null;
+            }
+            run.status = 'RUNNING';
+            run.startedAt ??= new Date();
+            return repo.save(run);
+        });
+    }
+    async saveImportTaskExecution(scope, id, claimAttemptToken, command) {
+        const attemptToken = requiredId(claimAttemptToken, '领取尝试标识');
+        return this.dataSource.transaction(async (manager) => {
+            const repo = manager.getRepository(ImportTask);
+            const task = await required(repo.findOne({
+                where: { ...activeScope(scope), id },
+                lock: { mode: 'pessimistic_write' }
+            }), '解析任务不存在');
+            if (task.status !== 'EXTRACTING' || task.claimAttemptToken !== attemptToken)
+                return null;
+            task.executionCommand = command;
+            task.commandDispatchedAt = null;
+            return repo.save(task);
+        });
     }
     async markImportCommandDispatched(scope, id) {
-        const repo = this.dataSource.getRepository(ImportTask);
-        const task = await required(repo.findOne({ where: { ...activeScope(scope), id } }), '解析任务不存在');
-        task.commandDispatchedAt ??= new Date();
-        return repo.save(task);
+        return this.dataSource.transaction(async (manager) => {
+            const repo = manager.getRepository(ImportTask);
+            const task = await required(repo.findOne({
+                where: { ...activeScope(scope), id },
+                lock: { mode: 'pessimistic_write' }
+            }), '解析任务不存在');
+            if (!RUNNING_IMPORT_TASK_STATUSES.includes(task.status)) {
+                return task;
+            }
+            task.commandDispatchedAt ??= new Date();
+            if (task.status === 'EXTRACTING')
+                task.status = 'AI_PARSING';
+            return repo.save(task);
+        });
+    }
+    async assertImportTaskCompleted(scope, id) {
+        return this.dataSource.transaction(async (manager) => {
+            const repo = manager.getRepository(ImportTask);
+            const task = await required(repo.findOne({
+                where: { ...activeScope(scope), id },
+                lock: { mode: 'pessimistic_write' }
+            }), '解析任务不存在');
+            if (task.status === 'AWAITING_REVIEW' || task.status === 'SUCCEEDED')
+                return task;
+            if (task.status === 'FAILED' || task.status === 'TIMED_OUT')
+                return task;
+            task.status = 'FAILED';
+            task.errorCode = 'AGENT_HANDOFF_RESULT_MISSING';
+            task.errorMessage = '智能体已结束，但解析工具未保存业务结果';
+            task.completedAt = new Date();
+            return repo.save(task);
+        });
+    }
+    async processImportTaskHandoffCallback(scope, id, input) {
+        validateHandoffCallbackInput(input);
+        return this.dataSource.transaction(async (manager) => {
+            const repo = manager.getRepository(ImportTask);
+            const task = await repo.findOne({
+                where: { ...activeScope(scope), id },
+                lock: { mode: 'pessimistic_write' }
+            });
+            if (!task)
+                return { accepted: false, reason: 'scope_mismatch', sequence: 0 };
+            if (!handoffCallbackIdentityMatches(input, `trade-compliance-import-task-${task.id}`, task.targetAssistantId))
+                return { accepted: false, reason: 'identity_mismatch', sequence: task.handoffCallbackSequence ?? 0 };
+            const currentSequence = task.handoffCallbackSequence ?? 0;
+            if (input.sequence <= currentSequence) {
+                return { accepted: false, reason: 'stale_sequence', sequence: currentSequence };
+            }
+            task.handoffCallbackSequence = input.sequence;
+            if (input.kind === 'complete' &&
+                task.status !== 'AWAITING_REVIEW' && task.status !== 'SUCCEEDED' &&
+                task.status !== 'FAILED' && task.status !== 'TIMED_OUT') {
+                task.status = 'FAILED';
+                task.errorCode = 'AGENT_HANDOFF_RESULT_MISSING';
+                task.errorMessage = '智能体已结束，但解析工具未保存业务结果';
+                task.completedAt = new Date();
+            }
+            else if (input.kind === 'error' &&
+                !TERMINAL_IMPORT_TASK_STATUSES.includes(task.status)) {
+                task.status = 'FAILED';
+                task.errorCode = requiredId(input.errorCode, '错误代码');
+                task.errorMessage = requiredId(input.errorMessage, '错误信息');
+                task.completedAt = new Date();
+            }
+            await repo.save(task);
+            return { accepted: true, sequence: input.sequence };
+        });
     }
     async markImportTaskFailed(scope, id, failure) {
-        const repo = this.dataSource.getRepository(ImportTask);
-        const task = await required(repo.findOne({ where: { ...activeScope(scope), id } }), '解析任务不存在');
-        task.status = 'FAILED';
-        task.errorCode = failure.errorCode;
-        task.errorMessage = failure.errorMessage;
-        task.completedAt = new Date();
-        return repo.save(task);
-    }
-    async createRetryImportTask(scope, sourceTaskId) {
+        return this.dataSource.transaction(async (manager) => {
+            const repo = manager.getRepository(ImportTask);
+            const task = await required(repo.findOne({ where: { ...activeScope(scope), id }, lock: { mode: 'pessimistic_write' } }), '解析任务不存在');
+            if (TERMINAL_IMPORT_TASK_STATUSES.includes(task.status))
+                return task;
+            task.status = 'FAILED';
+            task.errorCode = failure.errorCode;
+            task.errorMessage = failure.errorMessage;
+            task.completedAt = new Date();
+            return repo.save(task);
+        });
+    }
+    async markImportTaskRecoveryStateInvalidIfUnchanged(scope, id, snapshot, failure) {
+        return this.dataSource.transaction(async (manager) => {
+            const repo = manager.getRepository(ImportTask);
+            const task = await required(repo.findOne({
+                where: { ...activeScope(scope), id },
+                lock: { mode: 'pessimistic_write' }
+            }), '解析任务不存在');
+            if (!RUNNING_IMPORT_TASK_STATUSES.includes(task.status))
+                return task;
+            if (task.claimAttemptToken !== snapshot.claimAttemptToken)
+                return task;
+            if (!snapshotMissingRecoveryMetadataStillMissing(snapshot, task))
+                return task;
+            task.status = 'FAILED';
+            task.errorCode = failure.errorCode;
+            task.errorMessage = failure.errorMessage;
+            task.completedAt = new Date();
+            return repo.save(task);
+        });
+    }
+    async createRetryImportTask(scope, sourceTaskId, requestedTargetAssistantId) {
+        const targetAssistantId = requiredId(requestedTargetAssistantId, '目标智能体标识');
         return this.dataSource.transaction(async (manager) => {
             const repo = manager.getRepository(ImportTask);
             const source = await required(repo.findOne({ where: { ...activeScope(scope), id: sourceTaskId }, lock: { mode: 'pessimistic_write' } }), '解析任务不存在');
@@ -334,21 +962,30 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
             if (!source.executionInput)
                 throw new DomainError(DomainErrorCodes.INVALID_INPUT, '原任务缺少可恢复执行参数');
             const existing = await repo.findOne({ where: { ...activeScope(scope), retryOfTaskId: source.id } });
-            if (existing)
-                return existing;
-            return repo.save(repo.create({
+            if (existing) {
+                return TERMINAL_IMPORT_TASK_STATUSES.includes(existing.status)
+                    ? { kind: 'EXISTING_TERMINAL', task: existing }
+                    : { kind: 'EXISTING_ACTIVE', task: existing };
+            }
+            const task = await repo.save(repo.create({
                 ...createdScope(scope), documentType: source.documentType, sourceFileId: source.sourceFileId,
                 sourceFileName: source.sourceFileName, sourceFileFormat: source.sourceFileFormat,
+                originalSourceFileName: source.originalSourceFileName,
+                fileNameEncodingStatus: source.fileNameEncodingStatus,
                 sourcePlatformFileId: source.sourcePlatformFileId, sourceWorkspacePath: source.sourceWorkspacePath,
-                executionInput: source.executionInput,
-                retryOfTaskId: source.id, status: 'EXTRACTING', queuedAt: new Date(), createdById: scope.userId ?? null
+                executionInput: source.executionInput, targetAssistantId,
+                retryOfTaskId: source.id, status: 'QUEUED', queuedAt: new Date(), createdById: scope.userId ?? null
             }));
+            return { kind: 'CREATED_REDISPATCHABLE', task };
         });
     }
     async updateImportTaskDraft(scope, id, payload, version = 'v1') {
         return this.dataSource.transaction(async (manager) => {
             const repo = manager.getRepository(ImportTask);
             const task = await required(repo.findOne({ where: { ...activeScope(scope), id }, lock: { mode: 'pessimistic_write' } }), '解析任务不存在');
+            if (task.status === 'AWAITING_REVIEW')
+                return task;
+            assertImportTaskResultWritable(task);
             await invalidateCustomerContractReanalysis(manager, scope, { reviewSource: 'IMPORT_DRAFT', task });
             task.resultPayload = payload;
             task.resultPayloadVersion = version;
@@ -358,12 +995,19 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
         });
     }
     async markImportTaskParsing(scope, id) {
-        const repo = this.dataSource.getRepository(ImportTask);
-        const task = await required(repo.findOne({ where: { ...activeScope(scope), id } }), '解析任务不存在');
-        task.status = 'AI_PARSING';
-        task.startedAt ??= new Date();
-        task.completedAt = null;
-        return repo.save(task);
+        return this.dataSource.transaction(async (manager) => {
+            await lockOrganizationTaskClaim(manager, scope);
+            if (await organizationHasActiveParsing(manager, scope))
+                throw new DomainError(DomainErrorCodes.INVALID_INPUT, '组织内已有解析任务运行中');
+            const repo = manager.getRepository(ImportTask);
+            const task = await required(repo.findOne({ where: { ...activeScope(scope), id }, lock: { mode: 'pessimistic_write' } }), '解析任务不存在');
+            if (task.status !== 'QUEUED')
+                throw new DomainError(DomainErrorCodes.INVALID_INPUT, '只有排队中的解析任务可以开始解析');
+            task.status = 'AI_PARSING';
+            task.startedAt = new Date();
+            task.completedAt = null;
+            return repo.save(task);
+        });
     }
     async savePurchaseDraft(scope, importTaskId, draft) {
         assertPurchaseDraft(draft);
@@ -549,6 +1193,8 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
         const contract = await this.dataSource.transaction(async (manager) => {
             const taskRepo = manager.getRepository(ImportTask);
             const task = await required(taskRepo.findOne({ where: { ...activeScope(scope), id: importTaskId }, lock: { mode: 'pessimistic_write' } }), '解析任务不存在');
+            if (task.documentType !== 'CUSTOMER_CONTRACT' || task.status !== 'AWAITING_REVIEW' || task.resultEntityId != null)
+                throw new DomainError(DomainErrorCodes.INVALID_INPUT, '仅待审核且未入库的客户合同任务可以保存审核');
             await invalidateCustomerContractReanalysis(manager, scope, { reviewSource: 'IMPORT_DRAFT', task });
             const parsed = parseCustomerContractNo(draft.contract.contractNo);
             const contractRepo = manager.getRepository(CustomerContract);
@@ -675,9 +1321,10 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
         const latestRun = contract.latestAnalysisRunId ? runs.find(run => run.id === contract.latestAnalysisRunId && run.status === 'SUCCEEDED') ?? null : null;
         const analyses = latestRun ? await this.dataSource.getRepository(CustomerContractClauseAnalysis).find({ where: { ...activeScope(scope), analysisRunId: latestRun.id } }) : [];
         const sanctionMatchCount = customer ? await this.dataSource.getRepository(CompanySanctionMatch).count({ where: { ...activeScope(scope), subjectType: 'CUSTOMER', customerId: customer.id, deletedAt: IsNull() } }) : 0;
-        return { contract, customer, clauses, analyses, latestRun, analysisRuns: runs, sanctionStatus: customer?.complianceCheckStatus === 'CHECKED' ? sanctionMatchCount ? 'HIT' : 'CLEAR' : 'UNCHECKED' };
+        return { contract, customer, clauses, analyses, latestRun: latestRun ? publicCustomerContractReanalysisDto(latestRun) : null, analysisRuns: runs.map(publicCustomerContractReanalysisDto), sanctionStatus: customer?.complianceCheckStatus === 'CHECKED' ? sanctionMatchCount ? 'HIT' : 'CLEAR' : 'UNCHECKED' };
     }
-    async startCustomerContractReanalysis(scope, input) {
+    async startCustomerContractReanalysis(scope, input, requestedTargetAssistantId) {
+        const targetAssistantId = requiredId(requestedTargetAssistantId, '目标智能体标识');
         return this.dataSource.transaction(async (manager) => {
             const now = new Date();
             let importTaskId;
@@ -715,6 +1362,23 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
             if (activeRun) {
                 if (targetCurrentRunId && targetCurrentRunId !== activeRun.id)
                     throw new DomainError(DomainErrorCodes.INVALID_INPUT, '重新分析任务已不是当前运行');
+                if (!activeRun.targetAssistantId) {
+                    activeRun.status = 'FAILED';
+                    activeRun.errorCode = 'TARGET_ASSISTANT_MISSING';
+                    activeRun.errorMessage = '历史重新分析任务缺少目标智能体，无法自动恢复';
+                    activeRun.completedAt = now;
+                    await runRepo.save(activeRun);
+                    if (contractTarget?.currentReanalysisRunId === activeRun.id)
+                        contractTarget.currentReanalysisRunId = null;
+                    if (taskTarget?.currentReanalysisRunId === activeRun.id)
+                        taskTarget.currentReanalysisRunId = null;
+                    activeRun = null;
+                }
+                else if (activeRun.targetAssistantId !== targetAssistantId) {
+                    throw new DomainError(DomainErrorCodes.INVALID_INPUT, '重新分析任务的目标智能体不一致');
+                }
+            }
+            if (activeRun) {
                 const expiresAt = activeRun.expiresAt ?? new Date((activeRun.createdAt ?? now).getTime() + CUSTOMER_REANALYSIS_TIMEOUT_MS);
                 activeRun.expiresAt = expiresAt;
                 if (!await timeoutCustomerContractReanalysis(manager, { run: activeRun, contract: contractTarget, task: taskTarget }, now)) {
@@ -739,7 +1403,7 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
                     await runRepo.save(activeRun);
                 }
             }
-            const run = await runRepo.save(runRepo.create({ ...createdScope(scope), customerContractId, importTaskId, analysisType: 'REANALYSIS', status: 'PENDING', promptVersion: 'CUSTOMER_CLAUSE_V1', modelName: null, errorCode: null, errorMessage: null, analysisInput, executionCommand: null, expiresAt: new Date(now.getTime() + CUSTOMER_REANALYSIS_TIMEOUT_MS), commandDispatchedAt: null, startedAt: null, completedAt: null, createdById: scope.userId ?? null }));
+            const run = await runRepo.save(runRepo.create({ ...createdScope(scope), customerContractId, importTaskId, analysisType: 'REANALYSIS', status: 'PENDING', targetAssistantId, promptVersion: 'CUSTOMER_CLAUSE_V1', modelName: null, errorCode: null, errorMessage: null, analysisInput, executionCommand: null, expiresAt: new Date(now.getTime() + CUSTOMER_REANALYSIS_TIMEOUT_MS), commandDispatchedAt: null, startedAt: null, completedAt: null, createdById: scope.userId ?? null }));
             if (contractTarget) {
                 contractTarget.currentReanalysisRunId = run.id;
                 await manager.getRepository(CustomerContract).save(contractTarget);
@@ -772,6 +1436,7 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
     }
     async markCustomerContractReanalysisDispatched(scope, id) {
         const outcome = await this.dataSource.transaction(async (manager) => {
+            await lockOrganizationTaskClaim(manager, scope);
             const locked = await lockCustomerContractReanalysis(manager, scope, id);
             const run = locked.run;
             if (await timeoutCustomerContractReanalysis(manager, locked))
@@ -782,6 +1447,8 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
                 throw new DomainError(DomainErrorCodes.INVALID_INPUT, '重新分析任务尚未持久化执行命令');
             if (lockedCurrentReanalysisRunId(locked) !== run.id)
                 throw new DomainError(DomainErrorCodes.INVALID_INPUT, '重新分析任务已不是当前运行');
+            if (await organizationHasActiveParsing(manager, scope))
+                throw new DomainError(DomainErrorCodes.INVALID_INPUT, '组织内已有解析任务运行中');
             const dispatchedAt = new Date();
             run.commandDispatchedAt = dispatchedAt;
             run.startedAt = dispatchedAt;
@@ -792,6 +1459,92 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
             throw reanalysisTimeoutError();
         return outcome.run;
     }
+    async markCustomerContractReanalysisCommandDispatched(scope, id) {
+        return this.dataSource.transaction(async (manager) => {
+            const repo = manager.getRepository(CustomerContractAnalysisRun);
+            const run = await required(repo.findOne({
+                where: { ...activeScope(scope), id },
+                lock: { mode: 'pessimistic_write' }
+            }), '重新分析任务不存在');
+            if (run.status !== 'RUNNING')
+                return run;
+            if (!run.executionCommand) {
+                throw new DomainError(DomainErrorCodes.INVALID_INPUT, '重新分析任务尚未持久化执行命令');
+            }
+            run.commandDispatchedAt ??= new Date();
+            return repo.save(run);
+        });
+    }
+    async assertCustomerContractReanalysisCompleted(scope, id) {
+        return this.dataSource.transaction(async (manager) => {
+            const repo = manager.getRepository(CustomerContractAnalysisRun);
+            const locked = await lockCustomerContractReanalysis(manager, scope, id);
+            const run = locked.run;
+            if (run.status === 'SUCCEEDED' || run.status === 'FAILED' || run.status === 'TIMED_OUT')
+                return run;
+            run.status = 'FAILED';
+            run.errorCode = 'AGENT_HANDOFF_RESULT_MISSING';
+            run.errorMessage = '智能体已结束，但重新分析工具未保存业务结果';
+            run.completedAt = new Date();
+            await clearCurrentReanalysis(manager, locked);
+            return repo.save(run);
+        });
+    }
+    async processCustomerContractReanalysisHandoffCallback(scope, id, input) {
+        validateHandoffCallbackInput(input);
+        return this.dataSource.transaction(async (manager) => {
+            const repo = manager.getRepository(CustomerContractAnalysisRun);
+            const snapshot = await repo.findOne({ where: { ...activeScope(scope), id } });
+            if (!snapshot)
+                return { accepted: false, reason: 'scope_mismatch', sequence: 0 };
+            const locked = await lockCustomerContractReanalysis(manager, scope, id);
+            const run = locked.run;
+            if (!handoffCallbackIdentityMatches(input, `trade-compliance-customer-reanalysis-${run.id}`, run.targetAssistantId))
+                return { accepted: false, reason: 'identity_mismatch', sequence: run.handoffCallbackSequence ?? 0 };
+            const currentSequence = run.handoffCallbackSequence ?? 0;
+            if (input.sequence <= currentSequence) {
+                return { accepted: false, reason: 'stale_sequence', sequence: currentSequence };
+            }
+            run.handoffCallbackSequence = input.sequence;
+            if (input.kind === 'complete' &&
+                run.status !== 'SUCCEEDED' && run.status !== 'FAILED' && run.status !== 'TIMED_OUT') {
+                run.status = 'FAILED';
+                run.errorCode = 'AGENT_HANDOFF_RESULT_MISSING';
+                run.errorMessage = '智能体已结束，但重新分析工具未保存业务结果';
+                run.completedAt = new Date();
+                await clearCurrentReanalysis(manager, locked);
+            }
+            else if (input.kind === 'error' &&
+                run.status !== 'SUCCEEDED' && run.status !== 'FAILED' && run.status !== 'TIMED_OUT') {
+                if (!await timeoutCustomerContractReanalysis(manager, locked)) {
+                    run.status = 'FAILED';
+                    run.errorCode = requiredId(input.errorCode, '错误代码');
+                    run.errorMessage = requiredId(input.errorMessage, '错误信息');
+                    run.completedAt = new Date();
+                    await clearCurrentReanalysis(manager, locked);
+                }
+            }
+            await repo.save(run);
+            return { accepted: true, sequence: input.sequence };
+        });
+    }
+    async markCustomerContractReanalysisTimedOut(scope, id, claimAttemptToken) {
+        const attemptToken = requiredId(claimAttemptToken, '领取尝试标识');
+        return this.dataSource.transaction(async (manager) => {
+            const locked = await lockCustomerContractReanalysis(manager, scope, id);
+            const run = locked.run;
+            if (run.status !== 'RUNNING')
+                return run;
+            if (run.claimAttemptToken !== attemptToken)
+                return run;
+            run.status = 'TIMED_OUT';
+            run.errorCode = 'AI_REANALYSIS_TIMEOUT';
+            run.errorMessage = 'AI 重新分析超过 20 分钟';
+            run.completedAt = new Date();
+            await clearCurrentReanalysis(manager, locked);
+            return manager.getRepository(CustomerContractAnalysisRun).save(run);
+        });
+    }
     async markCustomerContractReanalysisFailed(scope, id, input) {
         const errorCode = requiredId(input.errorCode, '错误代码');
         const errorMessage = requiredId(input.errorMessage, '错误信息');
@@ -807,6 +1560,49 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
             run.errorCode = errorCode;
             run.errorMessage = errorMessage;
             run.completedAt = new Date();
+            await clearCurrentReanalysis(manager, locked);
+            return repo.save(run);
+        });
+    }
+    async markCustomerContractReanalysisFailedIfActive(scope, id, input) {
+        const errorCode = requiredId(input.errorCode, '错误代码');
+        const errorMessage = requiredId(input.errorMessage, '错误信息');
+        return this.dataSource.transaction(async (manager) => {
+            const repo = manager.getRepository(CustomerContractAnalysisRun);
+            const locked = await lockCustomerContractReanalysis(manager, scope, id);
+            const run = locked.run;
+            if (run.status === 'SUCCEEDED' || run.status === 'FAILED' || run.status === 'TIMED_OUT')
+                return run;
+            if (await timeoutCustomerContractReanalysis(manager, locked))
+                return run;
+            run.status = 'FAILED';
+            run.errorCode = errorCode;
+            run.errorMessage = errorMessage;
+            run.completedAt = new Date();
+            await clearCurrentReanalysis(manager, locked);
+            return repo.save(run);
+        });
+    }
+    async markCustomerContractReanalysisRecoveryStateInvalidIfUnchanged(scope, id, snapshot, input) {
+        const errorCode = requiredId(input.errorCode, '错误代码');
+        const errorMessage = requiredId(input.errorMessage, '错误信息');
+        return this.dataSource.transaction(async (manager) => {
+            const repo = manager.getRepository(CustomerContractAnalysisRun);
+            const locked = await lockCustomerContractReanalysis(manager, scope, id);
+            const run = locked.run;
+            if (run.status !== 'RUNNING')
+                return run;
+            if (await timeoutCustomerContractReanalysis(manager, locked))
+                return run;
+            if (run.claimAttemptToken !== snapshot.claimAttemptToken)
+                return run;
+            if (!snapshotMissingRecoveryMetadataStillMissing(snapshot, run))
+                return run;
+            run.status = 'FAILED';
+            run.errorCode = errorCode;
+            run.errorMessage = errorMessage;
+            run.completedAt = new Date();
+            await clearCurrentReanalysis(manager, locked);
             return repo.save(run);
         });
     }
@@ -816,12 +1612,13 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
             await timeoutCustomerContractReanalysis(manager, locked);
             return locked.run;
         });
+        const publicRun = publicCustomerContractReanalysisDto(run);
         if (run.status !== 'SUCCEEDED')
-            return { run };
+            return { run: publicRun };
         if (run.customerContractId)
-            return { run, review: await this.getCustomerContractReview(scope, run.customerContractId) };
+            return { run: publicRun, review: await this.getCustomerContractReview(scope, run.customerContractId) };
         const task = await required(this.dataSource.getRepository(ImportTask).findOne({ where: { ...activeScope(scope), id: run.importTaskId } }), '解析任务不存在');
-        return { run, task };
+        return { run: publicRun, task: publicImportTaskDto(task) };
     }
     async saveCustomerContractReanalysis(scope, analysisRunId, analyses) {
         assertCompleteClauseAnalyses(analyses);
@@ -1200,16 +1997,32 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
             await this.recalculateProductRisks(scope, 'CATALOG_CHANGED');
         if (entity === SanctionedCompanyRecord)
             await this.recalculateCompanyRisks(scope, 'CATALOG_CHANGED');
+        if (entity === ControlledGoodsRecord)
+            return controlledGoodsDto(row);
+        if (entity === SanctionedCompanyRecord)
+            return sanctionedCompanyDto(row);
         return row;
     }
     async listGeneratedFiles(scope, query = {}) { return this.pagedQuery(GeneratedSalesFile, scope, query, ['salesOrderNoSnapshot', 'documentNo', 'fileName'], { customerContractId: query.parameters?.customerContractId, purchaseOrderId: query.parameters?.purchaseOrderId, fileType: query.parameters?.fileType }); }
-    async settings(scope) {
+    async listMonthlyRates(scope, query = {}) {
+        const page = Math.max(1, Math.trunc(Number(query.page)) || 1);
+        const requestedPageSize = Number(query.pageSize);
+        const pageSize = [10, 20, 50, 100].includes(requestedPageSize) ? requestedPageSize : 20;
+        const [items, total] = await this.dataSource.getRepository(MonthlySafeExchangeRate).findAndCount({
+            where: { ...activeScope(scope), deletedAt: IsNull() },
+            order: { year: 'DESC', month: 'DESC' },
+            skip: (page - 1) * pageSize,
+            take: pageSize
+        });
+        return { items, total, page, pageSize, pageCount: Math.max(1, Math.ceil(total / pageSize)) };
+    }
+    async settings(scope, rateQuery = {}) {
         await this.bootstrapSettings(scope);
         const [profit, company, banks, rates] = await Promise.all([
             this.dataSource.getRepository(ProfitRuleSettings).findOne({ where: activeScope(scope) }),
             this.dataSource.getRepository(CompanySettings).findOne({ where: activeScope(scope) }),
             this.dataSource.getRepository(BankAccountSettings).find({ where: activeScope(scope), order: { bankType: 'ASC' } }),
-            this.dataSource.getRepository(MonthlySafeExchangeRate).find({ where: { ...activeScope(scope), deletedAt: IsNull() }, order: { year: 'DESC', month: 'DESC' } })
+            this.listMonthlyRates(scope, rateQuery)
         ]);
         return { company, banks, profit, rates };
     }
@@ -1485,7 +2298,7 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
                 await consume(row);
         });
     }
-    async recalculateProductRisks(scope, reason) {
+    async recalculateProductRisks(scope, reason, controlledBatchId) {
         return this.dataSource.transaction(async (manager) => {
             const matchRepo = manager.getRepository(ProductComplianceMatch);
             const lineRepo = manager.getRepository(PurchaseOrderLine);
@@ -1493,6 +2306,11 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
             if (this.dataSource.options?.type === 'postgres') {
                 await manager.query('SELECT pg_advisory_xact_lock(hashtext($1), hashtext($2))', [`trade-compliance:product-risk:${scope.tenantId}:${scope.organizationId}`, 'recalculate']);
             }
+            const controlledBatch = controlledBatchId
+                ? await required(manager.getRepository(ControlledCatalogBatch).findOne({ where: { ...activeScope(scope), id: controlledBatchId }, lock: { mode: 'pessimistic_write' } }), '管控目录批次不存在')
+                : null;
+            if (controlledBatch?.riskRecalculatedAt)
+                return { scanned: 0, matches: 0, riskRecalculatedAt: controlledBatch.riskRecalculatedAt };
             const lines = await lineRepo.find({
                 where: { ...activeScope(scope), deletedAt: IsNull() },
                 order: { id: 'ASC' },
@@ -1514,7 +2332,14 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
                 }
                 await lineRepo.update({ ...activeScope(scope), id: line.id, deletedAt: IsNull() }, { complianceCheckedAt: now, updatedById: scope.userId ?? null, updatedAt: now });
             }
-            return { scanned: lines.length, matches: await matchRepo.count({ where: { ...activeScope(scope), deletedAt: IsNull() } }) };
+            const matches = await matchRepo.count({ where: { ...activeScope(scope), deletedAt: IsNull() } });
+            if (controlledBatch) {
+                controlledBatch.riskRecalculatedAt = now;
+                controlledBatch.updatedById = scope.userId ?? null;
+                await manager.getRepository(ControlledCatalogBatch).save(controlledBatch);
+                return { scanned: lines.length, matches, riskRecalculatedAt: now };
+            }
+            return { scanned: lines.length, matches };
         });
     }
     async recalculateCompanyRisks(scope, reason) {
@@ -1769,12 +2594,21 @@ let TradeComplianceWorkbenchService = class TradeComplianceWorkbenchService {
             const startedAt = task.startedAt ?? task.queuedAt ?? task.createdAt;
             if (!startedAt || !importTaskTimedOut(startedAt, now))
                 continue;
-            task.status = 'TIMED_OUT';
-            task.errorCode = DomainErrorCodes.IMPORT_TIMED_OUT;
-            task.errorMessage = '文件解析超过 20 分钟，请重新上传';
-            task.completedAt = now;
-            task.machineElapsedMs = now.getTime() - startedAt.getTime();
-            await repo.save(task);
+            await this.dataSource.transaction(async (manager) => {
+                const lockedRepo = manager.getRepository(ImportTask);
+                const locked = await lockedRepo.findOne({ where: { ...activeScope(scope), id: task.id }, lock: { mode: 'pessimistic_write' } });
+                if (!locked || !RECOVERABLE_IMPORT_TASK_STATUSES.includes(locked.status))
+                    return;
+                const lockedStartedAt = locked.startedAt ?? locked.queuedAt ?? locked.createdAt;
+                if (!lockedStartedAt || !importTaskTimedOut(lockedStartedAt, now))
+                    return;
+                locked.status = 'TIMED_OUT';
+                locked.errorCode = DomainErrorCodes.IMPORT_TIMED_OUT;
+                locked.errorMessage = '文件解析超过 20 分钟，请重新上传';
+                locked.completedAt = now;
+                locked.machineElapsedMs = now.getTime() - lockedStartedAt.getTime();
+                await lockedRepo.save(locked);
+            });
         }
     }
     async countUnlinkedPurchases(scope) {
@@ -1798,11 +2632,75 @@ TradeComplianceWorkbenchService = __decorate([
     Injectable(),
     __param(0, InjectDataSource()),
     __param(1, Optional()),
+    __param(2, Optional()),
     __metadata("design:paramtypes", [DataSource,
-        TradeComplianceFileStorage])
+        TradeComplianceFileStorage,
+        TranslationProvider])
 ], TradeComplianceWorkbenchService);
 export { TradeComplianceWorkbenchService };
 function activeScope(scope) { return { tenantId: scope.tenantId, organizationId: scope.organizationId }; }
+function validateHandoffCallbackInput(input) {
+    if (input.kind !== 'stream' && input.kind !== 'complete' && input.kind !== 'error') {
+        throw new DomainError(DomainErrorCodes.INVALID_INPUT, 'Handoff 回调类型无效');
+    }
+    if (!Number.isInteger(input.sequence) || input.sequence <= 0) {
+        throw new DomainError(DomainErrorCodes.INVALID_INPUT, 'Handoff 回调序号无效');
+    }
+}
+function handoffCallbackIdentityMatches(input, expectedSourceMessageId, persistedTargetAssistantId) {
+    return input.sourceMessageId === expectedSourceMessageId &&
+        Boolean(persistedTargetAssistantId) &&
+        input.targetAssistantId === persistedTargetAssistantId;
+}
+async function lockOrganizationTaskClaim(manager, scope) {
+    await manager.query('SELECT pg_advisory_xact_lock(hashtext($1), hashtext($2))', [scope.tenantId, scope.organizationId]);
+}
+async function organizationHasActiveParsing(manager, scope) {
+    const activeImport = await manager.getRepository(ImportTask).findOne({
+        where: { ...activeScope(scope), status: In([...RUNNING_IMPORT_TASK_STATUSES]) },
+        order: { startedAt: 'ASC', id: 'ASC' },
+        lock: { mode: 'pessimistic_write' }
+    });
+    if (activeImport)
+        return true;
+    const activeRun = await manager.getRepository(CustomerContractAnalysisRun).findOne({
+        where: { ...activeScope(scope), status: 'RUNNING' },
+        order: { startedAt: 'ASC', id: 'ASC' },
+        lock: { mode: 'pessimistic_write' }
+    });
+    return Boolean(activeRun);
+}
+function assertImportTaskResultWritable(task) {
+    if (TERMINAL_IMPORT_TASK_STATUSES.includes(task.status)) {
+        throw new DomainError(DomainErrorCodes.INVALID_INPUT, '解析任务状态不允许保存结果');
+    }
+}
+function throwImportTaskTerminalState(task) {
+    const message = task.status === 'FAILED' || task.status === 'TIMED_OUT'
+        ? task.errorMessage || '解析任务未成功完成'
+        : '解析任务状态不允许保存结果';
+    throw new DomainError(DomainErrorCodes.INVALID_INPUT, message, { status: task.status, errorCode: task.errorCode });
+}
+function cancellableDelay(ms, signal) {
+    if (signal.aborted)
+        return Promise.resolve(false);
+    return new Promise(resolve => {
+        let settled = false;
+        const finish = (elapsed) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            signal.removeEventListener('abort', onAbort);
+            resolve(elapsed);
+        };
+        const onAbort = () => finish(false);
+        const timeout = setTimeout(() => finish(true), ms);
+        signal.addEventListener('abort', onAbort, { once: true });
+        if (signal.aborted)
+            onAbort();
+    });
+}
 function isPostgresUniqueViolation(error) {
     if (!error || typeof error !== 'object')
         return false;
@@ -1834,6 +2732,17 @@ async function lockCustomerContractReanalysis(manager, scope, id) {
 function lockedCurrentReanalysisRunId(locked) {
     return locked.contract?.currentReanalysisRunId ?? locked.task?.currentReanalysisRunId ?? null;
 }
+async function clearCurrentReanalysis(manager, locked) {
+    const { run, contract, task } = locked;
+    if (contract?.currentReanalysisRunId === run.id) {
+        contract.currentReanalysisRunId = null;
+        await manager.getRepository(CustomerContract).save(contract);
+    }
+    if (task?.currentReanalysisRunId === run.id) {
+        task.currentReanalysisRunId = null;
+        await manager.getRepository(ImportTask).save(task);
+    }
+}
 async function timeoutCustomerContractReanalysis(manager, locked, now = new Date()) {
     const { run, contract, task } = locked;
     if (run.status !== 'PENDING' && run.status !== 'RUNNING')
@@ -2086,6 +2995,11 @@ function completeCustomerClauseAnalyses(draft) {
         return analysis;
     });
 }
+function snapshotMissingRecoveryMetadataStillMissing(snapshot, current) {
+    const missingFields = ['claimAttemptToken', 'startedAt', 'commandDispatchedAt']
+        .filter(field => !snapshot[field]);
+    return missingFields.length > 0 && missingFields.every(field => !current[field]);
+}
 function requiredId(value, label) { const id = String(value ?? '').trim(); if (!id)
     throw new DomainError(DomainErrorCodes.INVALID_INPUT, `缺少${label}`); return id; }
 function assertCompleteClauseAnalyses(analyses) {