@mingxy/cerebro 2.3.4 → 2.3.6

package/src/hooks-tier3.test.ts

@@ -1,461 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-// --- Mocks ---
-vi.mock("./logger.js", () => ({
-  logInfo: vi.fn(),
-  logDebug: vi.fn(),
-  logError: vi.fn(),
-  setOpencodeClient: vi.fn(),
-}));
-
-vi.mock("./config.js", () => ({
-  DEFAULTS: {
-    ui: { toastDelayMs: 7000 },
-    logging: { logEnabled: false },
-    content: { maxContentChars: 6000 },
-  },
-  resolveAgentPolicy: vi.fn(() => "readwrite"),
-}));
-
-vi.mock("node:fs/promises", () => ({
-  readFile: vi.fn().mockRejectedValue("not found"),
-}));
-
-import { compactingHook, autocontinueHook, sessionIdleHook } from "./hooks.js";
-import { resolveAgentPolicy } from "./config.js";
-
-const mockCerebroClient = {
-  searchMemories: vi.fn().mockResolvedValue([]),
-  ingestMessages: vi.fn().mockResolvedValue({ id: "mem1" }),
-  sessionIngest: vi.fn().mockResolvedValue(undefined),
-};
-
-const mockTui = { showToast: vi.fn() };
-const containerTags = ["test-project"];
-
-beforeEach(() => {
-  vi.clearAllMocks();
-  mockCerebroClient.searchMemories.mockResolvedValue([]);
-  mockCerebroClient.ingestMessages.mockResolvedValue({ id: "mem1" });
-  mockCerebroClient.sessionIngest.mockResolvedValue(undefined);
-  (resolveAgentPolicy as ReturnType<typeof vi.fn>).mockReturnValue("readwrite");
-});
-
-// ========================================
-// compactingHook
-// ========================================
-describe("compactingHook", () => {
-  it("returns an async function", () => {
-    const hook = compactingHook(mockCerebroClient as any, containerTags, mockTui);
-    expect(typeof hook).toBe("function");
-  });
-
-  it("searches memories and injects compaction prompt into output", async () => {
-    const hook = compactingHook(mockCerebroClient as any, containerTags, mockTui);
-    const input = { sessionID: "sess1" };
-    const output = { context: ["existing"], prompt: "old" };
-    await hook(input, output);
-    expect(mockCerebroClient.searchMemories).toHaveBeenCalledWith("*", 20, undefined, containerTags);
-    // output.prompt should be replaced with compaction prompt
-    expect(output.prompt).toContain("[Cerebro Compaction Context]");
-  });
-
-  it("appends to context when output.prompt is undefined", async () => {
-    const hook = compactingHook(mockCerebroClient as any, containerTags, mockTui);
-    const input = { sessionID: "sess1" };
-    const output = { context: ["existing"] };
-    await hook(input, output);
-    expect(output.context.some((c: string) => c.includes("[Cerebro Compaction Context]"))).toBe(true);
-  });
-
-  it("skips ingest when sessionMessages is empty for session", async () => {
-    const hook = compactingHook(mockCerebroClient as any, containerTags, mockTui);
-    await hook({ sessionID: "no-messages-session" }, { context: [] });
-    expect(mockCerebroClient.searchMemories).toHaveBeenCalled();
-    expect(mockCerebroClient.ingestMessages).not.toHaveBeenCalled();
-  });
-
-  it("skips write when policy is readonly", async () => {
-    (resolveAgentPolicy as ReturnType<typeof vi.fn>).mockReturnValue("readonly");
-    const hook = compactingHook(
-      mockCerebroClient as any, containerTags, mockTui, "smart",
-      undefined, undefined, undefined, {},
-    );
-    await hook({ sessionID: "readonly-sess" }, { context: [] });
-    expect(mockCerebroClient.searchMemories).toHaveBeenCalled();
-    expect(mockCerebroClient.ingestMessages).not.toHaveBeenCalled();
-  });
-
-  it("skips non-main session when getMainSessionId mismatches", async () => {
-    const getMainSessionId = vi.fn(() => "main-sess");
-    const hook = compactingHook(
-      mockCerebroClient as any, containerTags, mockTui, "smart",
-      undefined, getMainSessionId,
-    );
-    await hook({ sessionID: "sub-sess" }, { context: [] });
-    // Should return early after search phase
-    expect(mockCerebroClient.ingestMessages).not.toHaveBeenCalled();
-  });
-
-  it("gracefully handles searchMemories failure", async () => {
-    mockCerebroClient.searchMemories.mockRejectedValue(new Error("network"));
-    const hook = compactingHook(mockCerebroClient as any, containerTags, mockTui);
-    const output = { context: [] };
-    await expect(hook({ sessionID: "s1" }, output)).resolves.toBeUndefined();
-    expect(mockCerebroClient.ingestMessages).not.toHaveBeenCalled();
-  });
-});
-
-// ========================================
-// autocontinueHook
-// ========================================
-describe("autocontinueHook", () => {
-  const makeInput = (overrides = {}) => ({
-    sessionID: "sess1",
-    agent: "opencode",
-    model: { id: "test" } as any,
-    message: { id: "msg1" } as any,
-    overflow: false,
-    ...overrides,
-  });
-
-  it("returns an async function", () => {
-    const hook = autocontinueHook(mockCerebroClient as any, containerTags, mockTui);
-    expect(typeof hook).toBe("function");
-  });
-
-  it("stores summary when sdkClient returns messages with matching id (level 1 fallback)", async () => {
-    const sdkClient = {
-      session: {
-        messages: vi.fn().mockResolvedValue({
-          data: [{
-            info: { id: "msg1", role: "assistant" },
-            parts: [{ type: "text", text: "This is a summary of the session." }],
-          }],
-        }),
-        get: vi.fn().mockResolvedValue({ data: { directory: "/tmp/project" } }),
-      },
-    };
-    const hook = autocontinueHook(
-      mockCerebroClient as any, containerTags, mockTui, "smart",
-      undefined, undefined, sdkClient,
-    );
-    await hook(makeInput(), { enabled: true });
-    expect(mockCerebroClient.ingestMessages).toHaveBeenCalledTimes(1);
-    expect(mockCerebroClient.ingestMessages.mock.calls[0][0][0].content).toBe("This is a summary of the session.");
-  });
-
-  it("falls back to summary-flagged message (level 2)", async () => {
-    const sdkClient = {
-      session: {
-        messages: vi.fn().mockResolvedValue({
-          data: [
-            { info: { id: "msg-other", role: "user" } },
-            {
-              info: { id: "msg2", role: "assistant", summary: true },
-              parts: [{ type: "text", text: "Summary from flag that is long enough to pass." }],
-            },
-          ],
-        }),
-        get: vi.fn().mockResolvedValue({ data: { directory: "/tmp" } }),
-      },
-    };
-    const hook = autocontinueHook(
-      mockCerebroClient as any, containerTags, mockTui, "smart",
-      undefined, undefined, sdkClient,
-    );
-    await hook(makeInput({ message: { id: "not-found" } as any }), { enabled: true });
-    expect(mockCerebroClient.ingestMessages).toHaveBeenCalledTimes(1);
-  });
-
-  it("falls back to last assistant message (level 3)", async () => {
-    const sdkClient = {
-      session: {
-        messages: vi.fn().mockResolvedValue({
-          data: [
-            {
-              info: { id: "a1", role: "assistant" },
-              parts: [{ type: "text", text: "Last assistant response here with enough content." }],
-            },
-          ],
-        }),
-        get: vi.fn().mockResolvedValue({ data: {} }),
-      },
-    };
-    const hook = autocontinueHook(
-      mockCerebroClient as any, containerTags, mockTui, "smart",
-      undefined, undefined, sdkClient,
-    );
-    await hook(makeInput({ message: { id: "none" } as any }), { enabled: true });
-    expect(mockCerebroClient.ingestMessages).toHaveBeenCalledTimes(1);
-  });
-
-  it("skips when no sdkClient", async () => {
-    const hook = autocontinueHook(mockCerebroClient as any, containerTags, mockTui);
-    await hook(makeInput(), { enabled: true });
-    expect(mockCerebroClient.ingestMessages).not.toHaveBeenCalled();
-  });
-
-  it("skips when policy is readonly", async () => {
-    (resolveAgentPolicy as ReturnType<typeof vi.fn>).mockReturnValue("readonly");
-    const sdkClient = {
-      session: { messages: vi.fn(), get: vi.fn() },
-    };
-    const hook = autocontinueHook(
-      mockCerebroClient as any, containerTags, mockTui, "smart",
-      undefined, undefined, sdkClient,
-    );
-    await hook(makeInput(), { enabled: true });
-    expect(mockCerebroClient.ingestMessages).not.toHaveBeenCalled();
-  });
-
-  it("skips when autoStore is disabled", async () => {
-    const isAutoStoreEnabled = vi.fn(() => false);
-    const hook = autocontinueHook(
-      mockCerebroClient as any, containerTags, mockTui, "smart",
-      isAutoStoreEnabled,
-    );
-    await hook(makeInput(), { enabled: true });
-    expect(mockCerebroClient.ingestMessages).not.toHaveBeenCalled();
-  });
-
-  it("skips when summaryText is empty", async () => {
-    const sdkClient = {
-      session: {
-        messages: vi.fn().mockResolvedValue({ data: [] }),
-        get: vi.fn(),
-      },
-    };
-    const hook = autocontinueHook(
-      mockCerebroClient as any, containerTags, mockTui, "smart",
-      undefined, undefined, sdkClient,
-    );
-    await hook(makeInput(), { enabled: true });
-    expect(mockCerebroClient.ingestMessages).not.toHaveBeenCalled();
-  });
-
-  it("shows error toast when ingestMessages throws", async () => {
-    mockCerebroClient.ingestMessages.mockRejectedValue(new Error("fail"));
-    const sdkClient = {
-      session: {
-        messages: vi.fn().mockResolvedValue({
-          data: [{
-            info: { id: "msg1", role: "assistant" },
-            parts: [{ type: "text", text: "Summary text here that is definitely long enough to pass." }],
-          }],
-        }),
-        get: vi.fn().mockResolvedValue({ data: {} }),
-      },
-    };
-    const hook = autocontinueHook(
-      mockCerebroClient as any, containerTags, mockTui, "smart",
-      undefined, undefined, sdkClient,
-    );
-    await hook(makeInput(), { enabled: true });
-    // Should not throw
-  });
-});
-
-// ========================================
-// sessionIdleHook
-// ========================================
-describe("sessionIdleHook", () => {
-  const makeEvent = (type: string, properties: any = {}) => ({
-    event: { type, properties },
-  });
-
-  it("returns an async function", () => {
-    const hook = sessionIdleHook(mockCerebroClient as any, containerTags, mockTui, {});
-    expect(typeof hook).toBe("function");
-  });
-
-  it("handles message.updated event", async () => {
-    const sdkClient = {
-      session: {
-        messages: vi.fn().mockResolvedValue({
-          data: [{
-            info: { role: "assistant", summary: true },
-            parts: [{ type: "text", text: "This is a decent summary of the session content." }],
-          }],
-        }),
-        get: vi.fn().mockResolvedValue({ data: { directory: "/tmp/project" } }),
-      },
-    };
-    const hook = sessionIdleHook(
-      mockCerebroClient as any, containerTags, mockTui, sdkClient,
-    );
-    await hook(makeEvent("message.updated", {
-      info: { role: "assistant", sessionID: "s1", finish: true },
-    }));
-    // Should trigger handleSummaryCapture → ingestMessages
-    expect(mockCerebroClient.ingestMessages).toHaveBeenCalledTimes(1);
-  });
-
-  it("skips message.updated for non-assistant role", async () => {
-    const hook = sessionIdleHook(mockCerebroClient as any, containerTags, mockTui, {});
-    await hook(makeEvent("message.updated", {
-      info: { role: "user", sessionID: "s1" },
-    }));
-    expect(mockCerebroClient.ingestMessages).not.toHaveBeenCalled();
-  });
-
-  it("skips message.updated when finish is false", async () => {
-    const hook = sessionIdleHook(mockCerebroClient as any, containerTags, mockTui, {});
-    await hook(makeEvent("message.updated", {
-      info: { role: "assistant", sessionID: "s1", finish: false },
-    }));
-    expect(mockCerebroClient.ingestMessages).not.toHaveBeenCalled();
-  });
-
-  it("handles session.deleted event (cleanup)", async () => {
-    const hook = sessionIdleHook(mockCerebroClient as any, containerTags, mockTui, {});
-    // Should not throw
-    await hook(makeEvent("session.deleted", {
-      info: { id: "s1" },
-    }));
-    expect(mockCerebroClient.ingestMessages).not.toHaveBeenCalled();
-  });
-
-  it("ignores unknown event types", async () => {
-    const hook = sessionIdleHook(mockCerebroClient as any, containerTags, mockTui, {});
-    await hook(makeEvent("unknown.event", {}));
-    expect(mockCerebroClient.ingestMessages).not.toHaveBeenCalled();
-  });
-
-  it("handles session.idle event with setTimeout", async () => {
-    vi.useFakeTimers();
-    const sdkClient = {
-      session: {
-        messages: vi.fn().mockResolvedValue({
-          data: [{
-            info: { id: "m1", role: "user", createdAt: new Date().toISOString() },
-            parts: [{ type: "text", text: "hello world" }],
-          }],
-        }),
-        get: vi.fn().mockResolvedValue({ data: { directory: "/tmp", agent: "opencode" } }),
-      },
-    };
-    const onAgentResolved = vi.fn();
-    const hook = sessionIdleHook(
-      mockCerebroClient as any, containerTags, mockTui, sdkClient,
-      "smart", 0, undefined, undefined, "opencode", {}, onAgentResolved,
-    );
-
-    await hook(makeEvent("session.idle", { sessionID: "s1" }));
-
-    // Not yet called (10s timeout)
-    expect(mockCerebroClient.sessionIngest).not.toHaveBeenCalled();
-
-    // Advance past 10s
-    await vi.advanceTimersByTimeAsync(11000);
-
-    expect(mockCerebroClient.sessionIngest).toHaveBeenCalledTimes(1);
-    expect(onAgentResolved).toHaveBeenCalledWith("opencode");
-
-    vi.useRealTimers();
-  });
-
-  it("skips session.idle when autoStore is disabled", async () => {
-    vi.useFakeTimers();
-    const isAutoStoreEnabled = vi.fn(() => false);
-    const hook = sessionIdleHook(
-      mockCerebroClient as any, containerTags, mockTui, {},
-      "smart", 0, undefined, isAutoStoreEnabled,
-    );
-    await hook(makeEvent("session.idle", { sessionID: "s1" }));
-    await vi.advanceTimersByTimeAsync(11000);
-    expect(mockCerebroClient.sessionIngest).not.toHaveBeenCalled();
-    vi.useRealTimers();
-  });
-
-  it("skips session.idle for non-main session", async () => {
-    vi.useFakeTimers();
-    const getMainSessionId = vi.fn(() => "main-sess");
-    const hook = sessionIdleHook(
-      mockCerebroClient as any, containerTags, mockTui, {},
-      "smart", 0, getMainSessionId,
-    );
-    await hook(makeEvent("session.idle", { sessionID: "sub-sess" }));
-    await vi.advanceTimersByTimeAsync(11000);
-    expect(mockCerebroClient.sessionIngest).not.toHaveBeenCalled();
-    vi.useRealTimers();
-  });
-
-  it("skips session.idle when policy is readonly", async () => {
-    vi.useFakeTimers();
-    (resolveAgentPolicy as ReturnType<typeof vi.fn>).mockReturnValue("readonly");
-    const sdkClient = {
-      session: {
-        messages: vi.fn().mockResolvedValue({
-          data: [{
-            info: { id: "policy-m1", role: "user", createdAt: new Date().toISOString() },
-            parts: [{ type: "text", text: "hello" }],
-          }],
-        }),
-        get: vi.fn().mockResolvedValue({ data: { directory: "/tmp" } }),
-      },
-    };
-    const hook = sessionIdleHook(
-      mockCerebroClient as any, containerTags, mockTui, sdkClient,
-      "smart", 0, undefined, undefined, "opencode", {},
-    );
-    await hook(makeEvent("session.idle", { sessionID: "policy-sess" }));
-    await vi.advanceTimersByTimeAsync(11000);
-    expect(mockCerebroClient.sessionIngest).not.toHaveBeenCalled();
-    vi.useRealTimers();
-  });
-
-  it("skips session.idle when no sessionID", async () => {
-    const hook = sessionIdleHook(mockCerebroClient as any, containerTags, mockTui, {});
-    await hook(makeEvent("session.idle", {}));
-    expect(mockCerebroClient.sessionIngest).not.toHaveBeenCalled();
-  });
-
-  it("skips messages below threshold", async () => {
-    vi.useFakeTimers();
-    const sdkClient = {
-      session: {
-        messages: vi.fn().mockResolvedValue({
-          data: [{
-            info: { id: "thresh-m1", role: "user", createdAt: new Date().toISOString() },
-            parts: [{ type: "text", text: "just one msg" }],
-          }],
-        }),
-        get: vi.fn().mockResolvedValue({ data: { directory: "/tmp", agent: "opencode" } }),
-      },
-    };
-    const hook = sessionIdleHook(
-      mockCerebroClient as any, containerTags, mockTui, sdkClient,
-      "smart", 5,
-      undefined, undefined, "opencode", {},
-    );
-    await hook(makeEvent("session.idle", { sessionID: "thresh-sess" }));
-    await vi.advanceTimersByTimeAsync(11000);
-    expect(mockCerebroClient.sessionIngest).not.toHaveBeenCalled();
-    vi.useRealTimers();
-  });
-
-  it("shows error toast on sessionIngest failure", async () => {
-    vi.useFakeTimers();
-    mockCerebroClient.sessionIngest.mockRejectedValue(new Error("server error"));
-    const sdkClient = {
-      session: {
-        messages: vi.fn().mockResolvedValue({
-          data: [{
-            info: { id: "err-m1", role: "user", createdAt: new Date().toISOString() },
-            parts: [{ type: "text", text: "hello world test" }],
-          }],
-        }),
-        get: vi.fn().mockResolvedValue({ data: { directory: "/tmp", agent: "opencode" } }),
-      },
-    };
-    const hook = sessionIdleHook(
-      mockCerebroClient as any, containerTags, mockTui, sdkClient,
-      "smart", 0, undefined, undefined, "opencode", {},
-    );
-    await hook(makeEvent("session.idle", { sessionID: "err-sess" }));
-    await vi.advanceTimersByTimeAsync(11000);
-    expect(mockCerebroClient.sessionIngest).toHaveBeenCalled();
-    vi.useRealTimers();
-  });
-});

