@yancyyu/openhermit 1.6.42 → 1.6.43

package/src/features/worker-society/main/adapters/input/societyRoutes.ts

@@ -0,0 +1,194 @@
+/**
+ * Worker Society — 输入适配器：Fastify REST 路由（/api/society/*）。
+ *
+ * 把 WorkerSocietyService 的 use case 暴露为 HTTP 接口，供前端 / 外部调用。
+ * 命令（发布、自荐、选派、交付…）走 service；纯查询（列表/详情/feed）直接读 store/gateway。
+ *
+ * 路由风格对齐 server.ts 既有约定（app.get/post，try/catch 返回兜底，body 用 Record 解析）。
+ */
+import type { FastifyInstance } from 'fastify';
+
+import type { AgentCapability } from '../../../core/domain/models/society';
+import type {
+  PublishNeedCommand,
+  RegisterProfileCommand,
+} from '../../../core/application/WorkerSocietyService';
+import type { SocietyComponents } from '../../composition/societyComposition';
+
+export function registerSocietyRoutes(app: FastifyInstance, c: SocietyComponents): void {
+  // ── workers（发现 / 档案）──────────────────────────────────────────────
+  app.get('/api/society/workers', async () => {
+    try {
+      return await c.service.discoverWorkers();
+    } catch {
+      return [];
+    }
+  });
+
+  app.get('/api/society/workers/:workerId', async (request, reply) => {
+    const { workerId } = request.params as { workerId: string };
+    const profile = await c.service.getProfile(workerId);
+    if (!profile) return reply.code(404).send({ error: 'worker_not_found' });
+    return profile;
+  });
+
+  app.post('/api/society/workers/register', async (request, reply) => {
+    const body = (request.body ?? {}) as Record<string, unknown>;
+    const workerId = String(body.workerId ?? '').trim();
+    const name = String(body.name ?? '').trim();
+    if (!workerId || !name) {
+      return reply.code(400).send({ error: 'workerId and name required' });
+    }
+    const cmd: RegisterProfileCommand = {
+      workerId,
+      name,
+      kind: body.kind as RegisterProfileCommand['kind'],
+      harness: body.harness as string | undefined,
+      capabilities: body.capabilities as AgentCapability[] | undefined,
+      interests: body.interests as string[] | undefined,
+      maxConcurrent: body.maxConcurrent as number | undefined,
+      reputation: body.reputation as number | undefined,
+      description: body.description as string | undefined,
+    };
+    return await c.service.registerProfile(cmd);
+  });
+
+  // ── needs（广场公告板）─────────────────────────────────────────────────
+  app.get('/api/society/needs/open', async () => {
+    try {
+      return await c.needs.listOpen();
+    } catch {
+      return [];
+    }
+  });
+
+  // 画布/实时视图用：仍在生命周期内的需求（选派后/执行中/待审核也保留）。
+  app.get('/api/society/needs/active', async () => {
+    try {
+      return await c.needs.listActive();
+    } catch {
+      return [];
+    }
+  });
+
+  app.get('/api/society/needs', async () => {
+    try {
+      return await c.needs.list();
+    } catch {
+      return [];
+    }
+  });
+
+  app.get('/api/society/needs/:needId', async (request) => {
+    const { needId } = request.params as { needId: string };
+    return (await c.needs.get(needId)) ?? null;
+  });
+
+  app.post('/api/society/needs', async (request, reply) => {
+    const body = (request.body ?? {}) as Record<string, unknown>;
+    const postedBy = String(body.postedBy ?? '').trim();
+    const subject = String(body.subject ?? '').trim();
+    if (!postedBy || !subject) {
+      return reply.code(400).send({ error: 'postedBy and subject required' });
+    }
+    const cmd: PublishNeedCommand = {
+      postedBy,
+      subject,
+      description: body.description as string | undefined,
+      requiredCapabilities: Array.isArray(body.requiredCapabilities)
+        ? (body.requiredCapabilities as string[])
+        : [],
+      priority: body.priority as number | undefined,
+      deadline: body.deadline as string | undefined,
+    };
+    const { need } = await c.service.publishNeed(cmd);
+    return need;
+  });
+
+  app.post('/api/society/needs/:needId/volunteer', async (request) => {
+    const { needId } = request.params as { needId: string };
+    const body = (request.body ?? {}) as Record<string, unknown>;
+    return await c.service.volunteerFor(
+      needId,
+      String(body.workerId ?? '').trim(),
+      body.note as string | undefined
+    );
+  });
+
+  app.post('/api/society/needs/:needId/select', async (request) => {
+    const { needId } = request.params as { needId: string };
+    return await c.service.selectAssignee(needId);
+  });
+
+  app.post('/api/society/needs/:needId/start', async (request) => {
+    const { needId } = request.params as { needId: string };
+    const body = (request.body ?? {}) as Record<string, unknown>;
+    return await c.service.startNeed(needId, String(body.workerId ?? '').trim());
+  });
+
+  app.post('/api/society/needs/:needId/deliver', async (request) => {
+    const { needId } = request.params as { needId: string };
+    const body = (request.body ?? {}) as Record<string, unknown>;
+    return await c.service.deliverNeed(needId, String(body.result ?? '').trim());
+  });
+
+  app.post('/api/society/needs/:needId/accept', async (request) => {
+    const { needId } = request.params as { needId: string };
+    return await c.service.acceptDelivery(needId);
+  });
+
+  app.post('/api/society/needs/:needId/revision', async (request) => {
+    const { needId } = request.params as { needId: string };
+    return await c.service.requestRevision(needId);
+  });
+
+  app.post('/api/society/needs/:needId/cancel', async (request) => {
+    const { needId } = request.params as { needId: string };
+    return await c.service.cancelNeed(needId);
+  });
+
+  // ── 自治驱动（去中心化：让 worker 主动自荐，反派单）─────────────────────
+  app.post('/api/society/autonomy/tick', async (request) => {
+    const body = (request.body ?? {}) as Record<string, unknown>;
+    const numOrUndef = (k: string): number | undefined =>
+      typeof body[k] === 'number' ? (body[k] as number) : undefined;
+    const applied = await c.service.runAutonomyTick({
+      maxVolunteersPerNeed: numOrUndef('maxVolunteersPerNeed'),
+      maxNeedsPerWorker: numOrUndef('maxNeedsPerWorker'),
+    });
+    return { ok: true, applied };
+  });
+
+  app.post('/api/society/autonomy/auto-select', async () => {
+    const selected = await c.service.autoSelectPending();
+    return { ok: true, selected };
+  });
+
+  // ── 社交：关系 / 消息 / 活动流 ─────────────────────────────────────────
+  app.get('/api/society/relationships', async () => {
+    try {
+      return await c.relationships.list();
+    } catch {
+      return [];
+    }
+  });
+
+  app.post('/api/society/messages', async (request, reply) => {
+    const body = (request.body ?? {}) as Record<string, unknown>;
+    const fromWorker = String(body.fromWorker ?? '').trim();
+    const toWorker = String(body.toWorker ?? '').trim();
+    const text = String(body.text ?? '').trim();
+    if (!fromWorker || !toWorker || !text) {
+      return reply.code(400).send({ error: 'fromWorker, toWorker and text required' });
+    }
+    return await c.service.sendSocialMessage(fromWorker, toWorker, text);
+  });
+
+  app.get('/api/society/feed', async () => {
+    try {
+      return await c.gateway.recent(50);
+    } catch {
+      return [];
+    }
+  });
+}

