tickflow-assist 0.3.5 → 0.3.7

package/dist/services/alert-service.js

@@ -1,4 +1,9 @@
+import { randomBytes } from "node:crypto";
+import { copyFile, mkdir, unlink } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
 import { createCommandRunner } from "../runtime/command-runner.js";
+import { basenameOrUndefined, buildAlertMessageHash, buildAlertSendId, truncateDiagnosticText, } from "../utils/alert-diagnostic-log.js";
 import { calculateProfitPct, formatCostPrice } from "../utils/cost-price.js";
 export class AlertService {
     options;
@@ -16,55 +21,84 @@ export class AlertService {
     async sendWithResult(input) {
         this.lastError = null;
         const payload = normalizeSendInput(input);
+        const sendId = buildAlertSendId(payload.message);
+        const messageHash = buildAlertMessageHash(payload.message);
+        const diagnosticContext = {
+            sendId,
+            step: "primary",
+            messageHash,
+        };
         const mediaAttempted = Boolean(payload.mediaPath);
-        const primaryError = await this.trySendPayload(payload);
-        if (primaryError === null) {
-            return {
+        await this.logDiagnostic("send_started", {
+            sendId,
+            step: diagnosticContext.step,
+            channel: this.channel,
+            messageHash,
+            messageLength: payload.message.length,
+            hasMedia: mediaAttempted,
+            mediaFile: basenameOrUndefined(payload.mediaPath),
+            filename: payload.filename,
+            accountConfigured: Boolean(this.options.account.trim()),
+            targetConfigured: Boolean(this.options.target.trim()),
+            runtimeAvailable: Boolean(this.options.runtime),
+            messagePreview: truncateDiagnosticText(payload.message.split("\n")[0] ?? ""),
+        });
+        const primaryFailure = await this.trySendPayload(payload, diagnosticContext);
+        if (primaryFailure === null) {
+            const result = {
                 ok: true,
                 mediaAttempted,
                 mediaDelivered: mediaAttempted,
                 error: null,
             };
+            await this.logCompletion(sendId, messageHash, payload, result);
+            return result;
         }
         if (payload.mediaPath) {
-            if (payload.message.trim()) {
-                const mediaOnlyError = await this.trySendPayload({
-                    ...payload,
-                    message: "",
-                });
-                if (mediaOnlyError === null) {
-                    const textFollowupError = await this.trySendPayload({ message: payload.message });
-                    return {
-                        ok: textFollowupError === null,
-                        mediaAttempted: true,
-                        mediaDelivered: true,
-                        error: textFollowupError,
-                    };
-                }
+            if (primaryFailure.ambiguous) {
+                const result = {
+                    ok: false,
+                    mediaAttempted: true,
+                    mediaDelivered: false,
+                    error: primaryFailure.error,
+                    deliveryUncertain: true,
+                };
+                await this.logCompletion(sendId, messageHash, payload, result);
+                return result;
             }
             const textFallback = normalizeSendInput(payload.message);
-            const textFallbackError = await this.trySendPayload(textFallback);
-            if (textFallbackError === null) {
-                return {
+            const textFallbackFailure = await this.trySendPayload(textFallback, {
+                sendId,
+                step: "text_fallback",
+                messageHash,
+            });
+            if (textFallbackFailure === null) {
+                const result = {
                     ok: true,
                     mediaAttempted: true,
                     mediaDelivered: false,
-                    error: primaryError,
+                    error: primaryFailure.error,
                 };
+                await this.logCompletion(sendId, messageHash, payload, result);
+                return result;
             }
-            return {
+            const result = {
                 ok: false,
                 mediaAttempted: true,
                 mediaDelivered: false,
-                error: this.combineErrors(primaryError, textFallbackError),
+                error: this.combineErrors(primaryFailure.error, textFallbackFailure.error),
             };
+            await this.logCompletion(sendId, messageHash, payload, result);
+            return result;
         }
-        return {
+        const result = {
             ok: false,
             mediaAttempted: false,
             mediaDelivered: false,
-            error: primaryError,
+            error: primaryFailure.error,
         };
+        await this.logCompletion(sendId, messageHash, payload, result);
+        return result;
     }
     getLastError() {
         return this.lastError;
@@ -132,17 +166,35 @@ export class AlertService {
         }
         return `${runtimeError}; ${fallbackError}`;
     }
-    async trySendPayload(payload) {
-        const runtimeError = await this.trySendViaRuntime(payload);
-        if (runtimeError === null) {
+    async trySendPayload(payload, context) {
+        // OpenClaw documents `api.runtime.channel` as channel-plugin-specific helper
+        // surface. For a regular tool/service plugin like tickflow-assist, Telegram
+        // and QQ Bot delivery are more reliable via the shared
+        // `openclaw message send` CLI path.
+        if (this.channel === "telegram" || this.channel === "qqbot") {
+            return await this.trySendViaCommand(payload, context);
+        }
+        const runtimeFailure = await this.trySendViaRuntime(payload, context);
+        if (runtimeFailure === null) {
             return null;
         }
-        return await this.trySendViaCommand(payload);
+        // Only image/media sends are risky to replay after an ambiguous transport error.
+        // Text-only notifications (for example session boundary notifications) should
+        // still fall back to the CLI path so transient runtime failures do not drop them.
+        if (runtimeFailure.ambiguous && payload.mediaPath) {
+            return runtimeFailure;
+        }
+        return await this.trySendViaCommand(payload, context);
     }
-    async trySendViaRuntime(payload) {
+    async trySendViaRuntime(payload, context) {
         const runtimeContext = this.options.runtime;
         if (!runtimeContext || !this.options.target.trim()) {
-            return "runtime delivery unavailable";
+            const failure = {
+                error: "runtime delivery unavailable",
+                ambiguous: false,
+            };
+            await this.logTransportFailure("runtime_unavailable", context, payload, failure);
+            return failure;
         }
         const baseOptions = {
             accountId: this.options.account || undefined,
@@ -152,33 +204,51 @@ export class AlertService {
         };
         try {
             switch (this.channel) {
-                case "telegram":
-                    await this.invokeRuntimeChannelSend(runtimeContext.runtime.channel, "telegram", "sendMessageTelegram", this.options.target, payload.message, baseOptions);
-                    return null;
                 case "discord":
                     await this.invokeRuntimeChannelSend(runtimeContext.runtime.channel, "discord", "sendMessageDiscord", this.options.target, payload.message, {
                         ...baseOptions,
                         filename: payload.filename,
                     });
-                    return null;
+                    break;
                 case "slack":
                     await this.invokeRuntimeChannelSend(runtimeContext.runtime.channel, "slack", "sendMessageSlack", this.options.target, payload.message, {
                         ...baseOptions,
                         uploadFileName: payload.filename,
                         uploadTitle: payload.filename,
                     });
-                    return null;
+                    break;
                 case "signal":
                     await this.invokeRuntimeChannelSend(runtimeContext.runtime.channel, "signal", "sendMessageSignal", this.options.target, payload.message, baseOptions);
-                    return null;
+                    break;
                 default:
                     // OpenClaw 2026.3.31 narrows the typed runtime channel surface.
                     // Fall back to `openclaw message send` for channels not exposed here.
-                    return `runtime delivery not supported for channel: ${this.channel}`;
+                    const failure = {
+                        error: `runtime delivery not supported for channel: ${this.channel}`,
+                        ambiguous: false,
+                    };
+                    await this.logTransportFailure("runtime_unsupported", context, payload, failure);
+                    return failure;
             }
+            await this.logDiagnostic("transport_success", {
+                sendId: context.sendId,
+                step: context.step,
+                transport: "runtime",
+                channel: this.channel,
+                messageHash: context.messageHash,
+                hasMedia: Boolean(payload.mediaPath),
+                mediaFile: basenameOrUndefined(payload.mediaPath),
+            });
+            return null;
         }
         catch (error) {
-            return `runtime delivery failed: ${formatErrorMessage(error)}`;
+            const detail = formatErrorMessage(error);
+            const failure = {
+                error: `runtime delivery failed: ${detail}`,
+                ambiguous: !isRuntimeCapabilityUnavailableError(detail),
+            };
+            await this.logTransportFailure("runtime_failed", context, payload, failure);
+            return failure;
         }
     }
     async invokeRuntimeChannelSend(runtimeChannel, channelName, methodName, target, message, options) {
@@ -189,19 +259,94 @@ export class AlertService {
         }
         await method.call(channelApi, target, message, options);
     }
-    async trySendViaCommand(payload) {
+    async trySendViaCommand(payload, context) {
+        const prepared = await this.prepareCommandPayload(payload);
+        const commandOptions = this.getCommandRunOptions(prepared.payload);
         try {
-            const result = await this.runCommandWithTimeout(this.buildCliArgs(payload), { timeoutMs: 15_000 });
+            const result = await this.runCommandWithTimeout(this.buildCliArgs(prepared.payload), commandOptions);
             if (result.code === 0) {
+                const commandOutcome = inspectCommandDeliveryResult(result.stdout);
+                if (commandOutcome?.error) {
+                    const failure = {
+                        error: commandOutcome.error,
+                        ambiguous: false,
+                    };
+                    await this.logTransportFailure("command_reported_error", context, payload, failure, {
+                        timeoutMs: commandOptions.timeoutMs,
+                        termination: result.termination,
+                        messageId: commandOutcome.messageId,
+                        stdout: truncateDiagnosticText(result.stdout.trim()),
+                    });
+                    return failure;
+                }
+                await this.logDiagnostic("transport_success", {
+                    sendId: context.sendId,
+                    step: context.step,
+                    transport: "command",
+                    channel: this.channel,
+                    messageHash: context.messageHash,
+                    hasMedia: Boolean(payload.mediaPath),
+                    mediaFile: basenameOrUndefined(payload.mediaPath),
+                    timeoutMs: commandOptions.timeoutMs,
+                    termination: result.termination,
+                    messageId: commandOutcome?.messageId,
+                });
                 return null;
             }
-            return (result.stderr.trim()
-                || result.stdout.trim()
-                || `command exited with ${result.code ?? "unknown"}`);
+            const failure = {
+                error: result.stderr.trim()
+                    || result.stdout.trim()
+                    || `command exited with ${result.code ?? "unknown"}`,
+                ambiguous: true,
+            };
+            await this.logTransportFailure("command_failed", context, payload, failure, {
+                code: result.code,
+                timeoutMs: commandOptions.timeoutMs,
+                termination: result.termination,
+                stderr: truncateDiagnosticText(result.stderr.trim()),
+                stdout: truncateDiagnosticText(result.stdout.trim()),
+            });
+            return failure;
         }
         catch (error) {
-            return `command delivery failed: ${formatErrorMessage(error)}`;
+            const failure = {
+                error: `command delivery failed: ${formatErrorMessage(error)}`,
+                ambiguous: false,
+            };
+            await this.logTransportFailure("command_error", context, payload, failure);
+            return failure;
+        }
+        finally {
+            await prepared.cleanup();
+        }
+    }
+    async prepareCommandPayload(payload) {
+        if (!shouldStageQQBotMedia(this.channel, payload.mediaPath)) {
+            return {
+                payload,
+                cleanup: async () => { },
+            };
+        }
+        const stagedMediaPath = await stageQQBotMediaFile(payload.mediaPath);
+        return {
+            payload: {
+                ...payload,
+                mediaPath: stagedMediaPath,
+            },
+            cleanup: async () => {
+                await unlink(stagedMediaPath).catch((error) => {
+                    if (error.code !== "ENOENT") {
+                        throw error;
+                    }
+                });
+            },
+        };
+    }
+    getCommandRunOptions(payload) {
+        if (payload.mediaPath) {
+            return { timeoutMs: 45_000 };
         }
+        return { timeoutMs: 15_000 };
     }
     buildCliArgs(payload) {
         const args = [
@@ -223,8 +368,40 @@ export class AlertService {
         if (this.options.account) {
             args.push("--account", this.options.account);
         }
+        args.push("--json");
         return args;
     }
+    async logCompletion(sendId, messageHash, payload, result) {
+        await this.logDiagnostic("send_completed", {
+            sendId,
+            channel: this.channel,
+            messageHash,
+            hasMedia: Boolean(payload.mediaPath),
+            mediaFile: basenameOrUndefined(payload.mediaPath),
+            ok: result.ok,
+            mediaAttempted: result.mediaAttempted,
+            mediaDelivered: result.mediaDelivered,
+            deliveryUncertain: result.deliveryUncertain === true,
+            error: result.error ? truncateDiagnosticText(result.error) : null,
+        });
+    }
+    async logTransportFailure(event, context, payload, failure, extra = {}) {
+        await this.logDiagnostic(event, {
+            sendId: context.sendId,
+            step: context.step,
+            transport: event.startsWith("command") ? "command" : "runtime",
+            channel: this.channel,
+            messageHash: context.messageHash,
+            hasMedia: Boolean(payload.mediaPath),
+            mediaFile: basenameOrUndefined(payload.mediaPath),
+            ambiguous: failure.ambiguous,
+            error: truncateDiagnosticText(failure.error),
+            ...extra,
+        });
+    }
+    async logDiagnostic(event, details) {
+        await this.options.diagnosticLogger?.append("alert_service", event, details);
+    }
 }
 function formatErrorMessage(error) {
     if (error instanceof Error) {
@@ -240,11 +417,62 @@ function formatErrorMessage(error) {
         return String(error);
     }
 }
+function isRuntimeCapabilityUnavailableError(detail) {
+    return /runtime channel .* unavailable/i.test(detail);
+}
 function normalizeSendInput(input) {
     return typeof input === "string"
         ? { message: input }
         : input;
 }
+function inspectCommandDeliveryResult(stdout) {
+    const payload = extractCommandJsonPayload(stdout);
+    if (!payload) {
+        return null;
+    }
+    const directResult = isRecord(payload.result) ? payload.result : null;
+    const directResultMeta = isRecord(directResult?.meta) ? directResult.meta : null;
+    const error = getNonEmptyString(directResult?.error)
+        ?? getNonEmptyString(directResultMeta?.error)
+        ?? getNonEmptyString(payload.error);
+    const messageId = getNonEmptyString(directResult?.messageId)
+        ?? getNonEmptyString(directResultMeta?.messageId)
+        ?? getNonEmptyString(payload.messageId);
+    if (!error && !messageId) {
+        return null;
+    }
+    return {
+        ...(error ? { error } : {}),
+        ...(messageId ? { messageId } : {}),
+    };
+}
+function extractCommandJsonPayload(stdout) {
+    const root = extractTrailingJsonObject(stdout);
+    if (!root) {
+        return null;
+    }
+    return isRecord(root.payload) ? root.payload : root;
+}
+function extractTrailingJsonObject(stdout) {
+    const trimmed = stdout.trim();
+    if (!trimmed) {
+        return null;
+    }
+    for (let start = trimmed.lastIndexOf("{"); start >= 0; start = trimmed.lastIndexOf("{", start - 1)) {
+        const candidate = trimmed.slice(start);
+        try {
+            const parsed = JSON.parse(candidate);
+            const record = isRecord(parsed) ? parsed : null;
+            if (record) {
+                return record;
+            }
+        }
+        catch {
+            // Keep scanning backward until the trailing JSON object is found.
+        }
+    }
+    return null;
+}
 function getRuntimeChannelApi(runtimeChannel, channelName) {
     if (!isRecord(runtimeChannel)) {
         return null;
@@ -255,6 +483,60 @@ function getRuntimeChannelApi(runtimeChannel, channelName) {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function getNonEmptyString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function shouldStageQQBotMedia(channel, mediaPath) {
+    return channel === "qqbot"
+        && typeof mediaPath === "string"
+        && mediaPath.length > 0
+        && !isRemoteMediaPath(mediaPath)
+        && !isUnderQQBotManagedMediaRoot(mediaPath);
+}
+function isRemoteMediaPath(mediaPath) {
+    return /^(?:https?:|data:)/i.test(mediaPath.trim());
+}
+function isUnderQQBotManagedMediaRoot(mediaPath) {
+    const candidate = path.resolve(mediaPath);
+    const mediaRoot = path.resolve(getQQBotManagedMediaRoot());
+    const relative = path.relative(mediaRoot, candidate);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+async function stageQQBotMediaFile(mediaPath) {
+    const destinationDir = path.join(getQQBotManagedMediaRoot(), "tickflow-assist");
+    await mkdir(destinationDir, { recursive: true });
+    const sourceExt = path.extname(mediaPath);
+    const sourceBase = path.basename(mediaPath, sourceExt);
+    const safeBase = sanitizeFileNamePart(sourceBase) || "alert-media";
+    const safeExt = sanitizeFileExtension(sourceExt);
+    const stagedName = `${safeBase}-${Date.now()}-${randomBytes(3).toString("hex")}${safeExt}`;
+    const stagedPath = path.join(destinationDir, stagedName);
+    await copyFile(mediaPath, stagedPath);
+    return stagedPath;
+}
+function getQQBotManagedMediaRoot() {
+    return path.join(resolveHomeDir(), ".openclaw", "media", "qqbot");
+}
+function resolveHomeDir() {
+    const fromOs = os.homedir();
+    if (fromOs) {
+        return fromOs;
+    }
+    return process.env.HOME || process.env.USERPROFILE || ".";
+}
+function sanitizeFileNamePart(value) {
+    return value.replace(/[^a-zA-Z0-9._-]+/g, "_");
+}
+function sanitizeFileExtension(value) {
+    if (!value) {
+        return "";
+    }
+    return /^\.[a-zA-Z0-9]+$/.test(value) ? value.toLowerCase() : "";
+}
 function getAlertStyle(ruleCode, fallbackTitle) {
     switch (ruleCode) {
         case "stop_loss_hit":

package/dist/services/industry-peer-service.d.ts

@@ -0,0 +1,9 @@
+import type { IndustryPeerContext } from "../analysis/types/composite-analysis.js";
+import { QuoteService } from "./quote-service.js";
+import { TickFlowUniverseService } from "./tickflow-universe-service.js";
+export declare class IndustryPeerService {
+    private readonly universeService;
+    private readonly quoteService;
+    constructor(universeService: TickFlowUniverseService | null, quoteService: QuoteService);
+    buildContext(symbol: string): Promise<IndustryPeerContext>;
+}

package/dist/services/industry-peer-service.js

@@ -0,0 +1,152 @@
+const MAX_PEER_MOVERS = 3;
+export class IndustryPeerService {
+    universeService;
+    quoteService;
+    constructor(universeService, quoteService) {
+        this.universeService = universeService;
+        this.quoteService = quoteService;
+    }
+    async buildContext(symbol) {
+        if (!this.universeService) {
+            return buildUnavailableContext("当前 TickFlow API Key Level 不支持标的池，已跳过申万三级同业表现。");
+        }
+        const industryProfile = await this.universeService.resolveIndustryProfile(symbol);
+        if (!industryProfile?.sw3UniverseId || !industryProfile.sw3Name) {
+            return buildUnavailableContext("未获取到可用的申万3级行业映射。");
+        }
+        const peerSymbols = await this.universeService.listUniverseSymbols(industryProfile.sw3UniverseId);
+        if (peerSymbols.length === 0) {
+            return buildUnavailableContext(`申万3级 ${industryProfile.sw3Name} 暂无可用成分股。`, industryProfile);
+        }
+        const quotes = await this.quoteService.fetchQuotes(peerSymbols);
+        const snapshots = quotes
+            .map(toPeerQuoteSnapshot)
+            .filter((item) => item != null)
+            .sort((left, right) => right.changePct - left.changePct || left.symbol.localeCompare(right.symbol));
+        if (snapshots.length === 0) {
+            return buildUnavailableContext(`申万3级 ${industryProfile.sw3Name} 暂未返回有效行情。`, industryProfile);
+        }
+        const targetIndex = snapshots.findIndex((item) => item.symbol === symbol);
+        const target = targetIndex >= 0 ? snapshots[targetIndex] : null;
+        const others = snapshots.filter((item) => item.symbol !== symbol);
+        const advanceCount = others.filter((item) => item.changePct > 0.0001).length;
+        const declineCount = others.filter((item) => item.changePct < -0.0001).length;
+        const flatCount = Math.max(0, others.length - advanceCount - declineCount);
+        const changeValues = others.map((item) => item.changePct);
+        const averageChangePct = changeValues.length > 0 ? average(changeValues) : null;
+        const medianChangePct = changeValues.length > 0 ? median(changeValues) : null;
+        const leaders = others.slice(0, MAX_PEER_MOVERS).map(toPeerMover);
+        const laggards = [...others]
+            .sort((left, right) => left.changePct - right.changePct || left.symbol.localeCompare(right.symbol))
+            .slice(0, MAX_PEER_MOVERS)
+            .map(toPeerMover);
+        const targetRank = targetIndex >= 0 ? targetIndex + 1 : null;
+        const targetPercentile = targetRank != null && snapshots.length > 1
+            ? 1 - ((targetRank - 1) / (snapshots.length - 1))
+            : targetRank != null ? 1 : null;
+        return {
+            available: true,
+            summary: buildSummary({
+                industryName: industryProfile.sw3Name,
+                peerCount: snapshots.length,
+                otherStockCount: others.length,
+                advanceCount,
+                declineCount,
+                flatCount,
+                averageChangePct,
+                medianChangePct,
+                target,
+                targetRank,
+            }),
+            sw1Name: industryProfile.sw1Name,
+            sw2Name: industryProfile.sw2Name,
+            sw3Name: industryProfile.sw3Name,
+            sw3UniverseId: industryProfile.sw3UniverseId,
+            peerCount: snapshots.length,
+            otherStockCount: others.length,
+            advanceCount,
+            declineCount,
+            flatCount,
+            averageChangePct,
+            medianChangePct,
+            targetChangePct: target?.changePct ?? null,
+            targetRank,
+            targetPercentile,
+            leaders,
+            laggards,
+            note: null,
+        };
+    }
+}
+function toPeerQuoteSnapshot(quote) {
+    const prevClose = Number(quote.prev_close ?? 0);
+    const lastPrice = Number(quote.last_price ?? 0);
+    if (!Number.isFinite(prevClose) || !Number.isFinite(lastPrice) || prevClose <= 0) {
+        return null;
+    }
+    return {
+        symbol: String(quote.symbol ?? "").trim(),
+        name: String(quote.name ?? quote.ext?.name ?? quote.symbol ?? "").trim(),
+        changePct: ((lastPrice - prevClose) / prevClose) * 100,
+    };
+}
+function toPeerMover(item) {
+    return {
+        symbol: item.symbol,
+        name: item.name || item.symbol,
+        changePct: item.changePct,
+    };
+}
+function buildSummary(input) {
+    const parts = [
+        `申万3级 ${input.industryName} 共 ${input.peerCount} 只`,
+        `除本股外上涨 ${input.advanceCount} / 下跌 ${input.declineCount} / 平 ${input.flatCount}`,
+    ];
+    if (input.averageChangePct != null) {
+        parts.push(`均值 ${formatSignedPct(input.averageChangePct)}`);
+    }
+    if (input.medianChangePct != null) {
+        parts.push(`中位数 ${formatSignedPct(input.medianChangePct)}`);
+    }
+    if (input.target && input.targetRank != null) {
+        parts.push(`本股 ${formatSignedPct(input.target.changePct)}，位列 ${input.targetRank}/${input.peerCount}`);
+    }
+    return parts.join("；");
+}
+function buildUnavailableContext(note, profile) {
+    return {
+        available: false,
+        summary: note,
+        sw1Name: profile?.sw1Name ?? null,
+        sw2Name: profile?.sw2Name ?? null,
+        sw3Name: profile?.sw3Name ?? null,
+        sw3UniverseId: profile?.sw3UniverseId ?? null,
+        peerCount: 0,
+        otherStockCount: 0,
+        advanceCount: 0,
+        declineCount: 0,
+        flatCount: 0,
+        averageChangePct: null,
+        medianChangePct: null,
+        targetChangePct: null,
+        targetRank: null,
+        targetPercentile: null,
+        leaders: [],
+        laggards: [],
+        note,
+    };
+}
+function average(values) {
+    return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+function median(values) {
+    const sorted = [...values].sort((left, right) => left - right);
+    const middle = Math.floor(sorted.length / 2);
+    if (sorted.length % 2 === 0) {
+        return (sorted[middle - 1] + sorted[middle]) / 2;
+    }
+    return sorted[middle] ?? 0;
+}
+function formatSignedPct(value) {
+    return `${value >= 0 ? "+" : ""}${value.toFixed(2)}%`;
+}

package/dist/services/jin10-flash-monitor-service.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import { parseFlashAlertDecision } from "../analysis/parsers/flash-alert-decision.parser.js";
 import { FLASH_MONITOR_ALERT_SYSTEM_PROMPT, buildFlashMonitorAlertUserPrompt, } from "../prompts/analysis/index.js";
 import { chinaHour, chinaToday, formatChinaDateTime } from "../utils/china-time.js";
+import { extractSectorKeywords } from "./watchlist-profile-service.js";
 const DEFAULT_STATE = {
     initialized: false,
     lastSeenKey: null,
@@ -446,7 +447,7 @@ function buildDirectKeywords(item) {
 }
 function buildBoardKeywords(item) {
     return uniqueStrings([
-        item.sector ?? "",
+        ...extractSectorKeywords(item.sector),
         ...item.themes,
     ]).filter((keyword) => isUsefulBoardKeyword(keyword));
 }