Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

25.9 KB
Raw Blame
/**
 * MakerMemoryManager owner 作用域守卫 — issue #2341 修复的回归测试:
 *  - owner 缺失 (resolveBasePath → null) 必须 fail-closed 抛 memory:not-ready,
 *    绝不创建/写入 %TEMP% 式临时目录 (静默丢失根源);
 *  - ownerScopeKey 变化 (登录/登出/切账号) 必须关闭旧 store 池并重建到新根,
 *    杜绝旧 db 句柄与新 owner 数据混用;
 *  - 无 resolveBasePath/ownerScopeKey 的静态 basePath 宿主行为不变。
 */

import { existsSync } from 'node:fs';
import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import path from 'node:path';

import DatabaseCtor from 'better-sqlite3';
import type Database from 'better-sqlite3';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';

import { MakerMemoryManager } from './manager.js';
import { buildBotMemoryScopeKey, memoryScopeDirName } from './storage.js';
import type { Logger } from '../interfaces/logger.js';

const noopLogger: Logger = {
  trace: () => {}, debug: () => {}, info: () => {}, warn: () => {}, error: () => {}, fatal: () => {},
  child: () => noopLogger,
};

const WORKDIR = 'D:/repo/workdir';
const SCOPE_DIR = memoryScopeDirName(WORKDIR); // Windows: 'D--repo-workdir'
const memoryDirFor = (root: string) => path.join(root, 'maker-memory', SCOPE_DIR);

// This file opens real better-sqlite3 databases and rebuilds FTS indexes. On
// Windows runners, Defender can make that synchronous file work exceed
// Vitest's default 5s timeout; keep the migration assertions unchanged while
// giving the test the same bounded Windows allowance as the contacts tests.
vi.setConfig({ testTimeout: process.platform === 'win32' ? 30_000 : 5_000 });

let rootA: string;
let rootB: string;

beforeEach(async () => {
  rootA = await mkdtemp(path.join(tmpdir(), 'memory-scope-a-'));
  rootB = await mkdtemp(path.join(tmpdir(), 'memory-scope-b-'));
});
afterEach(async () => {
  await rm(rootA, { recursive: true, force: true });
  await rm(rootB, { recursive: true, force: true });
});

/** 真 better-sqlite3, 并统计每个 open 的 db 的 close 次数 */
function trackingSqlite() {
  const closes: number[] = [];
  return {
    closes,
    factory: (filePath: string): Database.Database => {
      const db = new DatabaseCtor(filePath);
      const originalClose = db.close.bind(db);
      db.close = () => {
        closes.push(closes.length + 1);
        originalClose();
        return db; // better-sqlite3 声明 close(): this
      };
      return db;
    },
  };
}