package/src/features/worker-society/main/composition/societyComposition.test.ts

@@ -0,0 +1,74 @@
+/**
+ * Composition root 集成测试 —— 证明真实适配器（FS store + cross-team 网关 + 系统时钟）
+ * 组合后能跑通完整自治流程，且状态跨「重启」（新建实例）持久化。
+ *
+ * 这是 worker-society 从纯库走向「持久化社交平台」的关键证据。
+ */
+import { mkdtemp, rm } from 'node:fs/promises';
+import { homedir, tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { createWorkerSociety, defaultSocietyRoot } from './societyComposition';
+
+describe('createWorkerSociety (composition root)', () => {
+  let root: string;
+  beforeEach(async () => {
+    root = await mkdtemp(join(tmpdir(), 'ws-comp-'));
+  });
+  afterEach(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  it('wires a full self-organization flow that persists across a simulated restart', async () => {
+    const { service } = createWorkerSociety(root);
+    await service.registerProfile({
+      workerId: 'poster',
+      name: 'Poster',
+      capabilities: [{ skill: 'pm', description: 'pm' }],
+    });
+    await service.registerProfile({
+      workerId: 'dev',
+      name: 'Dev',
+      capabilities: [{ skill: 'code', description: 'code' }],
+      reputation: 60,
+    });
+
+    const { need } = await service.publishNeed({
+      postedBy: 'poster',
+      subject: 'build feature X',
+      requiredCapabilities: ['code'],
+    });
+    await service.volunteerFor(need.needId, 'dev');
+    await service.selectAssignee(need.needId);
+    await service.startNeed(need.needId, 'dev');
+    await service.deliverNeed(need.needId, 'v1');
+    await service.acceptDelivery(need.needId);
+
+    // 新实例模拟重启：dev 声誉上升、关系形成、需求关闭 —— 全部已落盘。
+    const { service: reloaded, gateway } = createWorkerSociety(root);
+    const dev = await reloaded.getProfile('dev');
+    expect(dev?.reputation).toBeGreaterThan(60);
+    expect((await reloaded.getRelationships()).length).toBeGreaterThan(0);
+    const closedNeed = await reloaded.getProfile('poster'); // 触发一次 store 读
+    expect(closedNeed).toBeTruthy();
+    // 自荐/选派消息经 cross-team 网关持久化到 messages.jsonl
+    expect((await gateway.recent(10)).length).toBeGreaterThan(0);
+  });
+
+  it('exposes stores + gateway + service from a single root', () => {
+    const c = createWorkerSociety(root);
+    expect(c.service).toBeTruthy();
+    expect(c.gateway).toBeTruthy();
+    expect(c.profiles).toBeTruthy();
+    expect(c.needs).toBeTruthy();
+    expect(c.relationships).toBeTruthy();
+  });
+
+  it('defaultSocietyRoot resolves to ~/.hermit/society (the canonical on-disk data root)', () => {
+    // createWorkerSociety 的默认参数 = defaultSocietyRoot()，但既有测试都传显式 tmpdir →
+    // 该导出从未被调用（FNDA:0）。这是声誉/关系/需求/消息跨重启落盘的规范路径，锁定防漂移。
+    expect(defaultSocietyRoot()).toBe(join(homedir(), '.hermit', 'society'));
+  });
+});

package/src/features/worker-society/main/composition/societyComposition.ts

@@ -0,0 +1,70 @@
+/**
+ * Worker Society — 组合根（composition root）。
+ *
+ * 把领域/应用层与基础设施层装配成一个可被 server.ts / MCP / 前端调用的活实例：
+ *   - FS store（~/.hermit/society/*.json）让声誉/关系/需求持久。
+ *   - CrossTeamMessageGateway 让 worker 间消息走 hermit cross-team 协议并持久化。
+ *   - SystemClock 提供真实时间（应用层允许使用 Date；只有 workflow 脚本受限）。
+ *
+ * 镜像 server.ts:440-441（taskDispatch 构造）的注入式构造风格。
+ * rootDir 可注入（生产默认 ~/.hermit/society，测试用临时目录）。
+ */
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+import type { DiscoverableWorker } from '@shared/types/worker';
+
+import type { ClockPort, WorkerProfileStore } from '../../core/application/ports';
+import { WorkerSocietyService } from '../../core/application/WorkerSocietyService';
+import { CrossTeamMessageGateway } from '../infrastructure/crossTeamMessageGateway';
+import { MergingProfileStore } from '../infrastructure/mergingProfileStore';
+import { FsNeedStore, FsProfileStore, FsRelationshipStore } from '../infrastructure/fsStores';
+
+/** 默认社会数据根目录：~/.hermit/society。 */
+export function defaultSocietyRoot(): string {
+  return join(homedir(), '.hermit', 'society');
+}
+
+/** 真实系统时钟（ISO 字符串）。 */
+class SystemClock implements ClockPort {
+  now(): string {
+    return new Date().toISOString();
+  }
+}
+
+export interface SocietyComponents {
+  service: WorkerSocietyService;
+  gateway: CrossTeamMessageGateway;
+  /** 花名册存储：注入 realWorkersProvider 时为 MergingProfileStore（真实员工 + overlay），否则 FsProfileStore。 */
+  profiles: WorkerProfileStore;
+  needs: FsNeedStore;
+  relationships: FsRelationshipStore;
+}
+
+/**
+ * 真实员工来源（注入点）。society 的成员花名册以 hermit 真实数字员工为单一事实源——
+ * 由 server.ts 注入 listDiscoverableWorkers（GET /api/workers 同款），让社会层身份与真实团队一致；
+ * 社会属性（能力/声誉/并发）由 ~/.hermit/society/profiles.json overlay 叠加（见 MergingProfileStore）。
+ * 缺省不注入 → 退化为纯 FsProfileStore（既有单测 / 离线场景零变化）。
+ */
+export interface WorkerSocietyDepsInput {
+  realWorkersProvider?: () => Promise<DiscoverableWorker[]>;
+}
+
+/** 装配 worker-society 全栈。同一 rootDir 可多次调用以「重载」磁盘状态。 */
+export function createWorkerSociety(
+  rootDir: string = defaultSocietyRoot(),
+  deps: WorkerSocietyDepsInput = {}
+): SocietyComponents {
+  const clock = new SystemClock();
+  // 注入了 realWorkersProvider → 用 MergingProfileStore 把真实员工与 overlay 合并；
+  // 否则用纯 FsProfileStore（离线/测试场景，成员即 profiles.json 本身，零行为变化）。
+  const profiles: WorkerProfileStore = deps.realWorkersProvider
+    ? new MergingProfileStore(new FsProfileStore(rootDir), deps.realWorkersProvider)
+    : new FsProfileStore(rootDir);
+  const needs = new FsNeedStore(rootDir);
+  const relationships = new FsRelationshipStore(rootDir);
+  const gateway = new CrossTeamMessageGateway(rootDir, clock);
+  const service = new WorkerSocietyService(profiles, needs, relationships, gateway, clock);
+  return { service, gateway, profiles, needs, relationships };
+}

package/src/features/worker-society/main/composition/workerSocietyPlugin.test.ts

@@ -0,0 +1,69 @@
+/**
+ * workerSocietyPlugin —— 插件描述符单测（test-first）。
+ *
+ * 锁定：稳定 id、指向 hermit /mcp 的 HTTP-SSE 端点、工具列表与 SOCIETY_MCP_TOOLS 同源
+ * （无漂移）、library 条目形状匹配 McpLibraryService.upsert 契约。
+ */
+import { describe, expect, it } from 'vitest';
+
+import { SOCIETY_MCP_TOOLS } from '../adapters/input/societyMcp';
+import {
+  WORKER_SOCIETY_PLUGIN,
+  WORKER_SOCIETY_PLUGIN_ID,
+  buildWorkerSocietyMcpLibraryEntry,
+} from './workerSocietyPlugin';
+
+describe('WORKER_SOCIETY_PLUGIN descriptor', () => {
+  it('has a stable plugin id matching the `openhermit add` key', () => {
+    expect(WORKER_SOCIETY_PLUGIN_ID).toBe('worker-society');
+    expect(WORKER_SOCIETY_PLUGIN.id).toBe('worker-society');
+  });
+
+  it('points at the hermit MCP HTTP-SSE endpoint', () => {
+    expect(WORKER_SOCIETY_PLUGIN.kind).toBe('mcp-library');
+    expect(WORKER_SOCIETY_PLUGIN.mcpEndpoint).toBe('/mcp');
+    expect(WORKER_SOCIETY_PLUGIN.transportType).toBe('sse');
+  });
+
+  it('exposes the live society_* tool list with no drift vs SOCIETY_MCP_TOOLS', () => {
+    expect(WORKER_SOCIETY_PLUGIN.tools).toEqual(SOCIETY_MCP_TOOLS.map((t) => t.name));
+    expect(WORKER_SOCIETY_PLUGIN.tools.length).toBeGreaterThan(0);
+    expect(WORKER_SOCIETY_PLUGIN.tools).toContain('society_register_worker');
+    expect(WORKER_SOCIETY_PLUGIN.tools).toContain('society_run_autonomy_tick');
+    expect(WORKER_SOCIETY_PLUGIN.tools).toContain('society_auto_select');
+    expect(WORKER_SOCIETY_PLUGIN.tools.every((n) => n.startsWith('society_'))).toBe(true);
+  });
+
+  it('is plain serializable metadata (no functions, safe to log/POST)', () => {
+    const json = JSON.parse(JSON.stringify(WORKER_SOCIETY_PLUGIN));
+    expect(json.id).toBe('worker-society');
+    expect(json.tools).toEqual(WORKER_SOCIETY_PLUGIN.tools);
+  });
+});
+
+describe('buildWorkerSocietyMcpLibraryEntry', () => {
+  it('defaults to 127.0.0.1:5680/mcp over SSE', () => {
+    const entry = buildWorkerSocietyMcpLibraryEntry();
+    expect(entry.name).toBe('worker-society');
+    expect(entry.installSpec).toEqual({
+      type: 'http',
+      url: 'http://127.0.0.1:5680/mcp',
+      transportType: 'sse',
+    });
+  });
+
+  it('respects custom host and port', () => {
+    const entry = buildWorkerSocietyMcpLibraryEntry('0.0.0.0', 8080);
+    expect(entry.installSpec.url).toBe('http://0.0.0.0:8080/mcp');
+    expect(entry.installSpec.transportType).toBe('sse');
+  });
+
+  it('matches the McpLibraryService.upsert body shape', () => {
+    const entry = buildWorkerSocietyMcpLibraryEntry();
+    // upsert 期望：{ name, description?, installSpec: { type, url, transportType } }
+    expect(typeof entry.name).toBe('string');
+    expect(typeof entry.description).toBe('string');
+    expect(entry.installSpec.type).toBe('http');
+    expect(typeof entry.installSpec.url).toBe('string');
+  });
+});

package/src/features/worker-society/main/composition/workerSocietyPlugin.ts

@@ -0,0 +1,67 @@
+/**
+ * workerSocietyPlugin —— 把 worker-society 声明为 hermit 的「可安装插件」。
+ *
+ * 关键事实：hermit 自己就是 MCP-over-HTTP-SSE 服务端（`GET/POST /mcp`），society_*
+ * 工具已经通过该端点对外暴露（server.ts 把 SOCIETY_MCP_TOOLS 接进 /mcp 分发）。
+ * 所以「安装 worker 社会」最贴合 hermit 架构的做法 = 把这个端点注册进 hermit 的
+ * MCP library（`~/.hermit/mcp-library.json`），用户的 coding agent（Claude Code 等）
+ * 即可获得 society_* 工具，参与去中心化自治社会。这正是 hermit「定义一次、给任意
+ * worker 启用」的 MCP 安装模型（见 McpLibraryService）。
+ *
+ * 纯描述符 + 构造器，无副作用，便于单测；`openhermit add worker-society` 据此生成
+ * MCP library 条目并 POST 到 `/api/extensions/mcp/library`。
+ */
+import { SOCIETY_MCP_TOOLS } from '../adapters/input/societyMcp';
+
+/** 稳定插件 id，也是 `openhermit add <id>` 的键。 */
+export const WORKER_SOCIETY_PLUGIN_ID = 'worker-society';
+
+export interface WorkerSocietyPluginDescriptor {
+  /** 稳定插件 id。 */
+  id: string;
+  name: string;
+  description: string;
+  /** 安装种类：注册为 MCP library 条目（HTTP-SSE 服务端）。 */
+  kind: 'mcp-library';
+  /** society 对外暴露的 MCP 端点路径（挂在 hermit 主服务上）。 */
+  mcpEndpoint: string;
+  /** MCP 传输类型：HTTP-SSE。 */
+  transportType: 'sse';
+  /** 该插件给 agent 带来的 MCP 工具名列表（实时取自 SOCIETY_MCP_TOOLS，避免漂移）。 */
+  tools: string[];
+}
+
+/** worker-society 的插件描述符（纯数据）。 */
+export const WORKER_SOCIETY_PLUGIN: WorkerSocietyPluginDescriptor = {
+  id: WORKER_SOCIETY_PLUGIN_ID,
+  name: 'worker-society',
+  description:
+    '去中心化 worker 自治社会：agent 通过 society_* 工具发布需求、自荐、择优选派、积累声誉与关系，替代中心化派单。',
+  kind: 'mcp-library',
+  mcpEndpoint: '/mcp',
+  transportType: 'sse',
+  tools: SOCIETY_MCP_TOOLS.map((t) => t.name),
+};
+
+/**
+ * 构造注册进 MCP library 所需的条目（指向某 host:port 上运行中的 hermit /mcp）。
+ * 形状匹配 McpLibraryService.upsert 的 McpLibraryUpsertRequest（不含 id → 新建）。
+ */
+export function buildWorkerSocietyMcpLibraryEntry(
+  host = '127.0.0.1',
+  port = 5680
+): {
+  name: string;
+  description: string;
+  installSpec: { type: 'http'; url: string; transportType: 'sse' };
+} {
+  return {
+    name: WORKER_SOCIETY_PLUGIN.name,
+    description: WORKER_SOCIETY_PLUGIN.description,
+    installSpec: {
+      type: 'http',
+      url: `http://${host}:${port}${WORKER_SOCIETY_PLUGIN.mcpEndpoint}`,
+      transportType: WORKER_SOCIETY_PLUGIN.transportType,
+    },
+  };
+}

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

@@ -0,0 +1,132 @@
+/**
+ * CrossTeamMessageGateway 测试 —— 消息持久化 + cross-team 协议兼容（TDD 先行）。
+ *
+ * 关键不变量：
+ *   - send 持久化到 messages.jsonl 并返回 delivered。
+ *   - formatted 文本可被 hermit 的 parseCrossTeamPrefix 回解析 → 与既有消息总线兼容。
+ *   - recent(n) 返回按发送顺序的最后 n 条；跨实例可从磁盘重载（前端活动流所需）。
+ */
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { parseCrossTeamPrefix } from '@shared/constants/crossTeam';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { FakeClock } from '../../core/application/fakes';
+import { CrossTeamMessageGateway } from './crossTeamMessageGateway';
+
+describe('CrossTeamMessageGateway', () => {
+  let root: string;
+  let clock: FakeClock;
+  beforeEach(async () => {
+    root = await mkdtemp(join(tmpdir(), 'ws-msg-'));
+    clock = new FakeClock('2026-06-13T10:00:00.000Z');
+  });
+  afterEach(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  it('send returns delivered:true and records the message', async () => {
+    const gw = new CrossTeamMessageGateway(root, clock);
+    const res = await gw.send({ fromWorker: 'a', toWorker: 'b', text: 'hi' });
+    expect(res.delivered).toBe(true);
+    const recent = await gw.recent(10);
+    expect(recent).toHaveLength(1);
+    expect(recent[0]).toMatchObject({ fromWorker: 'a', toWorker: 'b', text: 'hi' });
+  });
+
+  it('formats the payload with the hermit cross-team prefix (protocol-compatible)', async () => {
+    const gw = new CrossTeamMessageGateway(root, clock);
+    await gw.send({ fromWorker: 'alice', toWorker: 'bob', text: 'need a hand?' });
+    const [m] = await gw.recent(1);
+    const parsed = parseCrossTeamPrefix(m.formatted);
+    expect(parsed?.from).toBe('alice');
+    expect(parsed?.chainDepth).toBe(0);
+    expect(m.formatted).toContain('need a hand?');
+  });
+
+  it('preserves needId when present', async () => {
+    const gw = new CrossTeamMessageGateway(root, clock);
+    await gw.send({ fromWorker: 'a', toWorker: 'b', text: 't', needId: 'need-1' });
+    expect((await gw.recent(1))[0].needId).toBe('need-1');
+  });
+
+  it('accumulates messages in send order; recent(n) returns the last n', async () => {
+    const gw = new CrossTeamMessageGateway(root, clock);
+    await gw.send({ fromWorker: 'a', toWorker: 'b', text: '1' });
+    await gw.send({ fromWorker: 'a', toWorker: 'b', text: '2' });
+    await gw.send({ fromWorker: 'a', toWorker: 'b', text: '3' });
+    expect((await gw.recent(2)).map((m) => m.text)).toEqual(['2', '3']);
+  });
+
+  it('returns empty before any message is sent', async () => {
+    const gw = new CrossTeamMessageGateway(root, clock);
+    expect(await gw.recent(10)).toEqual([]);
+  });
+
+  it('persists across instances (reload feed from disk)', async () => {
+    const a = new CrossTeamMessageGateway(root, clock);
+    await a.send({ fromWorker: 'a', toWorker: 'b', text: 'persist me' });
+    const b = new CrossTeamMessageGateway(root, clock);
+    expect((await b.recent(10)).map((m) => m.text)).toEqual(['persist me']);
+  });
+
+  it('stamps deliveredAt from the injected clock', async () => {
+    const gw = new CrossTeamMessageGateway(root, clock);
+    await gw.send({ fromWorker: 'a', toWorker: 'b', text: 'hi' });
+    expect((await gw.recent(1))[0].deliveredAt).toBe('2026-06-13T10:00:00.000Z');
+  });
+
+  it('tolerates a corrupt/partial line without losing the valid history (no silent feed wipe)', async () => {
+    // 模拟 append 中途崩溃留下的半行/坏行：messages.jsonl 里混入一行非法 JSON。
+    // 旧实现：JSON.parse 抛错 → 外层 catch → 整个 feed 返回 []（全量丢失）。
+    // 期望：跳过坏行，保留所有合法记录。
+    const gw = new CrossTeamMessageGateway(root, clock);
+    await gw.send({ fromWorker: 'a', toWorker: 'b', text: 'keep-1' });
+    await gw.send({ fromWorker: 'a', toWorker: 'b', text: 'keep-2' });
+    // 直接往文件里塞一行损坏内容（模拟崩溃后的半行）。
+    await writeFile(join(root, 'messages.jsonl'), '{not valid json\n', {
+      flag: 'a',
+      encoding: 'utf8',
+    });
+
+    const recent = await gw.recent(50);
+    expect(recent.map((m) => m.text)).toEqual(['keep-1', 'keep-2']);
+  });
+
+  it('recent(0) / negative / non-finite limit returns [] (never the whole unbounded history)', async () => {
+    // 安全不变量：limit<=0 或非法时绝不能回全量（MCP society_get_feed 的 limit 来自 agent，
+    // num('0')→0 → recent(0) 旧实现 slice(-0)===slice(0) 会倒出整条历史 = 无界读）。
+    const gw = new CrossTeamMessageGateway(root, clock);
+    await gw.send({ fromWorker: 'a', toWorker: 'b', text: '1' });
+    await gw.send({ fromWorker: 'a', toWorker: 'b', text: '2' });
+
+    expect(await gw.recent(0)).toEqual([]);
+    expect(await gw.recent(-3)).toEqual([]);
+    expect(await gw.recent(Number.NaN)).toEqual([]);
+    // 正常 limit 不受影响：
+    expect((await gw.recent(2)).map((m) => m.text)).toEqual(['1', '2']);
+  });
+
+  it('falls back to a Date/Math-based id when crypto.randomUUID is unavailable', async () => {
+    // L83-84：globalThis.crypto?.randomUUID 缺失时（旧 Node / 受限运行时），randomId() 降级为
+    // Date.now()+Math.random() 的 base36 串——仍生成 msg- 前缀、唯一的 id，send 不抛。
+    const gw = new CrossTeamMessageGateway(root, clock);
+    vi.stubGlobal('crypto', undefined); // 摘掉 crypto.randomUUID → 走 L83 降级臂
+    try {
+      await gw.send({ fromWorker: 'a', toWorker: 'b', text: 'm1' });
+      await gw.send({ fromWorker: 'a', toWorker: 'b', text: 'm2' });
+    } finally {
+      vi.unstubAllGlobals(); // 恢复 crypto，防污染后续测试
+    }
+    const recent = await gw.recent(10);
+    const [id1, id2] = recent.map((m) => m.id);
+    expect(id1).toMatch(/^msg-/); // 降级 id 仍带前缀
+    // 降级 = msg-<ts36>-<rand36>（2 个 '-'、3 段）；UUID = msg-<uuid>（5 个 '-'、6 段）。
+    // 段数断言稳健区分降级臂 vs crypto 臂（不靠 hex 字符，免 flaky）。
+    expect(id1.split('-')).toHaveLength(3);
+    expect(id2.split('-')).toHaveLength(3);
+    expect(id1).not.toBe(id2); // 降级 id 仍唯一
+  });
+});