package/src/index.test.ts

@@ -1,190 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-// ─── Hoisted mocks ─────────────────────────────────────────────
-
-const { mockReadFileSync, mockWriteFileSync } = vi.hoisted(() => ({
-  mockReadFileSync: vi.fn(),
-  mockWriteFileSync: vi.fn(),
-}));
-
-// ─── Module mocks ──────────────────────────────────────────────
-
-vi.mock("node:fs", () => ({
-  readFileSync: mockReadFileSync,
-  writeFileSync: mockWriteFileSync,
-}));
-
-vi.mock("node:os", () => ({ tmpdir: () => "/test-tmp" }));
-
-vi.mock("node:path", () => ({
-  join: (...args: string[]) => args.join("/"),
-  dirname: (p: string) => p.split("/").slice(0, -1).join("/") || ".",
-}));
-
-vi.mock("node:url", () => ({
-  fileURLToPath: (url: string) => url.replace("file://", "/"),
-}));
-
-vi.mock("@opencode-ai/plugin", () => ({}));
-vi.mock("./client.js", () => ({ CerebroClient: vi.fn() }));
-vi.mock("./hooks.js", () => ({
-  chatMessageRecallHook: vi.fn(),
-  autocontinueHook: vi.fn(),
-  compactingHook: vi.fn(),
-  sessionIdleHook: vi.fn(),
-  sessionMessages: new Map(),
-  firstMessages: new Map(),
-  showToast: vi.fn(),
-}));
-vi.mock("./keywords.js", () => ({
-  detectSaveKeyword: vi.fn(),
-  detectRecallKeyword: vi.fn(),
-  KEYWORD_NUDGE: "",
-  RECALL_NUDGE: "",
-}));
-vi.mock("./tags.js", () => ({
-  getUserTag: vi.fn(() => "user:t"),
-  getProjectTag: vi.fn(() => "project:t"),
-}));
-vi.mock("./tools.js", () => ({ buildTools: vi.fn(() => ({})) }));
-vi.mock("./logger.js", () => ({
-  logInfo: vi.fn(),
-  logDebug: vi.fn(),
-  logError: vi.fn(),
-  setOpencodeClient: vi.fn(),
-}));
-vi.mock("./config.js", () => ({
-  loadPluginConfig: vi.fn(() => ({})),
-  resolveAgentPolicy: vi.fn(),
-}));
-vi.mock("./updater.js", () => ({ checkAndUpdate: vi.fn() }));
-vi.mock("./web-server.js", () => ({
-  startWebServer: vi.fn(),
-  stopWebServer: vi.fn(),
-}));
-
-// ─── Imports ───────────────────────────────────────────────────
-
-import { isAutoStoreEnabled, setAutoStoreEnabled } from "./index.js";
-
-// ─── Helpers ───────────────────────────────────────────────────
-
-function getMap(): Map<string, boolean> {
-  return (globalThis as any).__cerebro_autoStoreMap;
-}
-
-/** Make readFileSync return JSON for a specific sessionId file, throw ENOENT otherwise */
-function stubFileForSession(sessionId: string, data: Record<string, unknown>) {
-  mockReadFileSync.mockImplementation((path: string) => {
-    if (path.includes(`cerebro_autostore_${sessionId}.json`)) {
-      return JSON.stringify(data);
-    }
-    throw new Error("ENOENT");
-  });
-}
-
-// ─── Tests ─────────────────────────────────────────────────────
-
-describe("isAutoStoreEnabled", () => {
-  beforeEach(() => {
-    getMap().clear();
-    mockReadFileSync.mockImplementation(() => { throw new Error("ENOENT"); });
-  });
-
-  it("returns true when sessionId is undefined", () => {
-    expect(isAutoStoreEnabled(undefined)).toBe(true);
-  });
-
-  it("returns cached value from Map (true)", () => {
-    getMap().set("sess-a", true);
-    expect(isAutoStoreEnabled("sess-a")).toBe(true);
-  });
-
-  it("returns cached value from Map (false)", () => {
-    getMap().set("sess-b", false);
-    expect(isAutoStoreEnabled("sess-b")).toBe(false);
-  });
-
-  it("reads from file when Map has no entry (Bug1 fix: restart recovery)", () => {
-    stubFileForSession("sess-file", { enabled: false });
-    expect(isAutoStoreEnabled("sess-file")).toBe(false);
-  });
-
-  it("caches file value back to Map after reading", () => {
-    stubFileForSession("sess-cache", { enabled: false });
-    isAutoStoreEnabled("sess-cache");
-    // Map should now have the value
-    expect(getMap().get("sess-cache")).toBe(false);
-    // Second call uses Map, not file
-    mockReadFileSync.mockImplementation(() => { throw new Error("should not read file again"); });
-    expect(isAutoStoreEnabled("sess-cache")).toBe(false);
-  });
-
-  it("returns true (default) when no Map entry and file does not exist", () => {
-    expect(isAutoStoreEnabled("sess-noexist")).toBe(true);
-  });
-
-  it("handles malformed JSON in file gracefully → returns true", () => {
-    mockReadFileSync.mockImplementation((path: string) => {
-      if (path.includes("cerebro_autostore_sess-bad.json")) return "{invalid";
-      throw new Error("ENOENT");
-    });
-    expect(isAutoStoreEnabled("sess-bad")).toBe(true);
-  });
-
-  it("defaults to true when file has no 'enabled' field", () => {
-    stubFileForSession("sess-nofield", { something: "else" });
-    expect(isAutoStoreEnabled("sess-nofield")).toBe(true);
-  });
-
-  it("reads enabled:true from file correctly", () => {
-    stubFileForSession("sess-on", { enabled: true });
-    expect(isAutoStoreEnabled("sess-on")).toBe(true);
-  });
-});
-
-describe("setAutoStoreEnabled", () => {
-  beforeEach(() => {
-    getMap().clear();
-    mockWriteFileSync.mockImplementation(() => {});
-  });
-
-  it("sets Map entry to true", () => {
-    setAutoStoreEnabled("sess-1", true);
-    expect(getMap().get("sess-1")).toBe(true);
-  });
-
-  it("sets Map entry to false", () => {
-    setAutoStoreEnabled("sess-2", false);
-    expect(getMap().get("sess-2")).toBe(false);
-  });
-
-  it("writes correct JSON { enabled: false } to file", () => {
-    setAutoStoreEnabled("sess-1", false);
-    expect(mockWriteFileSync).toHaveBeenCalledWith(
-      expect.stringContaining("cerebro_autostore_sess-1.json"),
-      JSON.stringify({ enabled: false }),
-    );
-  });
-
-  it("writes correct JSON { enabled: true } to file", () => {
-    setAutoStoreEnabled("sess-2", true);
-    expect(mockWriteFileSync).toHaveBeenCalledWith(
-      expect.stringContaining("cerebro_autostore_sess-2.json"),
-      JSON.stringify({ enabled: true }),
-    );
-  });
-
-  it("handles write error gracefully — Map still updated", () => {
-    mockWriteFileSync.mockImplementation(() => { throw new Error("disk full"); });
-    expect(() => setAutoStoreEnabled("sess-err", true)).not.toThrow();
-    expect(getMap().get("sess-err")).toBe(true);
-  });
-
-  it("round-trip: set then get returns consistent value", () => {
-    setAutoStoreEnabled("sess-rt", false);
-    expect(isAutoStoreEnabled("sess-rt")).toBe(false);
-    setAutoStoreEnabled("sess-rt", true);
-    expect(isAutoStoreEnabled("sess-rt")).toBe(true);
-  });
-});