@musnows/scriverse 0.7.3 → 0.7.4

package/dist/ai.js

@@ -1,10 +1,13 @@
 import { ANALYSIS_TASK_TYPES, HISTORICAL_ANALYSIS_TASK_TYPES } from "./domain.js";
 import { buildCompletionRequestBody, isAiProviderProtocol, normalizeProviderBaseUrl, parseCompletionPayload, providerCompletionEndpoint, providerModelEndpoints, providerProtocolLabelText, providerRequestHeaders } from "./ai-protocol.js";
 import { AGENT_TOOL_RESULT_MAX_CHARS, DEFAULT_AGENT_TOOL_CALL_GLOBAL_MULTIPLIER, MIN_AGENT_TOOL_CALL_LIMIT, agentToolCallGlobalLimit, agentToolCallQuotaNoticeBudgetChars, agentToolCallQuotaUsedAfterCompact, agentToolCallSoftWarningThreshold, clampAgentToolCallGlobalMultiplier, paginateToolResultRecords, resolveMaxAgentToolCallLimit, shouldRejectAgentToolCalls, shouldRejectGlobalToolCalls, structuralToolResultRecords, withAgentToolCallQuotaNotice } from "./ai-tool-results.js";
+import { AiConnectivityTestGate, hashAiConnectivityConfiguration } from "./ai-connectivity-test.js";
+import { DEFAULT_AI_STREAM_IDLE_TIMEOUT_MS } from "./ai-stream-timeout.js";
+import { characterExtractionHash, characterExtractionSelectionFingerprint, editableCharacterExtractionCandidate, normalizeCharacterExtractionCandidate, parseStoredCharacterExtractionCandidates } from "./character-extraction.js";
 import { PLATFORM_AI_WORK_ID } from "./database.js";
 import { AppError, notFound } from "./errors.js";
 import { assertOfficialGoogleVertexBaseUrl, fetchGoogleOAuthAccessToken, GoogleVertexTokenCache, maskServiceAccountHint, parseGoogleServiceAccount } from "./google-vertex-auth.js";
-import { HYBRID_SEARCH_TYPES, buildHybridSearchSnippet, documentParagraphLineRange, fuseHybridSearchChannels } from "./hybrid-search.js";
+import { HYBRID_SEARCH_TYPES, MAXIMUM_WORK_SEARCH_QUERY_LENGTH, buildHybridSearchSnippet, documentParagraphLineRange, fuseHybridSearchChannels, normalizeWorkSearchQuery } from "./hybrid-search.js";
 import { logger, sanitizeError } from "./logger.js";
 import { paginated, paginationSql } from "./pagination.js";
 import { currentRequestActor } from "./request-context.js";
@@ -25,11 +28,83 @@ export function aiErrorForLog(error) {
         return { name: sanitized.name ?? "Error", message: "Provider returned invalid JSON" };
     return sanitized;
 }
+function connectivityTestErrorForLog(error) {
+    if (error instanceof AppError) {
+        return { category: "application_error", status: error.status, code: error.code };
+    }
+    if (!(error instanceof Error))
+        return { category: "upstream_failure" };
+    if (error.name === "AbortError")
+        return { category: "timeout" };
+    const httpStatus = error.message.match(/^HTTP ([1-5]\d{2})(?::|$)/u)?.[1];
+    if (httpStatus)
+        return { category: "upstream_http", status: Number(httpStatus) };
+    if (/无效 JSON|响应缺少可用回复|没有返回(?:模型列表|可用模型)/u.test(error.message)) {
+        return { category: "invalid_response" };
+    }
+    if (error instanceof TypeError)
+        return { category: "network_error" };
+    return { category: "upstream_failure" };
+}
 const AUTO_RUN_MAX_ATTEMPTS = 3;
 const AUTO_RUN_RETRY_DELAYS_MS = [5_000, 30_000];
 const AI_INTERACTIVE_TIMEOUT_MS = 60_000;
 const AI_LONG_RUNNING_TIMEOUT_MS = 300_000;
 const analysisTaskTypes = new Set(ANALYSIS_TASK_TYPES);
+const interactiveStreamErrorCodes = new Set([
+    "AI_STREAM_IDLE_TIMEOUT",
+    "AI_STREAM_UPSTREAM_CLOSED",
+    "AI_STREAM_NETWORK_ERROR",
+    "AI_STREAM_REQUEST_CANCELLED"
+]);
+function isInteractiveStreamError(error) {
+    return error instanceof AppError && interactiveStreamErrorCodes.has(error.code);
+}
+function interactiveStreamRequestCancelledError() {
+    return new AppError(499, "AI_STREAM_REQUEST_CANCELLED", "AI 流式请求已取消");
+}
+class InteractiveStreamIdleWatchdog {
+    controller;
+    timeoutMs;
+    timer = null;
+    completed = false;
+    failure = null;
+    constructor(controller, timeoutMs) {
+        this.controller = controller;
+        this.timeoutMs = timeoutMs;
+    }
+    start() {
+        this.arm("first_event");
+    }
+    receivedEvent() {
+        this.arm("between_events");
+    }
+    complete() {
+        this.completed = true;
+        this.clear();
+    }
+    dispose() {
+        this.clear();
+    }
+    arm(phase) {
+        if (this.completed || this.failure)
+            return;
+        this.clear();
+        this.timer = setTimeout(() => {
+            const idleTimeoutSeconds = this.timeoutMs / 1_000;
+            this.failure = new AppError(504, "AI_STREAM_IDLE_TIMEOUT", phase === "first_event"
+                ? `等待 AI 首个流事件超时（${idleTimeoutSeconds} 秒无新事件），流已关闭`
+                : `AI 流已因 ${idleTimeoutSeconds} 秒无新事件而关闭，已保留已生成内容`, { phase, idleTimeoutSeconds });
+            this.controller.abort(this.failure);
+        }, this.timeoutMs);
+    }
+    clear() {
+        if (!this.timer)
+            return;
+        clearTimeout(this.timer);
+        this.timer = null;
+    }
+}
 function isAnalysisTaskType(value) {
     return analysisTaskTypes.has(value);
 }
@@ -254,7 +329,7 @@ function redactProviderSecrets(value, secrets, depth = 0) {
         return null;
     return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redactProviderSecrets(item, list, depth + 1)]));
 }
