diff --git a/backend-java/src/main/java/com/nanri/aiimage/common/retry/CredentialFatalClassifier.java b/backend-java/src/main/java/com/nanri/aiimage/common/retry/CredentialFatalClassifier.java new file mode 100644 index 000000000..4078743c7 --- /dev/null +++ b/backend-java/src/main/java/com/nanri/aiimage/common/retry/CredentialFatalClassifier.java @@ -0,0 +1,151 @@ +package com.nanri.aiimage.common.retry; + +import com.nanri.aiimage.modules.brand.support.BrandCheckFailureNotice; +import com.nanri.aiimage.modules.task.service.TaskRetryEligibility; + +import java.util.List; +import java.util.Locale; + +/** + * 「凭据坏了、再跑多少次都是同一个结果」这一类失败的唯一判据,以及该给用户看的那句动作。 + * + *
用户口径(2026-11-12,34061 取证后):任何特性只要用到 LLM 密钥或代理 IP,遇到不可自愈的 + * 凭据故障都必须三件事一起做——行落失败并写真实原因、任务立即中断为终态、用户端弹窗一次。 + * 判据只此一处:外观专利、货源查询、跟价、店铺采集、采集数据都从这里取,不各自抄一份字面量表 + * (抄了就会改一处静默失效,与 {@link TaskRetryEligibility} 的注释同一条理由)。 + * + *
代理侧的分档不另立词汇表:{@link BrandCheckFailureNotice} 已经按"未配置 / 套餐耗尽 / + * 冷却 / 出口被拒 / 技术性 / 上游"六档分过品牌检测的原始原因(2026-10-20 起就是那张表)。 + * 这里只认它的前两档为致命,后四档一律继续重试——冷却与出口被拒是短时现象、上游不可用会自己恢复, + * 拿它们判死就是让用户整单给一次抖动陪葬(铁律 27(c))。 + * + *
LLM 那半边走 {@link TaskRetryEligibility.Category#BALANCE}(欠费与密钥失效同族)。 + * LLM 专属字样先于品牌侧判:品牌侧的「余额不足」与 LLM 的「余额欠费」都落在同一批中文词上, + * 顺序反了就会把"代理套餐没钱了"说成"上游 LLM 账户欠费"——2026-10-27 用户点名要避免的那种误导。 + */ +public final class CredentialFatalClassifier { + + /** 凭据故障的两种来源:给用户的那句动作不同。 */ + public enum Kind { + /** 上游 LLM 账户欠费/额度耗尽,或 LLM 密钥本身失效。 */ + LLM_CREDENTIAL, + /** 代理提取:套餐到期、余额不足、密钥/链接不可用,或根本没配置。 */ + PROXY_CREDENTIAL + } + + /** + * LLM 侧「钱/密钥」硬字样:与 {@code LlmBalanceGuard} 的余额识别、{@code TaskRetryEligibility.KEY_MARKERS} + * 同一套词,加 {@code 余额欠费}/{@code 额度不足} 这两个中文签。 + * + *
刻意不收裸「llm」或裸「余额不足」:任何一条 LLM 报错都带 {@code LLM} 三个字母
+ * ({@code LLM 网关无应答}、{@code LLM http 502}),拿它当凭据判据会把一次抖动判成终态;
+ * 「余额不足」是品牌侧套餐与 LLM 侧欠费共用的词,得靠品牌词汇表先分档。
+ */
+ private static final List 必须先于 {@link BrandCheckFailureNotice} 判:青果的 {@code API_AUTH_DENY} 常和「提取失败」
+ * 出现在同一句里,而品牌侧把「提取失败」归 TECHNICAL(补测轮会再来)——顺序反了,
+ * 一条注定失败的鉴权错就被说成"技术性失败、等等再试"。
+ */
+ private static final List 刻意不放裸数字(429/502/503/504):上游欠费原文里带着账户号({@code 用户[151502]}),
+ * 裸 {@code contains("502")} 会把一条真欠费判成 5xx 抖动——放过这一单,用户就又回到"只见失败、不见原因"。
+ */
+ private static final List 刻意只取 {@code BALANCE}:连接不可达({@code SERVICE_DOWN})、429 限流、5xx 抖动、
- * 抓取缺口都属「外部会自己恢复或补传能救」,判宽了就是拿用户的任务给一次网络抖动陪葬。
+ * 刻意放行连通性失败({@code SERVICE_DOWN})、429 限流、5xx 抖动、通道被占、风控墙与抓取缺口:
+ * 它们属「外部会自己恢复或补传能救」,判宽了就是拿用户的任务给一次网络抖动陪葬。
*/
- static boolean isFatalLlmArrearsFailure(String errorMessage) {
- return TaskRetryEligibility.forceMajeureCategory(errorMessage) == TaskRetryEligibility.Category.BALANCE;
+ static boolean isFatalCredentialFailure(String errorMessage) {
+ return CredentialFatalClassifier.isFatal(errorMessage);
}
/**
- * 上游余额欠费/密钥失效 → 任务立即落终态 FAILED。
+ * 凭据不可自愈 → 任务立即落终态 FAILED。
*
* 为什么必须由 Java 侧落终态(2026-10-27 现网):{@code f3445c21} 只做到「行级不再重试三次、
* 归因写对」,任务本身仍停在 RUNNING/WAIT_LLM 等 Python 继续回传分片。采集端
@@ -286,46 +289,14 @@ public class AppearancePatentResultJobSupport {
*
* 判定发生在作业执行线程(LLM 批次就在这里跑),不在心跳线程(铁律 8)。
* 写之前重读一次库里的现状态:已 SUCCESS/COMPLETED/CANCELLED/FAILED 的一律不动(铁律 14),
- * 本方法因此可重入,停放期间同一任务被多个入口命中欠费也只写一次。
+ * 落库与文案在 {@link CredentialFatalTaskCloser},本方法因此可重入。
*/
public void terminalizeOnFatalLlmFailure(FileTaskEntity task, String failureMessage) {
- if (task == null || task.getId() == null) {
- return;
- }
- if (!isFatalLlmArrearsFailure(failureMessage)) {
- // 兜底闸:调用方判宽了也不许把可恢复的失败写成终态
- return;
- }
- FileTaskEntity current = fileTaskMapper.selectById(task.getId());
- String currentStatus = current != null ? current.getStatus() : task.getStatus();
- if (TaskStatuses.FileTask.TERMINAL.contains(currentStatus)) {
- log.info("[appearance-patent] 任务已是终态,欠费归因不改写状态 taskId={} status={}",
- task.getId(), currentStatus);
- return;
- }
- String terminalMessage = fatalLlmTerminalMessage(failureMessage);
- task.setStatus(STATUS_FAILED);
- task.setSuccessFileCount(0);
- task.setFailedFileCount(1);
- task.setErrorMessage(terminalMessage);
- task.setFailureCategory(TaskFailureLedger.categoryOf(task.getErrorMessage()));
- task.setUpdatedAt(LocalDateTime.now());
- task.setFinishedAt(LocalDateTime.now());
- fileTaskMapper.updateById(task);
- taskCacheService.deleteTaskCache(task.getId());
- log.warn("[appearance-patent] LLM 上游欠费/密钥失效,任务落终态 FAILED 以停止为空转的行继续买出口 IP"
- + " taskId={} err={}", task.getId(), terminalMessage);
+ credentialFatalCloser().closeIfFatal(task, failureMessage);
}
- /**
- * 终态文案 = 生产者原文(客户端的欠费归因 + 上游 lastErr)+ 可执行动作,
- * 原文一个字都不在这里重写;文案里没有「稍后重试」,欠费不会被说成抖动。
- */
- static String fatalLlmTerminalMessage(String failureMessage) {
- String raw = failureMessage == null ? "" : failureMessage.trim();
- return raw.isEmpty()
- ? LlmBalanceGuard.TASK_TERMINAL_GUIDANCE
- : raw + ";" + LlmBalanceGuard.TASK_TERMINAL_GUIDANCE;
+ private CredentialFatalTaskCloser credentialFatalCloser() {
+ return new CredentialFatalTaskCloser(LOG_TAG, fileTaskMapper, taskCacheService::deleteTaskCache);
}
public FileResultEntity findOrCreateResultRecordForAssembly(FileTaskEntity task, int rowCount) {
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/support/AppearancePatentRowOutcome.java b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/support/AppearancePatentRowOutcome.java
index 2391e9e47..5b046344e 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/support/AppearancePatentRowOutcome.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/support/AppearancePatentRowOutcome.java
@@ -44,6 +44,20 @@ public final class AppearancePatentRowOutcome {
public static final String NO_DATA_TEXT = "该行未采集到数据(标题与图片都没有),无法检测";
+ /**
+ * 「这一格不是判定,而是没判成」的三族文案(唯一定义处,客户端与出表侧都引这里)。
+ *
+ * 2026-11-12 任务 34061:上游 LLM 余额见底,外观维一步都没发出去,但这三族文案此前都被
+ * {@link #isUsableField} 当成「有结论」——覆盖率算满、状态列还可能写「成功」(回退行拿整条标题
+ * 去品牌库蒙到一个「侵权」)。用户口径:没跑就是没跑,行必须是失败。
+ */
+ /** 商标维查询失败(含整批不可用的长文案),前缀保持不变:状态列与补检都按它判。 */
+ public static final String BRAND_QUERY_FAILED = "商标查询失败";
+ /** 我们根本没发出图片请求时的外观维标签。 */
+ public static final String APPEARANCE_NOT_RUN = "未执行外观检测";
+ /** 请求发出去了、上游没给出可用结论。 */
+ public static final String APPEARANCE_ANOMALY = "外观识别异常";
+
private AppearancePatentRowOutcome() {
}
@@ -65,7 +79,27 @@ public final class AppearancePatentRowOutcome {
public static boolean isUsableField(String value) {
String normalized = AppearancePatentSheetBuilder.normalize(value);
- return !normalized.isBlank() && !AppearancePatentSheetBuilder.isTechnicalLlmFailure(normalized);
+ return !normalized.isBlank()
+ && !AppearancePatentSheetBuilder.isTechnicalLlmFailure(normalized)
+ && !isNoVerdictText(normalized);
+ }
+
+ /**
+ * 这一格是不是「没判成」而不是判定:商标查询失败、外观没跑、外观异常、未取得结果、未完成检测。
+ *
+ * 单独成方法是为了让"覆盖率算不算这行"与"状态列写不写成功"共用同一句话,
+ * 而不是两处各写一遍字面量(34061 里两处就各判各的:覆盖率算满,状态列写成功)。
+ */
+ public static boolean isNoVerdictText(String value) {
+ String normalized = AppearancePatentSheetBuilder.normalize(value);
+ if (normalized.isBlank()) {
+ return true;
+ }
+ return normalized.contains(BRAND_QUERY_FAILED)
+ || normalized.contains(APPEARANCE_NOT_RUN)
+ || normalized.contains(APPEARANCE_ANOMALY)
+ || normalized.contains(AppearancePatentSheetBuilder.NO_RESULT_TEXT)
+ || normalized.contains(NOT_INSPECTED_TEXT);
}
/**
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/support/AppearancePatentSheetBuilder.java b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/support/AppearancePatentSheetBuilder.java
index 48af18fec..0d2e6052d 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/support/AppearancePatentSheetBuilder.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/support/AppearancePatentSheetBuilder.java
@@ -126,7 +126,7 @@ public final class AppearancePatentSheetBuilder {
row.createCell(col++).setCellValue(titleRiskCell);
row.createCell(col++).setCellValue(appearanceRiskCell);
row.createCell(col++).setCellValue(conclusionCell);
- row.createCell(col).setCellValue(resolveResultStatus(conclusionCell));
+ row.createCell(col).setCellValue(resolveResultStatus(conclusionCell, appearanceRiskCell));
}
writeReasonSheet(workbook, headerStyle, rowsToWrite, resultMap, finder);
}
@@ -294,8 +294,29 @@ public final class AppearancePatentSheetBuilder {
* 历史缺陷:曾按「结论非空即成功」,于是结论列写着"商标查询失败"、状态列却写"成功"。
* 带 {@link #PENDING_REVIEW_SUFFIX} 的结论含「侵权」二字,必须排在字面判定之前判掉,
* 否则「外观无侵权·商标待复核」会被读成成功。
+ *
+ * 单参版本只看结论串,保留给只拿到结论的历史调用方与单测;出表侧走
+ * {@link #resolveResultStatus(String, String)},多读一眼外观维(34061 那 158 行就是这么漏的)。
*/
public static String resolveResultStatus(String conclusion) {
+ return resolveResultStatus(conclusion, null);
+ }
+
+ /**
+ * 状态列口径(带外观维读数):外观检测压根没跑的行不许写「成功」。
+ *
+ * 2026-11-12 任务 34061 的反面样本:上游 LLM 余额见底,外观维一步都没发出去,
+ * 但回退路拿整条原始标题去品牌库查了一次,命中「阿凡达」的行 titleRisk=侵权 ⇒ 结论列=侵权,
+ * 状态列于是写成「成功」——1000 行里有 158 行是"图片识别一次没做却显示成功"。
+ * 结论列含「侵权」是必要不充分条件:外观维必须真的给出过判定(不是「未执行外观检测」/
+ * 「外观识别异常」/「未取得检测结果」/技术性失败)。
+ *
+ * @param appearanceRisk 外观维格子最终写给用户的那串字;null=调用方只给结论(历史单参口径)
+ */
+ public static String resolveResultStatus(String conclusion, String appearanceRisk) {
+ if (appearanceRisk != null && !hasAppearanceVerdict(appearanceRisk)) {
+ return "失败";
+ }
String normalized = conclusion == null ? "" : conclusion.trim();
if (normalized.isBlank() || isTechnicalLlmFailure(normalized)) {
return "失败";
@@ -306,6 +327,14 @@ public final class AppearancePatentSheetBuilder {
return normalized.contains("侵权") ? "成功" : "失败";
}
+ /** 外观维有没有真的判过:判据在 {@link AppearancePatentRowOutcome#isNoVerdictText},与覆盖率同一句话。 */
+ public static boolean hasAppearanceVerdict(String appearanceRisk) {
+ String normalized = normalize(appearanceRisk);
+ return !normalized.isBlank()
+ && !isTechnicalLlmFailure(normalized)
+ && !AppearancePatentRowOutcome.isNoVerdictText(normalized);
+ }
+
/**
* 只按当前直连 LLM 客户端会写入的文案判定技术性失败。早期 Coze 工作流特征串已随直连改造移除:
* 按 "coze" 子串匹配会把品牌词 "Cozee Bay" 误判成调用失败,真结论被清空。
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/service/CollectDataService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/service/CollectDataService.java
index a764a85e2..abeb41fa8 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/service/CollectDataService.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/service/CollectDataService.java
@@ -63,6 +63,8 @@ import com.nanri.aiimage.modules.task.model.entity.TaskChunkEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskFileJobEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskResultItemEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskScopeStateEntity;
+import com.nanri.aiimage.common.retry.CredentialFatalClassifier;
+import com.nanri.aiimage.modules.task.service.CredentialFatalTaskCloser;
import com.nanri.aiimage.modules.task.service.TaskDistributedLockService;
import com.nanri.aiimage.modules.task.service.TaskFileJobService;
import com.nanri.aiimage.modules.task.service.TaskHeartbeatPositionService;
@@ -979,6 +981,15 @@ public class CollectDataService extends AbstractFileTaskPipeline 为什么不能只留下 `brandQueryFailedCount` 让它跑成成功:2026-11-12 的用户口径是
+ * 「没余额要退成失败」——那一整批行既不进结果也不算无效品牌,用户拿到的是一张空表 +
+ * 一句「会在补测轮重试」,而补测轮对配置类原因重跑一万次都一样(现网 32573 两轮 0 净增)。
+ * 判据共用 {@link CredentialFatalClassifier};冷却/出口被拒/上游不可用照旧只补测不判死。
+ *
+ * @return true=本次已把任务写成终态
+ */
+ private boolean closeOnFatalCredential(FileTaskEntity task, String rawReason) {
+ CredentialFatalClassifier.Kind kind = CredentialFatalClassifier.kind(rawReason);
+ if (kind == null) {
+ return false;
+ }
+ log.warn("[collect-data] 品牌检测命中凭据不可自愈({}),整单改判死 taskId={} reason={}",
+ kind, task.getId(), rawReason);
+ return new CredentialFatalTaskCloser("collect-data", fileTaskMapper, null)
+ .close(task, rawReason, kind);
+ }
+
private CollectDataSubmitResultVo buildSubmitVo(FileTaskEntity task,
FileResultEntity result,
int chunkIndex,
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/pricetrack/service/PriceTrackTaskService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/pricetrack/service/PriceTrackTaskService.java
index fbbcd9fdd..0eb5f2303 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/pricetrack/service/PriceTrackTaskService.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/pricetrack/service/PriceTrackTaskService.java
@@ -33,6 +33,8 @@ import com.nanri.aiimage.modules.task.model.entity.FileResultEntity;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskFileJobEntity;
import com.nanri.aiimage.modules.task.service.AbstractModuleTaskCacheService;
+import com.nanri.aiimage.common.retry.CredentialFatalClassifier;
+import com.nanri.aiimage.modules.task.service.CredentialFatalTaskCloser;
import com.nanri.aiimage.modules.task.service.TaskDistributedLockService;
import com.nanri.aiimage.modules.task.service.TaskFileJobService;
import com.nanri.aiimage.modules.task.service.TaskFinalizeSupport;
@@ -2216,6 +2218,15 @@ public class PriceTrackTaskService extends AbstractShopPayloadTaskPipeline 为什么不能只靠上面那个行级 {@code error}:凭据不可自愈(未配置代理/套餐到期/LLM 欠费)
+ * 是整单判死(2026-11-12 铁律 29),收口器只写 {@code biz_file_task.error_message},
+ * 每个店铺行本身没有被标失败。没有这个字段,用户端在终态那刻拿不到任何原因,
+ * 「已中断」就变成一句话都不说的静默失败。
+ */
+ @Schema(description = "任务级失败原因(整单判死时为那句话,截断 300 字);任务未失败时为空", example = "任务已终止:代理 IP 套餐已到期…")
+ private String taskErrorMessage;
+
@Schema(description = "结果记录创建时间,ISO 本地日期时间", example = "2026-07-25T10:00:00")
private LocalDateTime createdAt;
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/shopdatacrawl/service/ShopDataCrawlTaskService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/shopdatacrawl/service/ShopDataCrawlTaskService.java
index a9528dfa8..212cda7a3 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/shopdatacrawl/service/ShopDataCrawlTaskService.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/shopdatacrawl/service/ShopDataCrawlTaskService.java
@@ -41,6 +41,8 @@ import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskFileJobEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskScopeStateEntity;
import com.nanri.aiimage.modules.task.service.AbstractModuleTaskCacheService;
+import com.nanri.aiimage.common.retry.CredentialFatalClassifier;
+import com.nanri.aiimage.modules.task.service.CredentialFatalTaskCloser;
import com.nanri.aiimage.modules.task.service.TaskDistributedLockService;
import com.nanri.aiimage.modules.task.service.TaskFileJobService;
import com.nanri.aiimage.modules.task.service.TaskFinalizeSupport;
@@ -102,6 +104,8 @@ public class ShopDataCrawlTaskService extends AbstractFileTaskPipeline 为什么必须由 Java 侧落终态:{@code maixiang similar_worker} 只看 {@code /task/heartbeat} 的
* {@code alive}({@code similar_worker.py:249}),任务还停在 RUNNING 它就看不到判决,会继续为
* 永远进不了 LLM 的行按次付费买出口 IP。任务一终态,{@code TaskHeartbeatService} 才对该任务
* 回 {@code alive=false},worker 下一跳收手。
*
- * 判据只取 {@link TaskRetryEligibility.Category#BALANCE}(欠费与 LLM 密钥失效同族,复用既有唯一
- * 判据、不抄第二份字面量表):连接不可达(SERVICE_DOWN)、429 限流、5xx 抖动、抓取缺口都属
- * "外部会自己恢复或补传能救",判宽了就是拿用户的整单给一次网络抖动陪葬。写之前重读库里现状态,
- * 已终态的一律不动(铁律 14),本方法因此可重入。
+ * 判据在 {@link CredentialFatalClassifier}(唯一出处),落库与文案在
+ * {@link CredentialFatalTaskCloser};连接不可达、429 限流、5xx 抖动、通道被占、抓取缺口都属
+ * "外部会自己恢复或补传能救",不会被判死。写之前重读库里现状态,已终态的一律不动(铁律 14),
+ * 本方法因此可重入。
*/
@Override
public void terminalizeOnFatalLlmFailure(FileTaskEntity task, String failureMessage) {
- if (task == null || task.getId() == null) {
- return;
- }
- if (TaskRetryEligibility.forceMajeureCategory(failureMessage) != TaskRetryEligibility.Category.BALANCE) {
- return;
- }
- FileTaskEntity current = fileTaskMapper.selectById(task.getId());
- String currentStatus = current != null ? current.getStatus() : task.getStatus();
- if (TaskStatuses.FileTask.TERMINAL.contains(currentStatus)) {
- log.info("[similar-asin] 任务已是终态,欠费归因不改写状态 taskId={} status={}", task.getId(), currentStatus);
- return;
- }
- String raw = failureMessage == null ? "" : failureMessage.trim();
- task.setStatus(STATUS_FAILED);
- task.setSuccessFileCount(0);
- task.setFailedFileCount(1);
- // 生产者原文一个字都不在这里重写(支持同学要对着上游响应体查根因);界面上那句中文由
- // TaskVisibleFailureNotice 在出口处给,英文原文与上游账户号不进界面。
- String terminalText = raw.isEmpty()
- ? LlmBalanceGuard.TASK_TERMINAL_GUIDANCE
- : raw + ";" + LlmBalanceGuard.TASK_TERMINAL_GUIDANCE;
- task.setErrorMessage(terminalText);
- task.setFailureCategory(TaskFailureLedger.categoryOf(terminalText));
- task.setUpdatedAt(LocalDateTime.now());
- task.setFinishedAt(LocalDateTime.now());
- fileTaskMapper.updateById(task);
- taskCacheService.deleteTaskCache(task.getId());
- log.warn("[similar-asin] LLM 上游欠费/密钥失效,任务落终态 FAILED 以停止为空转的行继续买出口 IP"
- + " taskId={} err={}", task.getId(), task.getErrorMessage());
+ new CredentialFatalTaskCloser(LOG_TAG, fileTaskMapper, taskCacheService::deleteTaskCache)
+ .closeIfFatal(task, failureMessage);
}
@Override
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/service/support/SimilarAsinResultTextSupport.java b/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/service/support/SimilarAsinResultTextSupport.java
index c33ccd773..21b2141e4 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/service/support/SimilarAsinResultTextSupport.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/service/support/SimilarAsinResultTextSupport.java
@@ -1,6 +1,7 @@
package com.nanri.aiimage.modules.similarasin.service.support;
import com.nanri.aiimage.modules.similarasin.model.dto.SimilarAsinResultRowDto;
+import com.nanri.aiimage.common.retry.CredentialFatalClassifier;
import java.util.ArrayList;
import java.util.Collection;
@@ -152,6 +153,12 @@ public final class SimilarAsinResultTextSupport {
if (row == null) {
return "失败";
}
+ // 凭据不可自愈(LLM 欠费/密钥失效、代理套餐/链接不可用):图片采到了也没判过,
+ // 行必须是失败并带上真因——2026-11-12 用户口径「没余额要退成失败」。排在图片判定之前,
+ // 否则采集端拿到的货源图会把一行"从没检测过"的行染成成功。
+ if (CredentialFatalClassifier.isFatal(row.getError()) || CredentialFatalClassifier.isFatal(row.getReason())) {
+ return "失败";
+ }
if (hasText(row.getMainUrl()) || hasText(row.getPuzzleImg1()) || hasText(row.getPuzzleImg2())) {
return "成功";
}
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/CredentialFatalTaskCloser.java b/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/CredentialFatalTaskCloser.java
new file mode 100644
index 000000000..4af572173
--- /dev/null
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/CredentialFatalTaskCloser.java
@@ -0,0 +1,103 @@
+package com.nanri.aiimage.modules.task.service;
+
+import com.nanri.aiimage.common.retry.CredentialFatalClassifier;
+import com.nanri.aiimage.common.task.TaskStatuses;
+import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
+import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
+import com.nanri.aiimage.modules.task.service.support.TaskFailureLedger;
+import lombok.extern.slf4j.Slf4j;
+
+import java.time.LocalDateTime;
+import java.util.function.LongConsumer;
+
+/**
+ * 凭据不可自愈(LLM 欠费/密钥失效、代理套餐/链接不可用)→ 任务立即落终态 FAILED。
+ *
+ * 为什么必须由 Java 侧落终态(2026-10-27 外观专利、2026-10-31 货源查询两笔现网的共同结论):
+ * 采集端只看 {@code /task/heartbeat} 的 {@code alive},看不到终态就会继续为那些永远进不了 LLM
+ * 的行按次付费买出口 IP。任务一终态,心跳对其返回 {@code alive=false},worker 下一跳收手。
+ * 2026-11-12 用户据此把这条从"外观专利/货源查询两步"扩成"所有涉及 LLM 密钥与代理 IP 的特性"。
+ *
+ * 判据与文案都从 {@link CredentialFatalClassifier} 取,本类只管"写下去"这一件事:
+ * 重读库里现状态(已终态的一律不动,铁律 14,因此可重入)、置 FAILED/successFileCount=0/
+ * failedFileCount=1/errorMessage/failureCategory/finishedAt、清模块缓存。
+ *
+ * 无状态、按调用现取(与外观专利 {@code resultJobSupport()} 同一先例):缓存清理是模块自己的事,
+ * 由调用方以 {@code cacheEvictor} 交进来,不在这个类里认任何一个模块的缓存实现。
+ */
+@Slf4j
+public final class CredentialFatalTaskCloser {
+
+ private static final String STATUS_FAILED = TaskStatuses.FileTask.FAILED;
+
+ private final String logTag;
+ private final FileTaskMapper fileTaskMapper;
+ private final LongConsumer cacheEvictor;
+
+ /**
+ * @param logTag 模块日志前缀(如 {@code appearance-patent}),与各面既有日志同形
+ * @param cacheEvictor 模块任务缓存清理;没有就传 null
+ */
+ public CredentialFatalTaskCloser(String logTag, FileTaskMapper fileTaskMapper, LongConsumer cacheEvictor) {
+ this.logTag = logTag;
+ this.fileTaskMapper = fileTaskMapper;
+ this.cacheEvictor = cacheEvictor;
+ }
+
+ /**
+ * 判据+落终态一步到位。
+ *
+ * @return true=本次真的把任务写成了终态;false=不致命或库里已是终态
+ */
+ public boolean closeIfFatal(FileTaskEntity task, String failureMessage) {
+ CredentialFatalClassifier.Kind kind = CredentialFatalClassifier.kind(failureMessage);
+ return kind != null && close(task, failureMessage, kind);
+ }
+
+ /**
+ * 已确定档位时直接落终态(调用方自己已经判过,避免同一句话判两遍)。
+ */
+ public boolean close(FileTaskEntity task, String failureMessage, CredentialFatalClassifier.Kind kind) {
+ if (task == null || task.getId() == null) {
+ return false;
+ }
+ if (kind == null) {
+ // 兜底闸:调用方判宽了也不许把可恢复的失败写成终态
+ return false;
+ }
+ FileTaskEntity current = fileTaskMapper.selectById(task.getId());
+ String currentStatus = current != null ? current.getStatus() : task.getStatus();
+ // 空状态的实体(测试/未落库形状)没有终态可言;TERMINAL 是不可变 Set,contains(null) 直接 NPE
+ if (currentStatus != null && TaskStatuses.FileTask.TERMINAL.contains(currentStatus)) {
+ log.info("[{}] 任务已是终态,凭据归因不改写状态 taskId={} status={}", logTag, task.getId(), currentStatus);
+ return false;
+ }
+ String terminalMessage = terminalMessage(failureMessage, kind);
+ task.setStatus(STATUS_FAILED);
+ task.setSuccessFileCount(0);
+ task.setFailedFileCount(1);
+ task.setErrorMessage(terminalMessage);
+ task.setFailureCategory(TaskFailureLedger.categoryOf(terminalMessage));
+ LocalDateTime now = LocalDateTime.now();
+ task.setUpdatedAt(now);
+ task.setFinishedAt(now);
+ fileTaskMapper.updateById(task);
+ if (cacheEvictor != null) {
+ cacheEvictor.accept(task.getId());
+ }
+ log.warn("[{}] 凭据不可自愈({}),任务落终态 FAILED 以停止为空转的行继续买出口 IP"
+ + " taskId={} err={}", logTag, kind, task.getId(), terminalMessage);
+ return true;
+ }
+
+ /**
+ * 终态文案 = 生产者原文(支持同学要对着上游响应体查根因)+ 可执行动作。
+ * 原文一个字都不在这里重写;文案里没有「稍后重试」,欠费不会被说成抖动。
+ * 界面那一层由 {@link TaskVisibleFailureNotice} 换成纯中文动作句(原文里的账户号与余额不进界面)。
+ */
+ public static String terminalMessage(String failureMessage, CredentialFatalClassifier.Kind kind) {
+ String raw = failureMessage == null ? "" : failureMessage.trim();
+ String guidance = CredentialFatalClassifier.guidance(kind);
+ return raw.isEmpty() ? guidance : raw + ";" + guidance;
+ }
+}
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/TaskRetryEligibility.java b/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/TaskRetryEligibility.java
index e94107fe6..1ccef5eb4 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/TaskRetryEligibility.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/TaskRetryEligibility.java
@@ -50,11 +50,20 @@ public final class TaskRetryEligibility {
}
}
- /** 余额/套餐类:覆盖 jikip 代理与 LLM 中转两种欠费文案。 */
+ /**
+ * 余额/套餐类:覆盖 jikip 代理与 LLM 中转两种欠费文案。
+ *
+ * 2026-11-12 补三族:① 钱包型欠费({@code insufficient_funds} / {@code wallet balance insufficient},
+ * 2026-11-11 现网形状,{@code LlmBalanceGuard} 已认、这里漏了,自动重试会照跑);② 代理套餐
+ * {@code 套餐到期};③ 根本没配代理(品牌检测回的原文,见 {@code BrandCheckClient.NO_PROXY_REASON})——
+ * 这三族都是「不修外部条件、重跑必然同结果」,放进本类才不会被 {@code TaskResumeService} 反复复位。
+ */
private static final List 收尾路径拿它决定「新文案能不能覆盖旧结论」:欠费判死的单后来被一次带空错误串的收尾
* 盖掉,界面上就又回到「只见失败、不见原因」,采集端也会以为这单还能跑。
@@ -60,8 +67,8 @@ public final class TaskVisibleFailureNotice {
}
/**
- * 这条库里原文是不是本仓自己写下的 LLM 欠费/密钥失效归因(生产者句 {@code REASON_LLM_BALANCE_DUE}
- * 或终态句 {@code TASK_TERMINAL_GUIDANCE} 命中其一)。
+ * 这条库里原文是不是本仓自己写下的凭据终态结论(LLM 那两句 {@code REASON_LLM_BALANCE_DUE} /
+ * {@code TASK_TERMINAL_GUIDANCE},或代理那句 {@code PROXY_TERMINAL_GUIDANCE})。
*
* 刻意不用 {@link TaskRetryEligibility.Category#BALANCE} 当这里的判据:那一类还涵盖
* jikip 代理 IP欠费与套餐过期("余额不足"/"套餐不存在"),拿它换句子会把"代理出口没钱了"
@@ -73,7 +80,8 @@ public final class TaskVisibleFailureNotice {
return false;
}
return errorMessage.contains(LlmBalanceGuard.REASON_LLM_BALANCE_DUE)
- || errorMessage.contains(LlmBalanceGuard.TASK_TERMINAL_GUIDANCE);
+ || errorMessage.contains(LlmBalanceGuard.TASK_TERMINAL_GUIDANCE)
+ || errorMessage.contains(CredentialFatalClassifier.PROXY_TERMINAL_GUIDANCE);
}
private static String trimToNull(String value) {
diff --git a/backend-java/src/test/java/com/nanri/aiimage/common/retry/CredentialFatalClassifierTest.java b/backend-java/src/test/java/com/nanri/aiimage/common/retry/CredentialFatalClassifierTest.java
new file mode 100644
index 000000000..dca98bb50
--- /dev/null
+++ b/backend-java/src/test/java/com/nanri/aiimage/common/retry/CredentialFatalClassifierTest.java
@@ -0,0 +1,168 @@
+package com.nanri.aiimage.common.retry;
+
+import com.nanri.aiimage.modules.brand.client.BrandCheckClient;
+import com.nanri.aiimage.modules.task.service.TaskResumeService;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * 凭据致命档的判据台账(2026-11-12,34061 取证后用户口径)。
+ *
+ * 这一档决定三件事:行落失败并写真实原因、任务立即中断、用户端弹窗。判宽了用户整单给一次
+ * 网络抖动陪葬;判窄了 34061 那种"余额见底 → 整单跑完 → 交付表只有一句没头没脑的异常"就会重演。
+ * 所以两条边界都要有正本:
+ * 2026-11-12 任务 34061 里三处各判各的——覆盖率算满(这三族被当"有结论")、
+ * 状态列还可能写「成功」——用户口径是「没余额要退成失败」,所以三处必须同一句话。
+ */
+ @Test
+ void credentialFailureTextsAreNotJudgements() {
+ for (String text : java.util.List.of(
+ AppearancePatentRowOutcome.BRAND_QUERY_FAILED,
+ AppearancePatentRowOutcome.BRAND_QUERY_FAILED + ":品牌库上游整体不可用",
+ AppearancePatentRowOutcome.APPEARANCE_NOT_RUN,
+ AppearancePatentRowOutcome.APPEARANCE_ANOMALY,
+ AppearancePatentSheetBuilder.NO_RESULT_TEXT,
+ AppearancePatentRowOutcome.NOT_INSPECTED_TEXT)) {
+ assertTrue(AppearancePatentRowOutcome.isNoVerdictText(text), "应判为没结论: " + text);
+ assertFalse(AppearancePatentRowOutcome.isUsableField(text), "不许算进已判: " + text);
+ }
+ }
+
+ /** 回退行:商标维命中、外观维没跑 → 不算判定(覆盖率掉下去),而不是"齐了"。 */
+ @Test
+ void fallbackRowWithOnlyBrandHitIsNotJudged() {
+ AppearancePatentParsedRowVo parsed = sheetRowWithData("1", "B0A", "阿凡达 玩具", "https://img/1.jpg");
+ AppearancePatentResultRowDto row = judgedRow("1", "B0A", "阿凡达 玩具", "https://img/1.jpg");
+ row.setTitleRisk("侵权");
+ row.setAppearanceRisk(AppearancePatentRowOutcome.APPEARANCE_NOT_RUN);
+ row.setConclusion("商标侵权·外观维未执行");
+
+ assertEquals(AppearancePatentRowOutcome.Kind.NOT_INSPECTED,
+ AppearancePatentRowOutcome.classify(parsed, row));
+ }
+
// ---------- 2. 三句文案不许互相顶替 ----------
@Test
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/appearancepatent/service/support/AppearancePatentSheetBuilderTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/appearancepatent/service/support/AppearancePatentSheetBuilderTest.java
index 9f84d4571..8177ce205 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/modules/appearancepatent/service/support/AppearancePatentSheetBuilderTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/appearancepatent/service/support/AppearancePatentSheetBuilderTest.java
@@ -366,9 +366,45 @@ class AppearancePatentSheetBuilderTest {
assertEquals("失败", AppearancePatentSheetBuilder.resolveResultStatus("外观无侵权·商标待复核"));
}
+ /**
+ * 图片识别一步都没跑的行,状态列不许写「成功」——哪怕商标维命中了侵权词。
+ *
+ * 2026-11-12 任务 34061:上游 LLM 余额见底,外观维一次没发出去,回退路却拿整条原始标题
+ * 去品牌库蒙到「侵权」,结论列写成侵权、状态列写成成功(1000 行里 158 行)。
+ */
@Test
- void test_sheet_builder_blank_asin_reason_row_skipped() throws Exception {
+ void test_sheet_builder_success_requires_the_image_step_to_have_run() throws Exception {
try (Workbook wb = new XSSFWorkbook()) {
+ AppearancePatentParsedRowVo p = parsedRow("2_1", "B01A", "US", "阿凡达 玩具", "https://img/1.jpg", "");
+ AppearancePatentResultRowDto r = resultRow("2_1", "B01A", "US");
+ r.setTitleRisk("侵权");
+ r.setAppearanceRisk(AppearancePatentRowOutcome.APPEARANCE_NOT_RUN);
+ r.setConclusion("商标侵权·外观维未执行");
+ r.setTitleReason("LLM 服务余额欠费(上游账户额度不足,非本行数据问题)");
+ AppearancePatentSheetBuilder.buildResultSheet(wb, List.of(p), Map.of(
+ AppearancePatentSheetBuilder.rowKey(r), r));
+
+ Row data = wb.getSheet("外观专利检测结果").getRow(1);
+ assertEquals(AppearancePatentRowOutcome.APPEARANCE_NOT_RUN,
+ data.getCell(10).getStringCellValue(), "外观维如实写「没跑」");
+ assertEquals("失败", data.getCell(12).getStringCellValue(),
+ "图片识别没做,一行就不许算成功: " + data.getCell(11).getStringCellValue());
+ }
+ }
+
+ @Test
+ void test_sheet_builder_status_gate_reads_the_appearance_column() {
+ assertEquals("成功", AppearancePatentSheetBuilder.resolveResultStatus("侵权", "无侵权"));
+ assertEquals("失败", AppearancePatentSheetBuilder.resolveResultStatus("侵权", AppearancePatentRowOutcome.APPEARANCE_NOT_RUN));
+ assertEquals("失败", AppearancePatentSheetBuilder.resolveResultStatus("侵权", AppearancePatentRowOutcome.APPEARANCE_ANOMALY));
+ assertEquals("失败", AppearancePatentSheetBuilder.resolveResultStatus("侵权", AppearancePatentSheetBuilder.NO_RESULT_TEXT));
+ assertEquals("失败", AppearancePatentSheetBuilder.resolveResultStatus("侵权", "LLM http 503: overloaded"));
+ // 单参历史口径不变:只拿到结论串时仍按结论判
+ assertEquals("成功", AppearancePatentSheetBuilder.resolveResultStatus("侵权"));
+ }
+
+ @Test
+ void test_sheet_builder_blank_asin_reason_row_skipped() throws Exception { try (Workbook wb = new XSSFWorkbook()) {
AppearancePatentParsedRowVo p = parsedRow("2_1", " ", "US", "t", "", "");
AppearancePatentSheetBuilder.buildResultSheet(wb, List.of(p), Map.of());
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/collectdata/service/CollectDataCredentialFatalTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/collectdata/service/CollectDataCredentialFatalTest.java
new file mode 100644
index 000000000..b55853791
--- /dev/null
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/collectdata/service/CollectDataCredentialFatalTest.java
@@ -0,0 +1,186 @@
+package com.nanri.aiimage.modules.collectdata.service;
+
+import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.nanri.aiimage.modules.asincache.service.AsinResultCacheService;
+import com.nanri.aiimage.modules.collectdata.model.dto.CollectDataSubmitResultRequest;
+import com.nanri.aiimage.modules.collectdata.model.dto.CollectDataSubmitRowDto;
+import com.nanri.aiimage.modules.collectdata.model.vo.CollectDataResultRowVo;
+import com.nanri.aiimage.modules.collectdata.model.vo.CollectDataSubmitResultVo;
+import com.nanri.aiimage.modules.collectdata.util.CollectDataBatchQuery;
+import com.nanri.aiimage.modules.collectdata.util.CollectDataBrandBatchFilter;
+import com.nanri.aiimage.modules.task.mapper.FileResultMapper;
+import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
+import com.nanri.aiimage.modules.task.mapper.TaskChunkMapper;
+import com.nanri.aiimage.modules.task.mapper.TaskScopeStateMapper;
+import com.nanri.aiimage.modules.task.model.entity.FileResultEntity;
+import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
+import com.nanri.aiimage.common.retry.CredentialFatalClassifier;
+import com.nanri.aiimage.modules.task.service.TaskDistributedLockService;
+import com.nanri.aiimage.modules.task.service.TransientPayloadStorageService;
+import com.nanri.aiimage.modules.usersecret.service.UserApiSecretCheckService;
+import org.apache.ibatis.builder.MapperBuilderAssistant;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Spy;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.test.util.ReflectionTestUtils;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * 采集数据:品牌校验整批查不了且原因不可自愈时,整单立即判死(2026-11-12 用户口径
+ * 「没余额要退成失败,且直接中断任务」)。
+ *
+ * 为什么必须整单判死而不是只记 {@code brandQueryFailedCount}:这些行既不进结果、也不算无效品牌,
+ * 用户拿到的是一张空表加一句「补测轮会重试」;而补测轮对「未配置代理/套餐到期/密钥无效」重跑
+ * 一万次都是同一句话(现网 32573 两轮 0 净增)。判宽了会把一次供应商抖动变成整单失败,
+ * 所以本类成对钉住:{@code 未配置代理} 判死、{@code 通道被占} 照旧继续。
+ *
+ * 夹具走 {@code service.submitResult} 这条生产接线,不反射调私有方法——判据要证明的是
+ * 「守卫挂在回传路径上」,不是「私有方法自己会写库」。
+ */
+@ExtendWith(MockitoExtension.class)
+class CollectDataCredentialFatalTest {
+
+ private static final Long TASK_ID = 32601L;
+ private static final Long RESULT_ID = 42601L;
+
+ @Mock private FileTaskMapper fileTaskMapper;
+ @Mock private FileResultMapper fileResultMapper;
+ @Mock private TaskChunkMapper taskChunkMapper;
+ @Mock private TaskScopeStateMapper taskScopeStateMapper;
+ @Mock private TaskDistributedLockService taskDistributedLockService;
+ @Mock private TaskDistributedLockService.LockHandle lockHandle;
+ @Mock private TransientPayloadStorageService transientPayloadStorageService;
+ @Mock private CollectDataBatchQuery collectDataBatchQuery;
+ @Mock private CollectDataBrandBatchFilter brandBatchFilter;
+ @Mock private AsinResultCacheService asinResultCacheService;
+ @Mock private CollectDataBrandRecheckService collectDataBrandRecheckService;
+
+ @Spy private ObjectMapper objectMapper = new ObjectMapper();
+
+ @InjectMocks private CollectDataService service;
+
+ @BeforeAll
+ static void initializeMybatisMetadata() {
+ MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
+ TableInfoHelper.initTableInfo(assistant, FileTaskEntity.class);
+ TableInfoHelper.initTableInfo(assistant, FileResultEntity.class);
+ }
+
+ @BeforeEach
+ void setUp() {
+ ReflectionTestUtils.setField(service, "staleTimeoutMinutes", 30L);
+ lenient().when(transientPayloadStorageService.isSharedWriteEnabled()).thenReturn(true);
+ // 分片落 RustFS:本类只观察凭据判据,指针形状给最小可过的一份
+ lenient().when(transientPayloadStorageService.storeChunkPayloadVersioned(
+ anyString(), anyLong(), anyString(), any(), anyString())).thenReturn("rustfs:chunk-1");
+ lenient().when(transientPayloadStorageService.extractPointer(anyString())).thenReturn("rustfs:chunk-1");
+ lenient().when(taskDistributedLockService.acquire(eq(CollectDataService.MODULE_TYPE), anyLong(), anyLong()))
+ .thenReturn(lockHandle);
+ lenient().when(fileTaskMapper.selectById(TASK_ID)).thenAnswer(invocation -> task);
+ lenient().when(fileResultMapper.selectOne(any())).thenAnswer(invocation -> result);
+ lenient().when(fileResultMapper.updateById(any(FileResultEntity.class))).thenReturn(1);
+ lenient().when(fileTaskMapper.updateById(any(FileTaskEntity.class))).thenReturn(1);
+ // 去重闸原样放行本批:真正要观察的是品牌检测那一格
+ lenient().when(collectDataBatchQuery.filter(any(), any())).thenAnswer(invocation ->
+ new CollectDataBatchQuery.FilterResult(invocation.getArgument(0), 0, 0, List.of()));
+ }
+
+ @Test
+ void unconfiguredProxyMakesTheWholeTaskFailInsteadOfEndingAsAnEmptySuccess() {
+ calledBackWith("用户未配置代理");
+
+ assertThat(task.getStatus())
+ .as("凭据不可自愈必须整单判死,不许跑成一张空表")
+ .isEqualTo("FAILED");
+ assertThat(task.getFinishedAt()).isNotNull();
+ assertThat(task.getSuccessFileCount()).isZero();
+ assertThat(task.getFailedFileCount()).isEqualTo(1);
+ assertThat(task.getErrorMessage()).contains(CredentialFatalClassifier.PROXY_TERMINAL_GUIDANCE);
+ verify(fileTaskMapper).updateById(task);
+ }
+
+ @Test
+ void proxyPackageExhaustedAlsoFailsTheTask() {
+ calledBackWith("代理套餐已过期");
+
+ assertThat(task.getStatus()).isEqualTo("FAILED");
+ assertThat(task.getErrorMessage()).contains(CredentialFatalClassifier.PROXY_TERMINAL_GUIDANCE);
+ }
+
+ /**
+ * 反向半边:通道被占(青果 {@code NO_AVAILABLE_CHANNEL} 那一族)是可自愈的供应商状态,
+ * 句子本身含「套餐」字样,绝不能因此判死整单(铁律 25② 的边界)。
+ */
+ @Test
+ void channelBusyKeepsTheTaskRunningAndOnlyCountsTheMissedRows() {
+ calledBackWith(UserApiSecretCheckService.CHANNEL_BUSY_MESSAGE);
+
+ assertThat(task.getStatus()).as("通道被占是可自愈的,不许判死").isEqualTo("RUNNING");
+ assertThat(task.getFinishedAt()).isNull();
+ assertThat(task.getErrorMessage()).isNull();
+ // 走上来的仍是普通进度落库那一格(同一个实体、RUNNING),不是收口器那笔终态写
+ verify(fileTaskMapper).updateById(task);
+ }
+
+ // ===== 夹具 =====
+
+ private FileTaskEntity task;
+ private FileResultEntity result;
+
+ private void calledBackWith(String brandQueryFailedReason) {
+ task = new FileTaskEntity();
+ task.setId(TASK_ID);
+ task.setUserId(7L);
+ task.setModuleType(CollectDataService.MODULE_TYPE);
+ task.setStatus("RUNNING");
+ task.setResultJson("{\"totalRows\":1,\"receivedRows\":0}");
+ task.setCreatedAt(LocalDateTime.now());
+ task.setUpdatedAt(LocalDateTime.now());
+
+ result = new FileResultEntity();
+ result.setId(RESULT_ID);
+ result.setTaskId(TASK_ID);
+ result.setUserId(7L);
+ result.setModuleType(CollectDataService.MODULE_TYPE);
+
+ CollectDataResultRowVo row = new CollectDataResultRowVo();
+ row.setAsin("B0A0000001");
+ row.setBrand("NIKE");
+ when(brandBatchFilter.filter(any(), any())).thenReturn(
+ new CollectDataBrandBatchFilter.BrandBatchOutcome(
+ List.of(), List.of(row), List.of(), brandQueryFailedReason));
+
+ CollectDataSubmitRowDto submitted = new CollectDataSubmitRowDto();
+ submitted.setAsin("B0A0000001");
+ submitted.setBrand("NIKE");
+ CollectDataSubmitResultRequest request = new CollectDataSubmitResultRequest();
+ request.setItems(List.of(submitted));
+ request.setChunkIndex(1);
+ request.setChunkTotal(1);
+
+ CollectDataSubmitResultVo vo = service.submitResult(TASK_ID, request);
+
+ // 回执里的状态是采集端决定「还要不要下一批」的唯一信号,必须是判死后的那条
+ assertThat(vo.getTaskId()).isEqualTo(TASK_ID);
+ verify(collectDataBrandRecheckService).enqueue(any(FileTaskEntity.class), any());
+ verify(lockHandle).close();
+ }
+}
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/pricetrack/service/PriceTrackTaskServiceTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/pricetrack/service/PriceTrackTaskServiceTest.java
index 9be4f1ef6..a11aa6e88 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/modules/pricetrack/service/PriceTrackTaskServiceTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/pricetrack/service/PriceTrackTaskServiceTest.java
@@ -11,9 +11,11 @@ import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
import com.nanri.aiimage.modules.task.model.entity.FileResultEntity;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskFileJobEntity;
+import com.nanri.aiimage.common.retry.CredentialFatalClassifier;
import com.nanri.aiimage.modules.task.service.TaskDistributedLockService;
import com.nanri.aiimage.modules.task.service.TaskFileJobService;
import com.nanri.aiimage.modules.task.service.TaskResultPayloadService;
+import com.nanri.aiimage.modules.usersecret.service.UserApiSecretCheckService;
import com.nanri.aiimage.modules.ziniao.service.ZiniaoShopSwitchService;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@@ -34,6 +36,7 @@ import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
@@ -352,6 +355,102 @@ class PriceTrackTaskServiceTest {
assertTrue(task.getErrorMessage() != null && task.getErrorMessage().contains("未跑完"));
}
+ /**
+ * 凭据不可自愈(用户没配代理 / 代理套餐到期 / LLM 欠费)⇒ 整单立刻判死,不再等剩下的店铺。
+ *
+ * 2026-11-12 用户口径「没余额要退成失败,且直接中断任务」。判宽了会把一次抖动变成整单失败,
+ * 判窄了客户端会继续为每一家店铺买出口 IP——所以这条与下一条 {@code channelBusy...} 必须成对存在。
+ */
+ @Test
+ void fatalCredentialShopErrorClosesTheWholeTaskInsteadOfWaitingForTheRestOfTheShops() throws Exception {
+ long taskId = 28501L;
+ String shopName = "林芳";
+ String error = "用户未配置代理";
+
+ FileTaskEntity task = runningTask(taskId);
+ FileResultEntity result = pendingResult(taskId, shopName);
+
+ PriceTrackSubmitResultRequest.ShopResult shopResult = shopResult(
+ shopName, Map.of("UK", List.of(asinRow("B0DWX8WJF8", "改价成功", "改价成功"))));
+ shopResult.setError(error);
+ PriceTrackSubmitResultRequest request = new PriceTrackSubmitResultRequest();
+ request.setShops(List.of(shopResult));
+
+ TaskFileJobEntity pendingJob = new TaskFileJobEntity();
+ pendingJob.setTaskId(taskId);
+ pendingJob.setResultId(result.getId());
+ pendingJob.setScopeKey(shopName);
+ pendingJob.setStatus("PENDING");
+
+ TaskDistributedLockService.LockHandle lock = mock(TaskDistributedLockService.LockHandle.class);
+ when(taskDistributedLockService.acquire("PRICE_TRACK", taskId)).thenReturn(lock);
+ when(priceTrackTaskCacheService.getTaskCacheBatch(List.of(taskId))).thenReturn(Map.of(taskId, task));
+ when(fileResultMapper.selectList(any())).thenReturn(List.of(result));
+ when(ziniaoShopSwitchService.normalizeShopName(shopName)).thenReturn(shopName);
+ when(excelAssemblyService.normalizeCountriesMap(any())).thenAnswer(invocation -> invocation.getArgument(0));
+ lenient().when(excelAssemblyService.countRows(any())).thenReturn(1);
+ // 判死分支在行账/文件组装之前返回,这两支只在本用例的反向半边被走到
+ lenient().when(taskFileJobService.findAssembleJobsByResultIds(anyString(), any()))
+ .thenReturn(Map.of(result.getId(), pendingJob));
+ lenient().when(objectMapper.writeValueAsString(any())).thenReturn("[]");
+
+ service.submitResult(taskId, request);
+
+ assertEquals("FAILED", task.getStatus(), "凭据不可自愈必须整单判死,不许停在 RUNNING 等别的店铺");
+ assertNotNull(task.getFinishedAt());
+ assertEquals(0, task.getSuccessFileCount());
+ assertEquals(1, task.getFailedFileCount());
+ assertTrue(task.getErrorMessage().contains(CredentialFatalClassifier.PROXY_TERMINAL_GUIDANCE),
+ "实际: " + task.getErrorMessage());
+ verify(priceTrackTaskCacheService).deleteTaskCache(taskId);
+ verify(priceTrackLoopRunService).syncLoopRunAfterChildTerminal(taskId);
+ verify(lock).close();
+ }
+
+ /**
+ * 反向半边:通道被占(青果 {@code NO_AVAILABLE_CHANNEL} 那一族)是可自愈的供应商状态,
+ * 句子本身含「套餐」字样,绝不能因此把整单判死(铁律 25② 的边界)。
+ */
+ @Test
+ void channelBusyErrorKeepsTaskRunningBecauseItHealsByItself() throws Exception {
+ long taskId = 28502L;
+ String shopName = "林芳";
+ String error = UserApiSecretCheckService.CHANNEL_BUSY_MESSAGE;
+
+ FileTaskEntity task = runningTask(taskId);
+ FileResultEntity result = pendingResult(taskId, shopName);
+
+ PriceTrackSubmitResultRequest.ShopResult shopResult = shopResult(
+ shopName, Map.of("UK", List.of(asinRow("B0DWX8WJF8", "改价成功", "改价成功"))));
+ shopResult.setError(error);
+ PriceTrackSubmitResultRequest request = new PriceTrackSubmitResultRequest();
+ request.setShops(List.of(shopResult));
+
+ TaskFileJobEntity pendingJob = new TaskFileJobEntity();
+ pendingJob.setTaskId(taskId);
+ pendingJob.setResultId(result.getId());
+ pendingJob.setScopeKey(shopName);
+ pendingJob.setStatus("PENDING");
+
+ TaskDistributedLockService.LockHandle lock = mock(TaskDistributedLockService.LockHandle.class);
+ when(taskDistributedLockService.acquire("PRICE_TRACK", taskId)).thenReturn(lock);
+ when(priceTrackTaskCacheService.getTaskCacheBatch(List.of(taskId))).thenReturn(Map.of(taskId, task));
+ when(fileResultMapper.selectList(any())).thenReturn(List.of(result));
+ when(ziniaoShopSwitchService.normalizeShopName(shopName)).thenReturn(shopName);
+ when(excelAssemblyService.normalizeCountriesMap(any())).thenAnswer(invocation -> invocation.getArgument(0));
+ when(excelAssemblyService.countRows(any())).thenReturn(1);
+ when(taskFileJobService.findAssembleJobsByResultIds(anyString(), any()))
+ .thenReturn(Map.of(result.getId(), pendingJob));
+ when(objectMapper.writeValueAsString(any())).thenReturn("[]");
+
+ service.submitResult(taskId, request);
+
+ assertEquals("RUNNING", task.getStatus(), "通道被占是可自愈的,不许判死");
+ assertNull(task.getFinishedAt());
+ verify(priceTrackTaskCacheService, never()).deleteTaskCache(taskId);
+ verify(lock).close();
+ }
+
private FileTaskEntity runningTask(long taskId) {
FileTaskEntity task = new FileTaskEntity();
task.setId(taskId);
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/shopdatacrawl/service/ShopDataCrawlProgressQueryTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/shopdatacrawl/service/ShopDataCrawlProgressQueryTest.java
index b768f55c1..f67012147 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/modules/shopdatacrawl/service/ShopDataCrawlProgressQueryTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/shopdatacrawl/service/ShopDataCrawlProgressQueryTest.java
@@ -50,6 +50,7 @@ import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
@@ -386,6 +387,36 @@ class ShopDataCrawlProgressQueryTest {
verify(taskDistributedLockService, never()).acquire(anyString(), anyLong());
}
+ /**
+ * 任务级失败原因只给已 FAILED 的任务带,且截断 300 字。
+ *
+ * 为什么进度批量必须有这一格:整单判死(未配置代理/套餐到期/LLM 欠费)只写
+ * `biz_file_task.error_message`,每个店铺行本身没被标失败,行级 `error` 是空的。
+ * 用户端在终态那刻靠这一格弹「去哪改」,缺了就是一句原因都没有的静默失败。
+ */
+ @Test
+ void progressBatchCarriesTheTaskLevelFailureReasonOnlyWhenTheTaskFailed() {
+ seedHistoryData(2);
+ String longReason = "任务已终止:代理 IP 套餐已到期或余额不足,请到密钥设置里充值或更换提取链接。".repeat(20);
+ FileTaskEntity failed = taskStore.get(8101L);
+ failed.setStatus("FAILED");
+ failed.setErrorMessage(longReason);
+ FileTaskEntity running = taskStore.get(8102L);
+ running.setStatus("RUNNING");
+ running.setErrorMessage("运行中不该把这句话带出去");
+
+ ShopDataCrawlTaskBatchVo batch = service.getTaskProgressBatch(List.of(8101L, 8102L));
+
+ Map 2026-11-12 用户口径「没余额要退成失败,且直接中断任务」:剩下的每一家都会在同一条死路上
+ * 各跑一遍,白等还白烧出口。判据共用 {@code CredentialFatalClassifier}。
+ */
+ @Test
+ void fatalCredentialShopErrorClosesTaskInsteadOfWaitingForTheRestOfTheShops() {
+ givenRunningTask(1301L, 2301L);
+ ShopDataCrawlShopPayloadDto payload = legacyChunk(true, "DE", row("2026-07-25", "B001"));
+ payload.setError("用户未配置代理");
+ when(taskCacheService.getAllShopMergedPayload(task.getId())).thenReturn(Map.of(SHOP_NAME, payload));
+
+ boolean finalized = service.tryFinalizeTask(task.getId(), true);
+
+ assertTrue(finalized);
+ assertEquals("FAILED", task.getStatus());
+ assertEquals(0, task.getSuccessFileCount());
+ assertEquals(1, task.getFailedFileCount());
+ assertTrue(task.getErrorMessage().contains(CredentialFatalClassifier.PROXY_TERMINAL_GUIDANCE),
+ "实际: " + task.getErrorMessage());
+ assertTrue(task.getFinishedAt() != null, "终态必须带 finished_at");
+ assertEquals(-1, result.getSuccess(), "凭据故障的行不许被洗成成功");
+ }
+
+ /**
+ * 反向半边:通道被占是可自愈的供应商状态(句子本身含「套餐」字样),不许判死整单。
+ */
+ @Test
+ void channelBusyShopErrorKeepsTaskRunningAndMarksOnlyThatShopFailed() {
+ givenRunningTask(1302L, 2302L);
+ ShopDataCrawlShopPayloadDto payload = legacyChunk(true, "DE", row("2026-07-25", "B001"));
+ payload.setError(UserApiSecretCheckService.CHANNEL_BUSY_MESSAGE);
+ when(taskCacheService.getAllShopMergedPayload(task.getId())).thenReturn(Map.of(SHOP_NAME, payload));
+
+ service.tryFinalizeTask(task.getId(), true);
+
+ assertEquals("FAILED", task.getStatus(), "只有这一家店铺失败,任务本身该照旧收口成失败");
+ assertTrue(task.getErrorMessage().contains("青果") || task.getErrorMessage().contains("空闲通道"),
+ "原因原样进任务文案: " + task.getErrorMessage());
+ // 关键反向判据:不是被「凭据不可自愈」那条早退路径判死的(该路径会写固定指引句)
+ assertTrue(!task.getErrorMessage().contains(CredentialFatalClassifier.PROXY_TERMINAL_GUIDANCE),
+ "通道被占被误判成凭据不可自愈: " + task.getErrorMessage());
+ assertEquals(0, task.getSuccessFileCount());
+ }
+
private void configureTransientPayloadStorage() {
lenient().when(transientPayloadStorageService.isSharedWriteEnabled()).thenReturn(true);
lenient().when(transientPayloadStorageService.storeChunkPayloadVersioned(
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/similarasin/service/support/SimilarAsinResultTextSupportTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/similarasin/service/support/SimilarAsinResultTextSupportTest.java
index 17dcd9d61..565513318 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/modules/similarasin/service/support/SimilarAsinResultTextSupportTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/similarasin/service/support/SimilarAsinResultTextSupportTest.java
@@ -113,6 +113,32 @@ class SimilarAsinResultTextSupportTest {
assertThat(detail).endsWith("…");
}
+ /**
+ * 凭据不可自愈的行,图片采到了也不许算「成功」:它一次都没进 LLM。
+ *
+ * 2026-11-12 用户口径「没余额要退成失败,且直接中断任务」。这条与
+ * {@link SimilarAsinResultTextSupport#resolveResultStatus} 的图片优先判据相反,顺序不能反。
+ */
+ @Test
+ void credentialFatalRowIsFailedEvenWhenImagesWereCollected() {
+ SimilarAsinResultRowDto quota = row("LLM 服务余额欠费;lastErr={\"code\":\"insufficient_user_quota\"}", "");
+ quota.setMainUrl("https://img.example.com/1.jpg");
+ SimilarAsinResultRowDto noProxy = row("", "用户未配置代理");
+ noProxy.setPuzzleImg1("https://img.example.com/2.jpg");
+
+ assertThat(SimilarAsinResultTextSupport.resolveResultStatus(quota))
+ .as("LLM 欠费")
+ .isEqualTo("失败");
+ assertThat(SimilarAsinResultTextSupport.resolveResultStatus(noProxy))
+ .as("没配代理")
+ .isEqualTo("失败");
+
+ // 反向半边:可自愈的失败照旧按图片算成功(判宽了就是拿整单给抖动陪葬)
+ SimilarAsinResultRowDto timeout = row("商品页抓取超时", "");
+ timeout.setMainUrl("https://img.example.com/3.jpg");
+ assertThat(SimilarAsinResultTextSupport.resolveResultStatus(timeout)).isEqualTo("成功");
+ }
+
private static SimilarAsinResultRowDto row(String error, String reason) {
SimilarAsinResultRowDto row = new SimilarAsinResultRowDto();
row.setError(error);
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskFailureCategoryGuardrailTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskFailureCategoryGuardrailTest.java
index 780cb6f82..b1ecc206b 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskFailureCategoryGuardrailTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskFailureCategoryGuardrailTest.java
@@ -61,10 +61,14 @@ class TaskFailureCategoryGuardrailTest {
"WithdrawTaskService.java",
"PatrolDeleteTaskService.java",
"ShopDataCrawlTaskService.java",
- "DeleteBrandRunService.java");
+ "DeleteBrandRunService.java",
+ // 2026-11-12:外观专利/相似ASIN 原来各自内联的那一处「写文案+派生写列」搬进了共用收口器
+ // (凭据不可自愈 ⇒ 整单终态,铁律 31)。它现在是这一族写点的唯一出口,不登记=最常走的那一处免检;
+ // 名单上下限随之各减 2、加 1。
+ "CredentialFatalTaskCloser.java");
- /** 名单内在册写点数(第二批 15 +第三批 32:风险 8/店铺匹配 5/查ASIN 3/提现 3/巡删 3/店铺采集 4/巡删品牌 6)。 */
- private static final int ENTITY_FACE_MIN_WRITE_SITES = 47;
+ /** 名单内在册写点数(第二批 15 +第三批 32:风险 8/店铺匹配 5/查ASIN 3/提现 3/巡删 3/店铺采集 4/巡删品牌 6;2026-11-12 收口器 −2+1=46)。 */
+ private static final int ENTITY_FACE_MIN_WRITE_SITES = 46;
/**
* {@code .updateById(} 写法总量的在册棘轮(B82-01 收口时的换算值:改前 173,本笔把 12 处
@@ -77,8 +81,12 @@ class TaskFailureCategoryGuardrailTest {
* {@code updateById},都值得先审一遍「实体里有没有 ALWAYS 字段、传进去的是不是新鲜实体」。
* 部分字段落库的正本形状是 {@code update(null, wrapper)} 显式 {@code .set}
* ({@code CollectDataService} 结果文件组装的条件更新)。
+ *
+ * 2026-11-12:外观专利/相似ASIN 两处实体式落库搬进 {@code CredentialFatalTaskCloser},
+ * 总量 160 − 2 + 1(收口器自己那一处,实体取自 {@code selectById} 的新鲜行,不涉 ALWAYS 抹列)= 159。
+ * 这是"在册写点被挪走"那一支,不是新增写法。
*/
- private static final int REGISTERED_UPDATE_BY_ID_SITES = 160;
+ private static final int REGISTERED_UPDATE_BY_ID_SITES = 159;
@Test
void 任务失败文案写点必须同笔写分类列() {
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskRetryEligibilityMarkersSnapshotTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskRetryEligibilityMarkersSnapshotTest.java
index ed21bd48b..3aa9a6070 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskRetryEligibilityMarkersSnapshotTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskRetryEligibilityMarkersSnapshotTest.java
@@ -46,9 +46,12 @@ class TaskRetryEligibilityMarkersSnapshotTest {
@Test
void 六组markers逐字快照() {
assertThat(markers("BALANCE_MARKERS")).containsExactly(
- "余额不足", "欠费", "套餐不存在", "套餐已过期", "套餐过期", "未开通",
- "insufficient_user_quota", "insufficient_quota", "quota exceeded",
- "预扣费额度");
+ "余额不足", "欠费", "套餐不存在", "套餐已过期", "套餐过期", "套餐到期", "未开通",
+ "insufficient_user_quota", "insufficient_quota", "insufficient_funds",
+ "wallet balance insufficient", "quota exceeded",
+ "预扣费额度",
+ // 2026-11-12:没配代理也是「不修外部条件重跑必然同结果」,不登记就会被自动重试反复复位
+ "未配置代理", "代理地址为空", "代理链接为空");
assertThat(markers("KEY_MARKERS")).containsExactly(
"密钥无效", "密钥失效", "无效的密钥", "密钥不可用",
"invalid api key", "invalid_api_key", "api key 无效", "apikey 无效");
diff --git a/frontend-vue/src/App.vue b/frontend-vue/src/App.vue
index 27239b11c..c9da9c3b7 100644
--- a/frontend-vue/src/App.vue
+++ b/frontend-vue/src/App.vue
@@ -4,6 +4,7 @@
+ *
+ */
+class CredentialFatalClassifierTest {
+
+ /** 现网 403 原文(外部世界的字符串,不是本仓文案)。 */
+ private static final String QUOTA_403_BODY = "{\"error\":{\"message\":\"预扣费额度失败, 用户[151502]剩余额度: "
+ + "฿0.030492, 需要预扣费额度: ฿0.032412\",\"code\":\"insufficient_user_quota\"}}";
+
+ // ===== 致命:LLM 侧 =====
+
+ @Test
+ void upstreamQuotaBodyIsLlmCredential() {
+ assertThat(CredentialFatalClassifier.kind(QUOTA_403_BODY))
+ .isEqualTo(CredentialFatalClassifier.Kind.LLM_CREDENTIAL);
+ }
+
+ @Test
+ void producerCopyWrappedByTheClientIsStillLlmCredential() {
+ String producer = LlmBalanceGuard.REASON_LLM_BALANCE_DUE + ";lastErr=" + QUOTA_403_BODY;
+
+ assertThat(CredentialFatalClassifier.kind(producer))
+ .isEqualTo(CredentialFatalClassifier.Kind.LLM_CREDENTIAL);
+ }
+
+ @Test
+ void invalidLlmKeyIsLlmCredential() {
+ assertThat(CredentialFatalClassifier.kind("LLM http 401: invalid api key"))
+ .isEqualTo(CredentialFatalClassifier.Kind.LLM_CREDENTIAL);
+ assertThat(CredentialFatalClassifier.kind("密钥无效(401)"))
+ .isEqualTo(CredentialFatalClassifier.Kind.LLM_CREDENTIAL);
+ }
+
+ /** 2026-11-11 现网的钱包型欠费:与 {@code insufficient_user_quota} 拼写完全不同,不能漏。 */
+ @Test
+ void walletStyleArrearsIsAlsoFatal() {
+ assertThat(CredentialFatalClassifier.kind("LLM 402: {\"code\":\"insufficient_funds\"}"))
+ .as("钱包型欠费")
+ .isEqualTo(CredentialFatalClassifier.Kind.LLM_CREDENTIAL);
+ assertThat(CredentialFatalClassifier.kind("wallet balance insufficient"))
+ .as("钱包型欠费的另一种拼写(没有连续 insufficient balance)")
+ .isEqualTo(CredentialFatalClassifier.Kind.LLM_CREDENTIAL);
+ }
+
+ // ===== 致命:代理侧(品牌检测的原始原因分六档,只有前两档判死) =====
+
+ @Test
+ void missingProxyConfigurationIsProxyCredential() {
+ assertThat(CredentialFatalClassifier.kind(BrandCheckClient.NO_PROXY_REASON))
+ .as("没配代理=根本没得查,重跑一万次都一样")
+ .isEqualTo(CredentialFatalClassifier.Kind.PROXY_CREDENTIAL);
+ }
+
+ @Test
+ void proxyPackageExhaustedIsProxyCredential() {
+ assertThat(CredentialFatalClassifier.kind("提取失败:套餐已过期"))
+ .isEqualTo(CredentialFatalClassifier.Kind.PROXY_CREDENTIAL);
+ assertThat(CredentialFatalClassifier.kind("供应商拒付:余额不足"))
+ .as("同一句「余额不足」在品牌侧是代理套餐,不能按 LLM 欠费解释")
+ .isEqualTo(CredentialFatalClassifier.Kind.PROXY_CREDENTIAL);
+ }
+
+ @Test
+ void qingguoAuthDenyIsProxyCredential() {
+ assertThat(CredentialFatalClassifier.kind("青果提取失败 API_AUTH_DENY"))
+ .as("账密档没填或鉴权被切走:用户必须去改链接")
+ .isEqualTo(CredentialFatalClassifier.Kind.PROXY_CREDENTIAL);
+ }
+
+ // ===== 不致命:短时/技术性/上游(这条半边与致命半边同等重要) =====
+
+ @Test
+ void channelBusyIsNotFatalEvenThoughItsCopyMentionsThePackage() {
+ String copy = com.nanri.aiimage.modules.usersecret.service.UserApiSecretCheckService.CHANNEL_BUSY_MESSAGE;
+
+ assertThat(copy).contains("套餐到期");
+ assertThat(CredentialFatalClassifier.kind(copy))
+ .as("通道被占是「等几分钟再来」,同句里的「套餐到期」是排查建议,不是结论")
+ .isNull();
+ }
+
+ @Test
+ void brandCooldownAndEgressRejectedAreNotFatal() {
+ assertThat(CredentialFatalClassifier.kind("该 key 处于冷却窗口")).isNull();
+ assertThat(CredentialFatalClassifier.kind("拒绝代理出口,请换 IP 重试")).isNull();
+ }
+
+ @Test
+ void brandTechnicalFailuresAreNotFatal() {
+ assertThat(CredentialFatalClassifier.kind("解密失败: Malformed UTF-8 data")).isNull();
+ assertThat(CredentialFatalClassifier.kind("代理请求失败")).isNull();
+ assertThat(CredentialFatalClassifier.kind("未返回可用 IP")).isNull();
+ }
+
+ @Test
+ void upstreamUnavailableAndServiceDownAreNotFatal() {
+ assertThat(CredentialFatalClassifier.kind("品牌库上游整体不可用(本批待查词无一返回结果)")).isNull();
+ assertThat(CredentialFatalClassifier.kind("LLM http 502: Bad Gateway")).isNull();
+ assertThat(CredentialFatalClassifier.kind("LLM 服务不可达(连接未建立):Connection refused")).isNull();
+ assertThat(CredentialFatalClassifier.kind("LLM http 429: Too Many Requests")).isNull();
+ assertThat(CredentialFatalClassifier.kind("任务心跳超时,已自动失败")).isNull();
+ }
+
+ /**
+ * 任何一条 LLM 报错都带 {@code LLM} 三个字母:拿这个裸词当凭据判据,一次网关抖动就会判死整单
+ * (2026-11-12 实现当天就被 {@code AppearancePatentRowMarkTimingTest} 撞出来,NPE 在终态闸上)。
+ */
+ @Test
+ void bareLlmWordingIsNotACredentialVerdict() {
+ assertThat(CredentialFatalClassifier.kind("LLM 网关无应答")).isNull();
+ assertThat(CredentialFatalClassifier.kind("LLM 检测失败")).isNull();
+ assertThat(CredentialFatalClassifier.kind("LLM http 500: internal error")).isNull();
+ }
+
+ @Test
+ void deliveryAndStoppedCopiesAreNotCredentialFatal() {
+ assertThat(CredentialFatalClassifier.kind("结果文件生成多次失败")).isNull();
+ assertThat(CredentialFatalClassifier.kind(TaskResumeService.DUPLICATE_STOP_REASON)).isNull();
+ }
+
+ @Test
+ void blankMessageIsNeverFatal() {
+ assertThat(CredentialFatalClassifier.kind(null)).isNull();
+ assertThat(CredentialFatalClassifier.kind(" ")).isNull();
+ assertThat(CredentialFatalClassifier.isFatal("")).isFalse();
+ }
+
+ // ===== 本仓自己写下的终态句:重读时不许在两面之间翻 =====
+
+ @Test
+ void ownTerminalSentencesKeepTheirSideOnReread() {
+ String llmStored = QUOTA_403_BODY + ";" + LlmBalanceGuard.TASK_TERMINAL_GUIDANCE;
+ String proxyStored = "用户未配置代理;" + CredentialFatalClassifier.PROXY_TERMINAL_GUIDANCE;
+
+ assertThat(CredentialFatalClassifier.kind(llmStored))
+ .as("LLM 终态句里也提到「代理出口额度」,重读必须仍判 LLM")
+ .isEqualTo(CredentialFatalClassifier.Kind.LLM_CREDENTIAL);
+ assertThat(CredentialFatalClassifier.kind(proxyStored))
+ .as("代理终态句里也提到「密钥无效」,重读必须仍判代理")
+ .isEqualTo(CredentialFatalClassifier.Kind.PROXY_CREDENTIAL);
+ }
+
+ @Test
+ void guidanceFollowsTheKindAndNeverSaysRetryLater() {
+ for (CredentialFatalClassifier.Kind kind : CredentialFatalClassifier.Kind.values()) {
+ String guidance = CredentialFatalClassifier.guidance(kind);
+ assertThat(guidance).as("%s 的终态动作句", kind)
+ .contains("任务已终止")
+ .doesNotContain("稍后重试");
+ }
+ }
+}
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentTaskServiceDelegationTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentTaskServiceDelegationTest.java
index a3f0648c5..8c9f66c22 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentTaskServiceDelegationTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentTaskServiceDelegationTest.java
@@ -68,6 +68,20 @@ import static org.mockito.Mockito.when;
*/
class AppearancePatentTaskServiceDelegationTest {
+ /**
+ * 「继续」复位现在会经 {@code LambdaUpdateWrapper