@yancyyu/openhermit 1.6.42 → 1.6.43

package/src/features/worker-society/core/application/WorkerSocietyService.ts

@@ -0,0 +1,428 @@
+/**
+ * Worker Society — 应用层自治引擎
+ *
+ * 把领域策略编排成可被 MCP 工具 / Fastify 路由 / 前端调用的 use case。
+ * 这是「worker 自治」替代「派单」的主路径：发布需求 → 自荐 → 选派 →
+ * 执行 → 交付 → 审核，全程无中心 dispatch，并持续积累声誉与关系。
+ *
+ * 依赖注入：所有副作用通过 ports，保证可单测。
+ */
+
+import type {
+  PublishedNeed,
+  Relationship,
+  SocialEvent,
+  WorkerDiscoveryQuery,
+  WorkerProfile,
+} from '../domain/models/society';
+import { HUMAN_OPERATOR } from '../domain/models/society';
+import {
+  applyReputationDelta,
+  autonomousVolunteers,
+  clampReputation,
+  computeFitScore,
+  discoverWorkers as discoverWorkersPolicy,
+  recordCollaboration,
+  reputationDeltaForOutcome,
+  requestRevision,
+  selectAssignee as selectAssigneePolicy,
+  transitionNeed,
+  volunteerFor,
+} from '../domain/policies/societyPolicies';
+import type { AutonomyOptions } from '../domain/policies/societyPolicies';
+import type {
+  ClockPort,
+  MessageGateway,
+  NeedStore,
+  RelationshipStore,
+  SocialEventSink,
+  WorkerProfileStore,
+} from './ports';
+
+export interface RegisterProfileCommand {
+  workerId: string;
+  name: string;
+  kind?: 'composite' | 'atomic';
+  harness?: string;
+  capabilities?: WorkerProfile['capabilities'];
+  interests?: string[];
+  maxConcurrent?: number;
+  reputation?: number;
+  description?: string;
+}
+
+export interface PublishNeedCommand {
+  postedBy: string;
+  subject: string;
+  description?: string;
+  requiredCapabilities: string[];
+  priority?: number;
+  deadline?: string;
+}
+
+export interface Outcome {
+  ok: boolean;
+  reason?: string;
+  [k: string]: unknown;
+}
+
+export class WorkerSocietyService {
+  constructor(
+    private readonly profiles: WorkerProfileStore,
+    private readonly needs: NeedStore,
+    private readonly relationships: RelationshipStore,
+    private readonly messages: MessageGateway,
+    private readonly clock: ClockPort,
+    private readonly events?: SocialEventSink
+  ) {}
+
+  // ── 身份 / 发现 ──────────────────────────────────────────────────
+
+  /** 注册或更新一个 worker 社会档案。 */
+  async registerProfile(cmd: RegisterProfileCommand): Promise<WorkerProfile> {
+    const existing = await this.profiles.get(cmd.workerId);
+    const profile: WorkerProfile = {
+      workerId: cmd.workerId,
+      name: cmd.name,
+      kind: cmd.kind ?? 'composite',
+      harness: cmd.harness ?? existing?.harness,
+      capabilities: cmd.capabilities ?? existing?.capabilities ?? [],
+      interests: cmd.interests ?? existing?.interests ?? [],
+      // 夹取到 ≥1：maxConcurrent:0 会让 isAtCapacity(activeTaskCount>=maxConcurrent) 永真，
+      // worker 被自荐/选派闸门永久拒之门外（不可用由 status 建模，非 maxConcurrent:0）。
+      maxConcurrent: Math.max(1, cmd.maxConcurrent ?? existing?.maxConcurrent ?? 3),
+      activeTaskCount: existing?.activeTaskCount ?? 0,
+      // 输入边界即夹取到 [0,100]——与 applyReputationDelta 同一不变量，否则注册 150/-20 会持久化出界原值。
+      reputation: clampReputation(cmd.reputation ?? existing?.reputation ?? 50),
+      status: existing?.status ?? 'online',
+      description: cmd.description ?? existing?.description,
+    };
+    return this.profiles.upsert(profile);
+  }
+
+  async getProfile(workerId: string): Promise<WorkerProfile | undefined> {
+    return this.profiles.get(workerId);
+  }
+
+  /** 动态发现 worker（按能力过滤、声誉排序）。 */
+  async discoverWorkers(query: WorkerDiscoveryQuery = {}): Promise<WorkerProfile[]> {
+    const all = await this.profiles.list();
+    return discoverWorkersPolicy(all, query);
+  }
+
+  async getRelationships(): Promise<Relationship[]> {
+    return this.relationships.list();
+  }
+
+  // ── 广场生命周期 ────────────────────────────────────────────────
+
+  /** 发布一个需求到广场。 */
+  async publishNeed(cmd: PublishNeedCommand): Promise<{ need: PublishedNeed }> {
+    const now = this.clock.now();
+    const needId = `need-${randomId()}`;
+    const need: PublishedNeed = {
+      needId,
+      postedBy: cmd.postedBy,
+      subject: cmd.subject,
+      description: cmd.description,
+      requiredCapabilities: cmd.requiredCapabilities,
+      priority: cmd.priority ?? 5,
+      deadline: cmd.deadline,
+      status: 'open',
+      volunteers: [],
+      createdAt: now,
+      revisionCount: 0,
+    };
+    const saved = await this.needs.upsert(need);
+    this.emit({
+      type: 'need_published',
+      actors: [cmd.postedBy],
+      needId,
+      summary: `${cmd.postedBy} 发布需求：${cmd.subject}`,
+    });
+    return { need: saved };
+  }
+
+  /** worker 对需求自荐。 */
+  async volunteerFor(needId: string, workerId: string, note?: string): Promise<Outcome> {
+    const need = await this.needs.get(needId);
+    if (!need) return { ok: false, reason: 'need_not_found' };
+    const worker = await this.profiles.get(workerId);
+    if (!worker) return { ok: false, reason: 'worker_not_found' };
+
+    const rels = await this.relationships.list();
+    const outcome = volunteerFor(need, worker, this.clock.now(), rels);
+    if (!outcome.ok) return { ok: false, reason: outcome.reason };
+
+    await this.needs.upsert(outcome.need);
+    this.emit({
+      type: 'volunteered',
+      actors: [workerId, need.postedBy],
+      needId,
+      summary: `${worker.name} 自荐了「${need.subject}」（适配度 ${(outcome.volunteer!.fitScore * 100).toFixed(0)}%）`,
+    });
+    await this.messages
+      .send({
+        fromWorker: workerId,
+        toWorker: need.postedBy,
+        text: note
+          ? `${worker.name} 自荐了你的需求「${need.subject}」。备注：${note}`
+          : `${worker.name} 自荐了你的需求「${need.subject}」。`,
+        needId,
+      })
+      .catch(() => undefined);
+    return { ok: true, fitScore: outcome.volunteer!.fitScore };
+  }
+
+  /** 为需求选择最优自荐者并进入 assigned。 */
+  async selectAssignee(needId: string): Promise<Outcome> {
+    const need = await this.needs.get(needId);
+    if (!need) return { ok: false, reason: 'need_not_found' };
+    const all = await this.profiles.list();
+    const byId = new Map(all.map((w) => [w.workerId, w]));
+    const rels = await this.relationships.list();
+    const chosen = selectAssigneePolicy(need, byId, rels);
+    if (!chosen) return { ok: false, reason: 'no_eligible_volunteer' };
+
+    const t = transitionNeed(need, 'assigned', this.clock.now(), { assignee: chosen.workerId });
+    if (!t.ok) return { ok: false, reason: t.reason };
+    const saved = await this.needs.upsert(t.need);
+    // 自荐者被选中后，占用一个并发槽。
+    const w = byId.get(chosen.workerId);
+    if (w) await this.profiles.upsert({ ...w, activeTaskCount: w.activeTaskCount + 1 });
+    this.emit({
+      type: 'assigned',
+      actors: [chosen.workerId, saved.postedBy],
+      needId,
+      summary: `${chosen.workerId} 被选派执行「${saved.subject}」`,
+    });
+    await this.messages
+      .send({
+        fromWorker: saved.postedBy,
+        toWorker: chosen.workerId,
+        text: `你被选派执行需求「${saved.subject}」。完成后请调用 deliver_need 交付。`,
+        needId,
+      })
+      .catch(() => undefined);
+    return { ok: true, assignee: chosen.workerId };
+  }
+
+  /** 执行者开始执行。 */
+  async startNeed(needId: string, byWorker: string): Promise<Outcome> {
+    const need = await this.needs.get(needId);
+    if (!need) return { ok: false, reason: 'need_not_found' };
+    if (need.assignee !== byWorker) return { ok: false, reason: 'not_assignee' };
+    const t = transitionNeed(need, 'in_progress', this.clock.now());
+    if (!t.ok) return { ok: false, reason: t.reason };
+    await this.needs.upsert(t.need);
+    this.emit({
+      type: 'collaboration_started',
+      actors: [byWorker],
+      needId,
+      summary: `${byWorker} 开始执行「${need.subject}」`,
+    });
+    return { ok: true };
+  }
+
+  /** 执行者交付结果。 */
+  async deliverNeed(needId: string, result: string): Promise<Outcome> {
+    const need = await this.needs.get(needId);
+    if (!need) return { ok: false, reason: 'need_not_found' };
+    const t = transitionNeed(need, 'delivered', this.clock.now(), { result });
+    if (!t.ok) return { ok: false, reason: t.reason };
+    await this.needs.upsert(t.need);
+    this.emit({
+      type: 'delivered',
+      actors: [need.assignee ?? '?', need.postedBy],
+      needId,
+      summary: `${need.assignee} 交付了「${need.subject}」`,
+    });
+    return { ok: true };
+  }
+
+  /** 审核通过 → 关闭，并奖励声誉 + 强化关系。 */
+  async acceptDelivery(needId: string): Promise<Outcome> {
+    const need = await this.needs.get(needId);
+    if (!need) return { ok: false, reason: 'need_not_found' };
+    const t = transitionNeed(need, 'closed', this.clock.now());
+    if (!t.ok) return { ok: false, reason: t.reason };
+    await this.needs.upsert(t.need);
+
+    if (need.assignee) await this.reward(need.assignee, need.postedBy, true, needId);
+    // 释放并发槽。
+    const w = await this.profiles.get(need.assignee ?? '');
+    if (w)
+      await this.profiles.upsert({ ...w, activeTaskCount: Math.max(0, w.activeTaskCount - 1) });
+
+    this.emit({
+      type: 'closed',
+      actors: [need.postedBy, need.assignee ?? '?'],
+      needId,
+      summary: `「${need.subject}」审核通过，协作完成`,
+    });
+    return { ok: true };
+  }
+
+  /** 审核退回 → 重做；记录一次未成功协作，声誉小幅下降。 */
+  async requestRevision(needId: string): Promise<Outcome> {
+    const need = await this.needs.get(needId);
+    if (!need) return { ok: false, reason: 'need_not_found' };
+    const t = requestRevision(need, this.clock.now());
+    if (!t.ok) return { ok: false, reason: t.reason };
+    await this.needs.upsert(t.need);
+    if (need.assignee) await this.reward(need.assignee, need.postedBy, false, needId);
+    this.emit({
+      type: 'delivered',
+      actors: [need.postedBy, need.assignee ?? '?'],
+      needId,
+      summary: `「${need.subject}」被退回重做（第 ${t.need.revisionCount} 次）`,
+    });
+    return { ok: true, escalated: t.reason === 'revision_limit_exceeded' };
+  }
+
+  async cancelNeed(needId: string): Promise<Outcome> {
+    const need = await this.needs.get(needId);
+    if (!need) return { ok: false, reason: 'need_not_found' };
+    const t = transitionNeed(need, 'cancelled', this.clock.now());
+    if (!t.ok) return { ok: false, reason: t.reason };
+    await this.needs.upsert(t.need);
+    // 释放执行者并发槽：assigned→cancelled 是合法转换，selectAssignee 已占用一槽，
+    // 不释放则 activeTaskCount 永久虚高，最终 isAtCapacity 误判、worker 接不了新活。
+    // open→cancelled 无 assignee，get('') 返回 undefined 自然跳过。
+    const w = await this.profiles.get(need.assignee ?? '');
+    if (w)
+      await this.profiles.upsert({ ...w, activeTaskCount: Math.max(0, w.activeTaskCount - 1) });
+    return { ok: true };
+  }
+
+  /** 扫描过期未分配的需求，标记 expired。返回处理数量。 */
+  async expireNeeds(): Promise<number> {
+    const now = this.clock.now();
+    const nowMs = Date.parse(now);
+    const open = await this.needs.listOpen();
+    let n = 0;
+    for (const need of open) {
+      if (need.deadline && Date.parse(need.deadline) < nowMs) {
+        const t = transitionNeed(need, 'expired', now);
+        if (t.ok) {
+          await this.needs.upsert(t.need);
+          n += 1;
+        }
+      }
+    }
+    return n;
+  }
+
+  /**
+   * 自治驱动一轮：扫描广场上所有 open 需求，让匹配的 worker 主动自荐。
+   * 返回本轮实际产生的自荐次数。这是「worker 自治」替代「派单」的运行时入口——
+   * 可由定时器、MCP 工具或前端按钮触发，全程无中心调度。
+   *
+   * 决策由纯策略 autonomousVolunteers 给出；此处只负责拉取快照、落库自荐、计数。
+   * 每个决策都通过 volunteerFor 走标准路径，复用其校验与事件/消息副作用。
+   */
+  async runAutonomyTick(opts: AutonomyOptions = {}): Promise<number> {
+    const [openNeeds, workers, relationships] = await Promise.all([
+      this.needs.listOpen(),
+      this.profiles.list(),
+      this.relationships.list(),
+    ]);
+    const decisions = autonomousVolunteers(openNeeds, workers, relationships, opts);
+    let applied = 0;
+    for (const d of decisions) {
+      const r = await this.volunteerFor(d.needId, d.workerId);
+      if (r.ok) applied += 1;
+    }
+    return applied;
+  }
+
+  /**
+   * 自治选派（去中心化）：扫描所有「仍有自荐者、尚未选派」的 open 需求，
+   * 逐一按适配度选出最优自荐者并进入 assigned。返回本轮选派次数。
+   *
+   * 与 runAutonomyTick 配合构成完整自治回路：先让 worker 自发投标（volunteer），
+   * 待竞争充分后再由适配度择优（select）——全程无中心 dispatcher 人工指派。
+   * 复用 selectAssignee 的标准路径（占用并发槽、发事件、发消息）。
+   */
+  async autoSelectPending(): Promise<number> {
+    const open = await this.needs.listOpen();
+    let selected = 0;
+    for (const need of open) {
+      if (need.volunteers.length === 0) continue;
+      const r = await this.selectAssignee(need.needId);
+      if (r.ok) selected += 1;
+    }
+    return selected;
+  }
+
+  // ── 社交消息 ────────────────────────────────────────────────────
+
+  /** worker 自由发送一条社交消息（非任务交付）；仅投递消息 + 发事件，不变更声誉/关系。 */
+  async sendSocialMessage(fromWorker: string, toWorker: string, text: string): Promise<Outcome> {
+    const from = await this.profiles.get(fromWorker);
+    // HUMAN_OPERATOR（'user'）不是注册 worker，但作为人类操作者必须允许发送——
+    // 否则图谱 overlay 的「发消息」（from='user'）会被静默丢弃。
+    if (!from && fromWorker !== HUMAN_OPERATOR) return { ok: false, reason: 'worker_not_found' };
+    const res = await this.messages.send({ fromWorker, toWorker, text });
+    this.emit({
+      type: 'message',
+      actors: [fromWorker, toWorker],
+      summary: `${from?.name ?? fromWorker} → ${toWorker}：${text.slice(0, 60)}`,
+    });
+    return { ok: res.delivered };
+  }
+
+  // ── helpers ────────────────────────────────────────────────────
+
+  /** 应用声誉增量 + 双向记录协作关系。 */
+  private async reward(
+    workerId: string,
+    partner: string,
+    success: boolean,
+    needId: string
+  ): Promise<void> {
+    const w = await this.profiles.get(workerId);
+    if (w) {
+      const delta = reputationDeltaForOutcome(success);
+      await this.profiles.upsert(applyReputationDelta(w, delta));
+    }
+    const rels = await this.relationships.list();
+    const now = this.clock.now();
+    const next = recordCollaboration(
+      recordCollaboration(rels, workerId, partner, success, now),
+      partner,
+      workerId,
+      success,
+      now
+    );
+    await this.relationships.bulkSet(next);
+    if (success) {
+      this.emit({
+        type: 'relationship_strengthened',
+        actors: [workerId, partner],
+        needId,
+        summary: `${workerId} 与 ${partner} 信任度上升`,
+      });
+    }
+  }
+
+  private emit(e: Omit<SocialEvent, 'eventId' | 'timestamp'>): void {
+    this.events?.append({ ...e, eventId: `evt-${randomId()}`, timestamp: this.clock.now() });
+  }
+}
+
+function randomId(): string {
+  // 应用层（非 workflow 脚本）可使用 crypto.randomUUID；降级到时间+计数。
+  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)}`;
+}
+
+/** 为外部调用方暴露 computeFitScore 的便捷包装（如前端预估）。 */
+export function estimateFit(
+  need: PublishedNeed,
+  worker: WorkerProfile,
+  relationships: Relationship[] = []
+): number {
+  return computeFitScore(need, worker, relationships).score;
+}

package/src/features/worker-society/core/application/fakes.ts

@@ -0,0 +1,101 @@
+/**
+ * Worker Society — 应用层测试用 Fake 实现（仿 teams-mvp/TaskDispatchService.test.ts）
+ *
+ * 供 application use case / adapter mapping / renderer utility 测试复用。
+ * 不含业务规则，只是 Map/数组的薄封装。
+ */
+
+import type {
+  PublishedNeed,
+  Relationship,
+  SocialEvent,
+  WorkerProfile,
+} from '../domain/models/society';
+import type {
+  ClockPort,
+  MessageGateway,
+  NeedStore,
+  RelationshipStore,
+  SocialEventSink,
+  SocialMessageOut,
+  WorkerProfileStore,
+} from './ports';
+import { ACTIVE_NEED_STATUSES } from '../domain/policies/societyPolicies';
+
+export class FakeClock implements ClockPort {
+  constructor(private t: string) {}
+  now(): string {
+    return this.t;
+  }
+  set(iso: string): void {
+    this.t = iso;
+  }
+}
+
+export class FakeProfileStore implements WorkerProfileStore {
+  private map = new Map<string, WorkerProfile>();
+  async get(workerId: string): Promise<WorkerProfile | undefined> {
+    return this.map.get(workerId);
+  }
+  async list(): Promise<WorkerProfile[]> {
+    return [...this.map.values()];
+  }
+  async upsert(profile: WorkerProfile): Promise<WorkerProfile> {
+    this.map.set(profile.workerId, profile);
+    return profile;
+  }
+  async delete(workerId: string): Promise<void> {
+    this.map.delete(workerId);
+  }
+}
+
+export class FakeNeedStore implements NeedStore {
+  private map = new Map<string, PublishedNeed>();
+  async get(needId: string): Promise<PublishedNeed | undefined> {
+    return this.map.get(needId);
+  }
+  async list(): Promise<PublishedNeed[]> {
+    return [...this.map.values()];
+  }
+  async listOpen(): Promise<PublishedNeed[]> {
+    return [...this.map.values()].filter((n) => n.status === 'open');
+  }
+  async listActive(): Promise<PublishedNeed[]> {
+    return [...this.map.values()].filter((n) => ACTIVE_NEED_STATUSES.includes(n.status));
+  }
+  async upsert(need: PublishedNeed): Promise<PublishedNeed> {
+    this.map.set(need.needId, need);
+    return need;
+  }
+}
+
+export class FakeRelationshipStore implements RelationshipStore {
+  private rels: Relationship[] = [];
+  async list(): Promise<Relationship[]> {
+    return [...this.rels];
+  }
+  async bulkSet(relationships: Relationship[]): Promise<void> {
+    this.rels = [...relationships];
+  }
+}
+
+export class FakeMessageGateway implements MessageGateway {
+  sent: SocialMessageOut[] = [];
+  async send(msg: SocialMessageOut): Promise<{ delivered: boolean }> {
+    this.sent.push(msg);
+    return { delivered: true };
+  }
+}
+
+export class MemoryEventSink implements SocialEventSink {
+  private events: SocialEvent[] = [];
+  append(event: SocialEvent): void {
+    this.events.push(event);
+  }
+  all(): SocialEvent[] {
+    return [...this.events];
+  }
+  recent(limit: number): SocialEvent[] {
+    return this.events.slice(-limit);
+  }
+}

package/src/features/worker-society/core/application/ports.ts

@@ -0,0 +1,70 @@
+/**
+ * Worker Society — 应用层 ports（被 main/infrastructure 实现）
+ *
+ * core/application 只依赖这些抽象端口，不触碰 FS/Redis/Fastify/cc-connect。
+ * 这样 worker 自治引擎可被纯单测驱动（Fake 实现）。
+ */
+
+import type {
+  PublishedNeed,
+  Relationship,
+  SocialEvent,
+  WorkerProfile,
+} from '../domain/models/society';
+
+/** 时钟端口，保证应用层可注入确定性时间。 */
+export interface ClockPort {
+  now(): string;
+}
+
+/** Worker 社会档案存储。 */
+export interface WorkerProfileStore {
+  get(workerId: string): Promise<WorkerProfile | undefined>;
+  list(): Promise<WorkerProfile[]>;
+  upsert(profile: WorkerProfile): Promise<WorkerProfile>;
+  delete?(workerId: string): Promise<void>;
+}
+
+/** 广场（Agora）需求存储。 */
+export interface NeedStore {
+  get(needId: string): Promise<PublishedNeed | undefined>;
+  list(): Promise<PublishedNeed[]>;
+  listOpen(): Promise<PublishedNeed[]>;
+  /** 仍在交互生命周期内（open/assigned/in_progress/delivered，未终结）的需求。 */
+  listActive(): Promise<PublishedNeed[]>;
+  upsert(need: PublishedNeed): Promise<PublishedNeed>;
+}
+
+/** worker 间关系图存储。 */
+export interface RelationshipStore {
+  list(): Promise<Relationship[]>;
+  bulkSet(relationships: Relationship[]): Promise<void>;
+}
+
+/** 出站社交消息（worker↔worker 或 worker→user）。由 cc-connect Bridge / inbox 实现。 */
+export interface SocialMessageOut {
+  fromWorker: string;
+  toWorker: string;
+  text: string;
+  needId?: string;
+}
+
+export interface MessageGateway {
+  send(msg: SocialMessageOut): Promise<{ delivered: boolean }>;
+}
+
+/** 社会活动流 sink —— 用于前端实时渲染社会视图。 */
+export interface SocialEventSink {
+  append(event: SocialEvent): void;
+  recent?(limit: number): SocialEvent[];
+}
+
+/** 聚合依赖，构造 WorkerSocietyService 时注入。 */
+export interface WorkerSocietyDeps {
+  profiles: WorkerProfileStore;
+  needs: NeedStore;
+  relationships: RelationshipStore;
+  messages: MessageGateway;
+  clock: ClockPort;
+  events?: SocialEventSink;
+}