describe('MakerMemoryManager · owner scope guard (#2341)', () => {
  it.each(['resetAll', 'resetDigests'] as const)(
    '%s preserves unopened legacy Bot memory until lazy Home migration',
    async (resetMethod) => {
      const botScope = buildBotMemoryScopeKey('bot-not-opened');
      // A normal project's sanitized path matches the legacy Bot name shape.
      const projectScope = path.join(path.sep, 'bot', 'proj', '0123456789abcdef');
      const deps = {
        basePath: rootA,
        resolveBasePath: () => rootA,
        ownerScopeKey: () => 'cloud:abc:1',
        sqliteFactory: trackingSqlite().factory,
        agents: {},
        logger: noopLogger,
        initialEnabled: true,
      };
      const legacyManager = new MakerMemoryManager(deps);
      try {
        for (const scope of [botScope, projectScope]) {
          await legacyManager.write(scope, {
            type: 'user', name: 'keep', title: 'Preference',
            description: 'Durable preference', body: 'Keep this preference.',
          });
          await legacyManager.write(scope, {
            type: 'digest', name: 'summary', title: 'Summary',
            description: 'Compaction summary', body: 'Keep this Bot summary.',
          });
        }
      } finally {
        legacyManager.dispose();
      }
      const legacyDir = path.join(rootA, 'maker-memory', memoryScopeDirName(botScope));
      const homeMemory = path.join(rootA, 'bots', 'bot-not-opened', 'memories');
      const manager = new MakerMemoryManager({
        ...deps,
        isIndependentScope: (scope) => scope === botScope,
        resolveStorageDir: (scope) => scope === botScope ? homeMemory : null,
      });
      try {
        expect(existsSync(homeMemory)).toBe(false);
        expect(await manager[resetMethod]()).toEqual({ removedCount: 1 });
        expect(existsSync(path.join(legacyDir, 'user_keep.md'))).toBe(true);
        expect(existsSync(path.join(legacyDir, 'digest_summary.md'))).toBe(true);
        const projectDir = path.join(rootA, 'maker-memory', memoryScopeDirName(projectScope));
        expect(existsSync(path.join(projectDir, 'digest_summary.md'))).toBe(false);
        expect(existsSync(path.join(projectDir, 'user_keep.md'))).toBe(resetMethod === 'resetDigests');

        const migrated = await manager.getStore(botScope);
        expect((await migrated.list()).map((record) => record.filename)).toEqual([
          'digest_summary.md', 'user_keep.md',
        ]);
        expect((await migrated.read('user_keep.md')).body.trim()).toBe('Keep this preference.');
        expect(await migrated.getIndex()).toContain('user_keep.md');
        expect(existsSync(path.join(homeMemory, 'user_keep.md'))).toBe(true);
      } finally {
        manager.dispose();
      }
    },
  );

  it.each(['resetAll', 'resetDigests'] as const)(
    '%s refuses ambiguous directory ownership without reporting a successful clear',
    async (resetMethod) => {
      const scope = path.join(path.sep, 'bot-project-0123456789abcdef');
      const deps = {
        basePath: rootA, sqliteFactory: trackingSqlite().factory,
        ownerScopeKey: () => 'cloud:abc:1',
        agents: {}, logger: noopLogger, initialEnabled: true,
      };
      const writer = new MakerMemoryManager(deps);
      try {
        await writer.write(scope, {
          type: 'digest', name: 'summary', title: 'Summary',
          description: 'Project summary', body: 'Project data.',
        });
      } finally {
        writer.dispose();
      }
      const dir = path.join(rootA, 'maker-memory', memoryScopeDirName(scope));
      const metaPath = path.join(dir, 'meta.json');
      const originalMeta = await readFile(metaPath, 'utf8');
      const manager = new MakerMemoryManager(deps);
      try {
        // Reuse the directory under test: an extra project could be removed
        // before or after the ambiguous entry depending on filesystem order.
        const previouslyOpen = resetMethod === 'resetAll' ? await manager.getStore(scope) : null;
        for (const metadata of [null, '{broken', JSON.stringify({ absPath: buildBotMemoryScopeKey('wrong-bot') })]) {
          if (metadata === null) await rm(metaPath);
          else await writeFile(metaPath, metadata, 'utf8');
          await expect(manager[resetMethod]()).rejects.toThrow(/cannot determine memory scope/);
          expect(existsSync(path.join(dir, 'digest_summary.md'))).toBe(true);
          if (previouslyOpen) await expect(previouslyOpen.list()).rejects.toThrow(/memory was reset/);
        }
        // Recovering authoritative metadata restores the normal clear path.
        await writeFile(metaPath, originalMeta, 'utf8');
        expect(await manager[resetMethod]()).toEqual({ removedCount: 1 });
        expect(existsSync(path.join(dir, 'digest_summary.md'))).toBe(false);
      } finally {
        manager.dispose();
      }
    },
  );

  it('keeps an independent Bot store available in Bot Home and copies legacy data', async () => {
    const botScope = buildBotMemoryScopeKey('bot-a');
    const legacyManager = new MakerMemoryManager({
      basePath: rootA,
      resolveBasePath: () => rootA,
      ownerScopeKey: () => 'cloud:abc:1',
      sqliteFactory: trackingSqlite().factory,
      agents: {},
      logger: noopLogger,
      initialEnabled: true,
    });
    const legacyStore = await legacyManager.getStore(botScope);
    await legacyStore.write({
      type: 'user',
      name: 'preference',
      title: 'Preference',
      description: 'legacy Bot memory',
      body: 'Keep this record.',
    });
    legacyManager.dispose();

    const homeMemory = path.join(rootA, 'bots', 'bot-a', 'memories');
    await mkdir(homeMemory, { recursive: true });
    await writeFile(path.join(homeMemory, 'USER.md'), 'Owner-scoped user profile.', 'utf8');
    const manager = new MakerMemoryManager({
      basePath: rootA,
      resolveBasePath: () => rootA,
      ownerScopeKey: () => 'cloud:abc:1',
      reloadEnabled: () => false,
      sqliteFactory: trackingSqlite().factory,
      agents: {},
      logger: noopLogger,
      initialEnabled: false,
      resolveStorageDir: (scopeKey) => scopeKey === botScope ? homeMemory : null,
      isIndependentScope: (scopeKey) => scopeKey === botScope,
    });

    const migrated = await manager.getStore(botScope);
    expect((await migrated.read('user_preference.md')).body.trim()).toBe('Keep this record.');
    expect(await readFile(path.join(homeMemory, 'USER.md'), 'utf8')).toBe('Owner-scoped user profile.');
    expect(existsSync(homeMemory)).toBe(true);
    expect(existsSync(path.join(rootA, 'maker-memory', memoryScopeDirName(botScope)))).toBe(true);
    expect(manager.getState()).toEqual({ enabled: false, activeWorkdirs: [] });
    manager.dispose();
  });

  it('global reset leaves an open Bot store and its Home memory intact', async () => {
    const botScope = buildBotMemoryScopeKey('bot-a');
    const homeMemory = path.join(rootA, 'bots', 'bot-a', 'memories');
    const manager = new MakerMemoryManager({
      basePath: rootA,
      resolveBasePath: () => rootA,
      ownerScopeKey: () => 'cloud:abc:1',
      reloadEnabled: () => true,
      sqliteFactory: trackingSqlite().factory,
      agents: {},
      logger: noopLogger,
      initialEnabled: true,
      resolveStorageDir: (scopeKey) => scopeKey === botScope ? homeMemory : null,
      isIndependentScope: (scopeKey) => scopeKey === botScope,
    });
    const botStore = await manager.getStore(botScope);
    await botStore.write({
      type: 'user',
      name: 'preference',
      title: 'Preference',
      description: 'Bot-owned memory',
      body: 'Keep this record.',
    });
    const globalStore = await manager.getStore(WORKDIR);
    await globalStore.write({
      type: 'project',
      name: 'temporary',
      title: 'Temporary',
      description: 'Global memory',
      body: 'Remove this record.',
    });

    expect((await manager.resetAll()).removedCount).toBe(1);
    expect((await botStore.read('user_preference.md')).body.trim()).toBe('Keep this record.');
    expect(existsSync(path.join(homeMemory, 'user_preference.md'))).toBe(true);
    expect(existsSync(memoryDirFor(rootA))).toBe(false);
    manager.dispose();
  });

  it('owner 缺失时 getStore 抛 memory:not-ready, 且不创建任何存储目录', async () => {
    const sqlite = trackingSqlite();
    const manager = new MakerMemoryManager({
      basePath: rootA,
      resolveBasePath: () => null, // 模拟 signed-out / 认证未落定
      ownerScopeKey: () => 'signed-out:none:0',
      sqliteFactory: sqlite.factory,
      agents: {},
      logger: noopLogger,
    });

    await expect(manager.getStore(WORKDIR)).rejects.toThrow(/memory:not-ready/);
    // 止血: 不得落盘 — 连 maker-memory 根目录都不该出现
    expect(existsSync(memoryDirFor(rootA))).toBe(false);
    expect(existsSync(path.join(rootA, 'maker-memory'))).toBe(false);
    expect(sqlite.closes).toHaveLength(0);
  });

  it('owner 缺失时 write / list 同路径 fail-closed (不经 getStore 成功)', async () => {
    const manager = new MakerMemoryManager({
      basePath: rootA,
      resolveBasePath: () => null,
      ownerScopeKey: () => 'signed-out:none:0',
      sqliteFactory: () => { throw new Error('must not open sqlite when owner missing'); },
      agents: {},
      logger: noopLogger,
    });

    await expect(
      manager.write(WORKDIR, {
        type: 'project',
        name: 'leak',
        title: '不应落盘',
        description: 'owner 缺失时禁止写临时库',
        body: 'xxx',
      }),
    ).rejects.toThrow(/memory:not-ready/);
    expect(existsSync(memoryDirFor(rootA))).toBe(false);
  });

  it('scope 稳定时复用同一 store 实例 (行为回归)', async () => {
    const sqlite = trackingSqlite();
    const manager = new MakerMemoryManager({
      basePath: rootA,
      resolveBasePath: () => rootA,
      ownerScopeKey: () => 'cloud:abc:1',
      sqliteFactory: sqlite.factory,
      agents: {},
      logger: noopLogger,
    });

    const store1 = await manager.getStore(WORKDIR);
    const store2 = await manager.getStore(WORKDIR);
    expect(store1).toBe(store2); // 同 scope 复用池内实例
    expect(sqlite.closes).toHaveLength(0); // 不应触发关闭
    manager.dispose();
  });

  it('scope 变化时关闭旧 db 并重建到新根 (owner 提交/切换)', async () => {
    let currentRoot = rootA;
    let currentScope = 'signed-out:none:0';
    const sqlite = trackingSqlite();
    const manager = new MakerMemoryManager({
      basePath: rootA,
      resolveBasePath: () => currentRoot,
      ownerScopeKey: () => currentScope,
      sqliteFactory: sqlite.factory,
      agents: {},
      logger: noopLogger,
    });

    // 首次 getStore → rootA 建库
    const storeA = await manager.getStore(WORKDIR);
    await storeA.write({
      type: 'project', name: 'note', title: 'A', description: 'desc', body: 'content-A',
    });
    expect(existsSync(memoryDirFor(rootA))).toBe(true);

    // owner 就绪/切换: root 与 scope 同时变化
    currentRoot = rootB;
    currentScope = 'cloud:abc:2';
    const storeB = await manager.getStore(WORKDIR);

    // 旧 store 的 db 已关闭, 新 store 指向新根且看不到旧数据
    expect(sqlite.closes.length).toBeGreaterThan(0);
    expect(storeB).not.toBe(storeA);
    expect((await storeB.list()).length).toBe(0);
    expect(existsSync(memoryDirFor(rootB))).toBe(true);

    // 再写一条 → 落在新根 (验证没有写回旧 owner 的库)
    await storeB.write({
      type: 'project', name: 'note-b', title: 'B', description: 'desc', body: 'content-B',
    });
    expect(existsSync(path.join(memoryDirFor(rootA), 'project_note.md'))).toBe(true);
    expect(existsSync(path.join(memoryDirFor(rootB), 'project_note-b.md'))).toBe(true);
    manager.dispose();
  });

  it('无 resolveBasePath/ownerScopeKey 的静态 basePath 宿主行为不变 (回归)', async () => {
    const sqlite = trackingSqlite();
    const manager = new MakerMemoryManager({
      basePath: rootA,
      sqliteFactory: sqlite.factory,
      agents: {},
      logger: noopLogger,
    });

    const store = await manager.getStore(WORKDIR);
    await store.write({
      type: 'project', name: 'plain', title: 'P', description: 'desc', body: 'content-P',
    });
    expect((await store.list()).length).toBe(1);
    expect(existsSync(memoryDirFor(rootA))).toBe(true);
    expect(sqlite.closes).toHaveLength(0);
    manager.dispose();
  });

  // ── 异步竞态 (review #2388 P1) ──────────────────────────────────────────

  it('getStore 异步 init 期间 owner 切换 → 抛 not-ready 且旧 store 不入池', async () => {
    let currentRoot = rootA;
    let currentScope = 'cloud:old:1';
    const sqlite = trackingSqlite();
    const manager = new MakerMemoryManager({
      basePath: rootA,
      resolveBasePath: () => currentRoot,
      ownerScopeKey: () => currentScope,
      sqliteFactory: (filePath) => {
        // 模拟「初始化 await 窗口内 owner commit」: factory 在 mkdir 后、
        // store.init 前被调用, 此时切换 scope/root 等效于窗口期切换账号。
        currentRoot = rootB;
        currentScope = 'cloud:new:2';
        return sqlite.factory(filePath);
      },
      agents: {},
      logger: noopLogger,
    });

    // 旧 owner 的 getStore 必须 fail-closed, 不得把旧 root store 提交入池
    await expect(manager.getStore(WORKDIR)).rejects.toThrow(/memory:not-ready/);

    // 当前 scope 已是 new/rootB: 后续 getStore 建在新根
    const store = await manager.getStore(WORKDIR);
    expect(store).toBeDefined();
    expect(existsSync(memoryDirFor(rootB))).toBe(true);
    manager.dispose();
  });

  it('owner 切换后 resetAll 扫新根, 不删旧 owner 数据', async () => {
    let currentRoot = rootA;
    let currentScope = 'cloud:old:1';
    const sqlite = trackingSqlite();
    const manager = new MakerMemoryManager({
      basePath: rootA,
      resolveBasePath: () => currentRoot,
      ownerScopeKey: () => currentScope,
      sqliteFactory: sqlite.factory,
      agents: {},
      logger: noopLogger,
    });

    // 旧 owner 在 rootA 写入一条 memory
    const storeA = await manager.getStore(WORKDIR);
    await storeA.write({
      type: 'project', name: 'keep', title: 'A', description: 'desc', body: 'content-A',
    });
    expect(existsSync(path.join(memoryDirFor(rootA), 'project_keep.md'))).toBe(true);

    // 切换 owner → resetAll 入口 ensureOwnerScope 换根到 rootB, 只扫 rootB (空)
    currentRoot = rootB;
    currentScope = 'cloud:new:2';
    const result = await manager.resetAll();
    expect(result.removedCount).toBe(0);
    // rootA (旧 owner) 数据完好
    expect(existsSync(path.join(memoryDirFor(rootA), 'project_keep.md'))).toBe(true);
    manager.dispose();
  });

  it('owner 切换后 resetDigests 用新根, 不动旧 owner digest 文件', async () => {
    let currentRoot = rootA;
    let currentScope = 'cloud:old:1';
    const sqlite = trackingSqlite();
    const manager = new MakerMemoryManager({
      basePath: rootA,
      resolveBasePath: () => currentRoot,
      ownerScopeKey: () => currentScope,
      sqliteFactory: sqlite.factory,
      agents: {},
      logger: noopLogger,
    });

    // 旧 owner 在 rootA 写入一条 digest + 一条 curated
    const storeA = await manager.getStore(WORKDIR);
    await storeA.write({
      type: 'digest', name: 'pi-drop', title: 'D', description: 'digest', body: 'summary',
    });
    await storeA.write({
      type: 'project', name: 'keep', title: 'K', description: 'curated', body: 'content-K',
    });
    expect(existsSync(path.join(memoryDirFor(rootA), 'digest_pi-drop.md'))).toBe(true);

    // 切换 owner → resetDigests 入口换根到 rootB (空), 不扫旧根
    currentRoot = rootB;
    currentScope = 'cloud:new:2';
    const result = await manager.resetDigests();
    expect(result.removedCount).toBe(0);
    expect(existsSync(path.join(memoryDirFor(rootA), 'digest_pi-drop.md'))).toBe(true);
    expect(existsSync(path.join(memoryDirFor(rootA), 'project_keep.md'))).toBe(true);
    manager.dispose();
  });

  it('同 workdir 并发 getStore 复用池内实例, 多余 db 被关闭', async () => {
    const sqlite = trackingSqlite();
    const manager = new MakerMemoryManager({
      basePath: rootA,
      resolveBasePath: () => rootA,
      ownerScopeKey: () => 'cloud:abc:1',
      sqliteFactory: sqlite.factory,
      agents: {},
      logger: noopLogger,
    });

    const [s1, s2] = await Promise.all([
      manager.getStore(WORKDIR),
      manager.getStore(WORKDIR),
    ]);
    expect(s1).toBe(s2); // 池内单实例
    // 后完成的那次打开了多余 db, 发现池中已有实例后必须关闭 (不泄漏句柄)
    expect(sqlite.closes.length).toBeGreaterThan(0);
    manager.dispose();
  });

  it('store 级 mutation 前置守卫: scope 变化后 write 抛 not-ready (review Codex 5th P1)', async () => {
    let currentScope = 'cloud:old:1';
    const sqlite = trackingSqlite();
    const manager = new MakerMemoryManager({
      basePath: rootA,
      resolveBasePath: () => rootA,
      ownerScopeKey: () => currentScope,
      sqliteFactory: sqlite.factory,
      agents: {},
      logger: noopLogger,
    });
    const store = await manager.getStore(WORKDIR);
    // 调用方拿到裸 store 后, owner 切换发生在 write 之前 — mutation 前置守卫拦截
    currentScope = 'cloud:new:2';
    await expect(
      store.write({
        type: 'project', name: 'x', title: 'X', description: 'd', body: 'b',
      }),
    ).rejects.toThrow(/memory:not-ready/);
    manager.dispose();
  });

  it('store 级只读守卫: scope 变化后 getIndex 抛 not-ready (review Codex 6th P1)', async () => {
    let currentScope = 'cloud:old:1';
    const sqlite = trackingSqlite();
    const manager = new MakerMemoryManager({
      basePath: rootA,
      resolveBasePath: () => rootA,
      ownerScopeKey: () => currentScope,
      sqliteFactory: sqlite.factory,
      agents: {},
      logger: noopLogger,
    });
    const store = await manager.getStore(WORKDIR);
    // session 启动路径: getStore().getIndex() 直接拼 prompt, 边界窗口不得注入旧 owner 索引
    currentScope = 'cloud:new:2';
    await expect(store.getIndex()).rejects.toThrow(/memory:not-ready/);
    await expect(store.list()).rejects.toThrow(/memory:not-ready/);
    manager.dispose();
  });

  it('rebind 到 disabled owner 后 getStore fail-closed (review Codex 5th P1)', async () => {
    let currentScope = 'cloud:enabled:1';
    let enabledForOwner = true;
    const sqlite = trackingSqlite();
    const manager = new MakerMemoryManager({
      basePath: rootA,
      resolveBasePath: () => rootA,
      ownerScopeKey: () => currentScope,
      reloadEnabled: () => enabledForOwner, // desktop: 按新 owner 根读 settings
      initialEnabled: true,
      sqliteFactory: sqlite.factory,
      agents: {},
      logger: noopLogger,
    });
    // owner A: enabled → 正常拿到 store
    const storeA = await manager.getStore(WORKDIR);
    expect(storeA).toBeDefined();
    // 切到关闭 maker memory 的 owner B: 调用方可能已持过期 enabled=true 快照,
    // getStore 必须 fail-closed, 不得打开 B 的 store
    currentScope = 'cloud:disabled:2';
    enabledForOwner = false;
    await expect(manager.getStore(WORKDIR)).rejects.toThrow(/memory:not-ready/);
    manager.dispose();
  });

  it('disabled owner 下 resetAll/resetWorkdir 仍可清空 (review Codex 10th P2)', async () => {
    let currentScope = 'cloud:disabled:2';
    let enabledForOwner = false;
    const sqlite = trackingSqlite();
    const manager = new MakerMemoryManager({
      basePath: rootA,
      resolveBasePath: () => rootA,
      ownerScopeKey: () => currentScope,
      reloadEnabled: () => enabledForOwner,
      initialEnabled: false,
      sqliteFactory: sqlite.factory,
      agents: {},
      logger: noopLogger,
    });
    // 打开 store 被拒 (disabled) — 正常工具/会话路径
    await expect(manager.getStore(WORKDIR)).rejects.toThrow(/memory:not-ready/);
    // 清理路径仍允许: 用户关闭 memory 后要能删掉已有记忆
    const viaManager = await manager.resetAll();
    expect(viaManager.removedCount).toBe(0);
    const viaWorkdir = await manager.resetWorkdir(WORKDIR);
    expect(viaWorkdir.removedCount).toBe(0);
    manager.dispose();
  });

  it('isEnabled 读取前同步 scope, 不残留旧 owner flag (review Codex 11th P1)', async () => {
    let currentScope = 'cloud:disabled:1'; // owner A: maker:false
    let enabledForOwner = false;
    const sqlite = trackingSqlite();
    const manager = new MakerMemoryManager({
      basePath: rootA,
      resolveBasePath: () => rootA,
      ownerScopeKey: () => currentScope,
      reloadEnabled: () => enabledForOwner,
      initialEnabled: false,
      sqliteFactory: sqlite.factory,
      agents: {},
      logger: noopLogger,
    });
    // 冷启动: owner 未就绪时 isEnabled 读的是初始值 (false) — withStore 会短路
    expect(manager.isEnabled()).toBe(false);
    // owner B 就绪且 maker:true: 无需任何 getStore, isEnabled 必须刷新
    currentScope = 'cloud:enabled:2';
    enabledForOwner = true;
    expect(manager.isEnabled()).toBe(true);
    // 反向: 切回 disabled owner, 再次同步
    currentScope = 'cloud:disabled:3';
    enabledForOwner = false;
    expect(manager.isEnabled()).toBe(false);
    manager.dispose();
  });

  // Windows runner 上 SQLite 文件关闭后,Defender 仍可能短暂占用目录;这个用例
  // 覆盖真实磁盘删除与重建,采用独立的 I/O 预算,避免拖宽整个 suite 的默认超时。
  it('resetAll 清空目录并重建 store (review Greptile 16th)', async () => {
    const sqlite = trackingSqlite();
    const manager = new MakerMemoryManager({
      basePath: rootA,
      resolveBasePath: () => rootA,
      ownerScopeKey: () => 'cloud:abc:1',
      sqliteFactory: sqlite.factory,
      agents: {},
      logger: noopLogger,
    });
    const storeA = await manager.getStore(WORKDIR);
    await storeA.write({
      type: 'project', name: 'a', title: 'A', description: 'd', body: 'b',
    });
    expect(existsSync(memoryDirFor(rootA))).toBe(true);

    // resetAll: 开头关闭入口池 (避免 fs.rm EBUSY) + 并发拒绝 → 删除全部目录
    const result = await manager.resetAll();
    expect(result.removedCount).toBeGreaterThan(0);
    expect(existsSync(memoryDirFor(rootA))).toBe(false);

    // 再次 getStore: 池已清空 → 全新 store + 目录重建
    const storeB = await manager.getStore(WORKDIR);
    expect(storeB).not.toBe(storeA);
    expect(existsSync(memoryDirFor(rootA))).toBe(true);
    manager.dispose();
  }, 20_000);

  it('resetAll 后旧 store 任何操作抛 not-ready, 不碰已关 db (review Greptile 20th P1)', async () => {
    const sqlite = trackingSqlite();
    const manager = new MakerMemoryManager({
      basePath: rootA,
      resolveBasePath: () => rootA,
      ownerScopeKey: () => 'cloud:abc:1',
      sqliteFactory: sqlite.factory,
      agents: {},
      logger: noopLogger,
    });
    const store = await manager.getStore(WORKDIR);
    await store.write({
      type: 'project', name: 'a', title: 'A', description: 'd', body: 'b',
    });
    // resetAll 完整执行 → 旧 store 的 db 已被 closeAllStores 关闭
    await manager.resetAll();
    // 调用方持有的旧世代 store: 读/搜均 fail-closed 抛 not-ready,
    // 不得访问已关句柄抛裸 database is closed
    await expect(store.list()).rejects.toThrow(/memory:not-ready/);
    await expect(store.search('a')).rejects.toThrow(/memory:not-ready/);
    await expect(store.getIndex()).rejects.toThrow(/memory:not-ready/);
    manager.dispose();
  });
});