-class ProviderSecretStreamRedactor {
+export class ProviderSecretStreamRedactor {
     pending = "";
     secrets;
     constructor(apiKey) {
@@ -275,10 +350,21 @@ class ProviderSecretStreamRedactor {
         this.pending = retainedLength > 0 ? combined.slice(-retainedLength) : "";
         return retainedLength > 0 ? combined.slice(0, -retainedLength) : combined;
     }
-    flush() {
-        const value = redactProviderSecretsText(this.pending, ...this.secrets);
+    flush(options = {}) {
+        const pending = this.pending;
+        const value = redactProviderSecretsText(pending, ...this.secrets);
         this.pending = "";
-        return value;
+        if (!options.interrupted || !pending)
+            return value;
+        const matchingSecrets = this.secrets.filter((secret) => secret.startsWith(pending));
+        if (matchingSecrets.length === 0)
+            return value;
+        const visiblePrefixLength = Math.min(...matchingSecrets.map((secret) => secret.length > 7 ? 4 : 0));
+        if (pending.length <= visiblePrefixLength)
+            return value;
+        if (visiblePrefixLength === 0)
+            return "********";
+        return `${pending.slice(0, visiblePrefixLength)}*****`;
     }
 }
 function sanitizeCompletionTraceResponse(value) {
@@ -338,7 +424,7 @@ const grepArguments = z.object({
     cursor: agentToolCursor
 }).strict();
 const searchStoryEntitiesArguments = z.object({
-    query: z.string().trim().min(1).max(200),
+    query: z.string().trim().min(1).max(MAXIMUM_WORK_SEARCH_QUERY_LENGTH),
     categories: z.array(z.enum(["setting", "character", "race", "organization", "timeline", "relationship", "outline", "foreshadow"])).max(8).default([]),
     limit: z.number().int().min(1).max(30).default(30),
     cursor: agentToolCursor
@@ -403,7 +489,7 @@ const AGENT_TOOL_DEFINITIONS = {
         function: {
             name: "search_story_entities",
             description: "按短关键词在结构化作品实体中进行元数据、精确全文和拼音混合检索：设定、人物（含 Markdown 档案章节）、种族、组织、时间线、关系、大纲和伏笔。人物、种族、组织结果分别包含权威布尔状态 isDead、isExtinct、isDissolved；只有值为 true 才能判定该角色已死亡、该种族已灭绝或该组织已解散，字段为 false 时必须视为仍存活、未灭绝或未解散，禁止根据正文情节自行改判。不是语义问答；请传入实体名、别名、标题、拼音或短关键词，不要传入自然语言整句。结果按综合相关度排序；人物结果含 sectionId 时可再调用 read_character_sections 精读。无匹配时改用更短关键词，或改用 story_index / grep。",
-            parameters: { type: "object", properties: { query: { type: "string", minLength: 1, maxLength: 200 }, categories: { type: "array", items: { type: "string", enum: ["setting", "character", "race", "organization", "timeline", "relationship", "outline", "foreshadow"] }, maxItems: 8 }, limit: { type: "integer", minimum: 1, maximum: 30, default: 30 }, cursor: agentToolCursorParameter }, required: ["query"], additionalProperties: false }
+            parameters: { type: "object", properties: { query: { type: "string", minLength: 1, maxLength: MAXIMUM_WORK_SEARCH_QUERY_LENGTH }, categories: { type: "array", items: { type: "string", enum: ["setting", "character", "race", "organization", "timeline", "relationship", "outline", "foreshadow"] }, maxItems: 8 }, limit: { type: "integer", minimum: 1, maximum: 30, default: 30 }, cursor: agentToolCursorParameter }, required: ["query"], additionalProperties: false }
         }
     },
     read_character_sections: {
@@ -692,6 +778,36 @@ function numberValue(row, key) {
 function boolValue(row, key) {
     return Number(row[key] ?? 0) === 1;
 }
+const providerConnectivityConfigurationFields = [
+    "name",
+    "base_url",
+    "protocol",
+    "encrypted_key",
+    "key_iv",
+    "key_tag",
+    "status",
+    "concurrency_limit",
+    "rpm_limit",
+    "max_tokens",
+    "default_model_id",
+    "note"
+];
+const modelConnectivityConfigurationFields = [
+    "display_name",
+    "model_id",
+    "purposes_json",
+    "context_note",
+    "context_window",
+    "output_note",
+    "preset_json",
+    "thinking_enabled",
+    "multimodal_enabled",
+    "enabled",
+    "note"
+];
+function connectivityConfigurationValues(row, fields) {
+    return fields.map((field) => row[field] ?? null);
+}
 function safeJsonObject(value) {
     return json(value, {});
 }
@@ -1425,6 +1541,7 @@ export class AiManager {
     authorizeTaskRun;
     attachmentStorage;
     contextBuilder;
+    interactiveStreamIdleTimeoutMs;
     taskControllers = new Map();
     autoRunStarting = new Map();
     autoRunTimers = new Map();
@@ -1438,13 +1555,19 @@ export class AiManager {
     relationshipIndexDisposed = false;
     providerSchedules = new Map();
     vertexTokenCache = new GoogleVertexTokenCache();
-    constructor(store, vault, fetchImpl = fetch, validateOutboundUrl, authorizeTaskRun, attachmentStorage) {
+    connectivityTestGate;
+    constructor(store, vault, fetchImpl = fetch, validateOutboundUrl, authorizeTaskRun, attachmentStorage, options = {}) {
         this.store = store;
         this.vault = vault;
         this.fetchImpl = fetchImpl;
         this.validateOutboundUrl = validateOutboundUrl;
         this.authorizeTaskRun = authorizeTaskRun;
         this.attachmentStorage = attachmentStorage;
+        this.connectivityTestGate = new AiConnectivityTestGate(store.db);
+        this.interactiveStreamIdleTimeoutMs = Number.isSafeInteger(options.interactiveStreamIdleTimeoutMs)
+            && Number(options.interactiveStreamIdleTimeoutMs) > 0
+            ? Number(options.interactiveStreamIdleTimeoutMs)
+            : DEFAULT_AI_STREAM_IDLE_TIMEOUT_MS;
         this.contextBuilder = new ContextBuilder(store);
         this.store.setAnalysisTaskQueuedHandler((workId) => this.scheduleAutoRun(workId));
         this.autoRunStartupTimer = setTimeout(() => {
@@ -1457,7 +1580,7 @@ export class AiManager {
             this.relationshipIndexTimer = null;
             void this.schedulePendingRelationshipIndexes();
         }, 0);
-        logger.info("ai.manager.ready");
+        logger.info("ai.manager.ready", { interactiveStreamIdleTimeoutMs: this.interactiveStreamIdleTimeoutMs });
     }
     getPlatformTokenUsage(timezoneOffset) {
         return this.getTokenUsage(null, timezoneOffset, true);
@@ -1490,7 +1613,7 @@ export class AiManager {
     }
     async searchWork(workId, query, options = {}) {
         this.store.getWork(workId);
-        const normalizedQuery = normalizeRelationshipSearchText(query).trim();
+        const normalizedQuery = normalizeWorkSearchQuery(query);
         if (!normalizedQuery)
             return [];
         const requestedTypes = options.type ? new Set([options.type]) : new Set(HYBRID_SEARCH_TYPES);
@@ -2075,7 +2198,7 @@ export class AiManager {
         this.vertexTokenCache.clear(providerId);
     }
     async testProvider(providerId) {
-        const row = this.getProviderRow(providerId);
+        const { row, configFingerprint, claim } = this.acquireProviderConnectivityTest(providerId);
         const protocol = providerProtocol(row);
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), AI_INTERACTIVE_TIMEOUT_MS);
@@ -2123,39 +2246,62 @@ export class AiManager {
                     : `${lastFailure}；也可先添加模型后再测试连接`);
             }
             await this.probeProviderModel(row, accessToken, probeModel, controller.signal);
-            const timestamp = now();
-            this.store.db.run("UPDATE providers SET connection_status = 'success', last_error = NULL, last_success_at = ?, updated_at = ? WHERE id = ?", timestamp, timestamp, providerId);
+            const cooldown = this.connectivityTestGate.complete(claim, "success", {
+                isConfigurationCurrent: () => {
+                    try {
+                        return this.providerConnectivityTestFingerprint(this.getProviderRow(providerId)) === configFingerprint;
+                    }
+                    catch {
+                        return false;
+                    }
+                },
+                onApplied: (completedAt) => {
+                    this.store.db.run("UPDATE providers SET connection_status = 'success', last_error = NULL, last_success_at = ?, updated_at = ? WHERE id = ?", completedAt, completedAt, providerId);
+                }
+            });
             logger.info("ai.provider_test.completed", {
                 providerId,
                 protocol,
                 ok: true,
+                cooldownApplied: cooldown.reason !== "configuration_changed",
                 availableModelCount: availableModels.length,
                 durationMs: Number(process.hrtime.bigint() - startedAt) / 1_000_000
             });
-            return { ok: true, availableModels, provider: this.getProvider(providerId) };
+            return { ok: true, availableModels, cooldown, provider: this.getProvider(providerId) };
         }
         catch (error) {
             const message = error instanceof Error
                 ? redactProviderSecretsText(error.message, credentialSecret, accessToken)
                 : "连接失败";
-            this.store.db.run("UPDATE providers SET connection_status = 'failed', last_error = ?, updated_at = ? WHERE id = ?", message, now(), providerId);
+            const cooldown = this.connectivityTestGate.complete(claim, "failure", {
+                isConfigurationCurrent: () => {
+                    try {
+                        return this.providerConnectivityTestFingerprint(this.getProviderRow(providerId)) === configFingerprint;
+                    }
+                    catch {
+                        return false;
+                    }
+                },
+                onApplied: (completedAt) => {
+                    this.store.db.run("UPDATE providers SET connection_status = 'failed', last_error = ?, updated_at = ? WHERE id = ?", message, completedAt, providerId);
+                }
+            });
             logger.warn("ai.provider_test.completed", {
                 providerId,
                 protocol,
                 ok: false,
+                cooldownApplied: cooldown.reason !== "configuration_changed",
                 durationMs: Number(process.hrtime.bigint() - startedAt) / 1_000_000,
-                error: aiErrorForLog(error)
+                error: connectivityTestErrorForLog(error)
             });
-            return { ok: false, error: message, provider: this.getProvider(providerId) };
+            return { ok: false, error: message, cooldown, provider: this.getProvider(providerId) };
         }
         finally {
             clearTimeout(timeout);
         }
     }
     async testModel(modelId) {
-        const model = this.getModelRow(modelId);
-        const providerId = stringValue(model, "provider_id");
-        const provider = this.getProviderRow(providerId);
+        const { model, provider, providerId, configFingerprint, claim } = this.acquireModelConnectivityTest(modelId);
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), AI_INTERACTIVE_TIMEOUT_MS);
         const startedAt = process.hrtime.bigint();
@@ -2167,31 +2313,60 @@ export class AiManager {
         try {
             ({ accessToken, credentialSecret } = await this.resolveProviderAccessToken(provider));
             await this.probeProviderModel(provider, accessToken, stringValue(model, "model_id"), controller.signal, { multimodal: multimodalTested });
-            const timestamp = now();
-            this.store.db.run("UPDATE providers SET connection_status = 'success', last_error = NULL, last_success_at = ?, updated_at = ? WHERE id = ?", timestamp, timestamp, providerId);
+            const cooldown = this.connectivityTestGate.complete(claim, "success", {
+                isConfigurationCurrent: () => {
+                    try {
+                        const currentModel = this.getModelRow(modelId);
+                        const currentProvider = this.getProviderRow(stringValue(currentModel, "provider_id"));
+                        return this.modelConnectivityTestFingerprint(currentModel, currentProvider) === configFingerprint;
+                    }
+                    catch {
+                        return false;
+                    }
+                },
+                onApplied: (completedAt) => {
+                    this.store.db.run("UPDATE providers SET connection_status = 'success', last_error = NULL, last_success_at = ?, updated_at = ? WHERE id = ?", completedAt, completedAt, providerId);
+                }
+            });
             logger.info("ai.model_test.completed", {
                 modelId,
                 providerId,
                 protocol,
                 ok: true,
+                cooldownApplied: cooldown.reason !== "configuration_changed",
                 durationMs: Number(process.hrtime.bigint() - startedAt) / 1_000_000
             });
-            return { ok: true, multimodalTested, model: this.getModel(modelId), provider: this.getProvider(providerId) };
+            return { ok: true, multimodalTested, cooldown, model: this.getModel(modelId), provider: this.getProvider(providerId) };
         }
         catch (error) {
             const message = error instanceof Error
                 ? redactProviderSecretsText(error.message, credentialSecret, accessToken)
                 : "连接失败";
-            this.store.db.run("UPDATE providers SET connection_status = 'failed', last_error = ?, updated_at = ? WHERE id = ?", message, now(), providerId);
+            const cooldown = this.connectivityTestGate.complete(claim, "failure", {
+                isConfigurationCurrent: () => {
+                    try {
+                        const currentModel = this.getModelRow(modelId);
+                        const currentProvider = this.getProviderRow(stringValue(currentModel, "provider_id"));
+                        return this.modelConnectivityTestFingerprint(currentModel, currentProvider) === configFingerprint;
+                    }
+                    catch {
+                        return false;
+                    }
+                },
+                onApplied: (completedAt) => {
+                    this.store.db.run("UPDATE providers SET connection_status = 'failed', last_error = ?, updated_at = ? WHERE id = ?", message, completedAt, providerId);
+                }
+            });
             logger.warn("ai.model_test.completed", {
                 modelId,
                 providerId,
                 protocol,
                 ok: false,
+                cooldownApplied: cooldown.reason !== "configuration_changed",
                 durationMs: Number(process.hrtime.bigint() - startedAt) / 1_000_000,
-                error: aiErrorForLog(error)
+                error: connectivityTestErrorForLog(error)
             });
-            return { ok: false, error: message, model: this.getModel(modelId), provider: this.getProvider(providerId) };
+            return { ok: false, error: message, cooldown, model: this.getModel(modelId), provider: this.getProvider(providerId) };
         }
         finally {
             clearTimeout(timeout);
@@ -2377,6 +2552,295 @@ export class AiManager {
             ...(modelId ? { modelId } : {})
         });
     }
+    assertCharacterExtractionTask(taskId) {
+        const task = this.store.getTask(taskId);
+        if (task.taskType !== "character-extraction" && task.taskType !== "character-summary") {
+            throw new AppError(409, "CHARACTER_EXTRACTION_TASK_REQUIRED", "只有角色抽取任务可以预览或应用角色档案");
+        }
+        if (task.status !== "review" && task.status !== "completed") {
+            throw new AppError(409, "CHARACTER_EXTRACTION_TASK_NOT_COMPLETED", "只有已成功完成的角色抽取任务可以应用角色档案");
+        }
+        return task;
+    }
+    characterExtractionMatches(candidate, characters) {
+        const candidateNames = [candidate.name, ...candidate.aliases];
+        const candidateNormalized = new Map(candidateNames.map((name) => [normalizeCharacterName(name), name]));
+        const stable = candidate.stableCharacterId
+            ? characters.find((character) => character.id === candidate.stableCharacterId)
+            : undefined;
+        const matches = new Map();
+        for (const character of characters) {
+            const primaryName = String(character.name);
+            const aliases = Array.isArray(character.aliases) ? character.aliases.map(String) : [];
+            const primaryNormalized = normalizeCharacterName(primaryName);
+            const aliasNormalized = new Set(aliases.map(normalizeCharacterName));
+            const matchedNames = [...candidateNormalized]
+                .filter(([normalized]) => normalized === primaryNormalized || aliasNormalized.has(normalized))
+                .map(([, name]) => name);
+            if (matchedNames.length === 0 && character !== stable)
+                continue;
+            const matchType = character === stable
+                ? "stable"
+                : matchedNames.some((name) => normalizeCharacterName(name) === primaryNormalized)
+                    ? "name"
+                    : "alias";
+            matches.set(String(character.id), {
+                characterId: String(character.id),
+                name: primaryName,
+                aliases,
+                versionNo: Number(character.versionNo),
+                matchType,
+                matchedNames
+            });
+        }
+        const conflicts = [];
+        if (candidate.stableCharacterId && !stable)
+            conflicts.push("任务生成时匹配的角色已不存在，请改为新建或跳过");
+        if (matches.size > 1)
+            conflicts.push("候选名称或别名分别命中了多个已有角色，必须明确选择目标或改名新建");
+        const priority = { stable: 0, name: 1, alias: 2 };
+        return {
+            matches: [...matches.values()].sort((left, right) => priority[left.matchType] - priority[right.matchType]
+                || left.name.localeCompare(right.name, "zh-CN")),
+            conflicts
+        };
+    }
+    characterExtractionPreviewData(task, result, candidates) {
+        const workId = String(task.workId);
+        const characters = this.store.listCharacters(workId, false, false, false);
+        const items = candidates.map((candidate) => {
+            const { matches, conflicts } = this.characterExtractionMatches(candidate, characters);
+            return {
+                ...candidate,
+                suggestedAction: matches.length === 0 ? "create" : matches.length === 1 || matches[0]?.matchType === "stable" ? "merge" : "skip",
+                matchCandidates: matches,
+                conflicts
+            };
+        });
+        const previewToken = characterExtractionHash({
+            taskId: task.id,
+            taskUpdatedAt: task.updatedAt,
+            candidates,
+            roster: characters.map((character) => ({
+                id: character.id,
+                name: character.name,
+                aliases: character.aliases,
+                raceId: character.raceId,
+                identity: character.attributes && typeof character.attributes === "object" && !Array.isArray(character.attributes)
+                    ? String(character.attributes.identity ?? "")
+                    : "",
+                firstChapterId: character.firstChapterId,
+                versionNo: character.versionNo
+            }))
+        });
+        const application = result.characterApplication && typeof result.characterApplication === "object"
+            && !Array.isArray(result.characterApplication)
+            ? result.characterApplication
+            : null;
+        return {
+            taskId: String(task.id),
+            status: application?.status === "applied" ? "applied" : "pending",
+            totalCount: candidates.length,
+            previewToken,
+            items,
+            ...(application?.status === "applied" ? { application } : {})
+        };
+    }
+    getCharacterExtractionPreview(taskId) {
+        const task = this.assertCharacterExtractionTask(taskId);
+        const result = this.store.getTaskStoredResult(taskId);
+        const application = result.characterApplication && typeof result.characterApplication === "object"
+            && !Array.isArray(result.characterApplication)
+            ? result.characterApplication
+            : null;
+        if (application?.status !== "applied" && !this.store.isTaskSourceCurrent(taskId)) {
+            throw new AppError(409, "CHARACTER_EXTRACTION_SOURCE_CHANGED", "任务分析的正文来源已发生变化，请重新运行角色抽取后再应用");
+        }
+        const candidates = parseStoredCharacterExtractionCandidates(result.characterCandidates);
+        return this.characterExtractionPreviewData(task, result, candidates);
+    }
+    characterExtractionFirstChapter(workId, candidate) {
+        if (!candidate.firstChapterId)
+            return { firstChapterId: null };
+        try {
+            const chapter = this.store.getChapter(candidate.firstChapterId);
+            if (chapter.workId === workId)
+                return { firstChapterId: candidate.firstChapterId };
+        }
+        catch {
+            // 原任务结果可能来自旧数据；应用时按当前作品重新核验。
+        }
+        return { firstChapterId: null, conflict: "首次登场章节已不存在或不属于当前作品，未写入该关联" };
+    }
+    applyCharacterExtractionPreview(taskId, previewToken, selections) {
+        this.assertCharacterExtractionTask(taskId);
+        const requestFingerprint = characterExtractionSelectionFingerprint(selections);
+        return this.store.db.transaction(() => {
+            const task = this.assertCharacterExtractionTask(taskId);
+            const result = this.store.getTaskStoredResult(taskId);
+            const application = result.characterApplication && typeof result.characterApplication === "object"
+                && !Array.isArray(result.characterApplication)
+                ? result.characterApplication
+                : null;
+            if (application?.status === "applied") {
+                if (application.requestFingerprint === requestFingerprint)
+                    return application;
+                throw new AppError(409, "CHARACTER_EXTRACTION_ALREADY_APPLIED", "本任务已按另一组确认结果应用，不能再次修改角色档案");
+            }
+            if (!this.store.isTaskSourceCurrent(taskId)) {
+                throw new AppError(409, "CHARACTER_EXTRACTION_SOURCE_CHANGED", "任务分析的正文来源已发生变化，请重新运行角色抽取后再应用");
+            }
+            const candidates = parseStoredCharacterExtractionCandidates(result.characterCandidates);
+            const selectionById = new Map(selections.map((selection) => [selection.candidateId, selection]));
+            if (selectionById.size !== selections.length
+                || selectionById.size !== candidates.length
+                || candidates.some((candidate) => !selectionById.has(candidate.candidateId))) {
+                throw new AppError(400, "CHARACTER_EXTRACTION_SELECTION_INVALID", "必须为预览中的每个角色候选明确选择新建、合并或跳过");
+            }
+            const preview = this.characterExtractionPreviewData(task, result, candidates);
+            if (preview.previewToken !== previewToken) {
+                throw new AppError(409, "CHARACTER_EXTRACTION_PREVIEW_STALE", "角色档案在预览后已发生变化，请刷新预览再确认");
+            }
+            const previewItems = new Map(preview.items
+                .map((item) => [item.candidateId, item]));
+            const workId = String(task.workId);
+            const appliedItems = [];
+            const characterIds = [];
+            for (const candidate of candidates) {
+                const selection = selectionById.get(candidate.candidateId);
+                if (selection.action === "skip") {
+                    appliedItems.push({ candidateId: candidate.candidateId, action: "skip", status: "skipped" });
+                    continue;
+                }
+                const editable = editableCharacterExtractionCandidate(candidate, selection);
+                const firstChapter = this.characterExtractionFirstChapter(workId, candidate);
+                const conflicts = firstChapter.conflict ? [firstChapter.conflict] : [];
+                const raceId = editable.species ? this.store.resolveRaceReference(workId, editable.species) : null;
+                if (editable.species && !raceId)
+                    conflicts.push(`种族“${editable.species}”未命中当前作品已有种族，未写入种族关联`);
+                if (selection.action === "create") {
+                    const created = this.store.createCharacter(workId, {
+                        name: editable.name,
+                        aliases: editable.aliases,
+                        raceId,
+                        attributes: editable.identity ? { identity: editable.identity } : {},
+                        firstChapterId: firstChapter.firstChapterId
+                    }, "ai", taskId, "应用 AI 角色抽取预览并新建档案");
+                    characterIds.push(String(created.id));
+                    appliedItems.push({
+                        candidateId: candidate.candidateId,
+                        action: "create",
+                        status: "created",
+                        characterId: String(created.id),
+                        characterName: String(created.name),
+                        ...(conflicts.length ? { conflicts } : {})
+                    });
+                    continue;
+                }
+                const previewItem = previewItems.get(candidate.candidateId);
+                const targetMatch = previewItem.matchCandidates.find((match) => match.characterId === selection.targetCharacterId);
+                if (!targetMatch || !selection.targetCharacterId) {
+                    throw new AppError(400, "CHARACTER_EXTRACTION_TARGET_INVALID", "合并目标不是服务端预览确认的候选角色", {
+                        candidateId: candidate.candidateId
+                    });
+                }
+                const target = this.store.getCharacter(selection.targetCharacterId);
+                if (target.workId !== workId || target.mergedIntoCharacterId) {
+                    throw new AppError(409, "CHARACTER_EXTRACTION_TARGET_STALE", "合并目标已失效，请刷新预览再确认", {
+                        candidateId: candidate.candidateId
+                    });
+                }
+                const existingAliases = Array.isArray(target.aliases) ? target.aliases.map(String) : [];
+                const existingNames = new Set([String(target.name), ...existingAliases].map(normalizeCharacterName));
+                const addedAliases = [];
+                for (const alias of [editable.name, ...editable.aliases]) {
+                    const normalized = normalizeCharacterName(alias);
+                    if (!normalized || existingNames.has(normalized))
+                        continue;
+                    const ownerId = this.store.resolveCharacterReference(workId, alias);
+                    if (ownerId && ownerId !== target.id) {
+                        conflicts.push(`名称或别名“${alias}”已属于其他角色，未合并该别名`);
+                        continue;
+                    }
+                    existingNames.add(normalized);
+                    addedAliases.push(alias);
+                }
+                const update = {};
+                if (addedAliases.length > 0)
+                    update.aliases = [...existingAliases, ...addedAliases];
+                const attributes = target.attributes && typeof target.attributes === "object" && !Array.isArray(target.attributes)
+                    ? target.attributes
+                    : {};
+                const existingIdentity = typeof attributes.identity === "string" ? attributes.identity.trim() : "";
+                if (editable.identity && !existingIdentity)
+                    update.attributes = { ...attributes, identity: editable.identity };
+                else if (editable.identity && normalizeCharacterName(editable.identity) !== normalizeCharacterName(existingIdentity)) {
+                    conflicts.push("已有身份与定位内容未被抽取结果覆盖");
+                }
+                if (editable.species) {
+                    if (!target.raceId && raceId)
+                        update.raceId = raceId;
+                    else if (target.raceId && (!raceId || target.raceId !== raceId))
+                        conflicts.push("已有种族关联未被抽取结果覆盖");
+                }
+                if (!target.firstChapterId && firstChapter.firstChapterId)
+                    update.firstChapterId = firstChapter.firstChapterId;
+                const changed = Object.keys(update).length > 0;
+                const updated = changed
+                    ? this.store.updateCharacter(String(target.id), update, "ai", taskId, "应用 AI 角色抽取预览并合并可靠信息", Number(target.versionNo))
+                    : target;
+                characterIds.push(String(updated.id));
+                appliedItems.push({
+                    candidateId: candidate.candidateId,
+                    action: "merge",
+                    status: changed ? "merged" : "unchanged",
+                    characterId: String(updated.id),
+                    characterName: String(updated.name),
+                    ...(addedAliases.length ? { addedAliases } : {}),
+                    ...(conflicts.length ? { conflicts } : {})
+                });
+            }
+            const appliedAt = now();
+            const applicationResult = {
+                status: "applied",
+                previewToken,
+                requestFingerprint,
+                ...(typeof application?.generatedAt === "string" ? { generatedAt: application.generatedAt } : {}),
+                appliedAt,
+                totalCount: candidates.length,
+                createdCount: appliedItems.filter((item) => item.status === "created").length,
+                mergedCount: appliedItems.filter((item) => item.status === "merged").length,
+                unchangedCount: appliedItems.filter((item) => item.status === "unchanged").length,
+                skippedCount: appliedItems.filter((item) => item.status === "skipped").length,
+                characterIds: [...new Set(characterIds)],
+                items: appliedItems
+            };
+            this.store.updateTask(taskId, {
+                status: String(task.status),
+                result: {
+                    ...result,
+                    characterIds: applicationResult.characterIds,
+                    savedCount: applicationResult.characterIds.length,
+                    characterApplication: applicationResult
+                }
+            });
+            this.store.audit(workId, "character.extraction.applied", "analysis-task", taskId, {
+                createdCount: applicationResult.createdCount,
+                mergedCount: applicationResult.mergedCount,
+                unchangedCount: applicationResult.unchangedCount,
+                skippedCount: applicationResult.skippedCount,
+                characterIds: applicationResult.characterIds
+            });
+            logger.info("ai.character_extraction.applied", {
+                taskId,
+                workId,
+                createdCount: applicationResult.createdCount,
+                mergedCount: applicationResult.mergedCount,
+                skippedCount: applicationResult.skippedCount
+            });
+            return applicationResult;
+        });
+    }
     applyRelationshipChangePreview(taskId) {
         const task = this.store.getTask(taskId);
         if (task.taskType !== "relationship-analysis") {
@@ -3192,18 +3656,29 @@ export class AiManager {
             }
         };
     }
-    async prepareConversationContext(input) {
+    inspectConversationContext(input) {
         const usage = this.getContextUsage({ ...input, taskType: "chat" });
         const conversation = this.store.getAiConversationContext(input.conversationId, input.workId);
         if (!usage.compactRecommended) {
-            if (conversation.warningPending)
-                this.store.setAiConversationContextWarning(input.conversationId, false);
             return { action: "ready", usage: { ...usage, contextWarningPending: false } };
         }
         if (!conversation.warningPending) {
-            this.store.setAiConversationContextWarning(input.conversationId, true);
             return { action: "warn", usage: { ...usage, contextWarningPending: true } };
         }
+        return { action: "compact", usage };
+    }
+    async prepareConversationContext(input, options = {}) {
+        const inspection = this.inspectConversationContext(input);
+        if (inspection.action === "ready") {
+            const conversation = this.store.getAiConversationContext(input.conversationId, input.workId);
+            if (conversation.warningPending)
+                this.store.setAiConversationContextWarning(input.conversationId, false);
+            return inspection;
+        }
+        if (inspection.action === "warn" && !options.skipWarning) {
+            this.store.setAiConversationContextWarning(input.conversationId, true);
+            return inspection;
+        }
         const compaction = await this.compactConversation(input);
         const compactedUsage = this.getContextUsage({ ...input, taskType: "chat" });
         return { action: "compacted", usage: compactedUsage, compaction };
@@ -3216,7 +3691,7 @@ export class AiManager {
         return this.mergeInstructionEntityMatches(input.scope, matches);
     }
     async compactConversation(input) {
-        const conversation = this.store.getAiConversationContext(input.conversationId, input.workId);
+        const conversation = this.store.getAiConversationContext(input.conversationId, input.workId, input.excludeConversationMessageId);
         const { model } = this.resolveModel(input.workId, "chat", input.modelId);
         const budget = this.contextBudget({ ...input, taskType: "chat", instruction: "" }, model);
         const recentTokenBudget = Math.max(128, Math.floor(Number(budget.conversationBudgetTokens) * 0.75));
@@ -4304,6 +4779,7 @@ export class AiManager {
             toolCount: tools.length
         });
         let activeSecrets = [];
+        let streamedContent = "";
         let trackedInputTokens = 0;
         let trackedOutputTokens = 0;
         let trackedCachedInputTokens = 0;
@@ -4337,7 +4813,6 @@ export class AiManager {
             let totalCachedInputTokens = 0;
             const processSteps = [];
             const completionDelivery = new WeakMap();
-            let streamedContent = "";
             let streamingGenerationRound = 0;
             const requestCompletion = async (toolChoice, options = {}) => {
                 const requestMessages = options.messages ?? completionMessages;
@@ -4387,7 +4862,14 @@ export class AiManager {
                                 forwardAbort();
                             else
                                 input.signal?.addEventListener("abort", forwardAbort, { once: true });
-                            const timeout = setTimeout(() => controller.abort(new Error(`AI 请求超时（${Math.round(timeoutMs / 1_000)} 秒）`)), timeoutMs);
+                            const streamWatchdog = streamResponse
+                                ? new InteractiveStreamIdleWatchdog(controller, this.interactiveStreamIdleTimeoutMs)
+                                : null;
+                            const timeout = streamResponse
+                                ? null
+                                : setTimeout(() => controller.abort(new Error(`AI 请求超时（${Math.round(timeoutMs / 1_000)} 秒）`)), timeoutMs);
+                            let responseReceived = false;
+                            streamWatchdog?.start();
                             try {
                                 const response = await this.outboundFetch(endpoint, {
                                     method: "POST",
@@ -4403,6 +4885,7 @@ export class AiManager {
                                     })),
                                     signal: controller.signal
                                 });
+                                responseReceived = true;
                                 if (!response.ok) {
                                     return { ok: false, status: response.status, body: await readResponseTextLimited(response) };
                                 }
@@ -4435,7 +4918,8 @@ export class AiManager {
                                     }
                                     streamedThinkingStep.content += delta;
                                     input.onProcessStep?.({ ...streamedThinkingStep, content: delta, append: true });
-                                });
+                                }, () => streamWatchdog?.receivedEvent());
+                                streamWatchdog?.complete();
                                 return {
                                     ok: true,
                                     status: response.status,
@@ -4443,8 +4927,20 @@ export class AiManager {
                                     delivery: "sse"
                                 };
                             }
+                            catch (error) {
+                                if (streamResponse && input.signal?.aborted)
+                                    throw interactiveStreamRequestCancelledError();
+                                if (streamWatchdog?.failure)
+                                    throw streamWatchdog.failure;
+                                if (streamResponse && !responseReceived) {
+                                    throw new AppError(502, "AI_STREAM_NETWORK_ERROR", "AI 上游流连接失败，尚未收到首个事件");
+                                }
+                                throw error;
+                            }
                             finally {
-                                clearTimeout(timeout);
+                                if (timeout)
+                                    clearTimeout(timeout);
+                                streamWatchdog?.dispose();
                                 input.signal?.removeEventListener("abort", forwardAbort);
                             }
                         });
@@ -4489,6 +4985,8 @@ export class AiManager {
                     }
                     catch (error) {
                         lastFailure = error;
+                        if (isInteractiveStreamError(error))
+                            retryable = false;
                         if (traceAttempt.status === "running") {
                             traceAttempt.completedAt = now();
                             traceAttempt.status = "failed";
@@ -4785,10 +5283,10 @@ export class AiManager {
             const message = error instanceof Error ? redactProviderSecretsText(error.message, ...activeSecrets) : "AI 调用失败";
             const failureTarget = aiFailureTargetDetails(provider, model);
             this.store.db.run(`UPDATE ai_calls
-         SET status = 'failed', failure = ?, input_tokens = ?, output_tokens = ?,
+         SET status = 'failed', failure = ?, output_chars = ?, input_tokens = ?, output_tokens = ?,
              cached_input_tokens = ?, cache_eligible_input_tokens = ?, cache_usage_available = ?,
              token_usage_source = ?, completed_at = ?
-         WHERE id = ?`, message, trackedInputTokens, trackedOutputTokens, trackedCachedInputTokens, trackedCacheEligibleInputTokens, trackedCacheEligibleInputTokens > 0 ? 1 : 0, trackedUsageSource(), now(), callId);
+         WHERE id = ?`, message, streamedContent.length, trackedInputTokens, trackedOutputTokens, trackedCachedInputTokens, trackedCacheEligibleInputTokens, trackedCacheEligibleInputTokens > 0 ? 1 : 0, trackedUsageSource(), now(), callId);
             logger.error("ai.call.failed", {
                 callId,
                 workId: input.workId,
@@ -4797,7 +5295,9 @@ export class AiManager {
                 durationMs: Number(process.hrtime.bigint() - callStartedAt) / 1_000_000,
                 error: aiErrorForLog(error)
             });
-            if (error instanceof AppError && (error.code === "CONTEXT_WINDOW_EXCEEDED" || error.code === "DAILY_TOKEN_QUOTA_EXCEEDED")) {
+            if (error instanceof AppError && (error.code === "CONTEXT_WINDOW_EXCEEDED"
+                || error.code === "DAILY_TOKEN_QUOTA_EXCEEDED"
+                || isInteractiveStreamError(error))) {
                 throw new AppError(error.status, error.code, error.message, {
                     callId,
                     ...(error.details && typeof error.details === "object" ? error.details : {}),
@@ -4807,7 +5307,7 @@ export class AiManager {
             throw new AppError(502, "AI_CALL_FAILED", "AI 调用失败", { callId, failure: message, ...failureTarget });
         }
     }
-    async readCompletionStream(response, protocol, apiKey, onDelta, onThinkingDelta) {
+    async readCompletionStream(response, protocol, apiKey, onDelta, onThinkingDelta, onEvent) {
         const protocolLabel = providerProtocolLabelText(protocol);
         if (!response.body)
             throw new Error(`${protocolLabel} 流式响应缺少正文`);
@@ -4880,10 +5380,10 @@ export class AiManager {
                 .join("\n")
                 .trim();
             if (!data)
-                return;
+                return false;
             if (data === "[DONE]") {
                 upstreamDone = true;
-                return;
+                return true;
             }
             const payload = JSON.parse(data);
             const error = payload.error && typeof payload.error === "object" && !Array.isArray(payload.error)
@@ -4960,7 +5460,7 @@ export class AiManager {
                 }
                 if (type === "message_stop")
                     upstreamDone = true;
-                return;
+                return true;
             }
             const streamUsage = payload.usage && typeof payload.usage === "object" && !Array.isArray(payload.usage)
                 ? payload.usage
@@ -5011,44 +5511,74 @@ export class AiManager {
             if (typeof delta === "string" && delta.length > 0) {
                 appendContent(delta);
             }
+            return true;
+        };
+        let redactorsFlushed = false;
+        const flushRedactors = (interrupted) => {
+            if (redactorsFlushed)
+                return;
+            redactorsFlushed = true;
+            const finalContent = contentRedactor.flush({ interrupted });
+            if (finalContent) {
+                content += finalContent;
+                onDelta(finalContent);
+            }
+            const finalReasoning = reasoningRedactor.flush({ interrupted });
+            if (finalReasoning) {
+                reasoning += finalReasoning;
+                onThinkingDelta(finalReasoning);
+            }
         };
         let receivedBytes = 0;
-        while (true) {
-            const chunk = await reader.read();
-            if (chunk.value?.byteLength) {
-                receivedBytes += chunk.value.byteLength;
-                if (receivedBytes > AI_RESPONSE_MAX_BYTES) {
+        let readerEnded = false;
+        try {
+            while (true) {
+                let chunk;
+                try {
+                    chunk = await reader.read();
+                }
+                catch (error) {
+                    if (error instanceof AppError)
+                        throw error;
+                    throw new AppError(502, "AI_STREAM_NETWORK_ERROR", "AI 上游流连接中断，已保留已生成内容");
+                }
+                if (chunk.value?.byteLength) {
+                    receivedBytes += chunk.value.byteLength;
+                    if (receivedBytes > AI_RESPONSE_MAX_BYTES) {
+                        await reader.cancel().catch(() => undefined);
+                        throw new AppError(502, "AI_RESPONSE_TOO_LARGE", `AI 供应商响应超过 ${AI_RESPONSE_MAX_BYTES} 字节上限`);
+                    }
+                }
+                buffer += decoder.decode(chunk.value, { stream: !chunk.done });
+                const events = buffer.split(/\r?\n\r?\n/u);
+                buffer = events.pop() ?? "";
+                for (const eventText of events) {
+                    if (consumeEvent(eventText))
+                        onEvent();
+                    if (upstreamDone)
+                        break;
+                }
+                if (upstreamDone) {
                     await reader.cancel().catch(() => undefined);
-                    throw new AppError(502, "AI_RESPONSE_TOO_LARGE", `AI 供应商响应超过 ${AI_RESPONSE_MAX_BYTES} 字节上限`);
+                    buffer = "";
+                    break;
                 }
-            }
-            buffer += decoder.decode(chunk.value, { stream: !chunk.done });
-            const events = buffer.split(/\r?\n\r?\n/u);
-            buffer = events.pop() ?? "";
-            for (const eventText of events) {
-                consumeEvent(eventText);
-                if (upstreamDone)
+                if (chunk.done) {
+                    readerEnded = true;
                     break;
+                }
             }
-            if (upstreamDone) {
-                await reader.cancel().catch(() => undefined);
-                buffer = "";
-                break;
-            }
-            if (chunk.done)
-                break;
+            if (buffer.trim() && consumeEvent(buffer))
+                onEvent();
         }
-        if (buffer.trim())
-            consumeEvent(buffer);
-        const finalContent = contentRedactor.flush();
-        if (finalContent) {
-            content += finalContent;
-            onDelta(finalContent);
+        catch (error) {
+            flushRedactors(true);
+            throw error;
         }
-        const finalReasoning = reasoningRedactor.flush();
-        if (finalReasoning) {
-            reasoning += finalReasoning;
-            onThinkingDelta(finalReasoning);
+        const upstreamClosed = readerEnded && !upstreamDone && finishReason === "unknown";
+        flushRedactors(upstreamClosed);
+        if (upstreamClosed) {
+            throw new AppError(502, "AI_STREAM_UPSTREAM_CLOSED", "AI 上游流在正常结束前已关闭，已保留已生成内容");
         }
         const sortedOpenAiToolCalls = [...openAiToolCalls.entries()].sort(([left], [right]) => left - right);
         const openAiToolCallsComplete = openAiToolCallsFinalized
@@ -5706,9 +6236,12 @@ export class AiManager {
             return { interrupted: true, callIds };
         const byChapterId = new Map(chapters.map((chapter) => [String(chapter.id), chapter]));
         const groups = [];
+        const preprocessingSkipped = [];
         for (const candidate of rawCandidates) {
-            if (typeof candidate.canonicalName !== "string" || !candidate.canonicalName.trim())
+            if (typeof candidate.canonicalName !== "string" || !candidate.canonicalName.trim()) {
+                preprocessingSkipped.push({ name: "未命名候选", reason: "角色标准名为空，未进入入库预览" });
                 continue;
+            }
             const name = candidate.canonicalName.normalize("NFKC").trim();
             const aliases = (Array.isArray(candidate.aliases) ? candidate.aliases : [])
                 .filter((value) => typeof value === "string")
@@ -5720,8 +6253,10 @@ export class AiManager {
             const chapterId = evidence && typeof evidence.chapterId === "string" ? evidence.chapterId : null;
             const quote = evidence && typeof evidence.quote === "string" ? evidence.quote.trim() : "";
             if (!chapterId || !quote || quote.length > 80 || !byChapterId.has(chapterId)
-                || !this.quoteExists(String(byChapterId.get(chapterId)?.content ?? ""), quote))
+                || !this.quoteExists(String(byChapterId.get(chapterId)?.content ?? ""), quote)) {
+                preprocessingSkipped.push({ name: name.slice(0, 200), reason: "首次出现证据无效或无法在本次正文范围内核验" });
                 continue;
+            }
             const refs = new Set([name, ...aliases].map((value) => this.normalizeReference(value)));
             const matches = groups.filter((group) => [...refs].some((value) => group.references.has(value)));
             const group = matches[0] ?? {
@@ -5818,7 +6353,7 @@ export class AiManager {
                 addVerificationPair(candidateSubjects[leftIndex], existing);
             }
         }
-        const skipped = [];
+        const skipped = [...preprocessingSkipped];
         let verificationCallId = null;
         let confirmedSameCount = 0;
         let confirmedSeparateCount = 0;
@@ -5940,50 +6475,42 @@ export class AiManager {
             if (!blockedReasons.has(root) && blockedReasons.has(index))
                 blockedReasons.set(root, blockedReasons.get(index));
         }
-        const characterIds = [];
+        const characterCandidates = [];
         for (const [root, group] of mergedGroups) {
             if (blockedGroups.has(root)) {
                 skipped.push({ name: group.name, reason: blockedReasons.get(root) ?? "角色身份二次确认未通过" });
                 continue;
             }
             const aliases = [...group.aliases].filter((alias) => this.isSafeGlobalAlias(alias));
-            const extractedRaceId = group.species ? this.store.resolveRaceReference(workId, group.species) : null;
             const existingId = existingIdByRoot.get(root) ?? [group.name, ...aliases]
                 .map((value) => this.store.resolveCharacterReference(workId, value))
                 .find((value) => Boolean(value));
-            try {
-                if (existingId) {
-                    const existing = this.store.getCharacter(existingId);
-                    const mergedAliases = [...new Set([...existing.aliases, group.name, ...aliases])]
-                        .filter((alias) => this.isSafeGlobalAlias(alias) && this.normalizeReference(alias) !== this.normalizeReference(String(existing.name)));
-                    const updated = this.store.updateCharacter(existingId, {
-                        aliases: mergedAliases,
-                        raceId: existing.raceId ?? extractedRaceId,
-                        attributes: { ...existing.attributes, ...(group.identity ? { identity: group.identity } : {}) },
-                        firstChapterId: existing.firstChapterId ?? group.firstChapterId
-                    }, "ai", taskId ?? null, "全书角色抽取及身份二次确认");
-                    characterIds.push(String(updated.id));
-                }
-                else {
-                    const created = this.store.createCharacter(workId, {
-                        name: group.name,
-                        aliases,
-                        raceId: extractedRaceId,
-                        attributes: group.identity ? { identity: group.identity } : {},
-                        firstChapterId: group.firstChapterId
-                    });
-                    characterIds.push(String(created.id));
-                }
-            }
-            catch (error) {
-                skipped.push({ name: group.name, reason: error instanceof Error ? error.message : "名称冲突" });
-            }
+            const candidate = normalizeCharacterExtractionCandidate({
+                name: group.name,
+                aliases,
+                species: group.species,
+                identity: group.identity,
+                firstChapterId: group.firstChapterId,
+                firstEvidence: group.firstEvidence,
+                stableCharacterId: existingId ?? null
+            }, characterCandidates.length);
+            if (candidate)
+                characterCandidates.push(candidate);
+            else
+                skipped.push({ name: group.name.slice(0, 200), reason: "候选名称或属性不符合角色档案字段限制" });
         }
+        const generatedAt = now();
         return {
-            characterIds: [...new Set(characterIds)],
-            candidateCount: mergedGroups.size,
-            savedCount: new Set(characterIds).size,
+            characterIds: [],
+            characterCandidates,
+            candidateCount: characterCandidates.length,
+            savedCount: 0,
             skipped,
+            characterApplication: {
+                status: "pending",
+                totalCount: characterCandidates.length,
+                generatedAt
+            },
             batchCount: chunks.length,
             coveredChapterCount: chapters.length,
             fallbackSegmentCount,
@@ -8634,6 +9161,53 @@ export class AiManager {
             throw new AppError(500, "CREDENTIAL_DECRYPT_FAILED", "供应商凭据无法解密，请重新填写密钥或服务账号 JSON");
         }
     }
+    providerConnectivityTestFingerprint(row) {
+        const localModels = this.store.db.all("SELECT * FROM models WHERE provider_id = ? ORDER BY created_at, id", stringValue(row, "id")).map((model) => [
+            stringValue(model, "id"),
+            connectivityConfigurationValues(model, modelConnectivityConfigurationFields)
+        ]);
+        return hashAiConnectivityConfiguration([
+            "provider-connectivity-v1",
+            connectivityConfigurationValues(row, providerConnectivityConfigurationFields),
+            localModels
+        ]);
+    }
+    acquireProviderConnectivityTest(providerId) {
+        const acquired = this.connectivityTestGate.acquireWithConfiguration("provider", providerId, () => {
+            const row = this.getProviderRow(providerId);
+            const configFingerprint = this.providerConnectivityTestFingerprint(row);
+            return { configFingerprint, configuration: row };
+        });
+        return {
+            row: acquired.configuration,
+            configFingerprint: acquired.configFingerprint,
+            claim: acquired.claim
+        };
+    }
+    modelConnectivityTestFingerprint(model, provider) {
+        return hashAiConnectivityConfiguration([
+            "model-connectivity-v1",
+            connectivityConfigurationValues(provider, providerConnectivityConfigurationFields),
+            connectivityConfigurationValues(model, modelConnectivityConfigurationFields)
+        ]);
+    }
+    acquireModelConnectivityTest(modelId) {
+        const acquired = this.connectivityTestGate.acquireWithConfiguration("model", modelId, () => {
+            const model = this.getModelRow(modelId);
+            const providerId = stringValue(model, "provider_id");
+            const provider = this.getProviderRow(providerId);
+            const configFingerprint = this.modelConnectivityTestFingerprint(model, provider);
+            return {
+                configFingerprint,
+                configuration: { model, provider, providerId }
+            };
+        });
+        return {
+            ...acquired.configuration,
+            configFingerprint: acquired.configFingerprint,
+            claim: acquired.claim
+        };
+    }
     getProviderRow(providerId) {
         const row = this.store.db.get("SELECT * FROM providers WHERE id = ?", providerId);
         if (!row)