@hzttt/multimodal-rag 0.3.0 → 0.3.1

package/README.md

@@ -11,7 +11,7 @@ OpenClaw 多模态 RAG 插件 — 使用本地 AI 模型对图像和音频进行
 - **自动监听**：实时监听文件夹变化，自动索引新增文件
 - **向量存储**：使用 LanceDB 高效存储和检索
 - **智能去重**：基于文件 SHA256 哈希去重
-- **索引通知**：批次聚合索引事件，默认唤醒 agent 生成并回复通知（可切换为 `message send` 直发）
+- **索引通知**：批次聚合索引事件，仅通过唤醒 agent 生成并回复通知
 
 ## 前置条件
 
@@ -157,7 +157,7 @@ openclaw multimodal-rag setup -n \
 - 非交互式执行时，`--notify-enabled` 仅负责“显式开启”，未传不会主动关闭通知。
 - 当前没有 `--notify-disabled` 选项；要关闭通知请手动编辑 `~/.openclaw/openclaw.json`。
 - `--notify-quiet-window` 和 `--notify-batch-timeout` 未传时会优先沿用已有配置，没有已有值才回退默认值。
-- `notifications.mode` / `notifications.agentId` / `notifications.channel` / `notifications.to` / `notifications.targets` 目前通过配置文件手动设置（setup 命令暂未提供对应参数）。
+- `notifications.agentId` / `notifications.channel` / `notifications.to` / `notifications.targets` 目前通过配置文件手动设置（setup 命令暂未提供对应参数）。
 - 未配置 `targets` 且未配置 `channel+to` 时，插件会自动从 session store 选取“最近活跃会话”的 `lastChannel + lastTo` 作为通知目标。
 
 ### 手动配置
