@yancyyu/openhermit 1.6.42 → 1.6.43

package/src/features/worker-society/main/infrastructure/crossTeamMessageGateway.ts

@@ -0,0 +1,84 @@
+/**
+ * Worker Society — 基础设施层：cross-team 协议格式化的持久化消息网关。
+ *
+ * 把应用层 MessageGateway 落地为「调用 hermit 接口」的具象实现：
+ *   - 用 hermit 的 formatCrossTeamText 给消息打上 cross-team 前缀，使其与既有
+ *     cross-team 消息总线（parseCrossTeamPrefix）完全兼容——worker 间社交消息可被
+ *     hermit 现有渲染/中继逻辑识别。
+ *   - 以 append-only JSONL（messages.jsonl）持久化，供前端活动流 / /api/society/feed 读取。
+ *   - 注入 ClockPort 保证可测与确定性。
+ */
+import { appendFile, mkdir, readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+
+import { formatCrossTeamText } from '@shared/constants/crossTeam';
+import type { ClockPort, MessageGateway, SocialMessageOut } from '../../core/application/ports';
+
+/** 一条已持久化的社交消息记录（含 cross-team 格式化文本）。 */
+export interface SocialMessageRecord {
+  id: string;
+  fromWorker: string;
+  toWorker: string;
+  text: string;
+  /** 经 formatCrossTeamText 格式化的文本，可被 parseCrossTeamPrefix 回解析。 */
+  formatted: string;
+  needId?: string;
+  deliveredAt: string;
+}
+
+export class CrossTeamMessageGateway implements MessageGateway {
+  private readonly file: string;
+  constructor(
+    rootDir: string,
+    private readonly clock: ClockPort
+  ) {
+    this.file = join(rootDir, 'messages.jsonl');
+  }
+
+  async send(msg: SocialMessageOut): Promise<{ delivered: boolean }> {
+    await mkdir(dirname(this.file), { recursive: true });
+    const record: SocialMessageRecord = {
+      id: `msg-${randomId()}`,
+      fromWorker: msg.fromWorker,
+      toWorker: msg.toWorker,
+      text: msg.text,
+      formatted: formatCrossTeamText(msg.fromWorker, 0, msg.text),
+      needId: msg.needId,
+      deliveredAt: this.clock.now(),
+    };
+    await appendFile(this.file, `${JSON.stringify(record)}\n`, 'utf8');
+    return { delivered: true };
+  }
+
+  /** 读取全部持久化消息（按发送顺序）。文件缺失返回空；单行损坏（崩溃残留的半行）被跳过，不丢失其余合法记录。 */
+  async all(): Promise<SocialMessageRecord[]> {
+    try {
+      const raw = await readFile(this.file, 'utf8');
+      const records: SocialMessageRecord[] = [];
+      for (const line of raw.split('\n')) {
+        if (!line.trim()) continue;
+        try {
+          records.push(JSON.parse(line) as SocialMessageRecord);
+        } catch {
+          // 跳过损坏/半行（append 中途崩溃的残留），不因一行坏数据抹掉整个 feed。
+        }
+      }
+      return records;
+    } catch {
+      return [];
+    }
+  }
+
+  /** 读取最近的 N 条消息（供前端活动流）。limit<=0 或非有限数返回空——绝不回全量（防无界读）。 */
+  async recent(limit: number): Promise<SocialMessageRecord[]> {
+    if (!Number.isFinite(limit) || limit <= 0) return [];
+    const all = await this.all();
+    return all.slice(-limit);
+  }
+}
+
+function randomId(): string {
+  const g = globalThis as { crypto?: { randomUUID?: () => string } };
+  if (g.crypto?.randomUUID) return g.crypto.randomUUID();
+  return `${Date.now().toString(36)}-${Math.floor(Math.random() * 1e9).toString(36)}`;
+}

package/src/features/worker-society/main/infrastructure/fsStores.test.ts

@@ -0,0 +1,216 @@
+/**
+ * FsStores 测试 —— 基础设施层持久化（TDD 先行）。
+ *
+ * 用 os.tmpdir() 隔离每个用例，断言：
+ *   - 基本增删查（get / list / upsert / delete / listOpen / bulkSet）
+ *   - 跨实例持久化（new 一个同 rootDir 的 store 仍能读到磁盘数据）—— 这是「社交平台」声誉/关系
+ *     跨重启存活的核心不变量。
+ */
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import type { PublishedNeed, Relationship, WorkerProfile } from '../../core/domain/models/society';
+import { FsNeedStore, FsProfileStore, FsRelationshipStore } from './fsStores';
+
+function profile(workerId: string, reputation = 50): WorkerProfile {
+  return {
+    workerId,
+    name: workerId.toUpperCase(),
+    kind: 'composite',
+    capabilities: [],
+    interests: [],
+    maxConcurrent: 3,
+    activeTaskCount: 0,
+    reputation,
+    status: 'online',
+  };
+}
+
+function need(needId: string, status: PublishedNeed['status'] = 'open'): PublishedNeed {
+  return {
+    needId,
+    postedBy: 'user',
+    subject: needId,
+    requiredCapabilities: [],
+    priority: 5,
+    status,
+    volunteers: [],
+    createdAt: '2026-06-13T10:00:00.000Z',
+    revisionCount: 0,
+  };
+}
+
+function rel(from: string, to: string): Relationship {
+  return {
+    fromWorker: from,
+    toWorker: to,
+    collaborations: 1,
+    successes: 1,
+    trust: 1,
+    lastInteractedAt: '2026-06-13T10:00:00.000Z',
+  };
+}
+
+describe('FsProfileStore', () => {
+  let root: string;
+  beforeEach(async () => {
+    root = await mkdtemp(join(tmpdir(), 'ws-profile-'));
+  });
+  afterEach(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  it('returns undefined for a missing worker', async () => {
+    const store = new FsProfileStore(root);
+    expect(await store.get('ghost')).toBeUndefined();
+  });
+  it('upserts and retrieves a profile', async () => {
+    const store = new FsProfileStore(root);
+    await store.upsert(profile('w1', 60));
+    const got = await store.get('w1');
+    expect(got?.workerId).toBe('w1');
+    expect(got?.reputation).toBe(60);
+  });
+  it('upsert overwrites an existing profile', async () => {
+    const store = new FsProfileStore(root);
+    await store.upsert(profile('w1', 50));
+    await store.upsert({ ...profile('w1'), name: 'Renamed', reputation: 90 });
+    const got = await store.get('w1');
+    expect(got?.name).toBe('Renamed');
+    expect(got?.reputation).toBe(90);
+  });
+  it('lists all profiles', async () => {
+    const store = new FsProfileStore(root);
+    await store.upsert(profile('a'));
+    await store.upsert(profile('b'));
+    const list = await store.list();
+    expect(list.map((p) => p.workerId).sort()).toEqual(['a', 'b']);
+  });
+  it('deletes a profile', async () => {
+    const store = new FsProfileStore(root);
+    await store.upsert(profile('w1'));
+    await store.delete('w1');
+    expect(await store.get('w1')).toBeUndefined();
+  });
+  it('delete is a no-op for a worker that was never stored (idempotent)', async () => {
+    // L65 真臂 `if (!(workerId in map)) return`：删一个不存在的 worker（未注册/已删过）应是
+    // 幂等 no-op——不抛、不写、不误伤既有数据。既有 delete 测删的是已存在的 w1（假臂）。
+    const store = new FsProfileStore(root);
+    await store.upsert(profile('w1'));
+    await store.delete('ghost'); // ghost 不在 map → 提前 return，无写
+    expect((await store.get('w1'))?.workerId).toBe('w1'); // 既有数据未被误伤
+    expect(await store.get('ghost')).toBeUndefined();
+  });
+  it('persists across instances (reload from disk)', async () => {
+    const a = new FsProfileStore(root);
+    await a.upsert(profile('w1', 77));
+    const b = new FsProfileStore(root);
+    expect((await b.get('w1'))?.reputation).toBe(77);
+  });
+  it('survives a missing/corrupt file by returning empty data', async () => {
+    // 全新 rootDir 下文件不存在 → list 不抛、返回空。
+    const store = new FsProfileStore(root);
+    expect(await store.list()).toEqual([]);
+  });
+});
+
+describe('FsNeedStore', () => {
+  let root: string;
+  beforeEach(async () => {
+    root = await mkdtemp(join(tmpdir(), 'ws-need-'));
+  });
+  afterEach(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  it('returns undefined for a missing need', async () => {
+    expect(await new FsNeedStore(root).get('nope')).toBeUndefined();
+  });
+  it('upserts and retrieves a need', async () => {
+    const store = new FsNeedStore(root);
+    await store.upsert(need('n1'));
+    expect((await store.get('n1'))?.subject).toBe('n1');
+  });
+  it('lists all needs', async () => {
+    const store = new FsNeedStore(root);
+    await store.upsert(need('n1'));
+    await store.upsert(need('n2', 'closed'));
+    expect((await store.list()).map((n) => n.needId).sort()).toEqual(['n1', 'n2']);
+  });
+  it('listOpen returns only open needs', async () => {
+    const store = new FsNeedStore(root);
+    await store.upsert(need('open1', 'open'));
+    await store.upsert(need('closed1', 'closed'));
+    await store.upsert(need('prog1', 'in_progress'));
+    expect((await store.listOpen()).map((n) => n.needId)).toEqual(['open1']);
+  });
+  it('listActive returns needs across the open→delivered lifecycle (excludes terminal)', async () => {
+    const store = new FsNeedStore(root);
+    await store.upsert(need('open1', 'open'));
+    await store.upsert(need('asg1', 'assigned'));
+    await store.upsert(need('prog1', 'in_progress'));
+    await store.upsert(need('deliv1', 'delivered'));
+    await store.upsert(need('closed1', 'closed'));
+    await store.upsert(need('expired1', 'expired'));
+    await store.upsert(need('cancel1', 'cancelled'));
+    const active = (await store.listActive()).map((n) => n.needId).sort();
+    // 画布要看到完整生命周期：选派后/执行中/待审核都保留；仅排除已终结状态。
+    expect(active).toEqual(['asg1', 'deliv1', 'open1', 'prog1']);
+  });
+  it('upsert overwrites a need (e.g. status transition open→closed)', async () => {
+    const store = new FsNeedStore(root);
+    await store.upsert(need('n1', 'open'));
+    await store.upsert({ ...need('n1'), status: 'closed' });
+    expect((await store.get('n1'))?.status).toBe('closed');
+    expect(await store.listOpen()).toHaveLength(0);
+  });
+  it('persists across instances', async () => {
+    const a = new FsNeedStore(root);
+    await a.upsert(need('n1'));
+    const b = new FsNeedStore(root);
+    expect((await b.get('n1'))?.needId).toBe('n1');
+  });
+});
+
+describe('FsRelationshipStore', () => {
+  let root: string;
+  beforeEach(async () => {
+    root = await mkdtemp(join(tmpdir(), 'ws-rel-'));
+  });
+  afterEach(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  it('starts empty when no file exists', async () => {
+    expect(await new FsRelationshipStore(root).list()).toEqual([]);
+  });
+  it('survives a corrupt relationships.json by returning [] (covers readJson catch branch)', async () => {
+    // 写入半截/非法 JSON —— 模拟崩溃导致的半写文件；list 不抛、降级为空。
+    await writeFile(join(root, 'relationships.json'), '{ not valid json', 'utf8');
+    expect(await new FsRelationshipStore(root).list()).toEqual([]);
+  });
+  it('bulkSet round-trips relationships', async () => {
+    const store = new FsRelationshipStore(root);
+    await store.bulkSet([rel('a', 'b'), rel('b', 'c')]);
+    expect((await store.list()).map((r) => `${r.fromWorker}->${r.toWorker}`).sort()).toEqual([
+      'a->b',
+      'b->c',
+    ]);
+  });
+  it('bulkSet replaces (not appends) the full set', async () => {
+    const store = new FsRelationshipStore(root);
+    await store.bulkSet([rel('a', 'b')]);
+    await store.bulkSet([rel('c', 'd')]);
+    expect(await store.list()).toHaveLength(1);
+    expect((await store.list())[0].fromWorker).toBe('c');
+  });
+  it('persists across instances', async () => {
+    const a = new FsRelationshipStore(root);
+    await a.bulkSet([rel('a', 'b')]);
+    const b = new FsRelationshipStore(root);
+    expect(await b.list()).toHaveLength(1);
+  });
+});

package/src/features/worker-society/main/infrastructure/fsStores.ts

@@ -0,0 +1,113 @@
+/**
+ * Worker Society — 基础设施层：文件系统持久化 store。
+ *
+ * 把应用层 ports（WorkerProfileStore / NeedStore / RelationshipStore）落地为
+ * `~/.hermit/society/` 下的 JSON 文件，使声誉 / 关系 / 需求跨重启持久——
+ * 这是「worker 社交平台」区别于一次性内存调度的核心。
+ *
+ * 设计：
+ *   - 注入 rootDir（生产用 ~/.hermit/society，测试用 os.tmpdir() 隔离）。
+ *   - 原子写：先写 .tmp 再 rename，避免半写损坏。
+ *   - 容错读：文件不存在或损坏时返回空数据，不抛——保证服务在冷启动时可启动。
+ *   - 不引入任何业务规则（纯 I/O），业务规则全部留在 core/domain。
+ */
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+
+import type { PublishedNeed, Relationship, WorkerProfile } from '../../core/domain/models/society';
+import type {
+  NeedStore,
+  RelationshipStore,
+  WorkerProfileStore,
+} from '../../core/application/ports';
+import { ACTIVE_NEED_STATUSES } from '../../core/domain/policies/societyPolicies';
+
+async function readJson<T>(filePath: string, fallback: T): Promise<T> {
+  try {
+    const raw = await readFile(filePath, 'utf8');
+    return JSON.parse(raw) as T;
+  } catch {
+    // 文件不存在或解析失败 → 返回 fallback，保证冷启动可用。
+    return fallback;
+  }
+}
+
+async function writeJsonAtomic(filePath: string, value: unknown): Promise<void> {
+  await mkdir(dirname(filePath), { recursive: true });
+  const tmp = `${filePath}.tmp`;
+  await writeFile(tmp, JSON.stringify(value, null, 2), 'utf8');
+  await rename(tmp, filePath);
+}
+
+type ProfileMap = Record<string, WorkerProfile>;
+type NeedMap = Record<string, PublishedNeed>;
+
+/** 声誉/能力档案的文件持久化（profiles.json）。 */
+export class FsProfileStore implements WorkerProfileStore {
+  private readonly file: string;
+  constructor(rootDir: string) {
+    this.file = join(rootDir, 'profiles.json');
+  }
+  async get(workerId: string): Promise<WorkerProfile | undefined> {
+    return (await readJson<ProfileMap>(this.file, {}))[workerId];
+  }
+  async list(): Promise<WorkerProfile[]> {
+    return Object.values(await readJson<ProfileMap>(this.file, {}));
+  }
+  async upsert(profile: WorkerProfile): Promise<WorkerProfile> {
+    const map = await readJson<ProfileMap>(this.file, {});
+    map[profile.workerId] = profile;
+    await writeJsonAtomic(this.file, map);
+    return profile;
+  }
+  async delete(workerId: string): Promise<void> {
+    const map = await readJson<ProfileMap>(this.file, {});
+    if (!(workerId in map)) return;
+    delete map[workerId];
+    await writeJsonAtomic(this.file, map);
+  }
+}
+
+/** 广场需求（任务帖）的文件持久化（needs.json）。 */
+export class FsNeedStore implements NeedStore {
+  private readonly file: string;
+  constructor(rootDir: string) {
+    this.file = join(rootDir, 'needs.json');
+  }
+  async get(needId: string): Promise<PublishedNeed | undefined> {
+    return (await readJson<NeedMap>(this.file, {}))[needId];
+  }
+  async list(): Promise<PublishedNeed[]> {
+    return Object.values(await readJson<NeedMap>(this.file, {}));
+  }
+  async listOpen(): Promise<PublishedNeed[]> {
+    const map = await readJson<NeedMap>(this.file, {});
+    return Object.values(map).filter((n) => n.status === 'open');
+  }
+  async listActive(): Promise<PublishedNeed[]> {
+    // 活跃需求 = 仍在交互生命周期内（未终结）：选派后/执行中/待审核也保留，
+    // 这样画布上的 worker 会在整个生命周期停在任务锚点，而非选派后即丢下任务飘走。
+    const map = await readJson<NeedMap>(this.file, {});
+    return Object.values(map).filter((n) => ACTIVE_NEED_STATUSES.includes(n.status));
+  }
+  async upsert(need: PublishedNeed): Promise<PublishedNeed> {
+    const map = await readJson<NeedMap>(this.file, {});
+    map[need.needId] = need;
+    await writeJsonAtomic(this.file, map);
+    return need;
+  }
+}
+
+/** worker 间关系图（有向边）的文件持久化（relationships.json）。 */
+export class FsRelationshipStore implements RelationshipStore {
+  private readonly file: string;
+  constructor(rootDir: string) {
+    this.file = join(rootDir, 'relationships.json');
+  }
+  async list(): Promise<Relationship[]> {
+    return readJson<Relationship[]>(this.file, []);
+  }
+  async bulkSet(relationships: Relationship[]): Promise<void> {
+    await writeJsonAtomic(this.file, relationships);
+  }
+}

package/src/features/worker-society/main/infrastructure/mergingProfileStore.test.ts

@@ -0,0 +1,195 @@
+/**
+ * MergingProfileStore 测试 —— 「真实数字员工 ↔ 社会层 overlay」合并的不变量。
+ *
+ * 核心断言：花名册以真实员工为单一事实源；身份/在线态恒取真实，社会属性取 overlay 或默认；
+ * overlay 里真实员工已不存在的孤儿（旧假数据）在读取时被丢弃。
+ */
+import { describe, expect, it } from 'vitest';
+
+import type { DiscoverableWorker } from '@shared/types/worker';
+import type { WorkerProfile } from '../../core/domain/models/society';
+
+import { MergingProfileStore, mergeRealWorker } from './mergingProfileStore';
+import type { WorkerProfileStore } from '../../core/application/ports';
+
+// ── 工厂 ──────────────────────────────────────────────────────────────────────
+
+function realWorker(overrides: Partial<DiscoverableWorker> = {}): DiscoverableWorker {
+  return {
+    workerId: 'hermit-dev',
+    name: 'Hermit 开发',
+    kind: 'composite',
+    harness: 'claudecode',
+    location: 'local',
+    status: 'online',
+    capabilities: [
+      { skill: 'claudecode', description: 'claudecode' },
+      { skill: 'general', description: 'general' },
+    ],
+    description: '本地 hermit 团队',
+    workDir: '/Users/yancyyu/code/hermit',
+    ...overrides,
+  };
+}
+
+function overlay(workerId: string, overrides: Partial<WorkerProfile> = {}): WorkerProfile {
+  return {
+    workerId,
+    name: 'SHOULD BE OVERWRITTEN',
+    kind: 'atomic',
+    harness: 'SHOULD-BE-OVERWRITTEN',
+    capabilities: [],
+    interests: [],
+    maxConcurrent: 3,
+    activeTaskCount: 0,
+    reputation: 50,
+    status: 'busy',
+    ...overrides,
+  };
+}
+
+/** 内存版 overlay store，供 MergingProfileStore 装饰。 */
+function fakeBase(
+  initial: WorkerProfile[] = []
+): WorkerProfileStore & { data: Map<string, WorkerProfile> } {
+  const data = new Map(initial.map((p) => [p.workerId, p]));
+  return {
+    data,
+    get: async (id) => data.get(id),
+    list: async () => [...data.values()],
+    upsert: async (p) => {
+      data.set(p.workerId, p);
+      return p;
+    },
+    delete: async (id) => {
+      data.delete(id);
+    },
+  };
+}
+
+// ── mergeRealWorker（纯函数）──────────────────────────────────────────────────
+
+describe('mergeRealWorker', () => {
+  it('身份字段恒取真实员工（overlay 的 name/kind/harness 被忽略）', () => {
+    const m = mergeRealWorker(
+      realWorker(),
+      overlay('hermit-dev', { name: 'FAKE', kind: 'atomic', harness: 'FAKE' })
+    );
+    expect(m.workerId).toBe('hermit-dev');
+    expect(m.name).toBe('Hermit 开发');
+    expect(m.kind).toBe('composite');
+    expect(m.harness).toBe('claudecode');
+    expect(m.workDir).toBe('/Users/yancyyu/code/hermit'); // 绑定目录恒取真实员工
+    expect(m.description).toBe('本地 hermit 团队');
+  });
+
+  it('status 由真实员工决定：online→online', () => {
+    expect(mergeRealWorker(realWorker({ status: 'online' })).status).toBe('online');
+  });
+
+  it('status 由真实员工决定：offline（及其它值）→offline，不合成 busy', () => {
+    expect(mergeRealWorker(realWorker({ status: 'offline' })).status).toBe('offline');
+    // overlay 的 'busy' 不能渗透——真实员工只有 online/offline。
+    expect(
+      mergeRealWorker(realWorker({ status: 'online' }), overlay('hermit-dev', { status: 'busy' }))
+        .status
+    ).toBe('online');
+  });
+
+  it('overlay 非空能力时覆盖真实员工的推断能力', () => {
+    const m = mergeRealWorker(
+      realWorker(),
+      overlay('hermit-dev', { capabilities: [{ skill: 'react', description: 'react' }] })
+    );
+    expect(m.capabilities.map((c) => c.skill)).toEqual(['react']);
+  });
+
+  it('overlay 缺省 / 能力为空时回退到真实员工被推断的能力', () => {
+    expect(mergeRealWorker(realWorker()).capabilities.map((c) => c.skill)).toEqual([
+      'claudecode',
+      'general',
+    ]);
+    expect(
+      mergeRealWorker(realWorker(), overlay('hermit-dev', { capabilities: [] })).capabilities.map(
+        (c) => c.skill
+      )
+    ).toEqual(['claudecode', 'general']);
+  });
+
+  it('真实员工无能力且无 overlay → 能力为空（不凭空造）', () => {
+    expect(mergeRealWorker(realWorker({ capabilities: undefined })).capabilities).toEqual([]);
+  });
+
+  it('reputation 默认 50；overlay 给值时夹取到 [0,100]', () => {
+    expect(mergeRealWorker(realWorker()).reputation).toBe(50);
+    expect(
+      mergeRealWorker(realWorker(), overlay('hermit-dev', { reputation: 150 })).reputation
+    ).toBe(100);
+    expect(
+      mergeRealWorker(realWorker(), overlay('hermit-dev', { reputation: -20 })).reputation
+    ).toBe(0);
+    expect(
+      mergeRealWorker(realWorker(), overlay('hermit-dev', { reputation: 80 })).reputation
+    ).toBe(80);
+  });
+
+  it('maxConcurrent 默认 2；overlay 覆盖', () => {
+    expect(mergeRealWorker(realWorker()).maxConcurrent).toBe(2);
+    expect(
+      mergeRealWorker(realWorker(), overlay('hermit-dev', { maxConcurrent: 5 })).maxConcurrent
+    ).toBe(5);
+  });
+
+  it('interests / activeTaskCount 默认空 / 0', () => {
+    const m = mergeRealWorker(realWorker());
+    expect(m.interests).toEqual([]);
+    expect(m.activeTaskCount).toBe(0);
+  });
+});
+
+// ── MergingProfileStore（list/get 写入语义）────────────────────────────────────
+
+describe('MergingProfileStore', () => {
+  it('list() 合并真实员工 + overlay，并丢弃 overlay 里的孤儿（假数据）', async () => {
+    const base = fakeBase([
+      overlay('hermit-dev', { reputation: 77 }), // 真实员工 → 合并
+      overlay('frontend', { reputation: 99 }), // 真实列表里没有 → 孤儿丢弃
+    ]);
+    const store = new MergingProfileStore(base, async () => [realWorker()]);
+
+    const list = await store.list();
+    expect(list).toHaveLength(1);
+    expect(list[0].workerId).toBe('hermit-dev');
+    expect(list[0].reputation).toBe(77); // overlay 的声誉生效
+    expect(list.map((w) => w.workerId)).not.toContain('frontend');
+  });
+
+  it('get() 对真实员工返回合并档案；对非真实员工返回 undefined', async () => {
+    const base = fakeBase([overlay('hermit-dev', { maxConcurrent: 4 })]);
+    const store = new MergingProfileStore(base, async () => [realWorker()]);
+
+    const got = await store.get('hermit-dev');
+    expect(got?.name).toBe('Hermit 开发'); // 真实身份
+    expect(got?.maxConcurrent).toBe(4); // overlay 社会属性
+
+    expect(await store.get('frontend')).toBeUndefined(); // 非真实 → 不可见
+  });
+
+  it('upsert 只写 overlay（身份字段下次读取被真实员工覆盖）', async () => {
+    const base = fakeBase();
+    const store = new MergingProfileStore(base, async () => [realWorker()]);
+
+    await store.upsert(overlay('hermit-dev', { reputation: 88, name: 'STALE-NAME' }));
+    expect(base.data.get('hermit-dev')?.reputation).toBe(88); // 写进了 overlay
+    const got = await store.get('hermit-dev');
+    expect(got?.reputation).toBe(88); // overlay 生效
+    expect(got?.name).toBe('Hermit 开发'); // 但身份仍取真实员工（STALE-NAME 被忽略）
+  });
+
+  it('delete 委托给 base', async () => {
+    const base = fakeBase([overlay('hermit-dev')]);
+    const store = new MergingProfileStore(base, async () => [realWorker()]);
+    await store.delete('hermit-dev');
+    expect(base.data.has('hermit-dev')).toBe(false);
+  });
+});