chatccc 0.2.190 → 0.2.192

package/src/__tests__/orchestrator.test.ts

@@ -77,14 +77,14 @@ import {
   _setAdapterForToolForTest,
   _setSessionRegistryFileForTest,
   _setSessionToolsFileForTest,
-  loadSessionRegistryForBinding,
-  recordSessionRegistry,
-  resetState,
-  sessionInfoMap,
-} from "../session.ts";
+  loadSessionRegistryForBinding,
+  recordSessionRegistry,
+  resetState,
+  sessionInfoMap,
+} from "../session.ts";
 import { activePrompts, resetBindingState } from "../session-chat-binding.ts";
-import { ABD_APPEND_PROMPT } from "../shared-prefix.ts";
-import { config } from "../config.ts";
+import { ABD_APPEND_PROMPT } from "../shared-prefix.ts";
+import { config } from "../config.ts";
 
 function mockPlatform(kind: "wechat" | "feishu" = "wechat"): PlatformAdapter {
   return {
@@ -131,12 +131,12 @@ describe("handleCommand WeChat processing ack", () => {
     tempDir = await mkdtemp(join(tmpdir(), "chatccc-orchestrator-"));
     _setSessionRegistryFileForTest(join(tempDir, "session-registry.json"));
     _setSessionToolsFileForTest(join(tempDir, "sessions.json"));
-    resetState();
-    resetBindingState();
-    config.claude.defaultAgent = true;
-    config.cursor.defaultAgent = false;
-    config.codex.defaultAgent = false;
-    mockStreamStates.clear();
+    resetState();
+    resetBindingState();
+    config.claude.defaultAgent = true;
+    config.cursor.defaultAgent = false;
+    config.codex.defaultAgent = false;
+    mockStreamStates.clear();
     mockGetCodexUsageSummary.mockReset();
     mockGetCursorUsageSummary.mockReset();
     mockGetChatGptSubscriptionStatus.mockReset();
@@ -367,11 +367,11 @@ describe("handleCommand WeChat processing ack", () => {
     expect(userText).not.toContain("/abd");
   });
 
-  it("cleans stale Feishu p2p binding but keeps valid commands from auto-creating a group", async () => {
-    const platform = mockPlatform("feishu");
-    await recordSessionRegistry({
-      chatId: "feishu-p2p",
-      sessionId: "stale-sid",
+  it("cleans stale Feishu p2p binding but keeps valid commands from auto-creating a group", async () => {
+    const platform = mockPlatform("feishu");
+    await recordSessionRegistry({
+      chatId: "feishu-p2p",
+      sessionId: "stale-sid",
       tool: "claude",
       chatName: "旧私聊绑定",
       running: false,
@@ -381,108 +381,108 @@ describe("handleCommand WeChat processing ack", () => {
 
     expect(platform.createGroup).not.toHaveBeenCalled();
     expect(platform.sendRawCard).toHaveBeenCalled();
-    const registry = await loadSessionRegistryForBinding();
-    expect(registry["feishu-p2p"]).toBeUndefined();
-  });
-
-  it("shows Claude effort switch card in an active Feishu session", async () => {
-    const platform = mockPlatform("feishu");
-    vi.mocked(platform.getChatInfo).mockResolvedValue({ name: "claude-session", description: "Claude Session: sid-claude-effort" });
-    vi.mocked(platform.extractSessionInfo).mockReturnValue({ sessionId: "sid-claude-effort", tool: "claude" });
-    await recordSessionRegistry({
-      chatId: "feishu-chat",
-      sessionId: "sid-claude-effort",
-      tool: "claude",
-      chatName: "claude-session",
-      running: false,
-    });
-    sessionInfoMap.set("feishu-chat", {
-      sessionId: "sid-claude-effort",
-      tool: "claude",
-      turnCount: 0,
-      lastContextTokens: 0,
-      startTime: Date.now(),
-    });
-
-    await handleCommand(platform, "/effort", "feishu-chat", "ou-user", Date.now(), "group");
-
-    expect(platform.sendRawCard).toHaveBeenCalled();
-    const card = JSON.parse(vi.mocked(platform.sendRawCard).mock.calls[0][1]);
-    const raw = JSON.stringify(card);
-    expect(raw).toContain("/effort low");
-    expect(raw).toContain("/effort xhigh");
-    expect(raw).toContain("/effort max");
-  });
-
-  it("switches Codex effort for the current session and reflects it in /state", async () => {
-    const platform = mockPlatform("feishu");
-    vi.mocked(platform.getChatInfo).mockResolvedValue({ name: "codex-session", description: "Codex Session: sid-codex-effort" });
-    vi.mocked(platform.extractSessionInfo).mockReturnValue({ sessionId: "sid-codex-effort", tool: "codex" });
-    _setAdapterForToolForTest("codex", mockAdapter("sid-codex-effort"));
-    await recordSessionRegistry({
-      chatId: "codex-chat",
-      sessionId: "sid-codex-effort",
-      tool: "codex",
-      chatName: "codex-session",
-      running: false,
-    });
-    sessionInfoMap.set("codex-chat", {
-      sessionId: "sid-codex-effort",
-      tool: "codex",
-      turnCount: 0,
-      lastContextTokens: 0,
-      startTime: Date.now(),
-    });
-
-    await handleCommand(platform, "/effort xhigh", "codex-chat", "ou-user", Date.now(), "group");
-    expect(platform.sendCard).toHaveBeenCalledWith(
-      "codex-chat",
-      "Effort 切换",
-      expect.stringContaining("xhigh"),
-      "green",
-    );
-
-    vi.mocked(platform.sendCard).mockClear();
-    vi.mocked(platform.sendRawCard).mockClear();
-    await handleCommand(platform, "/state", "codex-chat", "ou-user", Date.now() + 1, "group");
-
-    expect(platform.sendRawCard).toHaveBeenCalled();
-    const card = JSON.parse(vi.mocked(platform.sendRawCard).mock.calls[0][1]);
-    expect(JSON.stringify(card)).toContain("xhigh");
-  });
-
-  it("rejects /effort in Cursor sessions", async () => {
-    const platform = mockPlatform("feishu");
-    vi.mocked(platform.getChatInfo).mockResolvedValue({ name: "cursor-session", description: "Cursor Session: sid-cursor-effort" });
-    vi.mocked(platform.extractSessionInfo).mockReturnValue({ sessionId: "sid-cursor-effort", tool: "cursor" });
-    _setAdapterForToolForTest("cursor", mockAdapter("sid-cursor-effort"));
-    await recordSessionRegistry({
-      chatId: "cursor-chat",
-      sessionId: "sid-cursor-effort",
-      tool: "cursor",
-      chatName: "cursor-session",
-      running: false,
-    });
-    sessionInfoMap.set("cursor-chat", {
-      sessionId: "sid-cursor-effort",
-      tool: "cursor",
-      turnCount: 0,
-      lastContextTokens: 0,
-      startTime: Date.now(),
-    });
-
-    await handleCommand(platform, "/effort high", "cursor-chat", "ou-user", Date.now(), "group");
-
-    expect(platform.sendCard).toHaveBeenCalledWith(
-      "cursor-chat",
-      "Effort 切换",
-      expect.stringContaining("不支持 effort"),
-      "red",
-    );
-  });
-
-  it("handles /usage without creating a new Feishu group", async () => {
-    const platform = mockPlatform("feishu");
+    const registry = await loadSessionRegistryForBinding();
+    expect(registry["feishu-p2p"]).toBeUndefined();
+  });
+
+  it("shows Claude effort switch card in an active Feishu session", async () => {
+    const platform = mockPlatform("feishu");
+    vi.mocked(platform.getChatInfo).mockResolvedValue({ name: "claude-session", description: "Claude Session: sid-claude-effort" });
+    vi.mocked(platform.extractSessionInfo).mockReturnValue({ sessionId: "sid-claude-effort", tool: "claude" });
+    await recordSessionRegistry({
+      chatId: "feishu-chat",
+      sessionId: "sid-claude-effort",
+      tool: "claude",
+      chatName: "claude-session",
+      running: false,
+    });
+    sessionInfoMap.set("feishu-chat", {
+      sessionId: "sid-claude-effort",
+      tool: "claude",
+      turnCount: 0,
+      lastContextTokens: 0,
+      startTime: Date.now(),
+    });
+
+    await handleCommand(platform, "/effort", "feishu-chat", "ou-user", Date.now(), "group");
+
+    expect(platform.sendRawCard).toHaveBeenCalled();
+    const card = JSON.parse(vi.mocked(platform.sendRawCard).mock.calls[0][1]);
+    const raw = JSON.stringify(card);
+    expect(raw).toContain("/effort low");
+    expect(raw).toContain("/effort xhigh");
+    expect(raw).toContain("/effort max");
+  });
+
+  it("switches Codex effort for the current session and reflects it in /state", async () => {
+    const platform = mockPlatform("feishu");
+    vi.mocked(platform.getChatInfo).mockResolvedValue({ name: "codex-session", description: "Codex Session: sid-codex-effort" });
+    vi.mocked(platform.extractSessionInfo).mockReturnValue({ sessionId: "sid-codex-effort", tool: "codex" });
+    _setAdapterForToolForTest("codex", mockAdapter("sid-codex-effort"));
+    await recordSessionRegistry({
+      chatId: "codex-chat",
+      sessionId: "sid-codex-effort",
+      tool: "codex",
+      chatName: "codex-session",
+      running: false,
+    });
+    sessionInfoMap.set("codex-chat", {
+      sessionId: "sid-codex-effort",
+      tool: "codex",
+      turnCount: 0,
+      lastContextTokens: 0,
+      startTime: Date.now(),
+    });
+
+    await handleCommand(platform, "/effort xhigh", "codex-chat", "ou-user", Date.now(), "group");
+    expect(platform.sendCard).toHaveBeenCalledWith(
+      "codex-chat",
+      "Effort 切换",
+      expect.stringContaining("xhigh"),
+      "green",
+    );
+
+    vi.mocked(platform.sendCard).mockClear();
+    vi.mocked(platform.sendRawCard).mockClear();
+    await handleCommand(platform, "/state", "codex-chat", "ou-user", Date.now() + 1, "group");
+
+    expect(platform.sendRawCard).toHaveBeenCalled();
+    const card = JSON.parse(vi.mocked(platform.sendRawCard).mock.calls[0][1]);
+    expect(JSON.stringify(card)).toContain("xhigh");
+  });
+
+  it("rejects /effort in Cursor sessions", async () => {
+    const platform = mockPlatform("feishu");
+    vi.mocked(platform.getChatInfo).mockResolvedValue({ name: "cursor-session", description: "Cursor Session: sid-cursor-effort" });
+    vi.mocked(platform.extractSessionInfo).mockReturnValue({ sessionId: "sid-cursor-effort", tool: "cursor" });
+    _setAdapterForToolForTest("cursor", mockAdapter("sid-cursor-effort"));
+    await recordSessionRegistry({
+      chatId: "cursor-chat",
+      sessionId: "sid-cursor-effort",
+      tool: "cursor",
+      chatName: "cursor-session",
+      running: false,
+    });
+    sessionInfoMap.set("cursor-chat", {
+      sessionId: "sid-cursor-effort",
+      tool: "cursor",
+      turnCount: 0,
+      lastContextTokens: 0,
+      startTime: Date.now(),
+    });
+
+    await handleCommand(platform, "/effort high", "cursor-chat", "ou-user", Date.now(), "group");
+
+    expect(platform.sendCard).toHaveBeenCalledWith(
+      "cursor-chat",
+      "Effort 切换",
+      expect.stringContaining("不支持 effort"),
+      "red",
+    );
+  });
+
+  it("handles /usage without creating a new Feishu group", async () => {
+    const platform = mockPlatform("feishu");
     const usage = {
       fiveHour: { usedPercent: 37, remainingPercent: 63, resetAtEpochSeconds: 1781528212, resetAfterSeconds: 10349 },
       weekly: { usedPercent: 12, remainingPercent: 88, resetAtEpochSeconds: 1781842926, resetAfterSeconds: 325063 },

package/src/__tests__/privacy.test.ts

@@ -1,198 +1,198 @@
-import { describe, it, expect, beforeEach, afterEach, afterAll, vi } from "vitest";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-const TEST_DATA_DIR = await mkdtemp(join(tmpdir(), "chatccc-privacy-test-"));
-vi.mock("../config.ts", async () => {
-  const actual = await vi.importActual<typeof import("../config.ts")>("../config.ts");
-  return {
-    ...actual,
-    USER_DATA_DIR: TEST_DATA_DIR,
-    ts: () => "test-ts",
-  };
-});
-
-let applyPrivacy: (text: string) => string;
-let reloadPrivacyRules: () => void;
-let getPrivacyRules: () => Record<string, string>;
-let getPrivacyConfig: () => { enabled: boolean; rules: Record<string, string> };
-
-beforeEach(async () => {
-  vi.resetModules();
-  try {
-    await rm(join(TEST_DATA_DIR, "privacy.json"), { force: true });
-  } catch {}
-  const mod = await import("../privacy.ts");
-  applyPrivacy = mod.applyPrivacy;
-  reloadPrivacyRules = mod.reloadPrivacyRules;
-  getPrivacyRules = mod.getPrivacyRules;
-  getPrivacyConfig = mod.getPrivacyConfig;
-});
-
-afterEach(async () => {
-  try {
-    await rm(join(TEST_DATA_DIR, "privacy.json"), { force: true });
-  } catch {}
-});
-
-afterAll(async () => {
-  try {
-    await rm(TEST_DATA_DIR, { recursive: true, force: true });
-  } catch {}
-});
-
-describe("applyPrivacy", () => {
-  it("returns original text when privacy.json is missing", () => {
-    reloadPrivacyRules();
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello weizhangjian");
-  });
-
-  it("supports legacy flat privacy rules", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ weizhangjian: "wzj", secret: "***" }),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello wzj");
-    expect(applyPrivacy("my secret is safe")).toBe("my *** is safe");
-    expect(applyPrivacy("weizhangjian and secret")).toBe("wzj and ***");
-  });
-
-  it("supports privacy.json schema with enabled=false", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ enabled: false, rules: { weizhangjian: "wzj" } }),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(getPrivacyConfig()).toEqual({ enabled: false, rules: { weizhangjian: "wzj" } });
-    expect(getPrivacyRules()).toEqual({ weizhangjian: "wzj" });
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello weizhangjian");
-  });
-
-  it("supports privacy.json schema with enabled=true", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ enabled: true, rules: { weizhangjian: "wzj" } }),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello wzj");
-  });
-
-  it("accepts UTF-8 BOM in privacy.json", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      `\uFEFF${JSON.stringify({ enabled: false, rules: { weizhangjian: "wzj" } })}`,
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(getPrivacyConfig()).toEqual({ enabled: false, rules: { weizhangjian: "wzj" } });
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello weizhangjian");
-  });
-
-  it("auto reloads privacy.json changes without explicit reload", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ weizhangjian: "wzj" }),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello wzj");
-
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ enabled: false, rules: { weizhangjian: "wzj-disabled" } }),
-      "utf-8",
-    );
-
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello weizhangjian");
-    expect(getPrivacyConfig()).toEqual({ enabled: false, rules: { weizhangjian: "wzj-disabled" } });
-  });
-
-  it("replaces multiple rules and repeated occurrences", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ a: "A", b: "B" }),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("a b a b")).toBe("A B A B");
-  });
-
-  it("returns empty text directly", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ x: "y" }),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("")).toBe("");
-  });
-
-  it("treats special characters in rule keys literally", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ "a.b": "X", "(test)": "Y", "*star": "Z" }),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("hello a.b world")).toBe("hello X world");
-    expect(applyPrivacy("text (test) here")).toBe("text Y here");
-    expect(applyPrivacy("a *star shines")).toBe("a Z shines");
-  });
-
-  it("reloadPrivacyRules forces a reload", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ old: "OLD" }),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("old")).toBe("OLD");
-    expect(getPrivacyRules()).toEqual({ old: "OLD" });
-
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ new: "NEW" }),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("new")).toBe("NEW");
-    expect(getPrivacyRules()).toEqual({ new: "NEW" });
-  });
-
-  it("returns original text for malformed JSON", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      "not json",
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("hello")).toBe("hello");
-  });
-
-  it("returns original text for array JSON", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify(["a", "b"]),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("hello")).toBe("hello");
-  });
-});
+import { describe, it, expect, beforeEach, afterEach, afterAll, vi } from "vitest";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const TEST_DATA_DIR = await mkdtemp(join(tmpdir(), "chatccc-privacy-test-"));
+vi.mock("../config.ts", async () => {
+  const actual = await vi.importActual<typeof import("../config.ts")>("../config.ts");
+  return {
+    ...actual,
+    USER_DATA_DIR: TEST_DATA_DIR,
+    ts: () => "test-ts",
+  };
+});
+
+let applyPrivacy: (text: string) => string;
+let reloadPrivacyRules: () => void;
+let getPrivacyRules: () => Record<string, string>;
+let getPrivacyConfig: () => { enabled: boolean; rules: Record<string, string> };
+
+beforeEach(async () => {
+  vi.resetModules();
+  try {
+    await rm(join(TEST_DATA_DIR, "privacy.json"), { force: true });
+  } catch {}
+  const mod = await import("../privacy.ts");
+  applyPrivacy = mod.applyPrivacy;
+  reloadPrivacyRules = mod.reloadPrivacyRules;
+  getPrivacyRules = mod.getPrivacyRules;
+  getPrivacyConfig = mod.getPrivacyConfig;
+});
+
+afterEach(async () => {
+  try {
+    await rm(join(TEST_DATA_DIR, "privacy.json"), { force: true });
+  } catch {}
+});
+
+afterAll(async () => {
+  try {
+    await rm(TEST_DATA_DIR, { recursive: true, force: true });
+  } catch {}
+});
+
+describe("applyPrivacy", () => {
+  it("returns original text when privacy.json is missing", () => {
+    reloadPrivacyRules();
+    expect(applyPrivacy("hello weizhangjian")).toBe("hello weizhangjian");
+  });
+
+  it("supports legacy flat privacy rules", async () => {
+    await writeFile(
+      join(TEST_DATA_DIR, "privacy.json"),
+      JSON.stringify({ weizhangjian: "wzj", secret: "***" }),
+      "utf-8",
+    );
+    reloadPrivacyRules();
+
+    expect(applyPrivacy("hello weizhangjian")).toBe("hello wzj");
+    expect(applyPrivacy("my secret is safe")).toBe("my *** is safe");
+    expect(applyPrivacy("weizhangjian and secret")).toBe("wzj and ***");
+  });
+
+  it("supports privacy.json schema with enabled=false", async () => {
+    await writeFile(
+      join(TEST_DATA_DIR, "privacy.json"),
+      JSON.stringify({ enabled: false, rules: { weizhangjian: "wzj" } }),
+      "utf-8",
+    );
+    reloadPrivacyRules();
+
+    expect(getPrivacyConfig()).toEqual({ enabled: false, rules: { weizhangjian: "wzj" } });
+    expect(getPrivacyRules()).toEqual({ weizhangjian: "wzj" });
+    expect(applyPrivacy("hello weizhangjian")).toBe("hello weizhangjian");
+  });
+
+  it("supports privacy.json schema with enabled=true", async () => {
+    await writeFile(
+      join(TEST_DATA_DIR, "privacy.json"),
+      JSON.stringify({ enabled: true, rules: { weizhangjian: "wzj" } }),
+      "utf-8",
+    );
+    reloadPrivacyRules();
+
+    expect(applyPrivacy("hello weizhangjian")).toBe("hello wzj");
+  });
+
+  it("accepts UTF-8 BOM in privacy.json", async () => {
+    await writeFile(
+      join(TEST_DATA_DIR, "privacy.json"),
+      `\uFEFF${JSON.stringify({ enabled: false, rules: { weizhangjian: "wzj" } })}`,
+      "utf-8",
+    );
+    reloadPrivacyRules();
+
+    expect(getPrivacyConfig()).toEqual({ enabled: false, rules: { weizhangjian: "wzj" } });
+    expect(applyPrivacy("hello weizhangjian")).toBe("hello weizhangjian");
+  });
+
+  it("auto reloads privacy.json changes without explicit reload", async () => {
+    await writeFile(
+      join(TEST_DATA_DIR, "privacy.json"),
+      JSON.stringify({ weizhangjian: "wzj" }),
+      "utf-8",
+    );
+    reloadPrivacyRules();
+
+    expect(applyPrivacy("hello weizhangjian")).toBe("hello wzj");
+
+    await writeFile(
+      join(TEST_DATA_DIR, "privacy.json"),
+      JSON.stringify({ enabled: false, rules: { weizhangjian: "wzj-disabled" } }),
+      "utf-8",
+    );
+
+    expect(applyPrivacy("hello weizhangjian")).toBe("hello weizhangjian");
+    expect(getPrivacyConfig()).toEqual({ enabled: false, rules: { weizhangjian: "wzj-disabled" } });
+  });
+
+  it("replaces multiple rules and repeated occurrences", async () => {
+    await writeFile(
+      join(TEST_DATA_DIR, "privacy.json"),
+      JSON.stringify({ a: "A", b: "B" }),
+      "utf-8",
+    );
+    reloadPrivacyRules();
+
+    expect(applyPrivacy("a b a b")).toBe("A B A B");
+  });
+
+  it("returns empty text directly", async () => {
+    await writeFile(
+      join(TEST_DATA_DIR, "privacy.json"),
+      JSON.stringify({ x: "y" }),
+      "utf-8",
+    );
+    reloadPrivacyRules();
+
+    expect(applyPrivacy("")).toBe("");
+  });
+
+  it("treats special characters in rule keys literally", async () => {
+    await writeFile(
+      join(TEST_DATA_DIR, "privacy.json"),
+      JSON.stringify({ "a.b": "X", "(test)": "Y", "*star": "Z" }),
+      "utf-8",
+    );
+    reloadPrivacyRules();
+
+    expect(applyPrivacy("hello a.b world")).toBe("hello X world");
+    expect(applyPrivacy("text (test) here")).toBe("text Y here");
+    expect(applyPrivacy("a *star shines")).toBe("a Z shines");
+  });
+
+  it("reloadPrivacyRules forces a reload", async () => {
+    await writeFile(
+      join(TEST_DATA_DIR, "privacy.json"),
+      JSON.stringify({ old: "OLD" }),
+      "utf-8",
+    );
+    reloadPrivacyRules();
+
+    expect(applyPrivacy("old")).toBe("OLD");
+    expect(getPrivacyRules()).toEqual({ old: "OLD" });
+
+    await writeFile(
+      join(TEST_DATA_DIR, "privacy.json"),
+      JSON.stringify({ new: "NEW" }),
+      "utf-8",
+    );
+    reloadPrivacyRules();
+
+    expect(applyPrivacy("new")).toBe("NEW");
+    expect(getPrivacyRules()).toEqual({ new: "NEW" });
+  });
+
+  it("returns original text for malformed JSON", async () => {
+    await writeFile(
+      join(TEST_DATA_DIR, "privacy.json"),
+      "not json",
+      "utf-8",
+    );
+    reloadPrivacyRules();
+
+    expect(applyPrivacy("hello")).toBe("hello");
+  });
+
+  it("returns original text for array JSON", async () => {
+    await writeFile(
+      join(TEST_DATA_DIR, "privacy.json"),
+      JSON.stringify(["a", "b"]),
+      "utf-8",
+    );
+    reloadPrivacyRules();
+
+    expect(applyPrivacy("hello")).toBe("hello");
+  });
+});