@@ -184,7 +184,6 @@ openclaw multimodal-rag setup -n \
           "indexExistingOnStart": true,
           "notifications": {
             "enabled": true,
-            "mode": "agent",
             "agentId": "main",
             "quietWindowMs": 30000,
             "batchTimeoutMs": 600000,
@@ -213,13 +212,12 @@ openclaw multimodal-rag setup -n \
 | `watchDebounceMs`            | number   | `1000`                             | 文件监听去抖延迟（毫秒）                           |
 | `indexExistingOnStart`       | boolean  | `true`                             | 启动时是否索引已有文件                            |
 | `notifications.enabled`      | boolean  | `false`                            | 启用索引完成通知（默认唤醒 agent 回复）         |
-| `notifications.mode`         | string   | `"agent"`                          | 通知模式：`agent`（默认）/`message-send`/`auto` |
-| `notifications.agentId`      | string   | `"main"`                           | 通知触发使用的 agent ID（仅 `agent/auto`，会沿用该 agent 的性格/身份设定） |
+| `notifications.agentId`      | string   | `"main"`                           | 通知触发使用的 agent ID（会沿用该 agent 的性格/身份设定） |
 | `notifications.quietWindowMs` | number   | `30000`                            | 静默窗口：最后一个文件处理完后等待多久再发送总结（毫秒）         |
 | `notifications.batchTimeoutMs` | number   | `600000`                           | 批次最大超时：超过此时间强制发送总结（毫秒），防止大批量索引时等太久 |
-| `notifications.channel`      | string   | `"last"`                           | 回退链路渠道（未配置 `targets` 时使用）                      |
-| `notifications.to`           | string   | -                                  | 回退链路目标（未配置 `targets` 时使用）                      |
-| `notifications.targets`      | object[] | `[]`                               | 通知目标列表（agent 模式用于 reply-channel/reply-to）            |
+| `notifications.channel`      | string   | `"last"`                           | 通知渠道（未配置 `targets` 时使用）                      |
+| `notifications.to`           | string   | -                                  | 通知目标（未配置 `targets` 时使用）                      |
+| `notifications.targets`      | object[] | `[]`                               | 通知目标列表（用于 `agent --reply-channel/--reply-to`）            |
 
 
 配置完成后，重启 OpenClaw Gateway 使配置生效。
@@ -240,7 +238,7 @@ openclaw multimodal-rag setup -n \
 
 **开始通知**：
 ```
-[Multimodal RAG] 检测到 3 个新的媒体文件正在被索引...
+[Multimodal RAG] 已开始处理本轮新增媒体文件...
 ```
 
 **完成通知**：
@@ -272,18 +270,12 @@ openclaw multimodal-rag setup -n \
 
 ```json
 {
-  "hooks": {
-    "enabled": true,
-    "token": "replace-with-strong-random-token",
-    "path": "/hooks"
-  },
   "plugins": {
     "entries": {
       "multimodal-rag": {
         "config": {
           "notifications": {
             "enabled": true,
-            "mode": "agent",
             "agentId": "main",
             "quietWindowMs": 30000,
             "batchTimeoutMs": 600000,
@@ -304,7 +296,7 @@ openclaw multimodal-rag setup -n \
   }
 }
 ```
-如果未配置 `notifications.targets`，插件会先尝试 `channel+to`；若仍未配置，则自动使用最新活跃会话目标；都不可用时会回退到 hooks/system-event 兼容链路。
+如果未配置 `notifications.targets`，插件会先尝试 `channel+to`；若仍未配置，则自动使用最新活跃会话目标。
 
 ### Agent 工具
 

package/index.ts

@@ -51,7 +51,6 @@ const multimodalRagPlugin = {
       indexExistingOnStart: userConfig.indexExistingOnStart !== false,
       notifications: {
         enabled: userConfig.notifications?.enabled ?? false,
-        mode: userConfig.notifications?.mode || "agent",
         agentId: userConfig.notifications?.agentId,
         quietWindowMs: userConfig.notifications?.quietWindowMs ?? 30000,
         batchTimeoutMs: userConfig.notifications?.batchTimeoutMs ?? 600000,

package/openclaw.plugin.json

@@ -91,15 +91,9 @@
             "default": false,
             "description": "启用索引通知（默认唤醒 agent 回复）"
           },
-          "mode": {
-            "type": "string",
-            "enum": ["agent", "message-send", "auto"],
-            "default": "agent",
-            "description": "通知模式：agent(唤醒 agent 回复) / message-send(插件直发) / auto(先 agent 后直发)"
-          },
           "agentId": {
             "type": "string",
-            "description": "mode=agent/auto 时用于触发通知回复的 agent ID（默认 main）"
+            "description": "用于触发通知回复的 agent ID（默认 main）"
           },
           "quietWindowMs": {
             "type": "number",
@@ -114,15 +108,15 @@
           "channel": {
             "type": "string",
             "default": "last",
-            "description": "兼容回退链路的通知渠道，默认 last"
+            "description": "通知渠道（默认 last）"
           },
           "to": {
             "type": "string",
-            "description": "兼容回退链路的通知目标（可选）"
+            "description": "通知目标（可选）"
           },
           "targets": {
             "type": "array",
-            "description": "通知目标列表（agent 模式用于 reply-channel/reply-to，message-send 模式用于直发）",
+            "description": "通知目标列表（用于 agent 的 reply-channel/reply-to）",
             "items": {
               "type": "object",
               "properties": {
@@ -175,11 +169,6 @@
       "label": "启用通知",
       "help": "索引开始/完成时触发通知"
     },
-    "notifications.mode": {
-      "label": "通知模式",
-      "advanced": true,
-      "help": "默认用 agent 生成并回复消息；可切到 message-send 直发"
-    },
     "notifications.agentId": {
       "label": "通知 Agent ID",
       "advanced": true,
@@ -198,17 +187,17 @@
     "notifications.channel": {
       "label": "通知渠道",
       "advanced": true,
-      "help": "回退链路渠道（不填则自动取最近活跃会话）"
+      "help": "通知渠道（不填则自动取最近活跃会话）"
     },
     "notifications.to": {
       "label": "通知目标",
       "advanced": true,
-      "help": "回退链路目标（不填则自动取最近活跃会话）"
+      "help": "通知目标（不填则自动取最近活跃会话）"
     },
     "notifications.targets": {
-      "label": "直发目标列表",
+      "label": "通知目标列表",
       "advanced": true,
-      "help": "通知目标列表；agent 模式会作为回复投递目标使用"
+      "help": "用于通知回复的渠道/目标列表"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hzttt/multimodal-rag",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "OpenClaw plugin for multimodal RAG - semantic indexing and time-aware search for images and audio using local AI models",
   "type": "module",
   "repository": {

package/src/notifier.ts

@@ -9,9 +9,6 @@ type BatchFileStatus = "queued" | "indexed" | "skipped" | "failed";
 type BatchFile = { status: BatchFileStatus; fileType?: MediaType; error?: string };
 type MainSessionConfig = Parameters<PluginRuntime["system"]["resolveMainSessionKey"]>[0];
 type RuntimeSystemCompat = {
-  enqueueSystemEvent?: PluginRuntime["system"]["enqueueSystemEvent"];
-  requestHeartbeatNow?: PluginRuntime["system"]["requestHeartbeatNow"];
-  resolveMainSessionKey?: PluginRuntime["system"]["resolveMainSessionKey"];
   runCommandWithTimeout?: PluginRuntime["system"]["runCommandWithTimeout"];
 };
 type NotificationTargetResolved = {
@@ -19,32 +16,7 @@ type NotificationTargetResolved = {
   to: string;
   accountId?: string;
 };
-type NotificationDispatchMode = "agent" | "message-send" | "auto";
-type HookAgentPayload = {
-  message: string;
-  name: string;
-  wakeMode: "now" | "next-heartbeat";
-  sessionKey: string;
-  deliver: boolean;
-  channel: string;
-  to?: string;
-};
-type HookAgentTarget = {
-  url: string;
-  token: string;
-  payload: HookAgentPayload;
-};
-type HooksConfigCompat = {
-  enabled?: boolean;
-  token?: string;
-  path?: string;
-};
-type GatewayConfigCompat = {
-  port?: number;
-};
 type RootConfigCompat = MainSessionConfig & {
-  hooks?: HooksConfigCompat;
-  gateway?: GatewayConfigCompat;
   session?: {
     store?: string;
   };
@@ -64,7 +36,6 @@ export class IndexNotifier implements IndexEventCallbacks {
   private batchStartTime = 0;
   private quietTimer: NodeJS.Timeout | null = null;
   private batchTimeoutTimer: NodeJS.Timeout | null = null;
-  private warnedMissingHookToken = false;
 
   constructor(
     private readonly config: NotificationConfig,
@@ -190,7 +161,7 @@ export class IndexNotifier implements IndexEventCallbacks {
   }
 
   /**
-   * 触发通知：优先级由 notifications.mode 决定，最后回退到 hooks/system-event。
+   * 触发通知：仅保留 agent 主动回复链路。
    */
   private triggerAgent(text: string): void {
     void this.triggerAgentInternal(text);
@@ -200,71 +171,15 @@ export class IndexNotifier implements IndexEventCallbacks {
     const system = this.runtime.system as unknown as RuntimeSystemCompat;
 
     try {
-      const mode = this.resolveDispatchMode();
-      if (mode === "agent") {
-        if (await this.dispatchViaAgentTurn(text, system)) {
-          return;
-        }
-        if (await this.dispatchViaMessageSend(text, system)) {
-          return;
-        }
-      } else if (mode === "message-send") {
-        if (await this.dispatchViaMessageSend(text, system)) {
-          return;
-        }
-      } else {
-        if (await this.dispatchViaAgentTurn(text, system)) {
-          return;
-        }
-        if (await this.dispatchViaMessageSend(text, system)) {
-          return;
-        }
-      }
-
-      if (await this.dispatchViaHookAgent(text)) {
-        return;
-      }
-
-      if (
-        typeof system.enqueueSystemEvent === "function" &&
-        typeof system.requestHeartbeatNow === "function"
-      ) {
-        const sessionKey = this.resolveMainSessionKey(system);
-        system.enqueueSystemEvent(text, { sessionKey });
-        system.requestHeartbeatNow({ reason: "multimodal-rag:index-notify" });
-        this.logger.info?.(
-          `Notification enqueued and heartbeat requested (${sessionKey}): ${text.slice(0, 80)}...`,
-        );
+      if (await this.dispatchViaAgentTurn(text, system)) {
         return;
       }
-
-      if (typeof system.runCommandWithTimeout === "function") {
-        const argv = this.buildSystemEventCommand(text);
-        const result = await system.runCommandWithTimeout(argv, { timeoutMs: 15000 });
-        if (result.code === 0) {
-          this.logger.info?.(`Notification sent via CLI fallback: ${text.slice(0, 80)}...`);
-          return;
-        }
-        const detail = (result.stderr || result.stdout || "no output").trim();
-        this.logger.warn?.(`Notification CLI fallback failed (code=${String(result.code)}): ${detail}`);
-        this.enqueueWithoutWake(system, text);
-        return;
-      }
-
-      this.enqueueWithoutWake(system, text);
+      this.logger.warn?.(`Notification agent trigger failed for all targets: ${text.slice(0, 80)}...`);
     } catch (err) {
       this.logger.warn?.(`Failed to trigger notification: ${String(err)}`);
     }
   }
 
-  private resolveDispatchMode(): NotificationDispatchMode {
-    const rawMode = typeof this.config.mode === "string" ? this.config.mode.trim() : "";
-    if (rawMode === "agent" || rawMode === "message-send" || rawMode === "auto") {
-      return rawMode;
-    }
-    return "agent";
-  }
-
   /**
    * 通过 `openclaw agent --deliver` 触发 agent 主动回复用户。
    * 这条路径会让最终消息由 agent 生成并投递，而不是插件直接发送文本。
@@ -310,141 +225,6 @@ export class IndexNotifier implements IndexEventCallbacks {
     return false;
   }
 
-  /**
-   * 直发路径：通过 `openclaw message send` 向显式配置的目标推送通知。
-   * 不依赖 heartbeat，也不依赖 HTTP hooks。
-   */
-  private async dispatchViaMessageSend(
-    text: string,
-    system: RuntimeSystemCompat,
-  ): Promise<boolean> {
-    if (typeof system.runCommandWithTimeout !== "function") {
-      return false;
-    }
-
-    const targets = await this.resolveNotificationTargets();
-    if (targets.length === 0) {
-      return false;
-    }
-
-    let successCount = 0;
-    for (const target of targets) {
-      const argv = this.buildMessageSendCommand(text, target);
-      try {
-        const result = await system.runCommandWithTimeout(argv, { timeoutMs: 20000 });
-        if (result.code === 0) {
-          successCount += 1;
-          continue;
-        }
-        const detail = (result.stderr || result.stdout || "no output").trim();
-        this.logger.warn?.(
-          `Notification direct send failed (${target.channel}:${target.to}, code=${String(result.code)}): ${detail}`,
-        );
-      } catch (err) {
-        this.logger.warn?.(
-          `Notification direct send error (${target.channel}:${target.to}): ${String(err)}`,
-        );
-      }
-    }
-
-    if (successCount > 0) {
-      this.logger.info?.(
-        `Notification sent via message send targets (${successCount}/${targets.length}): ${text.slice(0, 80)}...`,
-      );
-      return true;
-    }
-
-    return false;
-  }
-
-  /**
-   * 优先用 Gateway hooks 主动触发 isolated agent，避免依赖 heartbeat 文件状态。
-   */
-  private async dispatchViaHookAgent(text: string): Promise<boolean> {
-    const target = this.resolveHookAgentTarget(text);
-    if (!target) {
-      return false;
-    }
-
-    try {
-      const response = await fetch(target.url, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${target.token}`,
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify(target.payload),
-      });
-      if (response.status === 202) {
-        this.logger.info?.(`Notification sent via hooks/agent: ${text.slice(0, 80)}...`);
-        return true;
-      }
-      const detail = (await response.text()).trim();
-      this.logger.warn?.(
-        `Notification hooks/agent failed (status=${response.status}): ${detail || "no output"}`,
-      );
-      return false;
-    } catch (err) {
-      this.logger.warn?.(`Notification hooks/agent error: ${String(err)}`);
-      return false;
-    }
-  }
-
-  private resolveHookAgentTarget(text: string): HookAgentTarget | null {
-    const cfg = this.mainSessionConfig as RootConfigCompat | undefined;
-    const hooks = cfg?.hooks;
-    if (hooks?.enabled !== true) {
-      return null;
-    }
-
-    const token = typeof hooks.token === "string" ? hooks.token.trim() : "";
-    if (!token) {
-      if (!this.warnedMissingHookToken) {
-        this.logger.warn?.(
-          "hooks.enabled=true but hooks.token is empty; skipping hooks/agent notification path",
-        );
-        this.warnedMissingHookToken = true;
-      }
-      return null;
-    }
-
-    const rawPort = cfg?.gateway?.port;
-    const gatewayPort =
-      typeof rawPort === "number" && Number.isFinite(rawPort) && rawPort > 0
-        ? Math.floor(rawPort)
-        : 18789;
-    const hooksPath = this.normalizeHooksPath(hooks.path);
-    const channel =
-      typeof this.config.channel === "string" && this.config.channel.trim()
-        ? this.config.channel.trim()
-        : "last";
-    const to =
-      typeof this.config.to === "string" && this.config.to.trim() ? this.config.to.trim() : undefined;
-
-    return {
-      url: `http://127.0.0.1:${gatewayPort}${hooksPath}/agent`,
-      token,
-      payload: {
-        message: text,
-        name: "Multimodal RAG",
-        wakeMode: "now",
-        sessionKey: "hook:multimodal-rag:index-notify",
-        deliver: true,
-        channel,
-        to,
-      },
-    };
-  }
-
-  private normalizeHooksPath(rawPath: string | undefined): string {
-    const normalized = typeof rawPath === "string" ? rawPath.trim() : "";
-    if (!normalized) {
-      return "/hooks";
-    }
-    const withLeadingSlash = normalized.startsWith("/") ? normalized : `/${normalized}`;
-    const withoutTrailingSlash = withLeadingSlash.replace(/\/+$/, "");
-    return withoutTrailingSlash || "/hooks";
-  }
 
   private async resolveNotificationTargets(): Promise<NotificationTargetResolved[]> {
     const explicitTargets = Array.isArray(this.config.targets) ? this.config.targets : [];
@@ -531,47 +311,6 @@ export class IndexNotifier implements IndexEventCallbacks {
     return null;
   }
 
-  /**
-   * 旧版 runtime 缺少 resolveMainSessionKey 时的兼容解析。
-   */
-  private resolveMainSessionKey(system: RuntimeSystemCompat): string {
-    if (typeof system.resolveMainSessionKey === "function") {
-      return system.resolveMainSessionKey(this.mainSessionConfig);
-    }
-
-    if (this.mainSessionConfig?.session?.scope === "global") {
-      return "global";
-    }
-
-    const configuredMainKey = this.mainSessionConfig?.session?.mainKey?.trim();
-    const mainKey = configuredMainKey && configuredMainKey.length > 0 ? configuredMainKey : "main";
-
-    const agents = this.mainSessionConfig?.agents?.list ?? [];
-    const defaultAgentId =
-      agents.find((agent) => agent.default && typeof agent.id === "string" && agent.id.trim())
-        ?.id?.trim() ??
-      agents.find((agent) => typeof agent.id === "string" && agent.id.trim())?.id?.trim() ??
-      "main";
-
-    return `agent:${defaultAgentId}:${mainKey}`;
-  }
-
-  /**
-   * 回退路径：至少入队系统事件，等待下一次 heartbeat。
-   */
-  private enqueueWithoutWake(system: RuntimeSystemCompat, text: string): void {
-    if (typeof system.enqueueSystemEvent !== "function") {
-      this.logger.warn?.("Failed to trigger notification: runtime.system.enqueueSystemEvent missing");
-      return;
-    }
-
-    const sessionKey = this.resolveMainSessionKey(system);
-    system.enqueueSystemEvent(text, { sessionKey });
-    this.logger.warn?.(
-      `Notification queued without wake (${sessionKey}); runtime lacks immediate heartbeat helper`,
-    );
-  }
-
   private resolveNotificationAgentId(): string {
     const configuredAgentId =
       typeof this.config.agentId === "string" ? this.config.agentId.trim() : "";
@@ -644,45 +383,6 @@ export class IndexNotifier implements IndexEventCallbacks {
     return `${target.channel}:${target.to}`;
   }
 
-  /**
-   * CLI 回退：兼容缺少 requestHeartbeatNow 的旧版 runtime。
-   */
-  private buildSystemEventCommand(text: string): string[] {
-    const nodeExec = process.execPath;
-    const cliEntry = process.argv[1];
-
-    if (typeof cliEntry === "string" && cliEntry.trim().length > 0) {
-      return [nodeExec, cliEntry, "system", "event", "--text", text, "--mode", "now"];
-    }
-
-    return ["openclaw", "system", "event", "--text", text, "--mode", "now"];
-  }
-
-  private buildMessageSendCommand(text: string, target: NotificationTargetResolved): string[] {
-    const nodeExec = process.execPath;
-    const cliEntry = process.argv[1];
-    const argvCore = [
-      "message",
-      "send",
-      "--channel",
-      target.channel,
-      "--target",
-      target.to,
-      "--message",
-      text,
-    ];
-
-    if (typeof target.accountId === "string" && target.accountId.length > 0) {
-      argvCore.push("--account", target.accountId);
-    }
-
-    if (typeof cliEntry === "string" && cliEntry.trim().length > 0) {
-      return [nodeExec, cliEntry, ...argvCore];
-    }
-
-    return ["openclaw", ...argvCore];
-  }
-
   /**
    * 构建"开始索引"消息
    */

package/src/setup.ts

@@ -31,7 +31,6 @@ type PluginConfigPartial = {
   indexExistingOnStart?: boolean;
   notifications?: {
     enabled?: boolean;
-    mode?: "agent" | "message-send" | "auto";
     agentId?: string;
     quietWindowMs?: number;
     batchTimeoutMs?: number;
@@ -137,9 +136,7 @@ export async function runNonInteractiveSetup(opts: NonInteractiveSetupOpts): Pro
     dbPath: opts.dbPath || existing.dbPath || "~/.openclaw/multimodal-rag.lance",
     indexExistingOnStart: opts.noIndexOnStart ? false : (existing.indexExistingOnStart !== false),
     notifications: {
-      ...existing.notifications,
       enabled: opts.notifyEnabled ?? existing.notifications?.enabled ?? false,
-      mode: existing.notifications?.mode ?? "agent",
       agentId: existing.notifications?.agentId,
       quietWindowMs: opts.notifyQuietWindowMs ?? existing.notifications?.quietWindowMs ?? 30000,
       batchTimeoutMs: opts.notifyBatchTimeoutMs ?? existing.notifications?.batchTimeoutMs ?? 600000,
@@ -162,7 +159,6 @@ export async function runNonInteractiveSetup(opts: NonInteractiveSetupOpts): Pro
   console.log(`  启动时索引:   ${pluginConfig.indexExistingOnStart ? "是" : "否"}`);
   console.log(`  索引通知:     ${pluginConfig.notifications!.enabled ? "已启用" : "已禁用"}`);
   if (pluginConfig.notifications!.enabled) {
-    console.log(`    通知模式:   ${pluginConfig.notifications!.mode || "agent"}`);
     if (pluginConfig.notifications!.agentId) {
       console.log(`    Agent ID:   ${pluginConfig.notifications!.agentId}`);
     }
@@ -173,7 +169,7 @@ export async function runNonInteractiveSetup(opts: NonInteractiveSetupOpts): Pro
       console.log(`    通知目标:   ${pluginConfig.notifications!.to}`);
     }
     if ((pluginConfig.notifications!.targets?.length ?? 0) > 0) {
-      console.log(`    直发目标:   ${pluginConfig.notifications!.targets!.length} 个`);
+      console.log(`    通知目标:   ${pluginConfig.notifications!.targets!.length} 个`);
     }
   }
   console.log();
@@ -224,7 +220,6 @@ export async function runSetup(): Promise<void> {
     indexExistingOnStart: true,
     notifications: {
       enabled: existing.notifications?.enabled ?? false,
-      mode: existing.notifications?.mode ?? "agent",
       agentId: existing.notifications?.agentId,
       quietWindowMs: existing.notifications?.quietWindowMs ?? 30000,
       batchTimeoutMs: existing.notifications?.batchTimeoutMs ?? 600000,
@@ -306,7 +301,7 @@ export async function runSetup(): Promise<void> {
       console.log(`    通知目标:   ${pluginConfig.notifications!.to}`);
     }
     if ((pluginConfig.notifications!.targets?.length ?? 0) > 0) {
-      console.log(`    直发目标:   ${pluginConfig.notifications!.targets!.length} 个`);
+      console.log(`    通知目标:   ${pluginConfig.notifications!.targets!.length} 个`);
     }
   }
   console.log();

package/src/types.ts

@@ -35,16 +35,15 @@ export type MediaSearchResult = {
  */
 export type NotificationConfig = {
   enabled: boolean; // 是否启用通知，默认 false
-  mode?: "agent" | "message-send" | "auto"; // 通知模式：默认 agent（唤醒 agent 回复）
-  agentId?: string; // mode=agent/auto 时用于触发的 agent，默认 main（或配置中的默认 agent）
+  agentId?: string; // 用于触发通知回复的 agent，默认 main（或配置中的默认 agent）
   quietWindowMs: number; // 静默窗口（毫秒），默认 30000
   batchTimeoutMs: number; // 批次最大超时（毫秒），默认 600000
-  channel?: string; // hooks/agent 投递渠道，默认 "last"
-  to?: string; // hooks/agent 投递目标（可选）
+  channel?: string; // agent 回复投递渠道，默认 "last"
+  to?: string; // agent 回复投递目标（可选）
   targets?: Array<{
-    channel: string; // 直发目标渠道（message send --channel）
-    to: string; // 直发目标（message send --target）
-    accountId?: string; // 可选 account（message send --account）
+    channel: string; // 回复目标渠道（agent --reply-channel）
+    to: string; // 回复目标（agent --reply-to）
+    accountId?: string; // 可选账号（agent --reply-account）
   }>;
 };
 

package/src/watcher.ts

@@ -3,10 +3,9 @@
  */
 
 import chokidar from "chokidar";
-import { stat, readdir, realpath } from "node:fs/promises";
-import { basename, extname, resolve, join } from "node:path";
+import { stat, readdir, realpath, readFile, writeFile, mkdir } from "node:fs/promises";
+import { basename, extname, resolve, join, dirname } from "node:path";
 import { createHash } from "node:crypto";
-import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import type { MediaType, PluginConfig, IndexEventCallbacks } from "./types.js";
 import type { MediaStorage } from "./storage.js";
@@ -14,6 +13,14 @@ import type { IEmbeddingProvider } from "./types.js";
 import type { IMediaProcessor } from "./types.js";
 
 const AUDIO_FAILURE_PATTERN = /^[（(]\s*转录失败[:：]/;
+const BROKEN_FILES_STATE_SUFFIX = ".broken-files.json";
+
+type BrokenFileRecord = {
+  mtimeMs: number;
+  size: number;
+  error: string;
+  markedAt: number;
+};
 
 /**
  * 扩展路径中的 ~ 为用户主目录
@@ -38,6 +45,8 @@ export class MediaWatcher {
   private processingFilePath: string | null = null;
   private debounceTimers: Map<string, NodeJS.Timeout> = new Map();
   private failedFiles: Map<string, { attempts: number; lastError: string }> = new Map();
+  private brokenFiles: Map<string, BrokenFileRecord> = new Map();
+  private readonly brokenFilesStatePath: string;
   private ollamaHealthy = true;
   private lastOllamaCheck = 0;
 
@@ -48,7 +57,10 @@ export class MediaWatcher {
     private readonly processor: IMediaProcessor,
     private readonly logger: { info?: (msg: string) => void; warn?: (msg: string) => void },
     private readonly callbacks?: IndexEventCallbacks,
-  ) {}
+  ) {
+    const resolvedDbPath = resolve(expandPath(this.config.dbPath));
+    this.brokenFilesStatePath = `${resolvedDbPath}${BROKEN_FILES_STATE_SUFFIX}`;
+  }
 
   /**
    * 启动监听
@@ -65,6 +77,8 @@ export class MediaWatcher {
       return;
     }
 
+    await this.loadBrokenFilesState();
+
     // 扩展 ~ 为用户主目录
     const expandedPaths = watchPaths.map(expandPath);
     this.logger.info?.(`Expanded watch paths: ${expandedPaths.join(", ")}`);
@@ -96,7 +110,7 @@ export class MediaWatcher {
 
       const timer = setTimeout(() => {
         this.debounceTimers.delete(filePath);
-        this.enqueueFile(filePath);
+        void this.enqueueFileWithBrokenFileGuard(filePath);
       }, watchDebounceMs);
 
       this.debounceTimers.set(filePath, timer);
@@ -116,7 +130,7 @@ export class MediaWatcher {
 
       const timer = setTimeout(() => {
         this.debounceTimers.delete(filePath);
-        this.enqueueFile(filePath);
+        void this.enqueueFileWithBrokenFileGuard(filePath);
       }, watchDebounceMs);
 
       this.debounceTimers.set(filePath, timer);
@@ -166,6 +180,17 @@ export class MediaWatcher {
     this.processNextFile();
   }
 
+  private async enqueueFileWithBrokenFileGuard(filePath: string): Promise<void> {
+    if (await this.shouldSkipBrokenFile(filePath)) {
+      const ext = extname(filePath).toLowerCase();
+      const fileType: MediaType = this.config.fileTypes.image.includes(ext) ? "image" : "audio";
+      this.callbacks?.onFileSkipped?.(filePath, fileType, "broken");
+      this.logger.info?.(`Skipping previously broken file: ${filePath}`);
+      return;
+    }
+    this.enqueueFile(filePath);
+  }
+
   /**
    * 处理队列中的下一个文件
    */
@@ -218,6 +243,12 @@ export class MediaWatcher {
         return false; // 不支持的类型
       }
 
+      if (await this.shouldSkipBrokenFile(filePath)) {
+        this.callbacks?.onFileSkipped?.(filePath, fileType, "broken");
+        this.logger.info?.(`Skipping unchanged broken file: ${fileName}`);
+        return true;
+      }
+
       // 检查 Ollama 健康状态
       const ollamaHealthy = await this.checkOllamaHealth();
       if (!ollamaHealthy) {
@@ -255,6 +286,7 @@ export class MediaWatcher {
         this.logger.info?.(`Skipping duplicate: ${fileName}`);
         // 已存在内容：标记为 skipped，不计入“本次新索引成功数”
         this.failedFiles.delete(filePath);
+        await this.clearBrokenFileMark(filePath);
         this.callbacks?.onFileSkipped?.(filePath, fileType, "duplicate");
         return true;
       }
@@ -291,6 +323,7 @@ export class MediaWatcher {
       
       // 索引成功，清除失败记录
       this.failedFiles.delete(filePath);
+      await this.clearBrokenFileMark(filePath);
       
       // 通知回调：文件索引成功
       this.callbacks?.onFileIndexed(filePath, fileType);
@@ -308,9 +341,7 @@ export class MediaWatcher {
       // 如果是 Ollama 相关错误且未超过重试次数，稍后重试
       if (
         failedInfo.attempts < 3 &&
-        (errorMsg.includes("Internal Server Error") ||
-          errorMsg.includes("Ollama") ||
-          errorMsg.includes("ECONNREFUSED"))
+        this.isTransientIndexingError(errorMsg)
       ) {
         this.logger.warn?.(
           `Will retry ${fileName} in 60s (attempt ${failedInfo.attempts}/3)`,
@@ -319,6 +350,9 @@ export class MediaWatcher {
           this.enqueueFile(filePath);
         }, 60000);
       } else {
+        if (this.shouldMarkFileAsBroken(errorMsg)) {
+          await this.markFileAsBroken(filePath, errorMsg);
+        }
         // 达到最大重试次数或非临时错误，通知回调：文件索引失败
         this.callbacks?.onFileFailed(filePath, errorMsg);
       }
@@ -394,8 +428,13 @@ export class MediaWatcher {
 
     // 找出缺失的文件
     let missingFiles = 0;
+    let skippedBrokenFiles = 0;
     for (const { filePath, comparablePath } of comparableAllFiles) {
       if (!indexedPathsSet.has(filePath) && !indexedPathsSet.has(comparablePath)) {
+        if (await this.shouldSkipBrokenFile(filePath, comparablePath)) {
+          skippedBrokenFiles++;
+          continue;
+        }
         missingFiles++;
         this.enqueueFile(filePath);
       }
@@ -408,6 +447,12 @@ export class MediaWatcher {
     } else {
       this.logger.info?.(`All ${allFiles.length} files are already indexed`);
     }
+
+    if (skippedBrokenFiles > 0) {
+      this.logger.info?.(
+        `Skipped ${skippedBrokenFiles} unchanged broken file(s) during startup scan`,
+      );
+    }
   }
 
   private async normalizeComparablePath(filePath: string): Promise<string> {
@@ -509,4 +554,121 @@ export class MediaWatcher {
 
     await this.scanAndIndexMissingFiles(expandedPaths, supportedExts);
   }
+
+  private isTransientIndexingError(errorMsg: string): boolean {
+    const normalized = errorMsg.toLowerCase();
+    return (
+      normalized.includes("internal server error") ||
+      normalized.includes("ollama") ||
+      normalized.includes("econnrefused") ||
+      normalized.includes("econnreset") ||
+      normalized.includes("etimedout") ||
+      normalized.includes("fetch failed") ||
+      normalized.includes("timeout") ||
+      normalized.includes("aborted")
+    );
+  }
+
+  private shouldMarkFileAsBroken(errorMsg: string): boolean {
+    return !this.isTransientIndexingError(errorMsg);
+  }
+
+  private async loadBrokenFilesState(): Promise<void> {
+    try {
+      const raw = await readFile(this.brokenFilesStatePath, "utf-8");
+      const parsed = JSON.parse(raw) as Record<string, Partial<BrokenFileRecord>>;
+      this.brokenFiles.clear();
+
+      for (const [filePath, value] of Object.entries(parsed || {})) {
+        if (!value || typeof value !== "object") {
+          continue;
+        }
+        const mtimeMs = Number(value.mtimeMs);
+        const size = Number(value.size);
+        const error = String(value.error ?? "");
+        const markedAt = Number(value.markedAt ?? Date.now());
+        if (!Number.isFinite(mtimeMs) || !Number.isFinite(size)) {
+          continue;
+        }
+        this.brokenFiles.set(filePath, { mtimeMs, size, error, markedAt });
+      }
+
+      if (this.brokenFiles.size > 0) {
+        this.logger.info?.(`Loaded ${this.brokenFiles.size} broken file marker(s)`);
+      }
+    } catch (error) {
+      const err = error as NodeJS.ErrnoException;
+      if (err?.code !== "ENOENT") {
+        this.logger.warn?.(`Failed to load broken file markers: ${String(error)}`);
+      }
+    }
+  }
+
+  private async saveBrokenFilesState(): Promise<void> {
+    const output: Record<string, BrokenFileRecord> = {};
+    for (const [filePath, info] of this.brokenFiles.entries()) {
+      output[filePath] = info;
+    }
+
+    await mkdir(dirname(this.brokenFilesStatePath), { recursive: true });
+    await writeFile(
+      this.brokenFilesStatePath,
+      `${JSON.stringify(output, null, 2)}\n`,
+      "utf-8",
+    );
+  }
+
+  private async markFileAsBroken(filePath: string, error: string): Promise<void> {
+    const key = await this.normalizeComparablePath(filePath);
+    let size = 0;
+    let mtimeMs = 0;
+
+    try {
+      const fileStat = await stat(filePath);
+      size = fileStat.size;
+      mtimeMs = fileStat.mtimeMs;
+    } catch {}
+
+    const existing = this.brokenFiles.get(key);
+    if (
+      existing &&
+      existing.size === size &&
+      existing.mtimeMs === mtimeMs &&
+      existing.error === error
+    ) {
+      return;
+    }
+
+    this.brokenFiles.set(key, { size, mtimeMs, error, markedAt: Date.now() });
+    await this.saveBrokenFilesState();
+    this.logger.warn?.(`Marked broken file to skip unchanged retries: ${filePath}`);
+  }
+
+  private async clearBrokenFileMark(filePath: string, normalizedPath?: string): Promise<void> {
+    const key = normalizedPath ?? (await this.normalizeComparablePath(filePath));
+    if (!this.brokenFiles.delete(key)) {
+      return;
+    }
+    await this.saveBrokenFilesState();
+    this.logger.info?.(`Removed broken file marker: ${filePath}`);
+  }
+
+  private async shouldSkipBrokenFile(filePath: string, normalizedPath?: string): Promise<boolean> {
+    const key = normalizedPath ?? (await this.normalizeComparablePath(filePath));
+    const marker = this.brokenFiles.get(key);
+    if (!marker) {
+      return false;
+    }
+
+    try {
+      const fileStat = await stat(filePath);
+      const unchanged = fileStat.size === marker.size && fileStat.mtimeMs === marker.mtimeMs;
+      if (unchanged) {
+        return true;
+      }
+    } catch {}
+
+    await this.clearBrokenFileMark(filePath, key);
+    return false;
+  }
 }