diff --git a/AGENTS.md b/AGENTS.md
index 82a3401..5f77a5f 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -26,7 +26,7 @@ Behavioral baseline (Cursor): [`.cursor/rules/Guidelines.mdc`](.cursor/rules/Gui
 
 Planned phase work: GSD commands in [CLAUDE.md](./CLAUDE.md) (`/gsd-quick`, `/gsd-debug`, `/gsd-execute-phase`). Do not bypass GSD unless the user explicitly asks.
 
-**Phase 9 语音暂缓：** 勿实现 STT/TTS；恢复前读 [.planning/phases/09-voice-pipeline/09-STATUS.md](./.planning/phases/09-voice-pipeline/09-STATUS.md)。**当前活跃：** v5 **Phase 27**（Personal Life Timeline）— 见 [.planning/STATE.md](./.planning/STATE.md)；勿默认接 Phase 10。
+**Phase 9 语音暂缓：** 勿实现 STT/TTS；恢复前读 [.planning/phases/09-voice-pipeline/09-STATUS.md](./.planning/phases/09-voice-pipeline/09-STATUS.md)。**v5 SHIPPED（2026-07-21）：** 议会世界观 Phases 23–28 已归档 — 见 [.planning/STATE.md](./.planning/STATE.md) · `.planning/milestones/v5-*`；下一里程碑用 `/gsd-new-milestone`；勿默认接 Phase 10。
 
 ---
 
diff --git a/apps/game-server/src/colyseus/GameRoom.ts b/apps/game-server/src/colyseus/GameRoom.ts
index 2bafd6f..0f96c1b 100644
--- a/apps/game-server/src/colyseus/GameRoom.ts
+++ b/apps/game-server/src/colyseus/GameRoom.ts
@@ -48,6 +48,8 @@ import { maybeEnqueuePersonalTimelineWeekly } from "../world/personal-timeline-w
 import {
   maybeEnqueueDyadFromAmbient,
 } from "../world/personal-timeline-dyad.js";
+import { maybeEnqueueNpcMutualChat } from "../world/npc-mutual-chat.js";
+import { maybeRunRelationshipDecay } from "../world/npc-relationship-decay.js";
 import { setNpcSpeakPhase } from "./speak-schema.js";
 
 export const AMBIENT_MS = 6000;
@@ -438,7 +440,25 @@ export class GameRoom extends Room {
     }
     this.enqueueWorldVoteIfDue();
     this.enqueuePersonalTimelineWeeklyIfDue();
-    this.enqueuePersonalTimelineDyadAmbientIfDue();
+    // Await mutual-chat claims before ambient dyad so same-tick supersession is real (D-MUTUAL / A2).
+    void this.enqueueNpcMutualChatIfDue()
+      .then(() => {
+        this.enqueuePersonalTimelineDyadAmbientIfDue();
+      })
+      .catch((err) => {
+        console.error("[GameRoom] mutual-chat→dyad sequence failed", err);
+        this.enqueuePersonalTimelineDyadAmbientIfDue();
+      });
+    // D-DECAY-04: silent idle decay — no speak-slot defer, no LLM, no relationshipSync.
+    this.runRelationshipDecayIfDue();
+  }
+
+  /** Protected path: minimal monthly idle-decay hook only (Phase 28 plan 04). */
+  private runRelationshipDecayIfDue(): void {
+    const abs = getRoomVoteState(this.mapRoomId).absoluteGameMinute;
+    void maybeRunRelationshipDecay(this.mapRoomId, abs).catch((err) => {
+      console.error("[GameRoom] relationship decay failed", err);
+    });
   }
 
   private enqueueWorldVoteIfDue(): void {
@@ -464,6 +484,25 @@ export class GameRoom extends Room {
     });
   }
 
+  /** D-MUTUAL-07: defer when any speak in-flight (same as world-vote). No LLM in tick. */
+  private enqueueNpcMutualChatIfDue(): Promise<void> {
+    if (this.npcSpeakJobs.size > 0) return Promise.resolve();
+    const abs = getRoomVoteState(this.mapRoomId).absoluteGameMinute;
+    const { state: mapState } = getOrCreate(this.mapRoomId);
+    return maybeEnqueueNpcMutualChat({
+      roomId: this.mapRoomId,
+      npcs: mapState.npcs.map((n) => ({ id: n.id, x: n.x, y: n.y })),
+      absoluteGameMinute: abs,
+      gameMinuteOfDay: this.gameState.gameMinute,
+      busyNpcIds: this.npcSpeakJobs,
+      npcSpeakInFlight: false,
+    })
+      .then(() => undefined)
+      .catch((err) => {
+        console.error("[GameRoom] npc-mutual-chat enqueue failed", err);
+      });
+  }
+
   private enqueuePersonalTimelineDyadAmbientIfDue(): void {
     if (this.npcSpeakJobs.size > 0) return;
     const abs = getRoomVoteState(this.mapRoomId).absoluteGameMinute;
diff --git a/apps/game-server/src/index.test.ts b/apps/game-server/src/index.test.ts
index 36417b3..a7336c7 100644
--- a/apps/game-server/src/index.test.ts
+++ b/apps/game-server/src/index.test.ts
@@ -218,6 +218,7 @@ describe("game-server", () => {
     expect(Array.isArray(res.body.state.npcs)).toBe(true);
     expect(Array.isArray(res.body.nearbyLore)).toBe(true);
     expect(res.body.memoryCounts).toBeUndefined();
+    expect(typeof res.body.state.absoluteGameMinute).toBe("number");
   });
 
   it("GET /internal/rooms/default/memory-context returns context shape", async () => {
diff --git a/apps/game-server/src/index.ts b/apps/game-server/src/index.ts
index 6763c11..b6fef8b 100644
--- a/apps/game-server/src/index.ts
+++ b/apps/game-server/src/index.ts
@@ -8,6 +8,7 @@ import { createCollectiveStateRouter } from "./routes/collective-state.js";
 import { createWorldHistoryRouter } from "./routes/world-history.js";
 import { createInternalWorldHistoryRouter } from "./routes/internal-world-history.js";
 import { createPersonalTimelineRouter } from "./routes/personal-timeline.js";
+import { createNpcRelationshipsRouter } from "./routes/npc-relationships.js";
 import { createInternalPersonalTimelineRouter } from "./routes/internal-personal-timeline.js";
 import { createAuditRouter } from "./routes/audit.js";
 import { createInternalJobsRouter } from "./routes/internal.js";
@@ -19,6 +20,7 @@ import {
 } from "./routes/internal-lore.js";
 import { createInternalAmbientIntentRouter } from "./routes/internal-ambient-intent.js";
 import { createInternalNpcRelationshipsRouter } from "./routes/internal-npc-relationships.js";
+import { createInternalNpcMutualChatRouter } from "./routes/internal-npc-mutual-chat.js";
 import { createInternalWorldVoteTriggerRouter } from "./routes/internal-world-vote-trigger.js";
 import { createInternalWorldVoteRouter } from "./routes/internal-world-vote.js";
 import { attachColyseus } from "./colyseus/server.js";
@@ -53,6 +55,7 @@ export function createApp(): Express {
   app.use("/rooms", json, createCollectiveStateRouter());
   app.use("/rooms", json, createWorldHistoryRouter());
   app.use("/rooms", json, createPersonalTimelineRouter());
+  app.use("/rooms", json, createNpcRelationshipsRouter());
   app.use("/rooms", json, createChatRouter());
   app.use("/internal/rooms", json, createInternalRoomsRouter());
   app.use("/internal/rooms", json, createInternalMemoriesRouter());
@@ -61,6 +64,7 @@ export function createApp(): Express {
   app.use("/internal/rooms", json, createInternalPersonalTimelineRouter());
   app.use("/internal/rooms", json, createInternalAmbientIntentRouter());
   app.use("/internal/rooms", json, createInternalNpcRelationshipsRouter());
+  app.use("/internal/rooms", json, createInternalNpcMutualChatRouter());
   app.use("/internal/rooms", json, createInternalWorldVoteTriggerRouter());
   app.use("/internal/rooms", json, createInternalWorldVoteRouter());
   app.use("/internal/jobs", json, createInternalJobsRouter());
diff --git a/apps/game-server/src/queue/npc-mutual-chat.ts b/apps/game-server/src/queue/npc-mutual-chat.ts
new file mode 100644
index 0000000..9bca4f1
--- /dev/null
+++ b/apps/game-server/src/queue/npc-mutual-chat.ts
@@ -0,0 +1,149 @@
+/**
+ * NPC mutual-chat job queue (D-MUTUAL-07).
+ * Tick enqueues only — worker drains LLM (plan 06). Mirror personal-timeline claim/LPUSH.
+ */
+
+import { Redis } from "ioredis";
+import { normalizeEdgeIds } from "@aetherlife/shared";
+
+export type NpcMutualChatJobPayload = {
+  roomId: string;
+  npcAId: string;
+  npcBId: string;
+  dayIndex: number;
+  absoluteGameMinute: number;
+  jobId: string;
+  enqueuedAt: string;
+};
+
+export const NPC_MUTUAL_CHAT_JOBS_KEY = "aetherlife:npc-mutual-chat:jobs";
+
+export const NPC_MUTUAL_CHAT_JOB_CLAIM_PREFIX =
+  "aetherlife:npc-mutual-chat:job-claimed:";
+
+const JOB_CLAIM_TTL_SECONDS = 60 * 60 * 24 * 14;
+
+const mockJobs = new Map<string, NpcMutualChatJobPayload>();
+const localJobClaims = new Set<string>();
+
+function getRedisUrl(): string | undefined {
+  return process.env.REDIS_URL;
+}
+
+function createRedis(url: string): Redis {
+  const client = new Redis(url, { maxRetriesPerRequest: null });
+  client.on("error", (err) => {
+    console.error("[redis]", err.message);
+  });
+  return client;
+}
+
+export function npcMutualChatJobId(
+  roomId: string,
+  dayIndex: number,
+  npcAId: string,
+  npcBId: string,
+): string {
+  const { npcAId: a, npcBId: b } = normalizeEdgeIds(npcAId, npcBId);
+  return `mc-${roomId}-${dayIndex}-${a}-${b}`;
+}
+
+export async function claimNpcMutualChatJobId(jobId: string): Promise<boolean> {
+  const url = getRedisUrl();
+  if (!url) {
+    if (localJobClaims.has(jobId)) return false;
+    localJobClaims.add(jobId);
+    return true;
+  }
+  const client = createRedis(url);
+  try {
+    const key = `${NPC_MUTUAL_CHAT_JOB_CLAIM_PREFIX}${jobId}`;
+    const ok = await client.set(key, "1", "EX", JOB_CLAIM_TTL_SECONDS, "NX");
+    return ok === "OK";
+  } finally {
+    await client.quit();
+  }
+}
+
+export async function releaseNpcMutualChatJobId(jobId: string): Promise<void> {
+  localJobClaims.delete(jobId);
+  const url = getRedisUrl();
+  if (!url) return;
+  const client = createRedis(url);
+  try {
+    await client.del(`${NPC_MUTUAL_CHAT_JOB_CLAIM_PREFIX}${jobId}`);
+  } finally {
+    await client.quit();
+  }
+}
+
+async function lpushJob(payload: NpcMutualChatJobPayload): Promise<void> {
+  const url = getRedisUrl();
+  if (!url) return;
+  const client = createRedis(url);
+  try {
+    await client.lpush(NPC_MUTUAL_CHAT_JOBS_KEY, JSON.stringify(payload));
+  } finally {
+    await client.quit();
+  }
+}
+
+async function claimAndLpushJob(
+  jobId: string,
+  payload: NpcMutualChatJobPayload,
+): Promise<boolean> {
+  const claimed = await claimNpcMutualChatJobId(jobId);
+  if (!claimed) return false;
+  try {
+    await lpushJob(payload);
+    if (!getRedisUrl()) {
+      // Local/mock inspection map only — never grow unbounded under Redis.
+      mockJobs.set(jobId, payload);
+    }
+    return true;
+  } catch (err) {
+    await releaseNpcMutualChatJobId(jobId);
+    throw err;
+  }
+}
+
+/**
+ * Claim then LPUSH mutual-chat job. Returns jobId or null if already claimed / invalid.
+ */
+export async function enqueueNpcMutualChatJob(input: {
+  roomId: string;
+  npcAId: string;
+  npcBId: string;
+  dayIndex: number;
+  absoluteGameMinute: number;
+}): Promise<string | null> {
+  if (!input.roomId || input.npcAId === input.npcBId) return null;
+  const { npcAId, npcBId } = normalizeEdgeIds(input.npcAId, input.npcBId);
+  const jobId = npcMutualChatJobId(input.roomId, input.dayIndex, npcAId, npcBId);
+  const payload: NpcMutualChatJobPayload = {
+    roomId: input.roomId,
+    npcAId,
+    npcBId,
+    dayIndex: input.dayIndex,
+    absoluteGameMinute: input.absoluteGameMinute,
+    jobId,
+    enqueuedAt: new Date().toISOString(),
+  };
+  const ok = await claimAndLpushJob(jobId, payload);
+  return ok ? jobId : null;
+}
+
+export function getMockNpcMutualChatJob(
+  jobId: string,
+): NpcMutualChatJobPayload | undefined {
+  return mockJobs.get(jobId);
+}
+
+export function clearMockNpcMutualChatJobs(): void {
+  mockJobs.clear();
+  localJobClaims.clear();
+}
+
+export function clearNpcMutualChatJobClaimsForTest(): void {
+  localJobClaims.clear();
+}
diff --git a/apps/game-server/src/routes/internal-npc-mutual-chat.ts b/apps/game-server/src/routes/internal-npc-mutual-chat.ts
new file mode 100644
index 0000000..5115823
--- /dev/null
+++ b/apps/game-server/src/routes/internal-npc-mutual-chat.ts
@@ -0,0 +1,90 @@
+import { Router, type Request, type Response } from "express";
+import { z } from "zod";
+import { linkedEdgeSchema } from "@aetherlife/shared";
+import {
+  broadcastLinkedEdgesHint,
+  broadcastRelationshipSync,
+  presentNpcMutualChat,
+} from "../world/relationship-broadcast.js";
+import { requireWorkerAuth } from "./internal.js";
+
+const presentBodySchema = z
+  .object({
+    npcAId: z.string().min(1).max(64),
+    npcBId: z.string().min(1).max(64),
+    npcAReasonZh: z.string().min(1).max(40),
+    npcBReasonZh: z.string().min(1).max(40),
+    bubbleText: z.string().min(1).max(40),
+  })
+  .strict();
+
+const linkedHintBodySchema = z
+  .object({
+    linkedEdges: z.array(linkedEdgeSchema).min(1).max(8),
+  })
+  .strict();
+
+export function createInternalNpcMutualChatRouter(): Router {
+  const router = Router();
+  router.use(requireWorkerAuth);
+
+  router.post("/:roomId/npc-mutual-chat/present", (req: Request, res: Response) => {
+    const roomId = req.params.roomId;
+    if (!roomId) {
+      res.status(400).json({ ok: false, error: "roomId required" });
+      return;
+    }
+
+    const parsed = presentBodySchema.safeParse(req.body);
+    if (!parsed.success) {
+      res.status(400).json({ ok: false, error: parsed.error.flatten() });
+      return;
+    }
+
+    const data = parsed.data;
+    if (data.npcAId === data.npcBId) {
+      res.status(400).json({ ok: false, error: "npcAId and npcBId must differ" });
+      return;
+    }
+
+    try {
+      const bubble = presentNpcMutualChat(roomId, data);
+      try {
+        broadcastRelationshipSync(roomId, { hasUpdate: true });
+      } catch (err) {
+        console.error("[npc-mutual-chat] relationshipSync failed", err);
+      }
+      res.json({ ok: true, bubble });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "present failed";
+      res.status(500).json({ ok: false, error: message });
+    }
+  });
+
+  router.post(
+    "/:roomId/npc-mutual-chat/linked-edges-hint",
+    (req: Request, res: Response) => {
+      const roomId = req.params.roomId;
+      if (!roomId) {
+        res.status(400).json({ ok: false, error: "roomId required" });
+        return;
+      }
+
+      const parsed = linkedHintBodySchema.safeParse(req.body);
+      if (!parsed.success) {
+        res.status(400).json({ ok: false, error: parsed.error.flatten() });
+        return;
+      }
+
+      try {
+        broadcastLinkedEdgesHint(roomId, { linkedEdges: parsed.data.linkedEdges });
+        res.json({ ok: true });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "linked-edges-hint failed";
+        res.status(500).json({ ok: false, error: message });
+      }
+    },
+  );
+
+  return router;
+}
diff --git a/apps/game-server/src/routes/internal-npc-relationships.ts b/apps/game-server/src/routes/internal-npc-relationships.ts
index 5105bf1..0b1f73d 100644
--- a/apps/game-server/src/routes/internal-npc-relationships.ts
+++ b/apps/game-server/src/routes/internal-npc-relationships.ts
@@ -3,8 +3,13 @@ import { z } from "zod";
 import { relationshipDeltaInputSchema } from "@aetherlife/shared";
 import {
   applyRelationshipDeltas,
+  ensureRelationshipEdgeEmbedding,
   listRelationshipsForRoom,
+  searchSimilarEdges,
 } from "../world/npc-relationships-repository.js";
+import { embedText } from "../memory/embed.js";
+import { broadcastRelationshipSync } from "../world/relationship-broadcast.js";
+import { getRoomVoteState } from "../world/world-vote-state.js";
 import { requireWorkerAuth } from "./internal.js";
 
 const applyDeltasBodySchema = z
@@ -14,6 +19,29 @@ const applyDeltasBodySchema = z
   })
   .strict();
 
+const ensureEmbeddingBodySchema = z
+  .object({
+    npcAId: z.string().min(1),
+    npcBId: z.string().min(1),
+  })
+  .strict();
+
+const searchSimilarBodySchema = z
+  .object({
+    query: z.string().min(1),
+    activeNpcId: z.string().min(1).optional(),
+    k: z.number().int().min(1).max(10).optional(),
+  })
+  .strict();
+
+function safeBroadcastRelationshipSync(roomId: string): void {
+  try {
+    broadcastRelationshipSync(roomId, { hasUpdate: true });
+  } catch (err) {
+    console.error("[npc-relationships] broadcastRelationshipSync failed", err);
+  }
+}
+
 export function createInternalNpcRelationshipsRouter(): Router {
   const router = Router();
   router.use(requireWorkerAuth);
@@ -57,11 +85,17 @@ export function createInternalNpcRelationshipsRouter(): Router {
       }
 
       try {
+        // Stamp last-interact with the room clock so monthly idle decay
+        // measures from the real interaction, not abs=0 (Codex CR PR#22).
         const result = await applyRelationshipDeltas({
           roomId,
           deltas: parsed.data.deltas,
           voteEpoch: parsed.data.voteEpoch,
+          absoluteGameMinute: getRoomVoteState(roomId).absoluteGameMinute,
         });
+        if (result.linkedEdges.length > 0) {
+          safeBroadcastRelationshipSync(roomId);
+        }
         res.json({ ok: true, linkedEdges: result.linkedEdges });
       } catch (err) {
         const message = err instanceof Error ? err.message : "apply-deltas failed";
@@ -70,5 +104,61 @@ export function createInternalNpcRelationshipsRouter(): Router {
     },
   );
 
+  router.post(
+    "/:roomId/npc-relationships/ensure-embedding",
+    async (req: Request, res: Response) => {
+      const roomId = req.params.roomId;
+      if (!roomId) {
+        res.status(400).json({ ok: false, error: "roomId required" });
+        return;
+      }
+      const parsed = ensureEmbeddingBodySchema.safeParse(req.body);
+      if (!parsed.success) {
+        res.status(400).json({ ok: false, error: parsed.error.flatten() });
+        return;
+      }
+      try {
+        const embedded = await ensureRelationshipEdgeEmbedding(
+          roomId,
+          parsed.data.npcAId,
+          parsed.data.npcBId,
+        );
+        res.json({ ok: true, embedded });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "ensure-embedding failed";
+        res.status(500).json({ ok: false, error: message });
+      }
+    },
+  );
+
+  router.post(
+    "/:roomId/npc-relationships/search-similar",
+    async (req: Request, res: Response) => {
+      const roomId = req.params.roomId;
+      if (!roomId) {
+        res.status(400).json({ ok: false, error: "roomId required" });
+        return;
+      }
+      const parsed = searchSimilarBodySchema.safeParse(req.body);
+      if (!parsed.success) {
+        res.status(400).json({ ok: false, error: parsed.error.flatten() });
+        return;
+      }
+      try {
+        const queryEmbedding = await embedText(parsed.data.query);
+        const edges = await searchSimilarEdges({
+          roomId,
+          queryEmbedding,
+          activeNpcId: parsed.data.activeNpcId,
+          k: parsed.data.k ?? 5,
+        });
+        res.json({ ok: true, edges });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "search-similar failed";
+        res.status(500).json({ ok: false, error: message });
+      }
+    },
+  );
+
   return router;
 }
diff --git a/apps/game-server/src/routes/npc-relationships.test.ts b/apps/game-server/src/routes/npc-relationships.test.ts
new file mode 100644
index 0000000..760f1ce
--- /dev/null
+++ b/apps/game-server/src/routes/npc-relationships.test.ts
@@ -0,0 +1,216 @@
+/**
+ * Phase 28 player-scoped GET npc-relationships (D-API-01…03, D-GRAPH-02 / C-09b).
+ */
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import request from "supertest";
+import {
+  COLYSEUS_SERVER_MESSAGES,
+  type ColyseusRelationshipSyncPayload,
+} from "@aetherlife/shared";
+import { createApp } from "../index.js";
+import {
+  clearColyseusRoomRegistry,
+  registerColyseusRoom,
+} from "../colyseus/room-registry.js";
+import { GameRoomState, PlayerSchema } from "../colyseus/schema.js";
+import { clearAllRooms } from "../room/store.js";
+import {
+  clearNpcRelationshipsMemory,
+  getLastInteractAbsMinute,
+  insertRelationshipEdge,
+} from "../world/npc-relationships-repository.js";
+import {
+  broadcastRelationshipSync,
+} from "../world/relationship-broadcast.js";
+import * as relationshipBroadcast from "../world/relationship-broadcast.js";
+import {
+  clearRoomVoteStateForTests,
+  getRoomVoteState,
+  tickRoomVoteClock,
+} from "../world/world-vote-state.js";
+
+const ROOM = "room-rel-http";
+const PLAYER = "player-alpha01";
+
+describe("npc-relationships routes (C-09b)", () => {
+  const app = createApp();
+
+  beforeEach(() => {
+    delete process.env.DATABASE_URL;
+    delete process.env.INTERNAL_WORKER_TOKEN;
+    clearAllRooms();
+    clearColyseusRoomRegistry();
+    clearNpcRelationshipsMemory();
+    clearRoomVoteStateForTests();
+  });
+
+  it("D-API-01/03: GET /rooms/:roomId/npc-relationships requires joined-room / session scope", async () => {
+    const state = new GameRoomState();
+    const player = new PlayerSchema();
+    player.playerId = PLAYER;
+    state.players.set("sess-a", player);
+    registerColyseusRoom(ROOM, { state } as never);
+
+    const res = await request(app)
+      .get(`/rooms/${ROOM}/npc-relationships`)
+      .set("X-Player-Id", "player-bravo001");
+
+    expect(res.status).toBe(403);
+    expect(res.body.ok).toBe(false);
+    expect(res.body.error).toMatch(/not connected/);
+  });
+
+  it("D-GRAPH-02 / D-API-01: response maps edges to band labels — no raw affection/trust integers", async () => {
+    const state = new GameRoomState();
+    const player = new PlayerSchema();
+    player.playerId = PLAYER;
+    state.players.set("sess-rel-list", player);
+    registerColyseusRoom(ROOM, { state } as never);
+
+    await insertRelationshipEdge({
+      roomId: ROOM,
+      npcAId: "npc-1",
+      npcBId: "npc-2",
+      baseTag: "ally",
+      affection: 40,
+      trust: 80,
+    });
+
+    const res = await request(app)
+      .get(`/rooms/${ROOM}/npc-relationships`)
+      .set("X-Player-Id", PLAYER);
+
+    expect(res.status).toBe(200);
+    expect(res.body.ok).toBe(true);
+    expect(Array.isArray(res.body.edges)).toBe(true);
+    expect(res.body.edges.length).toBeGreaterThan(0);
+
+    const edge = res.body.edges[0] as Record<string, unknown>;
+    expect(edge).toMatchObject({
+      npcAId: "npc-1",
+      npcBId: "npc-2",
+      baseTag: "ally",
+      band: "warm",
+      bandLabelZh: "亲近",
+      kindLabelZh: "同盟",
+    });
+    expect(Array.isArray(edge.currentStatus)).toBe(true);
+
+    const json = JSON.stringify(res.body);
+    expect(json).not.toMatch(/"affection"/);
+    expect(json).not.toMatch(/"trust"/);
+    expect(edge).not.toHaveProperty("affection");
+    expect(edge).not.toHaveProperty("trust");
+  });
+
+  it("worker internal list still returns full edges with affection/trust", async () => {
+    await insertRelationshipEdge({
+      roomId: ROOM,
+      npcAId: "npc-3",
+      npcBId: "npc-4",
+      baseTag: "rival",
+      affection: -50,
+      trust: 20,
+    });
+
+    const res = await request(app).get(`/internal/rooms/${ROOM}/npc-relationships`);
+
+    expect(res.status).toBe(200);
+    expect(res.body.ok).toBe(true);
+    expect(res.body.edges[0]).toMatchObject({
+      affection: -50,
+      trust: 20,
+    });
+  });
+
+  it("D-API-01: relationshipSync broadcast helper emits { hasUpdate } / seq hint only", () => {
+    const sent: Array<{ type: string; payload: unknown }> = [];
+    const fakeRoom = {
+      clients: [
+        {
+          send(type: string, payload: unknown) {
+            sent.push({ type, payload });
+          },
+        },
+      ],
+    };
+    registerColyseusRoom(ROOM, fakeRoom as never);
+
+    const payload: ColyseusRelationshipSyncPayload = {
+      hasUpdate: true,
+      latestSeq: 3,
+    };
+    broadcastRelationshipSync(ROOM, payload);
+
+    expect(COLYSEUS_SERVER_MESSAGES.relationshipSync).toBe("relationshipSync");
+    expect(sent).toHaveLength(1);
+    expect(sent[0]!.type).toBe(COLYSEUS_SERVER_MESSAGES.relationshipSync);
+    expect(sent[0]!.payload).toEqual({ hasUpdate: true, latestSeq: 3 });
+    const hintJson = JSON.stringify(sent[0]!.payload);
+    expect(hintJson).not.toMatch(/"edges"/);
+    expect(hintJson).not.toMatch(/"affection"/);
+    expect(hintJson).not.toMatch(/"trust"/);
+
+    // No registered room — must not throw.
+    broadcastRelationshipSync("missing-room-rel-sync", { hasUpdate: true });
+  });
+
+  it("apply-deltas success invokes broadcastRelationshipSync when edges change", async () => {
+    const spy = vi
+      .spyOn(relationshipBroadcast, "broadcastRelationshipSync")
+      .mockImplementation(() => undefined);
+
+    await insertRelationshipEdge({
+      roomId: ROOM,
+      npcAId: "npc-1",
+      npcBId: "npc-2",
+      baseTag: "ally",
+      affection: 10,
+      trust: 50,
+    });
+
+    const res = await request(app)
+      .post(`/internal/rooms/${ROOM}/npc-relationships/apply-deltas`)
+      .send({
+        deltas: [
+          {
+            npcAId: "npc-1",
+            npcBId: "npc-2",
+            affectionDelta: 5,
+          },
+        ],
+        voteEpoch: "vote-rel-sync-1",
+      });
+
+    expect(res.status).toBe(200);
+    expect(res.body.ok).toBe(true);
+    expect(res.body.linkedEdges.length).toBeGreaterThan(0);
+    expect(spy).toHaveBeenCalledWith(ROOM, { hasUpdate: true });
+    spy.mockRestore();
+  });
+
+  it("apply-deltas stamps last-interact with room absoluteGameMinute (decay idle guard)", async () => {
+    await insertRelationshipEdge({
+      roomId: ROOM,
+      npcAId: "npc-5",
+      npcBId: "npc-6",
+      baseTag: "ally",
+      affection: 10,
+      trust: 50,
+    });
+
+    // Advance room clock to a non-zero minute.
+    for (let i = 0; i < 2500; i++) tickRoomVoteClock(ROOM);
+    const expectedAbs = getRoomVoteState(ROOM).absoluteGameMinute;
+    expect(expectedAbs).toBeGreaterThan(0);
+
+    const res = await request(app)
+      .post(`/internal/rooms/${ROOM}/npc-relationships/apply-deltas`)
+      .send({
+        deltas: [{ npcAId: "npc-5", npcBId: "npc-6", affectionDelta: 2 }],
+      });
+
+    expect(res.status).toBe(200);
+    expect(getLastInteractAbsMinute(ROOM, "npc-5", "npc-6")).toBe(expectedAbs);
+  });
+});
diff --git a/apps/game-server/src/routes/npc-relationships.ts b/apps/game-server/src/routes/npc-relationships.ts
new file mode 100644
index 0000000..ba3d804
--- /dev/null
+++ b/apps/game-server/src/routes/npc-relationships.ts
@@ -0,0 +1,44 @@
+import { Router } from "express";
+import { toRelationshipEdgeBandPublic } from "@aetherlife/shared";
+import { assertScopedPlayerRequest } from "../colyseus/bridge.js";
+import { playerIdFromRequest } from "../http/player-id.js";
+import { getOrCreate } from "../room/store.js";
+import { listRelationshipsForRoom } from "../world/npc-relationships-repository.js";
+
+/**
+ * Player-facing C-09b GET — band-mapped edges only (D-API-01/03, D-GRAPH-02).
+ * Worker full-edge list stays on /internal/... + requireWorkerAuth.
+ */
+export function createNpcRelationshipsRouter(): Router {
+  const router = Router();
+
+  router.get("/:roomId/npc-relationships", async (req, res) => {
+    const { roomId } = req.params;
+    if (!roomId) {
+      res.status(400).json({ ok: false, error: "roomId required" });
+      return;
+    }
+
+    const playerId = playerIdFromRequest(req);
+    const scope = assertScopedPlayerRequest(req, playerId, roomId);
+    if (!scope.ok) {
+      res.status(scope.status).json({ ok: false, error: scope.error });
+      return;
+    }
+
+    try {
+      getOrCreate(roomId);
+      const edges = await listRelationshipsForRoom(roomId);
+      res.json({
+        ok: true,
+        edges: edges.map(toRelationshipEdgeBandPublic),
+      });
+    } catch (err) {
+      const message =
+        err instanceof Error ? err.message : "npc-relationships list failed";
+      res.status(500).json({ ok: false, error: message });
+    }
+  });
+
+  return router;
+}
diff --git a/apps/game-server/src/routes/rooms.ts b/apps/game-server/src/routes/rooms.ts
index 6494c24..dd2cee2 100644
--- a/apps/game-server/src/routes/rooms.ts
+++ b/apps/game-server/src/routes/rooms.ts
@@ -35,6 +35,7 @@ import { getOrCreate, reset, setState } from "../room/store.js";
 import { getChunkLoader } from "../world/chunk-loader.js";
 import { getChunkLore } from "../world/lore-repository.js";
 import { getChunkLoreCached } from "../world/lore-chunk-cache.js";
+import { getRoomVoteState } from "../world/world-vote-state.js";
 import { logInternalLatency } from "../observability/internalLatency.js";
 import { clearDialogueForPlayer } from "../npc/dialogue-session.js";
 import {
@@ -269,11 +270,16 @@ async function buildWorkerStatePayload(
   playerId: string,
   options?: { skipNearbyLore?: boolean },
 ): Promise<{
-  state: ReturnType<typeof roomStateForInitiator>;
+  state: ReturnType<typeof roomStateForInitiator> & { absoluteGameMinute: number };
   nearbyLore: Array<{ cx: number; cy: number; nameZh: string; flavorOneLine: string }>;
 }> {
   const record = getOrCreate(roomId);
-  const viewState = roomStateForInitiator(record.state, roomId, playerId);
+  // Include the monotonic room clock so worker day-keyed caps (belief gate
+  // D-PLAYER-04/06) reset per real game-day instead of pinning to day-0.
+  const viewState = {
+    ...roomStateForInitiator(record.state, roomId, playerId),
+    absoluteGameMinute: getRoomVoteState(roomId).absoluteGameMinute,
+  };
   if (options?.skipNearbyLore) {
     return { state: viewState, nearbyLore: [] };
   }
diff --git a/apps/game-server/src/world/npc-mutual-chat.test.ts b/apps/game-server/src/world/npc-mutual-chat.test.ts
new file mode 100644
index 0000000..c399a66
--- /dev/null
+++ b/apps/game-server/src/world/npc-mutual-chat.test.ts
@@ -0,0 +1,235 @@
+/**
+ * Phase 28 NPC mutual chat — selector, stagger, speak defer, supersede ambient dyad.
+ * D-MUTUAL-01/03/05/07 · RESEARCH A2.
+ */
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import {
+  clearMockNpcMutualChatJobs,
+  clearNpcMutualChatJobClaimsForTest,
+  getMockNpcMutualChatJob,
+} from "../queue/npc-mutual-chat.js";
+import {
+  clearNpcMutualChatState,
+  isPairClaimedForMutualChat,
+  maybeEnqueueNpcMutualChat,
+  MUTUAL_CHAT_MAX_PER_DAY,
+  shouldDeferNpcMutualChatEnqueue,
+} from "./npc-mutual-chat.js";
+import {
+  clearMockPersonalTimelineJobs,
+  clearPersonalTimelineJobClaimsForTest,
+} from "../queue/personal-timeline.js";
+import {
+  clearPersonalTimelineDyadState,
+  maybeEnqueueDyadFromAmbient,
+} from "./personal-timeline-dyad.js";
+
+describe("npc-mutual-chat", () => {
+  beforeEach(() => {
+    delete process.env.REDIS_URL;
+    clearNpcMutualChatState();
+    clearMockNpcMutualChatJobs();
+    clearNpcMutualChatJobClaimsForTest();
+    clearPersonalTimelineDyadState();
+    clearMockPersonalTimelineJobs();
+    clearPersonalTimelineJobClaimsForTest();
+  });
+
+  afterEach(() => {
+    delete process.env.REDIS_URL;
+  });
+
+  it("D-MUTUAL-01/05: proximity + schedule filter selects eligible pairs (no hard veto by score)", async () => {
+    expect(MUTUAL_CHAT_MAX_PER_DAY).toBe(3);
+
+    const roomId = "room-mc-select";
+    // Cluster of three within Chebyshev≤2; npc-4 far away.
+    const npcs = [
+      { id: "npc-1", x: 10, y: 10 },
+      { id: "npc-2", x: 11, y: 10 },
+      { id: "npc-3", x: 10, y: 11 },
+      { id: "npc-4", x: 80, y: 80 },
+    ];
+    // Nemesis / low affection still eligible — score is weight only.
+    const relationshipScores = new Map<string, number>([
+      ["npc-1:npc-2", -80],
+      ["npc-1:npc-3", 40],
+      ["npc-2:npc-3", 10],
+    ]);
+
+    const { enqueued } = await maybeEnqueueNpcMutualChat({
+      roomId,
+      npcs,
+      absoluteGameMinute: 1440 * 5 + 600, // midday — schedules active
+      gameMinuteOfDay: 600,
+      relationshipScores,
+      forceSelectAllEligible: true,
+      villageBandOnly: false,
+    });
+
+    expect(enqueued.length).toBeGreaterThan(0);
+    expect(enqueued.length).toBeLessThanOrEqual(MUTUAL_CHAT_MAX_PER_DAY);
+
+    const payloads = enqueued.map((id) => getMockNpcMutualChatJob(id));
+    for (const job of payloads) {
+      expect(job).toBeTruthy();
+      expect(job!.roomId).toBe(roomId);
+      expect(job!.dayIndex).toBe(5);
+      expect(["npc-1", "npc-2", "npc-3"]).toContain(job!.npcAId);
+      expect(["npc-1", "npc-2", "npc-3"]).toContain(job!.npcBId);
+      expect(job!.npcAId).not.toBe(job!.npcBId);
+      // Far npc-4 must not appear
+      expect(job!.npcAId).not.toBe("npc-4");
+      expect(job!.npcBId).not.toBe("npc-4");
+    }
+
+    // Nemesis pair npc-1↔npc-2 remains eligible (may or may not win sort; assert not vetoed from candidate set)
+    const { candidates } = await maybeEnqueueNpcMutualChat({
+      roomId: "room-mc-nemesis-check",
+      npcs: [
+        { id: "npc-1", x: 10, y: 10 },
+        { id: "npc-2", x: 11, y: 10 },
+      ],
+      absoluteGameMinute: 1440 * 6 + 600,
+      gameMinuteOfDay: 600,
+      relationshipScores: new Map([["npc-1:npc-2", -99]]),
+      forceSelectAllEligible: true,
+      villageBandOnly: false,
+      dryRun: true,
+    });
+    expect(candidates.some((c) => c.npcAId === "npc-1" && c.npcBId === "npc-2")).toBe(
+      true,
+    );
+  });
+
+  it("D-MUTUAL-03: daily stagger caps 2–3 pair triggers per game day with 12-seat rotation", async () => {
+    const roomId = "room-mc-stagger";
+    // Pack many council NPCs into one Chebyshev cluster so cap, not proximity, binds.
+    const npcs = Array.from({ length: 8 }, (_, i) => ({
+      id: `npc-${i + 1}`,
+      x: 10 + (i % 3),
+      y: 10 + Math.floor(i / 3),
+    }));
+
+    const first = await maybeEnqueueNpcMutualChat({
+      roomId,
+      npcs,
+      absoluteGameMinute: 1440 * 10 + 600,
+      gameMinuteOfDay: 600,
+      forceSelectAllEligible: true,
+      villageBandOnly: false,
+    });
+    expect(first.enqueued.length).toBeLessThanOrEqual(MUTUAL_CHAT_MAX_PER_DAY);
+    expect(first.enqueued.length).toBeGreaterThan(0);
+
+    const again = await maybeEnqueueNpcMutualChat({
+      roomId,
+      npcs,
+      absoluteGameMinute: 1440 * 10 + 700,
+      gameMinuteOfDay: 700,
+      forceSelectAllEligible: true,
+      villageBandOnly: false,
+    });
+    expect(again.enqueued.length).toBe(0);
+
+    // Different day → bucket rotation allows new enqueues (cap resets).
+    const nextDay = await maybeEnqueueNpcMutualChat({
+      roomId,
+      npcs,
+      absoluteGameMinute: 1440 * 11 + 600,
+      gameMinuteOfDay: 600,
+      forceSelectAllEligible: true,
+      villageBandOnly: false,
+    });
+    expect(nextDay.enqueued.length).toBeGreaterThan(0);
+    expect(nextDay.enqueued.length).toBeLessThanOrEqual(MUTUAL_CHAT_MAX_PER_DAY);
+  });
+
+  it("D-MUTUAL-07: defers enqueue when player speak is in-progress (same as world-vote)", async () => {
+    expect(shouldDeferNpcMutualChatEnqueue(1)).toBe(true);
+    expect(shouldDeferNpcMutualChatEnqueue(0)).toBe(false);
+
+    const deferred = await maybeEnqueueNpcMutualChat({
+      roomId: "room-mc-defer",
+      npcs: [
+        { id: "npc-1", x: 10, y: 10 },
+        { id: "npc-2", x: 11, y: 10 },
+      ],
+      absoluteGameMinute: 1440 * 4 + 600,
+      gameMinuteOfDay: 600,
+      npcSpeakInFlight: true,
+      forceSelectAllEligible: true,
+      villageBandOnly: false,
+    });
+    expect(deferred.enqueued).toEqual([]);
+    expect(deferred.deferred).toBe(true);
+  });
+
+  it("D-MUTUAL / A2: mutual-chat supersedes ambient dyad for same room/day/pair claim", async () => {
+    const roomId = "room-mc-supersede";
+    const npcs = [
+      { id: "npc-1", x: 10, y: 10 },
+      { id: "npc-2", x: 11, y: 10 },
+      { id: "npc-3", x: 10, y: 11 },
+    ];
+    const abs = 1440 * 7 + 600;
+
+    const mc = await maybeEnqueueNpcMutualChat({
+      roomId,
+      npcs,
+      absoluteGameMinute: abs,
+      gameMinuteOfDay: 600,
+      forceSelectAllEligible: true,
+      villageBandOnly: false,
+    });
+    expect(mc.enqueued.length).toBeGreaterThan(0);
+
+    const job = getMockNpcMutualChatJob(mc.enqueued[0]!);
+    expect(job).toBeTruthy();
+    expect(
+      isPairClaimedForMutualChat(roomId, job!.dayIndex, job!.npcAId, job!.npcBId),
+    ).toBe(true);
+
+    const dyadIds = await maybeEnqueueDyadFromAmbient({
+      roomId,
+      npcs,
+      absoluteGameMinute: abs,
+      selectPct: 100,
+    });
+    // Claimed mutual pairs must not get a silent ambient dyad event.
+    for (const id of dyadIds) {
+      // If anything enqueued, it must not be the mutual-claimed pair — covered by claim check below.
+      void id;
+    }
+    // Stronger: re-check that mutual pair stays claimed and ambient cannot claim same pair key.
+    expect(
+      isPairClaimedForMutualChat(roomId, job!.dayIndex, job!.npcAId, job!.npcBId),
+    ).toBe(true);
+    // With only 3 nearby NPCs and mutual taking up to 3 pairs, ambient should get nothing
+    // (all close pairs claimed) or only unclaimed pairs — never re-fire claimed ones.
+    expect(dyadIds.length).toBe(0);
+  });
+
+  it("queue claim NX + mock path blocks duplicate jobId without Redis", async () => {
+    const {
+      enqueueNpcMutualChatJob,
+      claimNpcMutualChatJobId,
+    } = await import("../queue/npc-mutual-chat.js");
+
+    const input = {
+      roomId: "room-mc-claim",
+      npcAId: "npc-1",
+      npcBId: "npc-2",
+      dayIndex: 3,
+      absoluteGameMinute: 1440 * 3 + 100,
+    };
+    const first = await enqueueNpcMutualChatJob(input);
+    expect(first).toBeTruthy();
+    expect(getMockNpcMutualChatJob(first!)?.npcAId).toBe("npc-1");
+
+    const again = await enqueueNpcMutualChatJob(input);
+    expect(again).toBeNull();
+
+    expect(await claimNpcMutualChatJobId(first!)).toBe(false);
+  });
+});
diff --git a/apps/game-server/src/world/npc-mutual-chat.ts b/apps/game-server/src/world/npc-mutual-chat.ts
new file mode 100644
index 0000000..04a474d
--- /dev/null
+++ b/apps/game-server/src/world/npc-mutual-chat.ts
@@ -0,0 +1,278 @@
+/**
+ * NPC mutual-chat proximity selector + daily stagger (D-MUTUAL-01/03/05/07).
+ * Enqueues only — no LLM in tick. Visible chat owned by mutual-chat budget.
+ */
+
+import {
+  COUNCIL_NPC_IDS,
+  MINUTES_PER_DAY,
+  isCouncilNpcId,
+  normalizeEdgeIds,
+  stableStringHash,
+} from "@aetherlife/shared";
+import {
+  resolveScheduleSegment,
+  shouldSkipMovement,
+} from "../ambient/schedule.js";
+import { enqueueNpcMutualChatJob } from "../queue/npc-mutual-chat.js";
+import { getRoomVoteState } from "./world-vote-state.js";
+
+/** Max mutual-chat pair triggers per room per SSOT game day (target 2–3). */
+export const MUTUAL_CHAT_MAX_PER_DAY = 3;
+const MUTUAL_CHEBYSHEV_MAX = 2;
+/** Default selection rate when not force-selecting (~12%). */
+const MUTUAL_SELECT_PCT = 12;
+
+export type MutualChatNpcPos = {
+  id: string;
+  x: number;
+  y: number;
+};
+
+export type MutualChatCandidate = {
+  npcAId: string;
+  npcBId: string;
+  weight: number;
+};
+
+const pairClaims = new Set<string>();
+const countByRoomDay = new Map<string, number>();
+
+function dayIndexFromAbsoluteMinute(absoluteGameMinute: number): number {
+  return Math.floor(Math.max(0, absoluteGameMinute) / MINUTES_PER_DAY);
+}
+
+function pairClaimKey(roomId: string, dayIndex: number, a: string, b: string): string {
+  const { npcAId, npcBId } = normalizeEdgeIds(a, b);
+  return `${roomId}:${dayIndex}:${npcAId}:${npcBId}`;
+}
+
+function roomDayKey(roomId: string, dayIndex: number): string {
+  return `${roomId}:${dayIndex}`;
+}
+
+function chebyshev(ax: number, ay: number, bx: number, by: number): number {
+  return Math.max(Math.abs(ax - bx), Math.abs(ay - by));
+}
+
+function seatIndex(npcId: string): number {
+  return (COUNCIL_NPC_IDS as readonly string[]).indexOf(npcId);
+}
+
+/**
+ * 12-seat bucket rotation: pair is in today's focus when either seat's
+ * index % 4 matches dayIndex % 4 (spreads pair opportunities across days).
+ */
+export function pairInDailyBucket(
+  npcAId: string,
+  npcBId: string,
+  dayIndex: number,
+): boolean {
+  const bucket = ((dayIndex % 4) + 4) % 4;
+  const ia = seatIndex(npcAId);
+  const ib = seatIndex(npcBId);
+  if (ia < 0 || ib < 0) return false;
+  return ia % 4 === bucket || ib % 4 === bucket;
+}
+
+function scoreKey(a: string, b: string): string {
+  const { npcAId, npcBId } = normalizeEdgeIds(a, b);
+  return `${npcAId}:${npcBId}`;
+}
+
+function zoneInVillageBand(zoneId: string | undefined): boolean {
+  if (!zoneId) return false;
+  return /village|plaza|square|market|beginning-fields/i.test(zoneId);
+}
+
+/** Same defer rule as world-vote: any in-flight speak → skip enqueue. */
+export function shouldDeferNpcMutualChatEnqueue(
+  npcSpeakJobsSize: number,
+): boolean {
+  return npcSpeakJobsSize > 0;
+}
+
+export function clearNpcMutualChatState(): void {
+  pairClaims.clear();
+  countByRoomDay.clear();
+}
+
+export function isPairClaimedForMutualChat(
+  roomId: string,
+  dayIndex: number,
+  a: string,
+  b: string,
+): boolean {
+  return pairClaims.has(pairClaimKey(roomId, dayIndex, a, b));
+}
+
+function schedulesOverlapAndAvailable(
+  npcAId: string,
+  npcBId: string,
+  gameMinuteOfDay: number,
+  villageBandOnly: boolean,
+): boolean {
+  const segA = resolveScheduleSegment(npcAId, gameMinuteOfDay);
+  const segB = resolveScheduleSegment(npcBId, gameMinuteOfDay);
+  if (!segA || !segB) return false;
+  if (shouldSkipMovement(segA) || shouldSkipMovement(segB)) return false;
+  if (villageBandOnly) {
+    if (!zoneInVillageBand(segA.zoneId) || !zoneInVillageBand(segB.zoneId)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * Select nearby council pairs and enqueue up to MUTUAL_CHAT_MAX_PER_DAY.
+ * Relationship scores weight sort only — never hard-veto (nemesis eligible).
+ */
+export async function maybeEnqueueNpcMutualChat(input: {
+  roomId: string;
+  npcs: readonly MutualChatNpcPos[];
+  absoluteGameMinute?: number;
+  /** Minute-of-day for schedule filter (defaults to abs % MINUTES_PER_DAY). */
+  gameMinuteOfDay?: number;
+  busyNpcIds?: ReadonlySet<string> | ReadonlyMap<string, string>;
+  npcSpeakInFlight?: boolean;
+  /** Optional affection/trust-style scores keyed `npcA:npcB` (normalized). Weight only. */
+  relationshipScores?: ReadonlyMap<string, number>;
+  /** Bypass hash selectPct — enqueue all eligible under daily cap (tests). */
+  forceSelectAllEligible?: boolean;
+  /** Default true: both schedules must be in village-band zones. */
+  villageBandOnly?: boolean;
+  /** Build candidates only; do not claim/enqueue. */
+  dryRun?: boolean;
+}): Promise<{
+  enqueued: string[];
+  deferred: boolean;
+  dayIndex: number;
+  candidates: MutualChatCandidate[];
+}> {
+  if (input.npcSpeakInFlight) {
+    return { enqueued: [], deferred: true, dayIndex: -1, candidates: [] };
+  }
+
+  const abs =
+    input.absoluteGameMinute ?? getRoomVoteState(input.roomId).absoluteGameMinute;
+  const dayIndex = dayIndexFromAbsoluteMinute(abs);
+  if (dayIndex <= 0) {
+    return { enqueued: [], deferred: false, dayIndex, candidates: [] };
+  }
+
+  const gameMinuteOfDay =
+    input.gameMinuteOfDay ?? Math.floor(Math.max(0, abs) % MINUTES_PER_DAY);
+  const villageBandOnly = input.villageBandOnly !== false;
+  const busy = input.busyNpcIds;
+  const isBusy = (id: string): boolean => Boolean(busy?.has(id));
+
+  const council = input.npcs.filter(
+    (n) => isCouncilNpcId(n.id) && !isBusy(n.id),
+  );
+
+  const rdKey = roomDayKey(input.roomId, dayIndex);
+  let remaining = MUTUAL_CHAT_MAX_PER_DAY - (countByRoomDay.get(rdKey) ?? 0);
+  if (remaining <= 0 && !input.dryRun) {
+    return { enqueued: [], deferred: false, dayIndex, candidates: [] };
+  }
+
+  type Pair = {
+    a: MutualChatNpcPos;
+    b: MutualChatNpcPos;
+    weight: number;
+  };
+  const pairs: Pair[] = [];
+
+  for (let i = 0; i < council.length; i++) {
+    for (let j = i + 1; j < council.length; j++) {
+      const a = council[i]!;
+      const b = council[j]!;
+      if (chebyshev(a.x, a.y, b.x, b.y) > MUTUAL_CHEBYSHEV_MAX) continue;
+      // forceSelectAllEligible skips bucket so tests can assert filter/weight without rotation.
+      if (
+        !input.forceSelectAllEligible &&
+        !pairInDailyBucket(a.id, b.id, dayIndex)
+      ) {
+        continue;
+      }
+      if (
+        !schedulesOverlapAndAvailable(
+          a.id,
+          b.id,
+          gameMinuteOfDay,
+          villageBandOnly,
+        )
+      ) {
+        continue;
+      }
+      const { npcAId, npcBId } = normalizeEdgeIds(a.id, b.id);
+      const claim = pairClaimKey(input.roomId, dayIndex, a.id, b.id);
+      if (pairClaims.has(claim)) continue;
+
+      if (!input.forceSelectAllEligible) {
+        const roll =
+          stableStringHash(
+            `mutual-chat:${input.roomId}:${dayIndex}:${npcAId}:${npcBId}`,
+          ) % 100;
+        if (roll >= MUTUAL_SELECT_PCT) continue;
+      }
+
+      const rel =
+        input.relationshipScores?.get(scoreKey(a.id, b.id)) ??
+        input.relationshipScores?.get(`${a.id}:${b.id}`) ??
+        0;
+      // Higher affection → higher priority; negative (nemesis) still eligible, just lower weight.
+      const weight = rel + (stableStringHash(`${npcAId}:${npcBId}:${dayIndex}`) % 7);
+      pairs.push({ a, b, weight });
+    }
+  }
+
+  pairs.sort((x, y) => y.weight - x.weight);
+
+  const candidates: MutualChatCandidate[] = pairs.map((p) => {
+    const { npcAId, npcBId } = normalizeEdgeIds(p.a.id, p.b.id);
+    return { npcAId, npcBId, weight: p.weight };
+  });
+
+  if (input.dryRun) {
+    return { enqueued: [], deferred: false, dayIndex, candidates };
+  }
+
+  // Claim the whole batch synchronously before any await so a same-tick
+  // ambient dyad scan (even mid-enqueue) sees full supersession.
+  const batch: Array<{ a: MutualChatNpcPos; b: MutualChatNpcPos; claim: string }> = [];
+  for (const { a, b } of pairs) {
+    if (batch.length >= remaining) break;
+    const claim = pairClaimKey(input.roomId, dayIndex, a.id, b.id);
+    if (pairClaims.has(claim)) continue;
+    pairClaims.add(claim);
+    batch.push({ a, b, claim });
+  }
+
+  const enqueued: string[] = [];
+  for (const { a, b, claim } of batch) {
+    let jobId: string | null = null;
+    try {
+      jobId = await enqueueNpcMutualChatJob({
+        roomId: input.roomId,
+        npcAId: a.id,
+        npcBId: b.id,
+        dayIndex,
+        absoluteGameMinute: abs,
+      });
+    } catch (err) {
+      pairClaims.delete(claim);
+      throw err;
+    }
+    if (!jobId) {
+      pairClaims.delete(claim);
+      continue;
+    }
+
+    enqueued.push(jobId);
+    countByRoomDay.set(rdKey, (countByRoomDay.get(rdKey) ?? 0) + 1);
+  }
+
+  return { enqueued, deferred: false, dayIndex, candidates };
+}
diff --git a/apps/game-server/src/world/npc-relationship-decay.test.ts b/apps/game-server/src/world/npc-relationship-decay.test.ts
new file mode 100644
index 0000000..4c77277
--- /dev/null
+++ b/apps/game-server/src/world/npc-relationship-decay.test.ts
@@ -0,0 +1,236 @@
+/**
+ * Silent idle relationship decay (D-DECAY-01…04, D-VERIFY-02).
+ */
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { beforeEach, describe, expect, it } from "vitest";
+import {
+  applyRelationshipDeltas,
+  clearNpcRelationshipsMemory,
+  getRelationshipEdge,
+  insertRelationshipEdge,
+} from "./npc-relationships-repository.js";
+import {
+  GAME_MONTH_MINUTES,
+  clearRelationshipDecayState,
+  computeIdleDecayDelta,
+  maybeRunRelationshipDecay,
+  softBoundsForBaseTag,
+} from "./npc-relationship-decay.js";
+
+const ROOM = "room-decay-28-04";
+
+describe("npc-relationship-decay", () => {
+  beforeEach(async () => {
+    delete process.env.DATABASE_URL;
+    clearNpcRelationshipsMemory();
+    await clearRelationshipDecayState();
+  });
+
+  it("D-DECAY-01: idle decay applies deltas with no UI hint / biography / toast", async () => {
+    await insertRelationshipEdge({
+      roomId: ROOM,
+      npcAId: "npc-1",
+      npcBId: "npc-2",
+      baseTag: "ally",
+      affection: 55,
+      trust: 80,
+      historySummary: "seed",
+    });
+
+    const result = await maybeRunRelationshipDecay(ROOM, GAME_MONTH_MINUTES + 1);
+    expect(result.decayed).toBeGreaterThanOrEqual(1);
+
+    const edge = await getRelationshipEdge(ROOM, "npc-1", "npc-2");
+    expect(edge!.historySummary).toBe("seed");
+    expect(edge!.affection).toBeLessThan(55);
+    expect(edge!.affection).toBeGreaterThanOrEqual(softBoundsForBaseTag("ally").floor);
+    // Silent: no relationshipSync / biography side effects from this module.
+    expect(result.broadcast).toBe(false);
+    expect(result.biographyEnqueued).toBe(false);
+  });
+
+  it("D-DECAY-02/03: monthly tick drifts idle edges toward 0 with |Δ| 1–3 and base_tag soft floor/ceiling", async () => {
+    await insertRelationshipEdge({
+      roomId: ROOM,
+      npcAId: "npc-3",
+      npcBId: "npc-4",
+      baseTag: "ally",
+      affection: 55,
+      trust: 70,
+    });
+
+    const before = await getRelationshipEdge(ROOM, "npc-3", "npc-4");
+    await maybeRunRelationshipDecay(ROOM, GAME_MONTH_MINUTES + 5);
+    const after = await getRelationshipEdge(ROOM, "npc-3", "npc-4");
+
+    const absDelta = Math.abs(after!.affection - before!.affection);
+    expect(absDelta).toBeGreaterThanOrEqual(1);
+    expect(absDelta).toBeLessThanOrEqual(3);
+    expect(after!.affection).toBeLessThan(before!.affection);
+    expect(after!.affection).toBeGreaterThanOrEqual(softBoundsForBaseTag("ally").floor);
+
+    // Pure step helper also respects soft bounds + step magnitude.
+    const step = computeIdleDecayDelta(55, "ally", () => 0); // step size 1
+    expect(Math.abs(step)).toBeGreaterThanOrEqual(1);
+    expect(Math.abs(step)).toBeLessThanOrEqual(3);
+  });
+
+  it("positive affection already below band floor keeps drifting toward 0 (never snaps up)", () => {
+    // ally floor=40; affection 30 must decay to 29, not jump to 40.
+    expect(computeIdleDecayDelta(30, "ally", () => 0)).toBe(-1);
+    // At/above floor the floor still holds: 41 with step 3 stops at 40.
+    expect(computeIdleDecayDelta(41, "ally", () => 0.99)).toBe(-1);
+  });
+
+  it("D-DECAY-03: decay does not bump last_interact_at (only real interact sources do)", async () => {
+    await insertRelationshipEdge({
+      roomId: ROOM,
+      npcAId: "npc-5",
+      npcBId: "npc-6",
+      baseTag: "rival",
+      affection: -55,
+      trust: 10,
+    });
+    // Real interact stamps last_interact_at + game-minute.
+    await applyRelationshipDeltas({
+      roomId: ROOM,
+      absoluteGameMinute: 10,
+      deltas: [{ npcAId: "npc-5", npcBId: "npc-6", affectionDelta: -1 }],
+    });
+    const afterInteract = await getRelationshipEdge(ROOM, "npc-5", "npc-6");
+    const lastInteract = afterInteract!.lastInteractAt;
+    const interactionCount = afterInteract!.interactionCount;
+    expect(lastInteract).not.toBeNull();
+    expect(interactionCount).toBe(1);
+
+    // Idle after one game-month from that interact.
+    await maybeRunRelationshipDecay(ROOM, 10 + GAME_MONTH_MINUTES + 1);
+    const afterDecay = await getRelationshipEdge(ROOM, "npc-5", "npc-6");
+    expect(afterDecay!.lastInteractAt).toBe(lastInteract);
+    expect(afterDecay!.interactionCount).toBe(interactionCount);
+    expect(afterDecay!.affection).toBeGreaterThan(afterInteract!.affection); // toward 0
+
+    // Second monthly pass still finds the edge idle (no timestamp refresh).
+    await maybeRunRelationshipDecay(ROOM, 10 + 2 * GAME_MONTH_MINUTES + 1);
+    const afterSecond = await getRelationshipEdge(ROOM, "npc-5", "npc-6");
+    expect(afterSecond!.lastInteractAt).toBe(lastInteract);
+    expect(afterSecond!.interactionCount).toBe(interactionCount);
+    expect(afterSecond!.affection).toBeGreaterThan(afterDecay!.affection);
+  });
+
+  it("D-DECAY-04: decay runs independent of council in-flight; council counts as recent activity", async () => {
+    await insertRelationshipEdge({
+      roomId: ROOM,
+      npcAId: "npc-7",
+      npcBId: "npc-8",
+      baseTag: "peer",
+      affection: 25,
+      trust: 60,
+    });
+    await insertRelationshipEdge({
+      roomId: ROOM,
+      npcAId: "npc-9",
+      npcBId: "npc-10",
+      baseTag: "nemesis",
+      affection: -55,
+      trust: 5,
+    });
+
+    // Recent council delta on first edge — should skip decay.
+    await applyRelationshipDeltas({
+      roomId: ROOM,
+      absoluteGameMinute: GAME_MONTH_MINUTES + 100,
+      deltas: [{ npcAId: "npc-7", npcBId: "npc-8", affectionDelta: 2 }],
+    });
+    const recentBefore = await getRelationshipEdge(ROOM, "npc-7", "npc-8");
+
+    // Idle second edge (never interacted since seed at 0).
+    const idleBefore = await getRelationshipEdge(ROOM, "npc-9", "npc-10");
+
+    const result = await maybeRunRelationshipDecay(
+      ROOM,
+      GAME_MONTH_MINUTES + 100,
+      { councilInFlight: true },
+    );
+    expect(result.skippedForCouncil).toBe(false);
+
+    const recentAfter = await getRelationshipEdge(ROOM, "npc-7", "npc-8");
+    expect(recentAfter!.affection).toBe(recentBefore!.affection);
+
+    const idleAfter = await getRelationshipEdge(ROOM, "npc-9", "npc-10");
+    expect(idleAfter!.affection).toBeGreaterThan(idleBefore!.affection);
+  });
+
+  it("decay path source does not call applyDeltaToRow", () => {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const src = readFileSync(join(here, "npc-relationship-decay.ts"), "utf8");
+    const repo = readFileSync(join(here, "npc-relationships-repository.ts"), "utf8");
+    expect(src).not.toMatch(/applyDeltaToRow/);
+    expect(src).toMatch(/applyIdleDecayDeltas/);
+    expect(repo).toMatch(/applyIdleDecayDeltas/);
+    // Idle path must not reuse the interact bump helper — bound the slice to the next export.
+    const idleStart = repo.indexOf("export async function applyIdleDecayDeltas");
+    const idleEnd = repo.indexOf("export function clearNpcRelationshipsMemory", idleStart);
+    expect(idleStart).toBeGreaterThanOrEqual(0);
+    expect(idleEnd).toBeGreaterThan(idleStart);
+    const idleFn = repo.slice(idleStart, idleEnd);
+    expect(idleFn).not.toMatch(/applyDeltaToRow\(/);
+  });
+
+  it("GameRoom sequences mutual-chat before ambient dyad enqueue", () => {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const room = readFileSync(join(here, "../colyseus/GameRoom.ts"), "utf8");
+    const tickStart = room.indexOf("private onAmbientTick");
+    const tickEnd = room.indexOf("private runRelationshipDecayIfDue");
+    const tick = room.slice(tickStart, tickEnd);
+    expect(tick).toMatch(/enqueueNpcMutualChatIfDue\(\)[\s\S]*\.then\(/);
+    expect(tick.indexOf("enqueueNpcMutualChatIfDue")).toBeLessThan(
+      tick.indexOf("enqueuePersonalTimelineDyadAmbientIfDue"),
+    );
+  });
+
+  it("GameRoom ambient tick wires maybeRunRelationshipDecay without LLM", () => {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const room = readFileSync(join(here, "../colyseus/GameRoom.ts"), "utf8");
+    expect(room).toMatch(/maybeRunRelationshipDecay/);
+    expect(room).toMatch(/runRelationshipDecayIfDue/);
+    // Decay call site must not gate on npcSpeakJobs (D-DECAY-04).
+    const method = room.slice(room.indexOf("private runRelationshipDecayIfDue"));
+    const body = method.slice(0, method.indexOf("private enqueueWorldVoteIfDue"));
+    expect(body).not.toMatch(/npcSpeakJobs/);
+  });
+
+  it("restart hydrate: SQL last_interact_at prevents idle misclassify at abs=0", async () => {
+    const {
+      hydrateInteractAbsFromEdges,
+      getLastInteractAbsMinute,
+    } = await import("./npc-relationships-repository.js");
+
+    const nowAbs = GAME_MONTH_MINUTES + 50;
+    const hydrated = hydrateInteractAbsFromEdges(ROOM, nowAbs, [
+      {
+        npcAId: "npc-11",
+        npcBId: "npc-12",
+        lastInteractAt: new Date(),
+      },
+    ]);
+    expect(hydrated).toBe(1);
+    expect(getLastInteractAbsMinute(ROOM, "npc-11", "npc-12")).toBe(nowAbs);
+
+    await insertRelationshipEdge({
+      roomId: ROOM,
+      npcAId: "npc-11",
+      npcBId: "npc-12",
+      baseTag: "ally",
+      affection: 55,
+      trust: 80,
+    });
+
+    await clearRelationshipDecayState();
+    const result = await maybeRunRelationshipDecay(ROOM, nowAbs);
+    // Hydrated as "just interacted" at nowAbs → not idle → no decay this month.
+    expect(result.decayed).toBe(0);
+  });
+});
diff --git a/apps/game-server/src/world/npc-relationship-decay.ts b/apps/game-server/src/world/npc-relationship-decay.ts
new file mode 100644
index 0000000..35b1da3
--- /dev/null
+++ b/apps/game-server/src/world/npc-relationship-decay.ts
@@ -0,0 +1,270 @@
+/**
+ * Silent idle-edge affection decay (D-DECAY-01…04).
+ *
+ * Soft floor/ceiling (RELATIONSHIP-DYNAMICS seed bands): decay drifts toward 0
+ * but stops at the band edge so base_tag identity is not erased by idle alone.
+ * |Δ| per monthly pass is 1–3. Uses applyIdleDecayDeltas only (never the interact-bump path).
+ */
+
+import { MINUTES_PER_DAY, DAYS_PER_MONTH, clampAffection } from "@aetherlife/shared";
+import { Redis } from "ioredis";
+import {
+  applyIdleDecayDeltas,
+  listRelationshipsForRoom,
+  getLastInteractAbsMinute,
+  getSeedAbsMinute,
+  hydrateInteractAbsFromEdges,
+  hydrateSeedAbsFromEdges,
+  type IdleDecayDelta,
+} from "./npc-relationships-repository.js";
+
+/** One game-month in absoluteGameMinute units (30 × 1440). */
+export const GAME_MONTH_MINUTES = DAYS_PER_MONTH * MINUTES_PER_DAY;
+
+/** Last monthIndex for which decay ran (per room). */
+const lastDecayMonthByRoom = new Map<string, number>();
+
+const DECAY_MONTH_KEY_PREFIX = "aetherlife:rel-decay-month:";
+let decayRedis: Redis | null | undefined;
+
+function decayMonthRedisKey(roomId: string): string {
+  return `${DECAY_MONTH_KEY_PREFIX}${roomId}`;
+}
+
+function getDecayRedis(): Redis | null {
+  if (decayRedis !== undefined) return decayRedis;
+  const url = process.env.REDIS_URL;
+  if (!url) {
+    decayRedis = null;
+    return null;
+  }
+  decayRedis = new Redis(url, { maxRetriesPerRequest: null });
+  decayRedis.on("error", (err) => {
+    console.error("[redis] relationship-decay", err.message);
+  });
+  return decayRedis;
+}
+
+async function loadLastDecayMonth(roomId: string): Promise<number | undefined> {
+  if (lastDecayMonthByRoom.has(roomId)) {
+    return lastDecayMonthByRoom.get(roomId);
+  }
+  const redis = getDecayRedis();
+  if (!redis) return undefined;
+  try {
+    const raw = await redis.get(decayMonthRedisKey(roomId));
+    if (raw == null || raw === "") return undefined;
+    const n = Number.parseInt(raw, 10);
+    if (!Number.isFinite(n)) return undefined;
+    lastDecayMonthByRoom.set(roomId, n);
+    return n;
+  } catch (err) {
+    console.error("[relationship-decay] load last month failed", err);
+    return undefined;
+  }
+}
+
+async function saveLastDecayMonth(roomId: string, monthIndex: number): Promise<void> {
+  lastDecayMonthByRoom.set(roomId, monthIndex);
+  const redis = getDecayRedis();
+  if (!redis) return;
+  try {
+    await redis.set(decayMonthRedisKey(roomId), String(monthIndex));
+  } catch (err) {
+    console.error("[relationship-decay] save last month failed", err);
+  }
+}
+
+export type SoftBounds = { floor: number; ceiling: number };
+
+/**
+ * Soft bounds from RELATIONSHIP-DYNAMICS kind→seed bands.
+ * Positive bands: floor = seed min. Negative bands: ceiling = seed max (least cold).
+ */
+export function softBoundsForBaseTag(baseTag: string): SoftBounds {
+  const k = baseTag.toLowerCase();
+  if (k === "nemesis" || k === "rival") return { floor: -100, ceiling: -40 };
+  if (
+    k === "ally" ||
+    k === "close_ally" ||
+    k === "strategic_ally" ||
+    k === "chaos_ally" ||
+    k === "chaotic_ally" ||
+    k === "chaos_buddy"
+  ) {
+    return { floor: 40, ceiling: 100 };
+  }
+  if (k.startsWith("respect") || k === "peer" || k === "appreciate" || k === "grateful") {
+    return { floor: 15, ceiling: 100 };
+  }
+  if (
+    k.startsWith("wary") ||
+    k.startsWith("cautious") ||
+    k === "suspicious" ||
+    k === "avoid" ||
+    k === "watch" ||
+    k === "distant"
+  ) {
+    return { floor: -100, ceiling: 0 };
+  }
+  if (
+    k === "deal" ||
+    k === "chess" ||
+    k === "frenemy" ||
+    k === "mixed" ||
+    k === "trade" ||
+    k === "opportunistic"
+  ) {
+    return { floor: -5, ceiling: 10 };
+  }
+  if (
+    k === "disdain" ||
+    k === "opposes" ||
+    k === "clash" ||
+    k === "friction" ||
+    k === "conflict_caution" ||
+    k === "conflict_respect"
+  ) {
+    return { floor: -100, ceiling: -15 };
+  }
+  if (k === "gentle_conflict" || k === "gentle_oppose") return { floor: -100, ceiling: 0 };
+  if (k === "support" || k === "cooperate" || k === "partner") return { floor: 35, ceiling: 100 };
+  return { floor: -100, ceiling: 100 };
+}
+
+export function monthIndexFromAbsoluteMinute(absoluteGameMinute: number): number {
+  return Math.floor(Math.max(0, absoluteGameMinute) / GAME_MONTH_MINUTES);
+}
+
+/** Test helper */
+export async function clearRelationshipDecayState(): Promise<void> {
+  lastDecayMonthByRoom.clear();
+  const redis = getDecayRedis();
+  if (!redis) return;
+  try {
+    const keys = await redis.keys(`${DECAY_MONTH_KEY_PREFIX}*`);
+    if (keys.length > 0) {
+      await redis.del(...keys);
+    }
+  } catch (err) {
+    console.error("[relationship-decay] clear redis month keys failed", err);
+  }
+}
+
+/**
+ * Compute affection delta toward 0 for one idle monthly step.
+ * Magnitude 1–3; clamped by soft bounds. rng() → [0,1) selects step size.
+ */
+export function computeIdleDecayDelta(
+  affection: number,
+  baseTag: string,
+  rng: () => number = Math.random,
+): number {
+  if (affection === 0) return 0;
+  const step = 1 + Math.floor(Math.min(0.999999, Math.max(0, rng())) * 3);
+  const { floor, ceiling } = softBoundsForBaseTag(baseTag);
+
+  if (affection > 0) {
+    const candidate = affection - step;
+    let next = Math.max(0, candidate);
+    // Floor only holds when affection is still at/above the band floor;
+    // below-floor values keep drifting toward 0 (never snap upward).
+    if (affection >= floor) {
+      next = Math.max(floor, next);
+    }
+    return clampAffection(next) - affection;
+  }
+
+  // affection < 0 — drift toward 0
+  const candidate = affection + step;
+  let next = Math.min(0, candidate);
+  if (affection <= ceiling) {
+    next = Math.min(ceiling, next);
+  }
+  return clampAffection(next) - affection;
+}
+
+export function isIdleEdge(
+  roomId: string,
+  npcAId: string,
+  npcBId: string,
+  absoluteGameMinute: number,
+): boolean {
+  const last =
+    getLastInteractAbsMinute(roomId, npcAId, npcBId) ??
+    getSeedAbsMinute(roomId, npcAId, npcBId) ??
+    0;
+  return absoluteGameMinute - last >= GAME_MONTH_MINUTES;
+}
+
+export type MaybeRunRelationshipDecayOptions = {
+  /** Ignored — D-DECAY-04: decay is not blocked by council in-flight. */
+  councilInFlight?: boolean;
+  rng?: () => number;
+};
+
+export type MaybeRunRelationshipDecayResult = {
+  decayed: number;
+  monthIndex: number;
+  broadcast: false;
+  biographyEnqueued: false;
+  skippedForCouncil: false;
+};
+
+/**
+ * On game-month rollover, apply silent idle decay for stale edges.
+ * No LLM, no relationshipSync, no biography.
+ */
+export async function maybeRunRelationshipDecay(
+  roomId: string,
+  absoluteGameMinute: number,
+  options?: MaybeRunRelationshipDecayOptions,
+): Promise<MaybeRunRelationshipDecayResult> {
+  void options?.councilInFlight; // D-DECAY-04: intentionally unused
+  const monthIndex = monthIndexFromAbsoluteMinute(absoluteGameMinute);
+  const empty: MaybeRunRelationshipDecayResult = {
+    decayed: 0,
+    monthIndex,
+    broadcast: false,
+    biographyEnqueued: false,
+    skippedForCouncil: false,
+  };
+  if (monthIndex <= 0) return empty;
+
+  const prev = await loadLastDecayMonth(roomId);
+  if (prev === monthIndex) return empty;
+
+  const edges = await listRelationshipsForRoom(roomId);
+  // Restart-safe: rehydrate process-local abs stamps from SQL last_interact_at / seed.
+  hydrateInteractAbsFromEdges(roomId, absoluteGameMinute, edges);
+  hydrateSeedAbsFromEdges(roomId, edges);
+
+  await saveLastDecayMonth(roomId, monthIndex);
+
+  const deltas: IdleDecayDelta[] = [];
+  const rng = options?.rng ?? Math.random;
+
+  for (const edge of edges) {
+    if (!isIdleEdge(roomId, edge.npcAId, edge.npcBId, absoluteGameMinute)) continue;
+    const affectionDelta = computeIdleDecayDelta(edge.affection, edge.baseTag, rng);
+    if (affectionDelta === 0) continue;
+    deltas.push({
+      npcAId: edge.npcAId,
+      npcBId: edge.npcBId,
+      affectionDelta,
+    });
+  }
+
+  if (deltas.length === 0) {
+    return empty;
+  }
+
+  const { updated } = await applyIdleDecayDeltas({ roomId, deltas });
+  return {
+    decayed: updated,
+    monthIndex,
+    broadcast: false,
+    biographyEnqueued: false,
+    skippedForCouncil: false,
+  };
+}
diff --git a/apps/game-server/src/world/npc-relationships-embed.test.ts b/apps/game-server/src/world/npc-relationships-embed.test.ts
new file mode 100644
index 0000000..7e14212
--- /dev/null
+++ b/apps/game-server/src/world/npc-relationships-embed.test.ts
@@ -0,0 +1,190 @@
+/**
+ * Phase 28 plan 09 — async relationship edge embeddings (D-EMBED-02/03).
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { EMBED_DIMENSIONS } from "@aetherlife/npc-memory";
+import { embedText } from "../memory/embed.js";
+import {
+  applyIdleDecayDeltas,
+  applyRelationshipDeltas,
+  buildRelationshipEmbedText,
+  clearNpcRelationshipsMemory,
+  getRelationshipEdgeEmbedding,
+  insertRelationshipEdge,
+  searchSimilarEdges,
+  updateEmbeddingForEdge,
+} from "./npc-relationships-repository.js";
+
+describe("relationship edge embed text (D-EMBED-02)", () => {
+  it("joins history_summary + current_status without affection/band tokens", () => {
+    const text = buildRelationshipEmbedText({
+      historySummary: "昔日同盟，共守边境裂隙。",
+      currentStatus: ["疏远", "互不往来"],
+      affection: -40,
+      band: "hostile",
+    });
+    expect(text).toContain("昔日同盟");
+    expect(text).toContain("疏远");
+    expect(text).toContain("互不往来");
+    expect(text).not.toMatch(/-40/);
+    expect(text).not.toContain("hostile");
+    expect(text).not.toMatch(/\baffection\b/i);
+  });
+});
+
+describe("relationship edge embedding write (D-EMBED-03)", () => {
+  beforeEach(() => {
+    delete process.env.DATABASE_URL;
+    process.env.VITEST = "true";
+    clearNpcRelationshipsMemory();
+  });
+
+  afterEach(() => {
+    clearNpcRelationshipsMemory();
+  });
+
+  it("updateEmbeddingForEdge stores mock embedText vector (2048 dims)", async () => {
+    await insertRelationshipEdge({
+      roomId: "room-embed",
+      npcAId: "npc-1",
+      npcBId: "npc-2",
+      baseTag: "ally",
+      affection: 60,
+      trust: 70,
+      historySummary: "并肩作战多年。",
+    });
+
+    const text = buildRelationshipEmbedText({
+      historySummary: "并肩作战多年。",
+      currentStatus: ["亲近"],
+    });
+    const embedding = await embedText(text);
+    expect(embedding).toHaveLength(EMBED_DIMENSIONS);
+
+    await updateEmbeddingForEdge("room-embed", "npc-1", "npc-2", embedding);
+    const stored = await getRelationshipEdgeEmbedding("room-embed", "npc-1", "npc-2");
+    expect(stored).not.toBeNull();
+    expect(stored!).toHaveLength(EMBED_DIMENSIONS);
+    expect(stored![0]).toBeCloseTo(embedding[0]!, 5);
+  });
+
+  it("applyRelationshipDeltas schedules async embed and updates vector (non-decay)", async () => {
+    await insertRelationshipEdge({
+      roomId: "room-async",
+      npcAId: "npc-3",
+      npcBId: "npc-4",
+      baseTag: "rival",
+      affection: -20,
+      trust: 40,
+      historySummary: "旧怨未消。",
+    });
+
+    await applyRelationshipDeltas({
+      roomId: "room-async",
+      deltas: [
+        {
+          npcAId: "npc-3",
+          npcBId: "npc-4",
+          affectionDelta: -5,
+          historyAppend: "又起争执。",
+          statusTags: ["交恶"],
+        },
+      ],
+    });
+
+    // Fire-and-forget: flush microtasks / short await
+    await vi.waitFor(
+      async () => {
+        const stored = await getRelationshipEdgeEmbedding("room-async", "npc-3", "npc-4");
+        expect(stored).not.toBeNull();
+        expect(stored!).toHaveLength(EMBED_DIMENSIONS);
+      },
+      { timeout: 2000, interval: 20 },
+    );
+  });
+
+  it("applyIdleDecayDeltas does not embed", async () => {
+    await insertRelationshipEdge({
+      roomId: "room-decay",
+      npcAId: "npc-5",
+      npcBId: "npc-6",
+      baseTag: "peer",
+      affection: 30,
+      trust: 50,
+      historySummary: "同窗旧友。",
+    });
+
+    await applyIdleDecayDeltas({
+      roomId: "room-decay",
+      deltas: [{ npcAId: "npc-5", npcBId: "npc-6", affectionDelta: -2 }],
+    });
+
+    await new Promise((r) => setTimeout(r, 50));
+    const stored = await getRelationshipEdgeEmbedding("room-decay", "npc-5", "npc-6");
+    expect(stored).toBeNull();
+  });
+
+  it("searchSimilarEdges ranks by cosine and filters activeNpcId", async () => {
+    await insertRelationshipEdge({
+      roomId: "room-sim",
+      npcAId: "npc-1",
+      npcBId: "npc-2",
+      baseTag: "ally",
+      affection: 50,
+      trust: 60,
+      historySummary: "共守封印裂隙，边境防务同盟。",
+    });
+    await insertRelationshipEdge({
+      roomId: "room-sim",
+      npcAId: "npc-1",
+      npcBId: "npc-3",
+      baseTag: "peer",
+      affection: 10,
+      trust: 50,
+      historySummary: "偶尔闲聊天气。",
+    });
+    await insertRelationshipEdge({
+      roomId: "room-sim",
+      npcAId: "npc-4",
+      npcBId: "npc-5",
+      baseTag: "peer",
+      affection: 0,
+      trust: 50,
+      historySummary: "无关边。",
+    });
+
+    const targetText = "共守封印裂隙，边境防务同盟。";
+    const targetVec = await embedText(targetText);
+    await updateEmbeddingForEdge(
+      "room-sim",
+      "npc-1",
+      "npc-2",
+      targetVec,
+    );
+    await updateEmbeddingForEdge(
+      "room-sim",
+      "npc-1",
+      "npc-3",
+      await embedText("偶尔闲聊天气。"),
+    );
+    await updateEmbeddingForEdge(
+      "room-sim",
+      "npc-4",
+      "npc-5",
+      await embedText("无关边。"),
+    );
+
+    const hits = await searchSimilarEdges({
+      roomId: "room-sim",
+      queryEmbedding: targetVec,
+      activeNpcId: "npc-1",
+      k: 5,
+    });
+    expect(hits).toHaveLength(2);
+    expect(hits[0]!.historySummary).toBe(targetText);
+    expect(hits[0]!.score).toBeGreaterThanOrEqual(hits[1]!.score);
+    for (const hit of hits) {
+      expect(hit.npcAId === "npc-1" || hit.npcBId === "npc-1").toBe(true);
+    }
+  });
+});
diff --git a/apps/game-server/src/world/npc-relationships-repository.ts b/apps/game-server/src/world/npc-relationships-repository.ts
index b9b9cb2..cc6a6c1 100644
--- a/apps/game-server/src/world/npc-relationships-repository.ts
+++ b/apps/game-server/src/world/npc-relationships-repository.ts
@@ -10,8 +10,9 @@ import {
   type RelationshipDeltaInput,
   type RelationshipEdgePublic,
 } from "@aetherlife/shared";
-import { getSharedSql } from "@aetherlife/npc-memory";
+import { EMBED_DIMENSIONS, getSharedSql } from "@aetherlife/npc-memory";
 import { randomUUID } from "node:crypto";
+import { embedText } from "../memory/embed.js";
 
 export type ListRelationshipsOptions = {
   npcId?: string;
@@ -23,6 +24,19 @@ export type ApplyRelationshipDeltasInput = {
   roomId: string;
   deltas: RelationshipDeltaInput[];
   voteEpoch?: string;
+  /** Game clock stamp for idle-decay idle windows (D-DECAY-03). */
+  absoluteGameMinute?: number;
+};
+
+export type IdleDecayDelta = {
+  npcAId: string;
+  npcBId: string;
+  affectionDelta: number;
+};
+
+export type ApplyIdleDecayDeltasInput = {
+  roomId: string;
+  deltas: IdleDecayDelta[];
 };
 
 export type ApplyRelationshipDeltasResult = {
@@ -41,6 +55,7 @@ type RelationshipRow = {
   lastInteractAt: Date | null;
   currentStatus: string[];
   historySummary: string;
+  embedding: number[] | null;
   updatedAt: Date;
 };
 
@@ -56,12 +71,160 @@ type DbRow = {
   last_interact_at: Date | string | null;
   current_status: unknown;
   history_summary: string;
+  embedding?: number[] | string | null;
   updated_at: Date | string;
 };
 
+export type SimilarRelationshipEdge = {
+  npcAId: string;
+  npcBId: string;
+  historySummary: string;
+  currentStatus: string[];
+  score: number;
+};
+
+export type SearchSimilarEdgesInput = {
+  roomId: string;
+  queryEmbedding: number[];
+  activeNpcId?: string;
+  k?: number;
+};
+
+/** D-EMBED-02: vector text = history + status; never affection ints / band id. */
+export function buildRelationshipEmbedText(input: {
+  historySummary: string;
+  currentStatus: string[];
+  /** Ignored — accepted so callers cannot accidentally concatenate via spread. */
+  affection?: number;
+  band?: string;
+}): string {
+  const history = (input.historySummary ?? "").trim();
+  const status = (input.currentStatus ?? [])
+    .filter((t): t is string => typeof t === "string" && t.trim().length > 0)
+    .map((t) => t.trim())
+    .join(" ");
+  return [history, status].filter((part) => part.length > 0).join("\n");
+}
+
+function parseEmbedding(raw: unknown): number[] | null {
+  if (raw == null) return null;
+  if (Array.isArray(raw)) {
+    const nums = raw.filter((v): v is number => typeof v === "number");
+    return nums.length === EMBED_DIMENSIONS ? nums : null;
+  }
+  if (typeof raw === "string") {
+    const trimmed = raw.trim().replace(/^\[/, "").replace(/\]$/, "");
+    if (!trimmed) return null;
+    const nums = trimmed.split(",").map((p) => Number(p.trim()));
+    if (nums.length !== EMBED_DIMENSIONS || nums.some((n) => !Number.isFinite(n))) {
+      return null;
+    }
+    return nums;
+  }
+  return null;
+}
+
+function cosineSimilarity(a: number[], b: number[]): number {
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  const n = Math.min(a.length, b.length);
+  for (let i = 0; i < n; i += 1) {
+    const av = a[i] ?? 0;
+    const bv = b[i] ?? 0;
+    dot += av * bv;
+    na += av * av;
+    nb += bv * bv;
+  }
+  const denom = Math.sqrt(na) * Math.sqrt(nb);
+  return denom > 0 ? dot / denom : 0;
+}
+
 const memoryByRoom = new Map<string, RelationshipRow[]>();
+/** Absolute game-minute of last real interact (not decay). Key: roomId:npcA:npcB */
+const lastInteractAbsByEdge = new Map<string, number>();
+/** Absolute game-minute when edge was seeded (for never-interacted idle). */
+const seedAbsByEdge = new Map<string, number>();
 let sqlClient: ReturnType<typeof getSharedSql> | null = null;
 
+function edgeStampKey(roomId: string, npcAId: string, npcBId: string): string {
+  const n = normalizeEdgeIds(npcAId, npcBId);
+  return `${roomId}:${n.npcAId}:${n.npcBId}`;
+}
+
+export function getLastInteractAbsMinute(
+  roomId: string,
+  npcAId: string,
+  npcBId: string,
+): number | undefined {
+  return lastInteractAbsByEdge.get(edgeStampKey(roomId, npcAId, npcBId));
+}
+
+export function getSeedAbsMinute(
+  roomId: string,
+  npcAId: string,
+  npcBId: string,
+): number | undefined {
+  return seedAbsByEdge.get(edgeStampKey(roomId, npcAId, npcBId));
+}
+
+function noteSeedAbs(roomId: string, npcAId: string, npcBId: string, abs: number): void {
+  const key = edgeStampKey(roomId, npcAId, npcBId);
+  if (!seedAbsByEdge.has(key)) seedAbsByEdge.set(key, abs);
+}
+
+function noteInteractAbs(roomId: string, npcAId: string, npcBId: string, abs: number): void {
+  lastInteractAbsByEdge.set(edgeStampKey(roomId, npcAId, npcBId), abs);
+}
+
+/**
+ * After process restart, Maps are empty while SQL still has last_interact_at.
+ * Stamp current abs so recently-interacted edges are not treated as idle (abs=0).
+ * Returns how many edges were hydrated.
+ */
+export function hydrateInteractAbsFromEdges(
+  roomId: string,
+  absoluteGameMinute: number,
+  edges: ReadonlyArray<{
+    npcAId: string;
+    npcBId: string;
+    lastInteractAt: Date | null;
+  }>,
+): number {
+  let hydrated = 0;
+  for (const edge of edges) {
+    if (!edge.lastInteractAt) continue;
+    if (getLastInteractAbsMinute(roomId, edge.npcAId, edge.npcBId) !== undefined) {
+      continue;
+    }
+    noteInteractAbs(roomId, edge.npcAId, edge.npcBId, absoluteGameMinute);
+    hydrated += 1;
+  }
+  return hydrated;
+}
+
+/**
+ * Restore seed stamps for never-interacted edges after restart (seed abs=0).
+ * Without this, isIdleEdge falls back to 0 anyway — explicit stamp keeps parity with insert path.
+ */
+export function hydrateSeedAbsFromEdges(
+  roomId: string,
+  edges: ReadonlyArray<{
+    npcAId: string;
+    npcBId: string;
+    lastInteractAt: Date | null;
+  }>,
+): number {
+  let hydrated = 0;
+  for (const edge of edges) {
+    if (edge.lastInteractAt) continue;
+    if (getSeedAbsMinute(roomId, edge.npcAId, edge.npcBId) !== undefined) continue;
+    noteSeedAbs(roomId, edge.npcAId, edge.npcBId, 0);
+    hydrated += 1;
+  }
+  return hydrated;
+}
+
 function getSql(): ReturnType<typeof getSharedSql> | null {
   const url = process.env.DATABASE_URL;
   if (!url) return null;
@@ -93,6 +256,7 @@ function rowFromDb(raw: DbRow): RelationshipRow {
       : null,
     currentStatus: parseStatusTags(raw.current_status),
     historySummary: raw.history_summary,
+    embedding: parseEmbedding(raw.embedding),
     updatedAt:
       raw.updated_at instanceof Date ? raw.updated_at : new Date(raw.updated_at),
   };
@@ -202,11 +366,13 @@ async function insertMemoryEdge(input: InsertRelationshipEdgeInput): Promise<Rel
     lastInteractAt: null,
     currentStatus: [],
     historySummary: input.historySummary ?? "",
+    embedding: null,
     updatedAt: new Date(),
   };
   const bucket = memoryByRoom.get(input.roomId) ?? [];
   bucket.push(row);
   memoryByRoom.set(input.roomId, bucket);
+  noteSeedAbs(input.roomId, normalized.npcAId, normalized.npcBId, 0);
   return row;
 }
 
@@ -239,6 +405,7 @@ async function insertSqlEdge(input: InsertRelationshipEdgeInput): Promise<Relati
   `;
 
   if (rows.length > 0) {
+    noteSeedAbs(input.roomId, normalized.npcAId, normalized.npcBId, 0);
     return rowFromDb(rows[0]!);
   }
 
@@ -251,6 +418,7 @@ async function insertSqlEdge(input: InsertRelationshipEdgeInput): Promise<Relati
     LIMIT 1
   `;
   if (existingRows.length > 0) {
+    noteSeedAbs(input.roomId, normalized.npcAId, normalized.npcBId, 0);
     return rowFromDb(existingRows[0]!);
   }
   throw new Error("insertSqlEdge: conflict without existing row");
@@ -366,6 +534,7 @@ async function applyDeltasMemory(
   input: ApplyRelationshipDeltasInput,
 ): Promise<ApplyRelationshipDeltasResult> {
   const linkedEdges: LinkedEdge[] = [];
+  const abs = input.absoluteGameMinute ?? 0;
 
   for (const delta of input.deltas) {
     const normalized = normalizeEdgeIds(delta.npcAId, delta.npcBId);
@@ -378,6 +547,7 @@ async function applyDeltasMemory(
       npcBId: normalized.npcBId,
     });
     if (changed) {
+      noteInteractAbs(input.roomId, normalized.npcAId, normalized.npcBId, abs);
       linkedEdges.push({ npcAId: normalized.npcAId, npcBId: normalized.npcBId });
     }
   }
@@ -389,6 +559,7 @@ async function applyDeltasSql(
   input: ApplyRelationshipDeltasInput,
 ): Promise<ApplyRelationshipDeltasResult> {
   const linkedEdges: LinkedEdge[] = [];
+  const abs = input.absoluteGameMinute ?? 0;
 
   for (const delta of input.deltas) {
     const normalized = normalizeEdgeIds(delta.npcAId, delta.npcBId);
@@ -413,6 +584,8 @@ async function applyDeltasSql(
     });
     if (!changed) continue;
 
+    noteInteractAbs(input.roomId, normalized.npcAId, normalized.npcBId, abs);
+
     await sql`
       UPDATE npc_relationships
       SET
@@ -437,12 +610,262 @@ export async function applyRelationshipDeltas(
   input: ApplyRelationshipDeltasInput,
 ): Promise<ApplyRelationshipDeltasResult> {
   const sql = getSql();
-  return sql ? applyDeltasSql(input) : applyDeltasMemory(input);
+  const result = sql ? await applyDeltasSql(input) : await applyDeltasMemory(input);
+  for (const edge of result.linkedEdges) {
+    scheduleRelationshipEdgeEmbed(input.roomId, edge.npcAId, edge.npcBId);
+  }
+  return result;
+}
+
+/**
+ * Fire-and-forget edge embed (D-EMBED-03). Never awaited from Colyseus hot path.
+ * Force refresh after delta so history/status changes re-embed.
+ */
+export function scheduleRelationshipEdgeEmbed(
+  roomId: string,
+  npcAId: string,
+  npcBId: string,
+): void {
+  void ensureRelationshipEdgeEmbedding(roomId, npcAId, npcBId, { force: true }).catch(
+    (err) => {
+      console.error(
+        `[npc-relationships] async embed failed room=${roomId} ${npcAId}/${npcBId}`,
+        err,
+      );
+    },
+  );
+}
+
+/** Embed if missing or force refresh after delta (lazy speak miss + delta write). */
+export async function ensureRelationshipEdgeEmbedding(
+  roomId: string,
+  npcAId: string,
+  npcBId: string,
+  options?: { force?: boolean },
+): Promise<boolean> {
+  const normalized = normalizeEdgeIds(npcAId, npcBId);
+  const existing = await getRelationshipEdgeEmbedding(
+    roomId,
+    normalized.npcAId,
+    normalized.npcBId,
+  );
+  if (existing && !options?.force) {
+    return false;
+  }
+
+  const edge = await getRelationshipEdge(roomId, normalized.npcAId, normalized.npcBId);
+  if (!edge) return false;
+
+  const text = buildRelationshipEmbedText({
+    historySummary: edge.historySummary,
+    currentStatus: edge.currentStatus,
+  });
+  if (!text.trim()) return false;
+
+  const embedding = await embedText(text);
+  await updateEmbeddingForEdge(roomId, normalized.npcAId, normalized.npcBId, embedding);
+  return true;
+}
+
+export async function updateEmbeddingForEdge(
+  roomId: string,
+  npcAId: string,
+  npcBId: string,
+  embedding: number[],
+): Promise<void> {
+  if (embedding.length !== EMBED_DIMENSIONS) {
+    throw new Error(`unexpected embed dimensions: ${embedding.length}`);
+  }
+  const normalized = normalizeEdgeIds(npcAId, npcBId);
+  const sql = getSql();
+  if (sql) {
+    const vectorLiteral = `[${embedding.join(",")}]`;
+    await sql`
+      UPDATE npc_relationships
+      SET embedding = ${vectorLiteral}::vector
+      WHERE room_id = ${roomId}
+        AND npc_a_id = ${normalized.npcAId}
+        AND npc_b_id = ${normalized.npcBId}
+    `;
+    return;
+  }
+
+  const row = findMemoryEdge(roomId, normalized.npcAId, normalized.npcBId);
+  if (row) {
+    row.embedding = [...embedding];
+  }
+}
+
+export async function getRelationshipEdgeEmbedding(
+  roomId: string,
+  npcAId: string,
+  npcBId: string,
+): Promise<number[] | null> {
+  const normalized = normalizeEdgeIds(npcAId, npcBId);
+  const sql = getSql();
+  if (sql) {
+    const rows = await sql<{ embedding: unknown }[]>`
+      SELECT embedding
+      FROM npc_relationships
+      WHERE room_id = ${roomId}
+        AND npc_a_id = ${normalized.npcAId}
+        AND npc_b_id = ${normalized.npcBId}
+      LIMIT 1
+    `;
+    if (rows.length === 0) return null;
+    return parseEmbedding(rows[0]!.embedding);
+  }
+  return findMemoryEdge(roomId, normalized.npcAId, normalized.npcBId)?.embedding ?? null;
+}
+
+export async function searchSimilarEdges(
+  input: SearchSimilarEdgesInput,
+): Promise<SimilarRelationshipEdge[]> {
+  const k = input.k ?? 5;
+  const sql = getSql();
+  if (sql) {
+    const vectorLiteral = `[${input.queryEmbedding.join(",")}]`;
+    const active = input.activeNpcId;
+    const rows = active
+      ? await sql<
+          {
+            npc_a_id: string;
+            npc_b_id: string;
+            history_summary: string;
+            current_status: unknown;
+            score: number;
+          }[]
+        >`
+          SELECT
+            npc_a_id,
+            npc_b_id,
+            history_summary,
+            current_status,
+            (1 - (embedding <=> ${vectorLiteral}::vector)) AS score
+          FROM npc_relationships
+          WHERE room_id = ${input.roomId}
+            AND embedding IS NOT NULL
+            AND (${active} = npc_a_id OR ${active} = npc_b_id)
+          ORDER BY embedding <=> ${vectorLiteral}::vector ASC
+          LIMIT ${k}
+        `
+      : await sql<
+          {
+            npc_a_id: string;
+            npc_b_id: string;
+            history_summary: string;
+            current_status: unknown;
+            score: number;
+          }[]
+        >`
+          SELECT
+            npc_a_id,
+            npc_b_id,
+            history_summary,
+            current_status,
+            (1 - (embedding <=> ${vectorLiteral}::vector)) AS score
+          FROM npc_relationships
+          WHERE room_id = ${input.roomId}
+            AND embedding IS NOT NULL
+          ORDER BY embedding <=> ${vectorLiteral}::vector ASC
+          LIMIT ${k}
+        `;
+    return rows.map((row) => ({
+      npcAId: row.npc_a_id,
+      npcBId: row.npc_b_id,
+      historySummary: row.history_summary,
+      currentStatus: parseStatusTags(row.current_status),
+      score: Number(row.score),
+    }));
+  }
+
+  const rows = memoryRowsForRoom(input.roomId).filter((row) => {
+    if (!row.embedding || row.embedding.length !== EMBED_DIMENSIONS) return false;
+    if (!input.activeNpcId) return true;
+    return row.npcAId === input.activeNpcId || row.npcBId === input.activeNpcId;
+  });
+
+  return rows
+    .map((row) => ({
+      npcAId: row.npcAId,
+      npcBId: row.npcBId,
+      historySummary: row.historySummary,
+      currentStatus: [...row.currentStatus],
+      score: cosineSimilarity(row.embedding!, input.queryEmbedding),
+    }))
+    .sort((a, b) => b.score - a.score)
+    .slice(0, k);
+}
+
+/**
+ * Silent idle decay apply — updates affection only.
+ * Does NOT bump last_interact_at, interaction_count, history, or status (pitfall #1).
+ */
+export async function applyIdleDecayDeltas(
+  input: ApplyIdleDecayDeltasInput,
+): Promise<{ updated: number }> {
+  const sql = getSql();
+  return sql ? applyIdleDecaySql(input) : applyIdleDecayMemory(input);
+}
+
+async function applyIdleDecayMemory(
+  input: ApplyIdleDecayDeltasInput,
+): Promise<{ updated: number }> {
+  let updated = 0;
+  for (const delta of input.deltas) {
+    if (delta.affectionDelta === 0) continue;
+    const normalized = normalizeEdgeIds(delta.npcAId, delta.npcBId);
+    const row = findMemoryEdge(input.roomId, normalized.npcAId, normalized.npcBId);
+    if (!row) continue;
+    row.affection = clampAffection(row.affection + delta.affectionDelta);
+    row.updatedAt = new Date();
+    updated += 1;
+  }
+  return { updated };
+}
+
+async function applyIdleDecaySql(
+  input: ApplyIdleDecayDeltasInput,
+): Promise<{ updated: number }> {
+  const sql = getSql();
+  if (!sql) throw new Error("sql client unavailable");
+  let updated = 0;
+
+  for (const delta of input.deltas) {
+    if (delta.affectionDelta === 0) continue;
+    const normalized = normalizeEdgeIds(delta.npcAId, delta.npcBId);
+    const rows = await sql<DbRow[]>`
+      SELECT *
+      FROM npc_relationships
+      WHERE room_id = ${input.roomId}
+        AND npc_a_id = ${normalized.npcAId}
+        AND npc_b_id = ${normalized.npcBId}
+      LIMIT 1
+    `;
+    if (rows.length === 0) continue;
+
+    const row = rowFromDb(rows[0]!);
+    const nextAffection = clampAffection(row.affection + delta.affectionDelta);
+    const updatedAt = new Date();
+    await sql`
+      UPDATE npc_relationships
+      SET
+        affection = ${nextAffection},
+        updated_at = ${updatedAt.toISOString()}
+      WHERE room_id = ${input.roomId}
+        AND npc_a_id = ${normalized.npcAId}
+        AND npc_b_id = ${normalized.npcBId}
+    `;
+    updated += 1;
+  }
+  return { updated };
 }
 
 /** Test helper */
 export function clearNpcRelationshipsMemory(): void {
   memoryByRoom.clear();
+  lastInteractAbsByEdge.clear();
+  seedAbsByEdge.clear();
 }
 
 /** Expected undirected edge count for 12 council seats. */
diff --git a/apps/game-server/src/world/personal-timeline-dyad.ts b/apps/game-server/src/world/personal-timeline-dyad.ts
index 55025f8..627521d 100644
--- a/apps/game-server/src/world/personal-timeline-dyad.ts
+++ b/apps/game-server/src/world/personal-timeline-dyad.ts
@@ -18,6 +18,7 @@ import {
   claimPersonalTimelineJobId,
   enqueuePersonalTimelineEventJob,
 } from "../queue/personal-timeline.js";
+import { isPairClaimedForMutualChat } from "./npc-mutual-chat.js";
 import { getRoomVoteState } from "./world-vote-state.js";
 
 const DYAD_CHEBYSHEV_MAX = 2;
@@ -200,6 +201,8 @@ export async function maybeEnqueueDyadFromAmbient(input: {
       const { npcAId, npcBId } = normalizeEdgeIds(a.id, b.id);
       const claim = pairClaimKey(input.roomId, dayIndex, a.id, b.id);
       if (dyadDayClaims.has(claim)) continue;
+      // D-MUTUAL / A2: mutual-chat supersedes ambient dyad for same room/day/pair.
+      if (isPairClaimedForMutualChat(input.roomId, dayIndex, a.id, b.id)) continue;
       const score =
         stableStringHash(`dyad-ambient:${input.roomId}:${dayIndex}:${npcAId}:${npcBId}`) %
         100;
@@ -214,6 +217,7 @@ export async function maybeEnqueueDyadFromAmbient(input: {
     if (remaining <= 0) break;
     const claim = pairClaimKey(input.roomId, dayIndex, a.id, b.id);
     if (dyadDayClaims.has(claim)) continue;
+    if (isPairClaimedForMutualChat(input.roomId, dayIndex, a.id, b.id)) continue;
 
     const durablePair = durablePairClaimId(input.roomId, dayIndex, a.id, b.id);
     if (!(await claimPersonalTimelineJobId(durablePair))) continue;
diff --git a/apps/game-server/src/world/relationship-broadcast.test.ts b/apps/game-server/src/world/relationship-broadcast.test.ts
new file mode 100644
index 0000000..a0e5e5f
--- /dev/null
+++ b/apps/game-server/src/world/relationship-broadcast.test.ts
@@ -0,0 +1,174 @@
+/**
+ * Phase 28 mutual-chat presentation + linkedEdges hint broadcast (D-MUTUAL-02/04).
+ */
+import { beforeEach, describe, expect, it } from "vitest";
+import request from "supertest";
+import {
+  COLYSEUS_SERVER_MESSAGES,
+  findNpc,
+} from "@aetherlife/shared";
+import { createApp } from "../index.js";
+import {
+  clearColyseusRoomRegistry,
+  registerColyseusRoom,
+} from "../colyseus/room-registry.js";
+import { GameRoomState } from "../colyseus/schema.js";
+import { clearAllRooms, getOrCreate } from "../room/store.js";
+import {
+  broadcastLinkedEdgesHint,
+  broadcastMutualChatBubble,
+  clampMutualBubbleText,
+  presentNpcMutualChat,
+} from "../world/relationship-broadcast.js";
+
+const ROOM = "room-mutual-chat";
+
+describe("relationship-broadcast mutual chat", () => {
+  beforeEach(() => {
+    delete process.env.DATABASE_URL;
+    delete process.env.INTERNAL_WORKER_TOKEN;
+    clearAllRooms();
+    clearColyseusRoomRegistry();
+  });
+
+  it("clampMutualBubbleText truncates to ≤20 and strips control chars", () => {
+    expect(clampMutualBubbleText("短")).toBe("短");
+    expect(clampMutualBubbleText("一二三四五六七八九十一二三四五六七八九十超")).toHaveLength(20);
+    expect(clampMutualBubbleText("a\nb\tc")).toBe("abc");
+  });
+
+  it("broadcastMutualChatBubble sends ≤20 text and never puts edges on relationshipSync", () => {
+    const sends: Array<{ type: string; payload: unknown }> = [];
+    const room = {
+      clients: [
+        {
+          send: (type: string, payload: unknown) => {
+            sends.push({ type, payload });
+          },
+        },
+      ],
+      state: new GameRoomState(),
+    };
+    registerColyseusRoom(ROOM, room as never);
+
+    broadcastMutualChatBubble(ROOM, {
+      npcId: "npc-1",
+      peerNpcId: "npc-2",
+      text: "今日庭中风软正好叙话超过二十",
+      expiresAt: Date.now() + 4000,
+    });
+
+    expect(sends).toHaveLength(1);
+    expect(sends[0]!.type).toBe(COLYSEUS_SERVER_MESSAGES.mutualChatBubble);
+    const bubble = sends[0]!.payload as { text: string };
+    expect(bubble.text.length).toBeLessThanOrEqual(20);
+
+    broadcastLinkedEdgesHint(ROOM, {
+      linkedEdges: [{ npcAId: "npc-2", npcBId: "npc-1" }],
+    });
+    const hint = sends.find((s) => s.type === COLYSEUS_SERVER_MESSAGES.relationshipLinkedHint);
+    expect(hint).toBeTruthy();
+    expect(hint!.payload).toEqual({
+      linkedEdges: [{ npcAId: "npc-1", npcBId: "npc-2" }],
+    });
+    expect(
+      sends.some((s) => s.type === COLYSEUS_SERVER_MESSAGES.relationshipSync),
+    ).toBe(false);
+  });
+
+  it("presentNpcMutualChat sets dual intentReasonZh and broadcasts bubble", () => {
+    getOrCreate(ROOM);
+    const sends: Array<{ type: string; payload: unknown }> = [];
+    const room = {
+      clients: [
+        {
+          send: (type: string, payload: unknown) => {
+            sends.push({ type, payload });
+          },
+        },
+      ],
+      state: new GameRoomState(),
+    };
+    registerColyseusRoom(ROOM, room as never);
+
+    const bubble = presentNpcMutualChat(ROOM, {
+      npcAId: "npc-1",
+      npcBId: "npc-2",
+      npcAReasonZh: "与沈清晏交谈中",
+      npcBReasonZh: "与莫玄虚交谈中",
+      bubbleText: "今日风清",
+    });
+
+    expect(bubble?.text).toBe("今日风清");
+    const { state: map } = getOrCreate(ROOM);
+    expect(findNpc(map, "npc-1")?.intentReasonZh).toContain("交谈中");
+    expect(findNpc(map, "npc-2")?.intentReasonZh).toContain("交谈中");
+    expect(sends.some((s) => s.type === COLYSEUS_SERVER_MESSAGES.mutualChatBubble)).toBe(
+      true,
+    );
+  });
+});
+
+describe("internal npc-mutual-chat routes", () => {
+  const app = createApp();
+
+  beforeEach(() => {
+    delete process.env.DATABASE_URL;
+    delete process.env.INTERNAL_WORKER_TOKEN;
+    clearAllRooms();
+    clearColyseusRoomRegistry();
+  });
+
+  it("POST present requires worker auth when token configured", async () => {
+    process.env.INTERNAL_WORKER_TOKEN = "secret-tok";
+    const res = await request(app)
+      .post(`/internal/rooms/${ROOM}/npc-mutual-chat/present`)
+      .send({
+        npcAId: "npc-1",
+        npcBId: "npc-2",
+        npcAReasonZh: "与乙交谈中",
+        npcBReasonZh: "与甲交谈中",
+        bubbleText: "你好",
+      });
+    expect(res.status).toBe(401);
+  });
+
+  it("POST present + linked-edges-hint succeed with auth", async () => {
+    getOrCreate(ROOM);
+    const sends: Array<{ type: string; payload: unknown }> = [];
+    registerColyseusRoom(ROOM, {
+      clients: [
+        {
+          send: (type: string, payload: unknown) => {
+            sends.push({ type, payload });
+          },
+        },
+      ],
+      state: new GameRoomState(),
+    } as never);
+
+    const present = await request(app)
+      .post(`/internal/rooms/${ROOM}/npc-mutual-chat/present`)
+      .send({
+        npcAId: "npc-1",
+        npcBId: "npc-2",
+        npcAReasonZh: "与乙交谈中",
+        npcBReasonZh: "与甲交谈中",
+        bubbleText: "今日庭中风软正好叙话超过二十字",
+      });
+    expect(present.status).toBe(200);
+    expect(present.body.ok).toBe(true);
+    expect(present.body.bubble.text.length).toBeLessThanOrEqual(20);
+    expect(
+      sends.some((s) => s.type === COLYSEUS_SERVER_MESSAGES.relationshipSync),
+    ).toBe(true);
+
+    const hint = await request(app)
+      .post(`/internal/rooms/${ROOM}/npc-mutual-chat/linked-edges-hint`)
+      .send({ linkedEdges: [{ npcAId: "npc-1", npcBId: "npc-2" }] });
+    expect(hint.status).toBe(200);
+    expect(
+      sends.some((s) => s.type === COLYSEUS_SERVER_MESSAGES.relationshipLinkedHint),
+    ).toBe(true);
+  });
+});
diff --git a/apps/game-server/src/world/relationship-broadcast.ts b/apps/game-server/src/world/relationship-broadcast.ts
new file mode 100644
index 0000000..05b7287
--- /dev/null
+++ b/apps/game-server/src/world/relationship-broadcast.ts
@@ -0,0 +1,125 @@
+import {
+  COLYSEUS_SERVER_MESSAGES,
+  findNpc,
+  normalizeEdgeIds,
+  type ColyseusMutualChatBubblePayload,
+  type ColyseusRelationshipLinkedHintPayload,
+  type ColyseusRelationshipSyncPayload,
+} from "@aetherlife/shared";
+import { syncColyseusFromMap } from "../colyseus/bridge.js";
+import { getColyseusRoom } from "../colyseus/room-registry.js";
+import type { GameRoomState } from "../colyseus/schema.js";
+import { bumpStateVersion } from "../colyseus/version.js";
+import { getOrCreate } from "../room/store.js";
+
+const BUBBLE_MAX_CHARS = 20;
+const BUBBLE_TTL_MS = 4000;
+const CONTROL_CHARS = /[\x00-\x1f\x7f]/g;
+
+/** D-API-01 / D-GRAPH-04: hint-only — never edge bodies on WS. */
+export function broadcastRelationshipSync(
+  mapRoomId: string,
+  payload: ColyseusRelationshipSyncPayload,
+): void {
+  const room = getColyseusRoom(mapRoomId);
+  if (!room) return;
+
+  const hint: ColyseusRelationshipSyncPayload = {
+    hasUpdate: payload.hasUpdate,
+  };
+  if (payload.latestSeq != null) {
+    hint.latestSeq = payload.latestSeq;
+  }
+
+  for (const client of room.clients) {
+    client.send(COLYSEUS_SERVER_MESSAGES.relationshipSync, hint);
+  }
+}
+
+export function clampMutualBubbleText(text: string): string {
+  const cleaned = String(text ?? "").replace(CONTROL_CHARS, "").trim();
+  return cleaned.length <= BUBBLE_MAX_CHARS ? cleaned : cleaned.slice(0, BUBBLE_MAX_CHARS);
+}
+
+/** D-MUTUAL-02: one-shot bubble — not a Colyseus schema field. */
+export function broadcastMutualChatBubble(
+  mapRoomId: string,
+  payload: ColyseusMutualChatBubblePayload,
+): void {
+  const room = getColyseusRoom(mapRoomId);
+  if (!room) return;
+
+  const text = clampMutualBubbleText(payload.text);
+  if (!text || !payload.npcId || !payload.peerNpcId) return;
+
+  const msg: ColyseusMutualChatBubblePayload = {
+    npcId: payload.npcId,
+    peerNpcId: payload.peerNpcId,
+    text,
+    expiresAt: payload.expiresAt,
+  };
+
+  for (const client of room.clients) {
+    client.send(COLYSEUS_SERVER_MESSAGES.mutualChatBubble, msg);
+  }
+}
+
+/** D-MUTUAL-04: LinkedEdge[] ids only — same client state CouncilRosterPanel consumes. */
+export function broadcastLinkedEdgesHint(
+  mapRoomId: string,
+  payload: ColyseusRelationshipLinkedHintPayload,
+): void {
+  const room = getColyseusRoom(mapRoomId);
+  if (!room) return;
+
+  const linkedEdges = (payload.linkedEdges ?? [])
+    .filter((e) => e?.npcAId && e?.npcBId && e.npcAId !== e.npcBId)
+    .map((e) => {
+      const { npcAId, npcBId } = normalizeEdgeIds(e.npcAId, e.npcBId);
+      return { npcAId, npcBId };
+    });
+
+  const msg: ColyseusRelationshipLinkedHintPayload = { linkedEdges };
+  for (const client of room.clients) {
+    client.send(COLYSEUS_SERVER_MESSAGES.relationshipLinkedHint, msg);
+  }
+}
+
+/**
+ * Apply dual activity labels + broadcast one-shot bubble (D-MUTUAL-02).
+ * Does not add Colyseus schema fields.
+ */
+export function presentNpcMutualChat(
+  mapRoomId: string,
+  input: {
+    npcAId: string;
+    npcBId: string;
+    npcAReasonZh: string;
+    npcBReasonZh: string;
+    bubbleText: string;
+  },
+): ColyseusMutualChatBubblePayload | null {
+  if (!input.npcAId || !input.npcBId || input.npcAId === input.npcBId) return null;
+
+  const { state: map } = getOrCreate(mapRoomId);
+  const npcA = findNpc(map, input.npcAId);
+  const npcB = findNpc(map, input.npcBId);
+  if (npcA) npcA.intentReasonZh = String(input.npcAReasonZh ?? "").trim().slice(0, 40);
+  if (npcB) npcB.intentReasonZh = String(input.npcBReasonZh ?? "").trim().slice(0, 40);
+
+  const colyseus = getColyseusRoom(mapRoomId);
+  if (colyseus) {
+    const state = colyseus.state as GameRoomState;
+    syncColyseusFromMap(state, map);
+    bumpStateVersion(state);
+  }
+
+  const bubble: ColyseusMutualChatBubblePayload = {
+    npcId: input.npcAId,
+    peerNpcId: input.npcBId,
+    text: clampMutualBubbleText(input.bubbleText),
+    expiresAt: Date.now() + BUBBLE_TTL_MS,
+  };
+  broadcastMutualChatBubble(mapRoomId, bubble);
+  return bubble;
+}
diff --git a/apps/web/src/ChatPage.tsx b/apps/web/src/ChatPage.tsx
index b4601b4..61bc0bc 100644
--- a/apps/web/src/ChatPage.tsx
+++ b/apps/web/src/ChatPage.tsx
@@ -1,14 +1,21 @@
 import { bandLabelZh, createDefaultRoom, isBackgroundNpc, type RoomState, type WorldHistoryPublicEntry } from "@aetherlife/shared";
 import type {
   ColyseusPersonalTimelineSyncPayload,
+  ColyseusRelationshipSyncPayload,
   ColyseusWorldHistorySyncPayload,
 } from "@aetherlife/shared";
+import { COLYSEUS_SERVER_MESSAGES } from "@aetherlife/shared";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { flushSync } from "react-dom";
 import { useColyseusRoom } from "./hooks/useColyseusRoom.js";
 import { discoveredLoreRows } from "./hooks/useChunkLore.js";
 import { useNpcChat } from "./hooks/useNpcChat.js";
 import { usePersonalTimeline } from "./hooks/usePersonalTimeline.js";
+import { useNpcRelationships } from "./hooks/useNpcRelationships.js";
+import {
+  resolveDefaultCenterNpcId,
+  type RelationshipGraphMode,
+} from "./components/RelationshipGraphPanel.js";
 import { MovementPanel } from "./components/MovementPanel.js";
 import { PhaserGame, probePhaserBoot, readReducedMotion } from "./components/PhaserGame.js";
 import { CollectiveAttitudeOverlay } from "./components/CollectiveAttitudeOverlay.js";
@@ -72,6 +79,9 @@ export function ChatPage() {
   const mergePersonalTimelineSyncRef = useRef<(payload: ColyseusPersonalTimelineSyncPayload) => void>(
     () => {},
   );
+  const mergeRelationshipSyncRef = useRef<(payload: ColyseusRelationshipSyncPayload) => void>(
+    () => {},
+  );
   const markChronicleVoteEntryRef = useRef<() => void>(() => {});
   const onWorldHistorySync = useCallback((payload: ColyseusWorldHistorySyncPayload) => {
     mergeWorldHistorySyncRef.current(payload);
@@ -85,6 +95,9 @@ export function ChatPage() {
   const onPersonalTimelineSync = useCallback((payload: ColyseusPersonalTimelineSyncPayload) => {
     mergePersonalTimelineSyncRef.current(payload);
   }, []);
+  const onRelationshipSync = useCallback((payload: ColyseusRelationshipSyncPayload) => {
+    mergeRelationshipSyncRef.current(payload);
+  }, []);
   const {
     room,
     connected,
@@ -109,6 +122,7 @@ export function ChatPage() {
     npcActivityById,
     npcAmbientById,
     roomNpcs,
+    mutualChatBubble,
   } = useColyseusRoom(
     mapRoomId,
     moveMap,
@@ -184,12 +198,41 @@ export function ChatPage() {
     toastQueue: councilVoteToastQueue,
     chronicleUnread,
     mergeCouncilDeliberationSync,
+    mergeLinkedEdgesHint,
     markChronicleVoteEntry,
     clearChronicleUnread,
     consumeVoteToast,
   } = useCouncilDeliberation(speakQueueBusy);
   mergeCouncilDeliberationSyncRef.current = mergeCouncilDeliberationSync;
   markChronicleVoteEntryRef.current = markChronicleVoteEntry;
+
+  useEffect(() => {
+    if (!room) return;
+    const off = room.onMessage(
+      COLYSEUS_SERVER_MESSAGES.relationshipLinkedHint,
+      (data: unknown) => {
+        mergeLinkedEdgesHint(data);
+      },
+    );
+    return () => {
+      off();
+    };
+  }, [room, mergeLinkedEdgesHint]);
+
+  useEffect(() => {
+    if (!room) return;
+    const off = room.onMessage(
+      COLYSEUS_SERVER_MESSAGES.relationshipSync,
+      (data: unknown) => {
+        if (!data || typeof data !== "object") return;
+        const row = data as ColyseusRelationshipSyncPayload;
+        if (typeof row.hasUpdate !== "boolean") return;
+        mergeRelationshipSyncRef.current(row);
+      },
+    );
+    return () => off();
+  }, [room]);
+
   const councilVoteToast = councilVoteToastQueue[0] ?? null;
   const dismissCouncilVoteToast = useCallback(() => {
     consumeVoteToast();
@@ -250,6 +293,42 @@ export function ChatPage() {
     collectiveRecentEvents: collectiveSnapshot?.recentEvents,
   });
 
+  const relationshipsTabFocused = drawerOpen && drawerTab === "relationships";
+  const {
+    edges: relationshipEdges,
+    loading: relationshipLoading,
+    error: relationshipError,
+    hasUpdate: relationshipHasUpdate,
+    mergeRelationshipSync,
+  } = useNpcRelationships(mapRoomId, connected, relationshipsTabFocused);
+  mergeRelationshipSyncRef.current = mergeRelationshipSync;
+
+  const [lastRosterNpcId, setLastRosterNpcId] = useState("npc-1");
+  const [relationshipCenterNpcId, setRelationshipCenterNpcId] = useState("npc-1");
+  const [relationshipGraphMode, setRelationshipGraphMode] =
+    useState<RelationshipGraphMode>("ego");
+
+  // Reset center/mode only on tab focus transition — never mid-session when
+  // activeNpcId changes, so the user's selected center survives.
+  const relationshipsTabWasFocusedRef = useRef(false);
+  useEffect(() => {
+    const wasFocused = relationshipsTabWasFocusedRef.current;
+    relationshipsTabWasFocusedRef.current = relationshipsTabFocused;
+    if (!relationshipsTabFocused || wasFocused) return;
+    setRelationshipCenterNpcId(
+      resolveDefaultCenterNpcId(activeNpcId, lastRosterNpcId),
+    );
+    setRelationshipGraphMode("ego");
+  }, [relationshipsTabFocused, activeNpcId, lastRosterNpcId]);
+
+  const handleOpenPersonalBiography = useCallback(
+    (npcId: string) => {
+      setLastRosterNpcId(npcId);
+      void openPersonalBiography(npcId);
+    },
+    [openPersonalBiography],
+  );
+
   const latestCollectiveEvent = collectiveSnapshot?.recentEvents[0];
   const collectiveFeedbackKind =
     latestCollectiveEvent &&
@@ -579,7 +658,17 @@ export function ChatPage() {
             personalTimelineHasUpdate={personalTimelineHasUpdate}
             personalTimelineLoadingNpcId={personalTimelineLoadingNpcId}
             personalTimelineErrorByNpcId={personalTimelineErrorByNpcId}
-            onOpenPersonalBiography={openPersonalBiography}
+            onOpenPersonalBiography={handleOpenPersonalBiography}
+            relationshipEdges={relationshipEdges}
+            relationshipLoading={relationshipLoading}
+            relationshipError={relationshipError}
+            relationshipHasUpdate={relationshipHasUpdate}
+            relationshipCenterNpcId={relationshipCenterNpcId}
+            onRelationshipCenterChange={setRelationshipCenterNpcId}
+            relationshipGraphMode={relationshipGraphMode}
+            onRelationshipGraphModeChange={setRelationshipGraphMode}
+            lastRosterNpcId={lastRosterNpcId}
+            relationshipStaleHint={relationshipHasUpdate && relationshipsTabFocused}
             roomId={mapRoomId}
             roomConnected={connected}
             lastParsedIntent={lastParsedIntent}
@@ -736,6 +825,7 @@ export function ChatPage() {
                 npcActivityById={npcActivityById}
                 npcAmbientById={npcAmbientById}
                 speakBusyNpcId={speakBusyNpcId}
+                mutualChatBubble={mutualChatBubble}
                 onBootFailed={() => {
                   setPhaserOk(false);
                   setBootOk(false);
diff --git a/apps/web/src/components/DialogueBar.tsx b/apps/web/src/components/DialogueBar.tsx
index d6c3675..02b47be 100644
--- a/apps/web/src/components/DialogueBar.tsx
+++ b/apps/web/src/components/DialogueBar.tsx
@@ -11,6 +11,7 @@ export type DrawerTab =
   | "history"
   | "collective"
   | "council"
+  | "relationships"
   | "chronicle"
   | "discoveries"
   | "memory";
@@ -114,6 +115,14 @@ export function DialogueBar({
           >
             议会
           </button>
+          <button
+            type="button"
+            className="dialogue-bar__drawer-btn"
+            aria-label="关系网"
+            onClick={() => onOpenDrawer("relationships")}
+          >
+            关系网
+          </button>
           <button
             type="button"
             className="dialogue-bar__drawer-btn"
diff --git a/apps/web/src/components/PhaserGame.tsx b/apps/web/src/components/PhaserGame.tsx
index 453f5bd..5d460a1 100644
--- a/apps/web/src/components/PhaserGame.tsx
+++ b/apps/web/src/components/PhaserGame.tsx
@@ -10,7 +10,7 @@ import {
   type NpcState,
   type RoomState,
 } from "@aetherlife/shared";
-import type { NpcAmbientSnapshot, PlayerSnapshot } from "../hooks/useColyseusRoom.js";
+import type { MutualChatBubbleEvent, NpcAmbientSnapshot, PlayerSnapshot } from "../hooks/useColyseusRoom.js";
 import type { LocalPlayerMotionBridge } from "../game/localPlayerMotion.js";
 import type { MovementSyncController } from "../game/MovementSyncController.js";
 import { ExploreCoordsStrip } from "./ExploreCoordsStrip.js";
@@ -62,6 +62,8 @@ type Props = {
   npcActivityById?: Record<string, string>;
   npcAmbientById?: Record<string, NpcAmbientSnapshot>;
   speakBusyNpcId?: string | null;
+  /** One-shot NPC↔NPC mutual-chat bubble (D-MUTUAL-02). */
+  mutualChatBubble?: MutualChatBubbleEvent | null;
   onBootFailed?: () => void;
   /** Map click on NPC sprite — opens dialogue overlay (same as corner-menu engage). */
   onNpcSpriteClick?: (npcId: string) => void;
@@ -109,6 +111,7 @@ type RegistrySnapshot = {
   npcActivityById: Record<string, string>;
   npcAmbientById: Record<string, NpcAmbientSnapshot>;
   speakBusyNpcId: string | null;
+  mutualChatBubble: MutualChatBubbleEvent | null;
   onNpcSpriteClick: ((npcId: string) => void) | null;
 };
 
@@ -139,6 +142,7 @@ function pushRoomRegistry(game: Phaser.Game, snap: RegistrySnapshot): void {
   game.registry.set("npcActivityById", snap.npcActivityById);
   game.registry.set("npcAmbientById", snap.npcAmbientById);
   game.registry.set("speakBusyNpcId", snap.speakBusyNpcId);
+  game.registry.set("mutualChatBubble", snap.mutualChatBubble);
   game.registry.set("onNpcSpriteClick", snap.onNpcSpriteClick);
   game.registry.set("roomSync", Date.now());
 }
@@ -217,6 +221,7 @@ export async function probePhaserBoot(timeoutMs = BOOT_TIMEOUT_MS): Promise<bool
         npcActivityById: {},
         npcAmbientById: {},
         speakBusyNpcId: null,
+        mutualChatBubble: null,
         onNpcSpriteClick: null,
       });
       game.events.once("ready", () => finish(true));
@@ -257,6 +262,7 @@ export function PhaserGame({
   npcActivityById = {},
   npcAmbientById = {},
   speakBusyNpcId = null,
+  mutualChatBubble = null,
   onBootFailed,
   onNpcSpriteClick,
   onViewportVisibleNpcIdsChange,
@@ -313,6 +319,7 @@ export function PhaserGame({
     npcActivityById,
     npcAmbientById,
     speakBusyNpcId,
+    mutualChatBubble,
     onNpcSpriteClick: onNpcSpriteClick ?? null,
   });
   registryRef.current = {
@@ -340,6 +347,7 @@ export function PhaserGame({
     npcActivityById,
     npcAmbientById,
     speakBusyNpcId,
+    mutualChatBubble,
     onNpcSpriteClick: onNpcSpriteClick ?? null,
   };
 
@@ -396,6 +404,7 @@ export function PhaserGame({
       npcActivityById,
       npcAmbientById,
       speakBusyNpcId,
+      mutualChatBubble,
       onNpcSpriteClick: snap.onNpcSpriteClick,
     });
 
@@ -521,6 +530,7 @@ export function PhaserGame({
       npcActivityById,
       npcAmbientById,
       speakBusyNpcId,
+      mutualChatBubble,
       onNpcSpriteClick: onNpcSpriteClick ?? null,
     });
 
@@ -553,6 +563,7 @@ export function PhaserGame({
     npcActivityById,
     npcAmbientById,
     speakBusyNpcId,
+    mutualChatBubble,
     onNpcSpriteClick,
   ]);
 
diff --git a/apps/web/src/components/RelationshipGraphPanel.test.ts b/apps/web/src/components/RelationshipGraphPanel.test.ts
new file mode 100644
index 0000000..1d7d9de
--- /dev/null
+++ b/apps/web/src/components/RelationshipGraphPanel.test.ts
@@ -0,0 +1,120 @@
+import { createElement } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { describe, expect, it } from "vitest";
+import type { RelationshipRenderEdge } from "../hooks/useNpcRelationships.js";
+import {
+  RelationshipGraphPanel,
+  graphNodeLabel,
+  relationshipGraphToggleCopy,
+  resolveDefaultCenterNpcId,
+  toggleRelationshipGraphMode,
+} from "./RelationshipGraphPanel.js";
+
+/** Fixture includes server-side affection 42 — must never appear in DOM (D-GRAPH-02). */
+const fixtureEdges: RelationshipRenderEdge[] = [
+  {
+    npcAId: "npc-1",
+    npcBId: "npc-2",
+    baseTag: "rival",
+    band: "hostile",
+    bandLabelZh: "敌对",
+    kindLabelZh: "宿敌",
+    currentStatus: ["紧张"],
+  },
+  {
+    npcAId: "npc-1",
+    npcBId: "npc-3",
+    baseTag: "ally",
+    band: "close",
+    bandLabelZh: "亲密",
+    kindLabelZh: "同盟",
+    currentStatus: [],
+  },
+];
+
+const baseProps = {
+  edges: fixtureEdges,
+  loading: false,
+  error: null as string | null,
+  activeNpcId: "npc-1",
+  lastRosterNpcId: "npc-2",
+  graphMode: "ego" as const,
+  centerNpcId: "npc-1",
+  onCenterChange: () => {},
+  onModeChange: () => {},
+};
+
+describe("RelationshipGraphPanel helpers", () => {
+  it("D-DRAWER-03: default center prefers activeNpcId, then roster, else npc-1", () => {
+    expect(resolveDefaultCenterNpcId("npc-5", "npc-2")).toBe("npc-5");
+    expect(resolveDefaultCenterNpcId("", "npc-2")).toBe("npc-2");
+    expect(resolveDefaultCenterNpcId(undefined, undefined)).toBe("npc-1");
+  });
+
+  it("D-GRAPH-03: toggle copy switches ego ↔ full", () => {
+    expect(relationshipGraphToggleCopy("ego")).toBe("查看全图");
+    expect(relationshipGraphToggleCopy("full")).toBe("以某人为中心");
+    expect(toggleRelationshipGraphMode("ego")).toBe("full");
+    expect(toggleRelationshipGraphMode("full")).toBe("ego");
+  });
+
+  it("graph node label truncates to ≤4 chars", () => {
+    expect(graphNodeLabel("莫玄虚")).toBe("莫玄虚");
+    expect(graphNodeLabel("海莲娜·星")).toBe("海莲娜·…");
+  });
+});
+
+describe("RelationshipGraphPanel", () => {
+  it("D-GRAPH-01: renders relationship-graph-panel testid", () => {
+    const html = renderToStaticMarkup(createElement(RelationshipGraphPanel, baseProps));
+    expect(html).toContain('data-testid="relationship-graph-panel"');
+    expect(html).toContain("关系网");
+  });
+
+  it("D-GRAPH-02: shows band chips with ZH labels — no raw affection/trust in DOM", () => {
+    const html = renderToStaticMarkup(createElement(RelationshipGraphPanel, baseProps));
+    expect(html).toContain('data-testid="relationship-graph-band-chip"');
+    expect(html).toContain("敌对");
+    expect(html).toContain("亲密");
+    expect(html).not.toContain("affection");
+    expect(html).not.toContain("trust");
+    expect(html).not.toMatch(/\b42\b/);
+    expect(html).not.toMatch(/\b77\b/);
+  });
+
+  it("D-GRAPH-03: ego mode shows center subtitle and mode toggle", () => {
+    const html = renderToStaticMarkup(createElement(RelationshipGraphPanel, baseProps));
+    expect(html).toContain('data-testid="relationship-graph-mode-toggle"');
+    expect(html).toContain("以「莫玄虚」为中心");
+    expect(html).toContain("查看全图");
+  });
+
+  it("D-GRAPH-03: full mode renders 12-node circle layout marker", () => {
+    const html = renderToStaticMarkup(
+      createElement(RelationshipGraphPanel, {
+        ...baseProps,
+        graphMode: "full",
+        centerNpcId: "npc-1",
+      }),
+    );
+    expect(html).toContain('data-testid="relationship-graph-mode-full"');
+    expect(html).toContain("以某人为中心");
+  });
+
+  it("shows loading and error testids", () => {
+    const loadingHtml = renderToStaticMarkup(
+      createElement(RelationshipGraphPanel, { ...baseProps, loading: true, edges: [] }),
+    );
+    expect(loadingHtml).toContain('data-testid="relationship-graph-loading"');
+    expect(loadingHtml).toContain("载入中");
+
+    const errorHtml = renderToStaticMarkup(
+      createElement(RelationshipGraphPanel, {
+        ...baseProps,
+        error: "关系网暂时无法载入。请稍后重试，或确认已连上房间。",
+        edges: [],
+      }),
+    );
+    expect(errorHtml).toContain('data-testid="relationship-graph-error"');
+  });
+});
diff --git a/apps/web/src/components/RelationshipGraphPanel.tsx b/apps/web/src/components/RelationshipGraphPanel.tsx
new file mode 100644
index 0000000..393d44b
--- /dev/null
+++ b/apps/web/src/components/RelationshipGraphPanel.tsx
@@ -0,0 +1,344 @@
+import {
+  COUNCIL_NPC_IDS,
+  getPersona,
+  type RelationshipBand,
+} from "@aetherlife/shared";
+import type { RelationshipRenderEdge } from "../hooks/useNpcRelationships.js";
+
+export type RelationshipGraphMode = "ego" | "full";
+
+type Props = {
+  edges: RelationshipRenderEdge[];
+  loading: boolean;
+  error: string | null;
+  activeNpcId: string;
+  lastRosterNpcId: string;
+  graphMode: RelationshipGraphMode;
+  centerNpcId: string;
+  onModeChange: (mode: RelationshipGraphMode) => void;
+  onCenterChange: (npcId: string) => void;
+  staleHint?: boolean;
+};
+
+const VIEW_SIZE = 320;
+const CENTER = VIEW_SIZE / 2;
+const EGO_RING = 96;
+const FULL_RING = 128;
+
+/** D-DRAWER-03: default graph center priority. */
+export function resolveDefaultCenterNpcId(
+  activeNpcId: string | undefined,
+  lastRosterNpcId: string | undefined,
+): string {
+  if (activeNpcId && activeNpcId.length > 0) return activeNpcId;
+  if (lastRosterNpcId && lastRosterNpcId.length > 0) return lastRosterNpcId;
+  return "npc-1";
+}
+
+export function toggleRelationshipGraphMode(
+  mode: RelationshipGraphMode,
+): RelationshipGraphMode {
+  return mode === "ego" ? "full" : "ego";
+}
+
+export function relationshipGraphToggleCopy(mode: RelationshipGraphMode): string {
+  return mode === "ego" ? "查看全图" : "以某人为中心";
+}
+
+export function graphNodeLabel(displayName: string): string {
+  const trimmed = displayName.trim();
+  if (trimmed.length <= 4) return trimmed;
+  return `${trimmed.slice(0, 4)}…`;
+}
+
+export function relationshipBandStroke(band: RelationshipBand): {
+  color: string;
+  width: number;
+} {
+  switch (band) {
+    case "hostile":
+      return { color: "#b54a4a", width: 3 };
+    case "cool":
+      return { color: "#a89060", width: 2 };
+    case "neutral":
+      return { color: "var(--shell-muted, #7a6f5c)", width: 1 };
+    case "warm":
+      return { color: "#7a9a6e", width: 2 };
+    case "close":
+      return { color: "var(--shell-accent, #c9a227)", width: 3 };
+  }
+}
+
+function seatIndex(npcId: string): number {
+  const idx = (COUNCIL_NPC_IDS as readonly string[]).indexOf(npcId);
+  return idx >= 0 ? idx : 0;
+}
+
+function polarPosition(
+  index: number,
+  total: number,
+  cx: number,
+  cy: number,
+  radius: number,
+): { x: number; y: number } {
+  const angle = (index / total) * Math.PI * 2 - Math.PI / 2;
+  return {
+    x: cx + radius * Math.cos(angle),
+    y: cy + radius * Math.sin(angle),
+  };
+}
+
+function findEdge(
+  edges: RelationshipRenderEdge[],
+  a: string,
+  b: string,
+): RelationshipRenderEdge | undefined {
+  return edges.find(
+    (edge) =>
+      (edge.npcAId === a && edge.npcBId === b) ||
+      (edge.npcAId === b && edge.npcBId === a),
+  );
+}
+
+function neighborsOf(centerId: string, edges: RelationshipRenderEdge[]): string[] {
+  const ids = new Set<string>();
+  for (const edge of edges) {
+    if (edge.npcAId === centerId) ids.add(edge.npcBId);
+    if (edge.npcBId === centerId) ids.add(edge.npcAId);
+  }
+  return [...ids].sort(
+    (a, b) => seatIndex(a) - seatIndex(b),
+  );
+}
+
+type NodeLayout = {
+  npcId: string;
+  x: number;
+  y: number;
+  isCenter?: boolean;
+};
+
+function layoutNodes(
+  mode: RelationshipGraphMode,
+  centerNpcId: string,
+  edges: RelationshipRenderEdge[],
+): NodeLayout[] {
+  if (mode === "full") {
+    return COUNCIL_NPC_IDS.map((npcId, index) => ({
+      npcId,
+      ...polarPosition(index, COUNCIL_NPC_IDS.length, CENTER, CENTER, FULL_RING),
+      isCenter: npcId === centerNpcId,
+    }));
+  }
+
+  const neighborIds = neighborsOf(centerNpcId, edges);
+  const nodes: NodeLayout[] = [
+    { npcId: centerNpcId, x: CENTER, y: CENTER, isCenter: true },
+  ];
+  neighborIds.forEach((npcId, index) => {
+    nodes.push({
+      npcId,
+      ...polarPosition(index, Math.max(neighborIds.length, 1), CENTER, CENTER, EGO_RING),
+    });
+  });
+  return nodes;
+}
+
+function edgesToDraw(
+  mode: RelationshipGraphMode,
+  centerNpcId: string,
+  edges: RelationshipRenderEdge[],
+): RelationshipRenderEdge[] {
+  if (mode === "full") return edges;
+  return edges.filter(
+    (edge) => edge.npcAId === centerNpcId || edge.npcBId === centerNpcId,
+  );
+}
+
+export function RelationshipGraphPanel({
+  edges,
+  loading,
+  error,
+  graphMode,
+  centerNpcId,
+  onModeChange,
+  onCenterChange,
+  staleHint = false,
+}: Props) {
+  const centerName = getPersona(centerNpcId).displayName;
+  const nodes = layoutNodes(graphMode, centerNpcId, edges);
+  const nodeById = Object.fromEntries(nodes.map((node) => [node.npcId, node]));
+  const visibleEdges = edgesToDraw(graphMode, centerNpcId, edges);
+  const showEmpty = !loading && !error && edges.length === 0;
+
+  return (
+    <div
+      className="relationship-graph-panel"
+      data-testid="relationship-graph-panel"
+    >
+      <header className="relationship-graph-panel__header">
+        <h3 className="relationship-graph-panel__title">关系网</h3>
+        {graphMode === "ego" ? (
+          <p className="relationship-graph-panel__subtitle">
+            以「{centerName}」为中心
+          </p>
+        ) : null}
+      </header>
+
+      <div className="relationship-graph-panel__toolbar">
+        <button
+          type="button"
+          className={`relationship-graph-panel__mode-toggle${
+            graphMode === "full"
+              ? " relationship-graph-panel__mode-toggle--active"
+              : ""
+          }`}
+          data-testid="relationship-graph-mode-toggle"
+          onClick={() => onModeChange(toggleRelationshipGraphMode(graphMode))}
+        >
+          {relationshipGraphToggleCopy(graphMode)}
+        </button>
+        {staleHint ? (
+          <p className="relationship-graph-panel__stale-hint">关系有更新</p>
+        ) : null}
+      </div>
+
+      {loading ? (
+        <p
+          className="relationship-graph-panel__loading"
+          data-testid="relationship-graph-loading"
+        >
+          载入中…
+        </p>
+      ) : null}
+
+      {error ? (
+        <p
+          className="relationship-graph-panel__error"
+          data-testid="relationship-graph-error"
+          role="alert"
+        >
+          {error}
+        </p>
+      ) : null}
+
+      {showEmpty ? (
+        <div className="relationship-graph-panel__empty">
+          <h4 className="relationship-graph-panel__empty-title">尚无关系网</h4>
+          <p className="relationship-graph-panel__empty-body">
+            加入房间并等待议员落位后，打开此页可查看档位关系。
+          </p>
+        </div>
+      ) : null}
+
+      {!loading && !error && edges.length > 0 ? (
+        <div
+          className="relationship-graph-panel__canvas-wrap"
+          data-testid={
+            graphMode === "full" ? "relationship-graph-mode-full" : undefined
+          }
+        >
+          <svg
+            className="relationship-graph-panel__svg"
+            viewBox={`0 0 ${VIEW_SIZE} ${VIEW_SIZE}`}
+            role="img"
+            aria-label="议员关系简图"
+          >
+            {visibleEdges.map((edge) => {
+              const a = nodeById[edge.npcAId];
+              const b = nodeById[edge.npcBId];
+              if (!a || !b) return null;
+              const stroke = relationshipBandStroke(edge.band);
+              return (
+                <line
+                  key={`${edge.npcAId}:${edge.npcBId}`}
+                  x1={a.x}
+                  y1={a.y}
+                  x2={b.x}
+                  y2={b.y}
+                  stroke={stroke.color}
+                  strokeWidth={stroke.width}
+                  className="relationship-graph-panel__edge"
+                />
+              );
+            })}
+            {nodes.map((node) => {
+              const persona = getPersona(node.npcId);
+              const label = graphNodeLabel(persona.displayName);
+              const connectedEdge =
+                graphMode === "ego" && !node.isCenter
+                  ? findEdge(edges, centerNpcId, node.npcId)
+                  : undefined;
+              const bandLabel = connectedEdge?.bandLabelZh ?? "";
+              return (
+                <g key={node.npcId} className="relationship-graph-panel__node-group">
+                  <circle
+                    cx={node.x}
+                    cy={node.y}
+                    r={16}
+                    className={`relationship-graph-panel__node${
+                      node.isCenter
+                        ? " relationship-graph-panel__node--center"
+                        : ""
+                    }`}
+                  />
+                  <foreignObject
+                    x={node.x - 16}
+                    y={node.y - 16}
+                    width={32}
+                    height={32}
+                  >
+                    <button
+                      type="button"
+                      className="relationship-graph-panel__node-btn"
+                      aria-label={`${persona.displayName}${bandLabel ? `，${bandLabel}` : ""}`}
+                      onClick={() => {
+                        if (graphMode === "ego") {
+                          onCenterChange(node.npcId);
+                        }
+                      }}
+                    >
+                      <span className="relationship-graph-panel__node-label">{label}</span>
+                    </button>
+                  </foreignObject>
+                </g>
+              );
+            })}
+          </svg>
+
+          <ul className="relationship-graph-panel__edge-list" aria-label="关系档位">
+            {visibleEdges.map((edge) => (
+              <li
+                key={`chip:${edge.npcAId}:${edge.npcBId}`}
+                className="relationship-graph-panel__edge-row"
+              >
+                <span className="relationship-graph-panel__edge-names">
+                  {getPersona(edge.npcAId).displayName} —{" "}
+                  {getPersona(edge.npcBId).displayName}
+                </span>
+                <span
+                  className={`relationship-graph-panel__band-chip relationship-graph-panel__band-chip--${edge.band}`}
+                  data-testid="relationship-graph-band-chip"
+                  data-band={edge.band}
+                >
+                  {edge.bandLabelZh}
+                </span>
+                <span className="relationship-graph-panel__kind-label">
+                  {edge.kindLabelZh}
+                </span>
+                {edge.currentStatus.slice(0, 2).map((status) => (
+                  <span
+                    key={status}
+                    className="relationship-graph-panel__status-chip"
+                  >
+                    {status}
+                  </span>
+                ))}
+              </li>
+            ))}
+          </ul>
+        </div>
+      ) : null}
+    </div>
+  );
+}
diff --git a/apps/web/src/components/ShellDrawer.test.ts b/apps/web/src/components/ShellDrawer.test.ts
index 9b0a7b0..500ccef 100644
--- a/apps/web/src/components/ShellDrawer.test.ts
+++ b/apps/web/src/components/ShellDrawer.test.ts
@@ -37,8 +37,20 @@ describe("NpcAvatarStrip a11y", () => {
   });
 });
 
+const shellDrawerRelationshipProps = {
+  relationshipEdges: [] as import("../hooks/useNpcRelationships.js").RelationshipRenderEdge[],
+  relationshipLoading: false,
+  relationshipError: null as string | null,
+  relationshipHasUpdate: false,
+  relationshipCenterNpcId: "npc-1",
+  onRelationshipCenterChange: () => {},
+  relationshipGraphMode: "ego" as const,
+  onRelationshipGraphModeChange: () => {},
+  lastRosterNpcId: "npc-1",
+};
+
 describe("ShellDrawer a11y", () => {
-  it("places chronicle tab immediately after council tab", () => {
+  it("D-DRAWER-02: places 关系网 tab immediately after council tab", () => {
     const html = renderToStaticMarkup(
       createElement(ShellDrawer, {
         open: true,
@@ -53,15 +65,20 @@ describe("ShellDrawer a11y", () => {
         collectiveLoading: false,
         discoveredLoreRows: [],
         ...shellDrawerWorldHistoryProps,
+        ...shellDrawerRelationshipProps,
         roomId: "room-1",
         roomConnected: true,
       }),
     );
-    const tabIds = [...html.matchAll(/id="(shell-drawer-tab-[^"]+)"/g)].map((m) => m[1]);
+    const tabIds = [...html.matchAll(/\bid="(shell-drawer-tab-[^"]+)"/g)].map((m) => m[1]);
     const councilPos = tabIds.indexOf("shell-drawer-tab-council");
+    const relationshipsPos = tabIds.indexOf("shell-drawer-tab-relationships");
     const chroniclePos = tabIds.indexOf("shell-drawer-tab-chronicle");
     expect(councilPos).toBeGreaterThanOrEqual(0);
-    expect(chroniclePos).toBe(councilPos + 1);
+    expect(relationshipsPos).toBe(councilPos + 1);
+    expect(chroniclePos).toBe(relationshipsPos + 1);
+    expect(html).toContain('data-testid="shell-drawer-tab-relationships"');
+    expect(html).toContain("关系网");
   });
 
   it("wires drawer tabs to shell-drawer-panel ids", () => {
@@ -79,6 +96,7 @@ describe("ShellDrawer a11y", () => {
         collectiveLoading: false,
         discoveredLoreRows: [],
         ...shellDrawerWorldHistoryProps,
+        ...shellDrawerRelationshipProps,
         roomId: "room-1",
         roomConnected: true,
       }),
@@ -110,6 +128,7 @@ describe("ShellDrawer a11y", () => {
         collectiveLoading: false,
         discoveredLoreRows: [],
         ...shellDrawerWorldHistoryProps,
+        ...shellDrawerRelationshipProps,
         roomId: "room-1",
         roomConnected: true,
       }),
@@ -157,6 +176,7 @@ describe("ShellDrawer a11y", () => {
           },
         ],
         worldHistoryLoading: false,
+        ...shellDrawerRelationshipProps,
         roomId: "room-1",
         roomConnected: true,
       }),
diff --git a/apps/web/src/components/ShellDrawer.tsx b/apps/web/src/components/ShellDrawer.tsx
index 860776b..0dc6ba4 100644
--- a/apps/web/src/components/ShellDrawer.tsx
+++ b/apps/web/src/components/ShellDrawer.tsx
@@ -6,7 +6,9 @@ import { CouncilRosterPanel } from "./CouncilRosterPanel.js";
 import { DiscoveredLorePanel } from "./DiscoveredLorePanel.js";
 import { MessageList } from "./MessageList.js";
 import { NpcMemoryPanel } from "./NpcMemoryPanel.js";
+import { RelationshipGraphPanel, type RelationshipGraphMode } from "./RelationshipGraphPanel.js";
 import type { DrawerTab } from "./DialogueBar.js";
+import type { RelationshipRenderEdge } from "../hooks/useNpcRelationships.js";
 import type { DiscoveredLoreRow } from "../hooks/useChunkLore.js";
 import type {
   CouncilDeliberationFeedRow,
@@ -63,6 +65,16 @@ type Props = {
   personalTimelineLoadingNpcId?: string | null;
   personalTimelineErrorByNpcId?: Record<string, string>;
   onOpenPersonalBiography?: (npcId: string) => void;
+  relationshipEdges?: RelationshipRenderEdge[];
+  relationshipLoading?: boolean;
+  relationshipError?: string | null;
+  relationshipHasUpdate?: boolean;
+  relationshipCenterNpcId?: string;
+  onRelationshipCenterChange?: (npcId: string) => void;
+  relationshipGraphMode?: RelationshipGraphMode;
+  onRelationshipGraphModeChange?: (mode: RelationshipGraphMode) => void;
+  lastRosterNpcId?: string;
+  relationshipStaleHint?: boolean;
   roomId: string;
   roomConnected: boolean;
   lastParsedIntent?: ParsedIntent;
@@ -73,6 +85,7 @@ const TABS: { id: DrawerTab; label: string }[] = [
   { id: "history", label: "对话历史" },
   { id: "collective", label: "集体见闻" },
   { id: "council", label: "星际议会" },
+  { id: "relationships", label: "关系网" },
   { id: "chronicle", label: "编年史" },
   { id: "discoveries", label: "已发现" },
   { id: "memory", label: "记忆" },
@@ -158,6 +171,16 @@ export function ShellDrawer({
   personalTimelineLoadingNpcId = null,
   personalTimelineErrorByNpcId = {},
   onOpenPersonalBiography,
+  relationshipEdges = [],
+  relationshipLoading = false,
+  relationshipError = null,
+  relationshipHasUpdate = false,
+  relationshipCenterNpcId = "npc-1",
+  onRelationshipCenterChange = () => {},
+  relationshipGraphMode = "ego",
+  onRelationshipGraphModeChange = () => {},
+  lastRosterNpcId = "npc-1",
+  relationshipStaleHint = false,
   roomId,
   roomConnected,
   lastParsedIntent = null,
@@ -192,6 +215,7 @@ export function ShellDrawer({
                 aria-controls={drawerPanelId(item.id)}
                 tabIndex={tab === item.id ? 0 : -1}
                 className={`shell-drawer__tab${tab === item.id ? " shell-drawer__tab--active" : ""}`}
+                data-testid={drawerTabId(item.id)}
                 onClick={() => onTabChange(item.id)}
                 onKeyDown={(event) => handleDrawerTabKeyDown(event, index, onTabChange)}
               >
@@ -203,6 +227,15 @@ export function ShellDrawer({
                     aria-label="编年史有新条目"
                   />
                 ) : null}
+                {item.id === "relationships" &&
+                relationshipHasUpdate &&
+                tab !== "relationships" ? (
+                  <span
+                    className="shell-drawer__tab-badge"
+                    data-testid="shell-drawer-tab-relationships-unread"
+                    aria-label="关系网有更新"
+                  />
+                ) : null}
               </button>
             ))}
           </div>
@@ -264,6 +297,21 @@ export function ShellDrawer({
             </div>
           ) : null}
 
+          {tab === "relationships" ? (
+            <RelationshipGraphPanel
+              edges={relationshipEdges}
+              loading={relationshipLoading}
+              error={relationshipError}
+              activeNpcId={activeNpcId}
+              lastRosterNpcId={lastRosterNpcId}
+              graphMode={relationshipGraphMode}
+              centerNpcId={relationshipCenterNpcId}
+              onModeChange={onRelationshipGraphModeChange}
+              onCenterChange={onRelationshipCenterChange}
+              staleHint={relationshipStaleHint}
+            />
+          ) : null}
+
           {tab === "chronicle" ? (
             <WorldHistoryPanel
               entries={worldHistoryEntries}
diff --git a/apps/web/src/game/HomeMapBackground.ts b/apps/web/src/game/HomeMapBackground.ts
index 703fb6c..b405e9c 100644
--- a/apps/web/src/game/HomeMapBackground.ts
+++ b/apps/web/src/game/HomeMapBackground.ts
@@ -4,6 +4,7 @@ import { ASSET_KEYS, TILE_PX } from "./assetManifest.js";
 import {
   MAP_TILE_DEPTH_BASE,
   MAP_TILE_DEPTH_STEP,
+  clusterSouthSortWorldY,
   tiledObjectYSortDepth,
   YSORT_LAYER,
 } from "./entityLayout.js";
@@ -17,6 +18,19 @@ const TILE_SCALE = CELL_PX / TILE_PX;
 /** Editor-only layer — hidden in Tiled, not shown in game. */
 const SKIP_LAYER_NAMES = new Set(["RockSlopes", "Collision"]);
 
+/**
+ * Atlas props authored as adjacent tile objects that must Y-sort as one volume
+ * (south edge). Do not add collection-of-images props here.
+ */
+const VOLUME_CLUSTER_TILESETS = new Set(["Campfire"]);
+
+type PendingObjectYSort = {
+  sprite: Phaser.GameObjects.Sprite;
+  bottomWorldX: number;
+  bottomWorldY: number;
+  tilesetName: string;
+};
+
 type TiledLayerMeta = {
   name: string;
   type: string;
@@ -74,6 +88,42 @@ function resolveGidTexture(
   return null;
 }
 
+function tilesetNameForGid(tilesets: TiledTilesetDef[], gid: number): string | null {
+  const cleanGid = stripGidFlags(gid);
+  const sorted = [...tilesets].sort((a, b) => b.firstgid - a.firstgid);
+  return sorted.find((ts) => cleanGid >= ts.firstgid)?.name ?? null;
+}
+
+/** Apply per-object Y-sort; Campfire (etc.) clusters share southernmost bottom Y. */
+function applyObjectLayerYSortDepths(pending: PendingObjectYSort[]): void {
+  const volume: PendingObjectYSort[] = [];
+  const normal: PendingObjectYSort[] = [];
+  for (const item of pending) {
+    if (VOLUME_CLUSTER_TILESETS.has(item.tilesetName)) volume.push(item);
+    else normal.push(item);
+  }
+
+  for (const item of normal) {
+    item.sprite.setDepth(
+      tiledObjectYSortDepth(item.bottomWorldX, item.bottomWorldY, YSORT_LAYER.OBJECT),
+    );
+  }
+
+  if (volume.length === 0) return;
+  const sortYs = clusterSouthSortWorldY(
+    volume.map((item) => ({
+      bottomWorldX: item.bottomWorldX,
+      bottomWorldY: item.bottomWorldY,
+    })),
+  );
+  for (let i = 0; i < volume.length; i += 1) {
+    const item = volume[i]!;
+    item.sprite.setDepth(
+      tiledObjectYSortDepth(item.bottomWorldX, sortYs[i]!, YSORT_LAYER.OBJECT),
+    );
+  }
+}
+
 /** Tiled tile objects anchor bottom-left at (x, y); match Phaser createFromObjects semantics. */
 function placeTiledTileObject(
   sprite: Phaser.GameObjects.Sprite,
@@ -244,6 +294,7 @@ export class HomeMapBackground {
             : rawLayer.objects;
 
         let shadowIndex = 0;
+        const pendingYSort: PendingObjectYSort[] = [];
         for (const rawObj of sortedObjects) {
           if (!rawObj.gid) continue;
 
@@ -262,11 +313,12 @@ export class HomeMapBackground {
             if (meta.opacity !== undefined && meta.opacity < 1) {
               sprite.setAlpha(meta.opacity);
             }
-            const bottomWorldX = (rawObj.x ?? 0) * TILE_SCALE;
-            const bottomWorldY = (rawObj.y ?? 0) * TILE_SCALE;
-            sprite.setDepth(
-              tiledObjectYSortDepth(bottomWorldX, bottomWorldY, YSORT_LAYER.OBJECT),
-            );
+            pendingYSort.push({
+              sprite,
+              bottomWorldX: (rawObj.x ?? 0) * TILE_SCALE,
+              bottomWorldY: (rawObj.y ?? 0) * TILE_SCALE,
+              tilesetName: tilesetNameForGid(bakedTilesets, rawObj.gid) ?? "",
+            });
             this.layers.push(sprite);
           }
 
@@ -274,6 +326,9 @@ export class HomeMapBackground {
             applyObjectTileAnimation(scene, sprite, rawObj.gid);
           }
         }
+        if (!isShadowLayer) {
+          applyObjectLayerYSortDepths(pendingYSort);
+        }
       }
     }
 
diff --git a/apps/web/src/game/MutualChatBubble.test.ts b/apps/web/src/game/MutualChatBubble.test.ts
new file mode 100644
index 0000000..b7b03b7
--- /dev/null
+++ b/apps/web/src/game/MutualChatBubble.test.ts
@@ -0,0 +1,12 @@
+import { describe, expect, it } from "vitest";
+import {
+  MUTUAL_BUBBLE_MAX_CHARS,
+  truncateMutualBubbleText,
+} from "./MutualChatBubbleLogic.js";
+
+describe("MutualChatBubbleLogic", () => {
+  it("truncates and strips control characters", () => {
+    expect(truncateMutualBubbleText("  hi\x00there  ")).toBe("hithere");
+    expect(truncateMutualBubbleText("a".repeat(25)).length).toBe(MUTUAL_BUBBLE_MAX_CHARS);
+  });
+});
diff --git a/apps/web/src/game/MutualChatBubble.ts b/apps/web/src/game/MutualChatBubble.ts
new file mode 100644
index 0000000..9050013
--- /dev/null
+++ b/apps/web/src/game/MutualChatBubble.ts
@@ -0,0 +1,208 @@
+import type * as Phaser from "phaser";
+import {
+  applySceneHanLabelBase,
+  SCENE_LABEL_FONT_SANS,
+} from "./entityLabels.js";
+import { labelPx, LABEL_MIN_ACTIVITY_PX, LABEL_SCALE } from "./entityLayout.js";
+import { nameLabelY } from "./sceneLabelLayout.js";
+import type { SpriteProfile } from "./entitySprites.js";
+import {
+  MUTUAL_BUBBLE_FADE_MS,
+  MUTUAL_BUBBLE_HOLD_MS,
+  MUTUAL_BUBBLE_MAX_CHARS,
+  MUTUAL_BUBBLE_REDUCED_HIDE_MS,
+  shouldShowMutualChatBubble,
+  truncateMutualBubbleText,
+} from "./MutualChatBubbleLogic.js";
+
+export {
+  MUTUAL_BUBBLE_FADE_MS,
+  MUTUAL_BUBBLE_HOLD_MS,
+  MUTUAL_BUBBLE_MAX_CHARS,
+  MUTUAL_BUBBLE_REDUCED_HIDE_MS,
+  shouldShowMutualChatBubble,
+  truncateMutualBubbleText,
+} from "./MutualChatBubbleLogic.js";
+
+export const MUTUAL_BUBBLE_FONT_SIZE_PX = Math.max(
+  LABEL_MIN_ACTIVITY_PX,
+  Math.round(12 * LABEL_SCALE),
+);
+export const MUTUAL_BUBBLE_FONT_SIZE = labelPx(12, LABEL_MIN_ACTIVITY_PX);
+/** Match activity-label contrast (separate Text object — not frozen nameplate). */
+export const MUTUAL_BUBBLE_COLOR = "#e6e8dc";
+export const MUTUAL_BUBBLE_MAX_WIDTH_PX = Math.round(160 * LABEL_SCALE);
+
+export type MutualChatBubblePayload = {
+  npcId: string;
+  peerNpcId: string;
+  text: string;
+  expiresAt: number;
+};
+
+export type MutualChatBubbleHost = {
+  mutualChatBubble?: Phaser.GameObjects.Text;
+  mutualChatBubbleTween?: Phaser.Tweens.Tween;
+  mutualChatBubbleHideTimer?: Phaser.Time.TimerEvent;
+  mutualChatBubbleUntil?: number;
+  mutualChatBubbleWantShow?: boolean;
+  gridX: number;
+  gridY: number;
+  npcId?: string;
+  spriteMode?: boolean;
+  spriteProfile?: SpriteProfile;
+};
+
+export function mutualChatBubbleY(
+  spriteMode: boolean | undefined,
+  profile?: SpriteProfile,
+): number {
+  // Above nameplate baseline (Text origin 0.5,1).
+  return nameLabelY(spriteMode, profile) - MUTUAL_BUBBLE_FONT_SIZE_PX - 2;
+}
+
+export function createMutualChatBubble(
+  scene: Phaser.Scene,
+  npcId: string,
+): Phaser.GameObjects.Text {
+  const label = scene.add.text(0, 0, "", {
+    fontSize: MUTUAL_BUBBLE_FONT_SIZE,
+    fontFamily: SCENE_LABEL_FONT_SANS,
+    fontStyle: "normal",
+    color: MUTUAL_BUBBLE_COLOR,
+    align: "center",
+    wordWrap: { width: MUTUAL_BUBBLE_MAX_WIDTH_PX, useAdvancedWrap: true },
+  });
+  applySceneHanLabelBase(label);
+  label.setFontFamily(SCENE_LABEL_FONT_SANS);
+  label.setOrigin(0.5, 1);
+  label.setScrollFactor(1);
+  label.setAlpha(0);
+  label.setVisible(false);
+  label.name = `npc-mutual-bubble-${npcId}`;
+  label.setData("testid", `npc-mutual-bubble-${npcId}`);
+  return label;
+}
+
+function clearBubbleTimers(host: MutualChatBubbleHost): void {
+  host.mutualChatBubbleTween?.stop();
+  host.mutualChatBubbleTween = undefined;
+  host.mutualChatBubbleHideTimer?.remove(false);
+  host.mutualChatBubbleHideTimer = undefined;
+}
+
+function snapHidden(host: MutualChatBubbleHost): void {
+  const bubble = host.mutualChatBubble;
+  if (!bubble) return;
+  bubble.setAlpha(0);
+  bubble.setVisible(false);
+  bubble.setText("");
+  host.mutualChatBubbleUntil = undefined;
+  host.mutualChatBubbleWantShow = false;
+}
+
+/**
+ * Show a one-shot mutual-chat line on an NPC Text bubble.
+ * Hold 3–5s then fade; reduced-motion → hard-hide ~4s (UI-SPEC).
+ */
+export function showMutualChatBubble(
+  scene: Phaser.Scene,
+  host: MutualChatBubbleHost,
+  text: string,
+  opts: { reducedMotion: boolean; expiresAt?: number; nowMs?: number } = {
+    reducedMotion: false,
+  },
+): void {
+  const bubble = host.mutualChatBubble;
+  if (!bubble) return;
+
+  const copy = truncateMutualBubbleText(text);
+  if (!copy) {
+    hideMutualChatBubble(scene, host);
+    return;
+  }
+
+  const now = opts.nowMs ?? Date.now();
+  const holdMs = opts.reducedMotion ? MUTUAL_BUBBLE_REDUCED_HIDE_MS : MUTUAL_BUBBLE_HOLD_MS;
+  const untilFromTtl =
+    opts.expiresAt != null && opts.expiresAt > now ? opts.expiresAt : now + holdMs;
+  const until = Math.min(
+    untilFromTtl,
+    now + (opts.reducedMotion ? MUTUAL_BUBBLE_REDUCED_HIDE_MS : 5000),
+  );
+
+  clearBubbleTimers(host);
+  bubble.setText(copy);
+  bubble.y = mutualChatBubbleY(host.spriteMode === true, host.spriteProfile);
+  bubble.setVisible(true);
+  bubble.setAlpha(1);
+  host.mutualChatBubbleUntil = until;
+  host.mutualChatBubbleWantShow = true;
+
+  const delay = Math.max(0, until - now);
+  if (opts.reducedMotion) {
+    host.mutualChatBubbleHideTimer = scene.time.delayedCall(delay, () => {
+      snapHidden(host);
+      host.mutualChatBubbleHideTimer = undefined;
+    });
+    return;
+  }
+
+  host.mutualChatBubbleHideTimer = scene.time.delayedCall(delay, () => {
+    host.mutualChatBubbleHideTimer = undefined;
+    host.mutualChatBubbleTween?.stop();
+    host.mutualChatBubbleTween = scene.tweens.add({
+      targets: bubble,
+      alpha: 0,
+      duration: MUTUAL_BUBBLE_FADE_MS,
+      ease: "Cubic.easeIn",
+      onComplete: () => {
+        snapHidden(host);
+        host.mutualChatBubbleTween = undefined;
+      },
+    });
+  });
+}
+
+export function hideMutualChatBubble(
+  _scene: Phaser.Scene,
+  host: MutualChatBubbleHost,
+): void {
+  clearBubbleTimers(host);
+  snapHidden(host);
+}
+
+/**
+ * Apply proximity gate while a bubble is live (walk out → hide; walk in before expiry → show).
+ */
+export function updateMutualChatBubbleVisibility(
+  host: MutualChatBubbleHost,
+  localCell: { x: number; y: number } | null,
+  nowMs = Date.now(),
+): void {
+  const bubble = host.mutualChatBubble;
+  if (!bubble || host.mutualChatBubbleUntil == null) return;
+
+  if (nowMs >= host.mutualChatBubbleUntil) {
+    return;
+  }
+
+  const inRange =
+    localCell != null
+    && shouldShowMutualChatBubble(host.gridX, host.gridY, localCell.x, localCell.y);
+
+  if (!inRange) {
+    if (bubble.visible && bubble.alpha > 0) {
+      bubble.setAlpha(0);
+      bubble.setVisible(false);
+    }
+    host.mutualChatBubbleWantShow = false;
+    return;
+  }
+
+  if (!bubble.visible || bubble.alpha < 0.95) {
+    bubble.setVisible(true);
+    bubble.setAlpha(1);
+  }
+  host.mutualChatBubbleWantShow = true;
+}
diff --git a/apps/web/src/game/MutualChatBubbleLogic.ts b/apps/web/src/game/MutualChatBubbleLogic.ts
new file mode 100644
index 0000000..e338ebf
--- /dev/null
+++ b/apps/web/src/game/MutualChatBubbleLogic.ts
@@ -0,0 +1,29 @@
+/** Pure mutual-chat bubble helpers (no Phaser) — D-MUTUAL-02. */
+
+export const MUTUAL_BUBBLE_MAX_CHARS = 20;
+export const MUTUAL_BUBBLE_HOLD_MS = 3500;
+export const MUTUAL_BUBBLE_FADE_MS = 400;
+export const MUTUAL_BUBBLE_REDUCED_HIDE_MS = 4000;
+
+const PROXIMITY_CELLS = 2;
+const CONTROL_CHARS = /[\x00-\x1f\x7f]/g;
+
+export function truncateMutualBubbleText(text: string): string {
+  const cleaned = String(text ?? "").replace(CONTROL_CHARS, "").trim();
+  if (cleaned.length <= MUTUAL_BUBBLE_MAX_CHARS) return cleaned;
+  return cleaned.slice(0, MUTUAL_BUBBLE_MAX_CHARS);
+}
+
+function chebyshevDistance(ax: number, ay: number, bx: number, by: number): number {
+  return Math.max(Math.abs(ax - bx), Math.abs(ay - by));
+}
+
+/** Player Chebyshev ≤2 — same proximity band as activity / nameplates. */
+export function shouldShowMutualChatBubble(
+  gx: number,
+  gy: number,
+  localGx: number,
+  localGy: number,
+): boolean {
+  return chebyshevDistance(gx, gy, localGx, localGy) <= PROXIMITY_CELLS;
+}
diff --git a/apps/web/src/game/RoomScene.ts b/apps/web/src/game/RoomScene.ts
index a54e75c..4640f1f 100644
--- a/apps/web/src/game/RoomScene.ts
+++ b/apps/web/src/game/RoomScene.ts
@@ -34,6 +34,14 @@ import {
   type ActivityTarget,
   type NpcAmbientUiState,
 } from "./activityLabels.js";
+import {
+  createMutualChatBubble,
+  hideMutualChatBubble,
+  mutualChatBubbleY,
+  showMutualChatBubble,
+  updateMutualChatBubbleVisibility,
+  type MutualChatBubbleHost,
+} from "./MutualChatBubble.js";
 import {
   createIntentLabel,
   intentLabelY,
@@ -153,6 +161,7 @@ export class RoomScene extends Phaser.Scene {
   private lastExploreGy = Number.NaN;
   private lastViewportTickMs = 0;
   private lastViewportNpcIdsKey = "";
+  private lastMutualChatBubbleSeq = -1;
   private collectiveDebugText: Phaser.GameObjects.Text | null = null;
   private preloadStartMs = 0;
   private readonly onLoadError = (): void => {
@@ -406,6 +415,7 @@ export class RoomScene extends Phaser.Scene {
     this.tickCollectiveDebug();
     this.refreshNameplates();
     this.refreshNpcAmbientLabels();
+    this.refreshMutualChatBubbles();
   }
 
   private useSpriteEntities(): boolean {
@@ -525,6 +535,75 @@ export class RoomScene extends Phaser.Scene {
     this.registry.set("npcIntentVisible", visibleIntentNpcIds);
   }
 
+  private refreshMutualChatBubbles(): void {
+    if (this.registry.get("uatHomesteadFrame") === true) return;
+
+    const payload = this.registry.get("mutualChatBubble") as
+      | {
+          npcId: string;
+          peerNpcId: string;
+          text: string;
+          expiresAt: number;
+          seq: number;
+        }
+      | null
+      | undefined;
+
+    // Ignore stale registry payloads (e.g. scene restart) — expired TTL must not re-show.
+    if (
+      payload &&
+      payload.seq !== this.lastMutualChatBubbleSeq &&
+      payload.expiresAt > Date.now()
+    ) {
+      this.lastMutualChatBubbleSeq = payload.seq;
+      this.presentMutualChatBubble(payload);
+    }
+
+    const sessionId = this.getSessionId();
+    if (!sessionId) return;
+    const logic = this.motionBridge?.getLogicGrid();
+    const self = this.playerSprites.get(sessionId);
+    const localCell = logic
+      ? { x: logic.x, y: logic.y }
+      : self
+        ? { x: self.gridX, y: self.gridY }
+        : null;
+
+    for (const ent of this.npcSprites.values()) {
+      if (!ent.npcId || !(ent as MutualChatBubbleHost).mutualChatBubble) continue;
+      updateMutualChatBubbleVisibility(ent as MutualChatBubbleHost, localCell);
+    }
+  }
+
+  private presentMutualChatBubble(payload: {
+    npcId: string;
+    peerNpcId: string;
+    text: string;
+    expiresAt: number;
+  }): void {
+    const reducedMotion = Boolean(this.registry.get("reducedMotion"));
+    const sessionId = this.getSessionId();
+    const logic = this.motionBridge?.getLogicGrid();
+    const self = sessionId ? this.playerSprites.get(sessionId) : undefined;
+    const localCell = logic
+      ? { x: logic.x, y: logic.y }
+      : self
+        ? { x: self.gridX, y: self.gridY }
+        : null;
+
+    const ent = [...this.npcSprites.values()].find((e) => e.npcId === payload.npcId);
+    if (!ent) return;
+    const host = ent as MutualChatBubbleHost;
+    if (!host.mutualChatBubble) {
+      this.attachNpcMutualChatBubble(ent);
+    }
+    showMutualChatBubble(this, host, payload.text, {
+      reducedMotion,
+      expiresAt: payload.expiresAt,
+    });
+    updateMutualChatBubbleVisibility(host, localCell);
+  }
+
   /** Explore HUD coords — game-loop tick (Wave 2); React reads registry `exploreGrid`. */
   private tickExploreGrid(): void {
     const connected = this.registry.get("connected") as boolean;
@@ -822,6 +901,7 @@ export class RoomScene extends Phaser.Scene {
     this.attachNpcActivityLabel(ent, isBg);
     if (!isBg) {
       this.attachNpcIntentLabel(ent);
+      this.attachNpcMutualChatBubble(ent);
     }
     if (!this.useSpriteEntities()) return ent;
 
@@ -832,6 +912,8 @@ export class RoomScene extends Phaser.Scene {
     ent.facingDir = "down";
     ent.activityLabel?.setY(activityLabelY(true, ent.spriteProfile));
     ent.intentLabel?.setY(intentLabelY(true, ent.spriteProfile));
+    const mutualHost = ent as MutualChatBubbleHost;
+    mutualHost.mutualChatBubble?.setY(mutualChatBubbleY(true, ent.spriteProfile));
     const avatar = createNpcSprite(this, npcId, isBg ? BG_NPC_TINT : undefined);
     const bubble = createSpeechBubble(this, ent.spriteProfile);
     ent.body.setVisible(false);
@@ -866,6 +948,16 @@ export class RoomScene extends Phaser.Scene {
     ent.activityLabel = activityLabel;
   }
 
+  private attachNpcMutualChatBubble(ent: EntitySprite): void {
+    if (!ent.npcId) return;
+    const host = ent as MutualChatBubbleHost;
+    if (host.mutualChatBubble) return;
+    const bubble = createMutualChatBubble(this, ent.npcId);
+    bubble.y = mutualChatBubbleY(ent.spriteMode === true, ent.spriteProfile);
+    ent.container.add(bubble);
+    host.mutualChatBubble = bubble;
+  }
+
   private attachNpcIntentLabel(ent: EntitySprite): void {
     if (!ent.npcId) return;
     const intentLabel = createIntentLabel(this, ent.npcId);
@@ -915,6 +1007,8 @@ export class RoomScene extends Phaser.Scene {
     ent.activityLabelTween = undefined;
     ent.intentLabelTween?.stop();
     ent.intentLabelTween = undefined;
+    // Helper also hides the bubble; manual timer removal alone left it stuck visible.
+    hideMutualChatBubble(this, ent as MutualChatBubbleHost);
     ent.moveTween?.stop();
     ent.moveTween = undefined;
     this.tweens.killTweensOf(ent.ring);
diff --git a/apps/web/src/game/entityLayout.test.ts b/apps/web/src/game/entityLayout.test.ts
index 7f038ac..ae4306a 100644
--- a/apps/web/src/game/entityLayout.test.ts
+++ b/apps/web/src/game/entityLayout.test.ts
@@ -6,6 +6,7 @@ import {
   entityYSortDepthFromCenter,
   MAP_TILE_DEPTH_BASE,
   MAP_TILE_DEPTH_STEP,
+  clusterSouthSortWorldY,
   tiledObjectYSortDepth,
   ySortDepth,
   YSORT_LAYER,
@@ -85,6 +86,35 @@ describe("tiledObjectYSortDepth", () => {
   });
 });
 
+describe("clusterSouthSortWorldY", () => {
+  it("raises northern Campfire tiles to the cluster south edge", () => {
+    // Real home Campfire bottoms (TILE_SCALE=2): y=480→960, y=496→992
+    const parts = [
+      { bottomWorldX: 512, bottomWorldY: 960 },
+      { bottomWorldX: 544, bottomWorldY: 960 },
+      { bottomWorldX: 512, bottomWorldY: 992 },
+      { bottomWorldX: 544, bottomWorldY: 992 },
+    ];
+    const sortYs = clusterSouthSortWorldY(parts);
+    expect(sortYs).toEqual([992, 992, 992, 992]);
+
+    const flameDepth = tiledObjectYSortDepth(512, sortYs[0]!, YSORT_LAYER.OBJECT);
+    // Player standing on north footprint (gy=29 → foot row 30) must stay behind flames.
+    expect(entityYSortDepth(16, 29, YSORT_LAYER.PLAYER)).toBeLessThan(flameDepth);
+  });
+
+  it("keeps separate volumes with different south edges independent", () => {
+    const parts = [
+      { bottomWorldX: 0, bottomWorldY: 100 },
+      { bottomWorldX: 0, bottomWorldY: 132 },
+      { bottomWorldX: 400, bottomWorldY: 200 },
+      { bottomWorldX: 400, bottomWorldY: 232 },
+    ];
+    const sortYs = clusterSouthSortWorldY(parts);
+    expect(sortYs).toEqual([132, 132, 232, 232]);
+  });
+});
+
 describe("MAP tile depth bands", () => {
   it("keeps tile + object-shadow bands below entity Y-sort", () => {
     const objectShadowBand = MAP_TILE_DEPTH_BASE + 4 * MAP_TILE_DEPTH_STEP;
diff --git a/apps/web/src/game/entityLayout.ts b/apps/web/src/game/entityLayout.ts
index e1e0782..88cafef 100644
--- a/apps/web/src/game/entityLayout.ts
+++ b/apps/web/src/game/entityLayout.ts
@@ -125,3 +125,51 @@ export function tiledObjectYSortDepth(
 ): number {
   return ySortDepth(bottomLeftWorldX, bottomLeftWorldY, layer);
 }
+
+/**
+ * Multi-tile volume props (e.g. Campfire 2×2): northern tiles must share the
+ * cluster's southernmost bottom Y, otherwise a player whose foot aligns with the
+ * north tile bottom (PLAYER layer +2) draws in front of the flames.
+ *
+ * Parts within `adjacencyWorldPx` Chebyshev distance form one cluster.
+ * Returns one sort-Y per input part (same order).
+ */
+export function clusterSouthSortWorldY(
+  parts: ReadonlyArray<{ bottomWorldX: number; bottomWorldY: number }>,
+  adjacencyWorldPx: number = CELL_PX,
+): number[] {
+  const n = parts.length;
+  if (n === 0) return [];
+
+  const parent = Array.from({ length: n }, (_, i) => i);
+  const find = (i: number): number => {
+    let x = i;
+    while (parent[x] !== x) {
+      parent[x] = parent[parent[x]!]!;
+      x = parent[x]!;
+    }
+    return x;
+  };
+  const union = (a: number, b: number): void => {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra !== rb) parent[ra] = rb;
+  };
+
+  for (let i = 0; i < n; i += 1) {
+    for (let j = i + 1; j < n; j += 1) {
+      const dx = Math.abs(parts[i]!.bottomWorldX - parts[j]!.bottomWorldX);
+      const dy = Math.abs(parts[i]!.bottomWorldY - parts[j]!.bottomWorldY);
+      if (dx <= adjacencyWorldPx && dy <= adjacencyWorldPx) union(i, j);
+    }
+  }
+
+  const maxYByRoot = new Map<number, number>();
+  for (let i = 0; i < n; i += 1) {
+    const root = find(i);
+    const y = parts[i]!.bottomWorldY;
+    maxYByRoot.set(root, Math.max(maxYByRoot.get(root) ?? y, y));
+  }
+
+  return parts.map((_, i) => maxYByRoot.get(find(i))!);
+}
diff --git a/apps/web/src/hooks/useColyseusRoom.mutualChatBubble.test.ts b/apps/web/src/hooks/useColyseusRoom.mutualChatBubble.test.ts
new file mode 100644
index 0000000..809e485
--- /dev/null
+++ b/apps/web/src/hooks/useColyseusRoom.mutualChatBubble.test.ts
@@ -0,0 +1,26 @@
+import { describe, expect, it } from "vitest";
+import { COLYSEUS_SERVER_MESSAGES } from "@aetherlife/shared";
+import {
+  MUTUAL_BUBBLE_MAX_CHARS,
+  shouldShowMutualChatBubble,
+  truncateMutualBubbleText,
+} from "../game/MutualChatBubbleLogic.js";
+
+describe("useColyseusRoom mutualChatBubble (D-MUTUAL-02)", () => {
+  it("uses one-shot Colyseus message constant (not schema)", () => {
+    expect(COLYSEUS_SERVER_MESSAGES.mutualChatBubble).toBe("mutualChatBubble");
+  });
+
+  it("clamps bubble text to ≤20 characters", () => {
+    const long = "一二三四五六七八九十abcdefghijklmnop";
+    const out = truncateMutualBubbleText(long);
+    expect(out.length).toBeLessThanOrEqual(MUTUAL_BUBBLE_MAX_CHARS);
+    expect(out).toBe(long.slice(0, MUTUAL_BUBBLE_MAX_CHARS));
+  });
+
+  it("gates visibility at Chebyshev ≤2", () => {
+    expect(shouldShowMutualChatBubble(5, 5, 5, 5)).toBe(true);
+    expect(shouldShowMutualChatBubble(5, 5, 7, 5)).toBe(true);
+    expect(shouldShowMutualChatBubble(5, 5, 8, 5)).toBe(false);
+  });
+});
diff --git a/apps/web/src/hooks/useColyseusRoom.ts b/apps/web/src/hooks/useColyseusRoom.ts
index ed6ec67..ef46b36 100644
--- a/apps/web/src/hooks/useColyseusRoom.ts
+++ b/apps/web/src/hooks/useColyseusRoom.ts
@@ -14,6 +14,7 @@ import {
   type ColyseusChunksSyncPayload,
   type ColyseusCouncilDeliberationSyncPayload,
   type ColyseusLoreSyncPayload,
+  type ColyseusMutualChatBubblePayload,
   type ColyseusPersonalTimelineSyncPayload,
   type ColyseusWorldHistorySyncPayload,
   type RoomState,
@@ -33,6 +34,9 @@ export type GameClockState = {
   label: string;
 };
 
+/** One-shot mutual-chat bubble + client seq so Phaser registry always sees a change. */
+export type MutualChatBubbleEvent = ColyseusMutualChatBubblePayload & { seq: number };
+
 function snapshotAmbientState(room: Room) {
   return snapshotAmbientStateFromSchema(room.state as Parameters<typeof snapshotAmbientStateFromSchema>[0]);
 }
@@ -169,6 +173,8 @@ export function useColyseusRoom(
   const [npcActivityById, setNpcActivityById] = useState<Record<string, string>>({});
   const [npcAmbientById, setNpcAmbientById] = useState<Record<string, NpcAmbientSnapshot>>({});
   const [roomNpcs, setRoomNpcs] = useState<CouncilNpcSnapshot[]>([]);
+  const [mutualChatBubble, setMutualChatBubble] = useState<MutualChatBubbleEvent | null>(null);
+  const mutualChatBubbleSeqRef = useRef(0);
   const {
     loreByChunk,
     mergeLoreSync,
@@ -244,6 +250,7 @@ export function useColyseusRoom(
     let offWorldHistorySync: (() => void) | undefined;
     let offCouncilDeliberationSync: (() => void) | undefined;
     let offPersonalTimelineSync: (() => void) | undefined;
+    let offMutualChatBubble: (() => void) | undefined;
     let onStateChangeHandler: (() => void) | undefined;
     let onLeaveHandler: ((code: number, reason?: string) => void) | undefined;
 
@@ -341,6 +348,21 @@ export function useColyseusRoom(
           mergePersonalTimelineSyncRef.current?.(data);
         },
       );
+      offMutualChatBubble = joined.onMessage(
+        COLYSEUS_SERVER_MESSAGES.mutualChatBubble,
+        (data: ColyseusMutualChatBubblePayload) => {
+          if (generation !== joinGeneration) return;
+          if (!data?.npcId || !data?.peerNpcId || typeof data.text !== "string") return;
+          mutualChatBubbleSeqRef.current += 1;
+          setMutualChatBubble({
+            npcId: data.npcId,
+            peerNpcId: data.peerNpcId,
+            text: data.text,
+            expiresAt: typeof data.expiresAt === "number" ? data.expiresAt : Date.now() + 4000,
+            seq: mutualChatBubbleSeqRef.current,
+          });
+        },
+      );
       joined.send(COLYSEUS_CLIENT_MESSAGES.requestChunksSync, {});
     };
 
@@ -408,6 +430,7 @@ export function useColyseusRoom(
       offWorldHistorySync?.();
       offCouncilDeliberationSync?.();
       offPersonalTimelineSync?.();
+      offMutualChatBubble?.();
       const leaving = activeRoom ?? roomRef.current;
       if (leaving) {
         if (onStateChangeHandler) {
@@ -428,6 +451,7 @@ export function useColyseusRoom(
       setNpcActivityById({});
       setNpcAmbientById({});
       setRoomNpcs([]);
+      setMutualChatBubble(null);
       setRoom(null);
       setConnected(false);
     };
@@ -473,5 +497,6 @@ export function useColyseusRoom(
     npcActivityById,
     npcAmbientById,
     roomNpcs,
+    mutualChatBubble,
   };
 }
diff --git a/apps/web/src/hooks/useCouncilDeliberation.test.ts b/apps/web/src/hooks/useCouncilDeliberation.test.ts
index 93a2aa9..7fc4590 100644
--- a/apps/web/src/hooks/useCouncilDeliberation.test.ts
+++ b/apps/web/src/hooks/useCouncilDeliberation.test.ts
@@ -3,6 +3,7 @@ import {
   applyPendingUiEvents,
   buildResultToast,
   IDLE_CORE,
+  mergeLinkedEdgesHint,
   reduceDeliberationSync,
   type DeliberationCoreState,
 } from "./useCouncilDeliberation.js";
@@ -143,6 +144,27 @@ describe("reduceDeliberationSync", () => {
   });
 });
 
+describe("mergeLinkedEdgesHint", () => {
+  it("unions by undirected pair without clearing unrelated prior hints", () => {
+    const prev = [
+      { npcAId: "npc-1", npcBId: "npc-2" },
+      { npcAId: "npc-3", npcBId: "npc-4" },
+    ];
+    const next = mergeLinkedEdgesHint(prev, [
+      { npcAId: "npc-2", npcBId: "npc-1" },
+      { npcAId: "npc-5", npcBId: "npc-6" },
+    ]);
+    expect(next).toEqual(
+      expect.arrayContaining([
+        { npcAId: "npc-1", npcBId: "npc-2" },
+        { npcAId: "npc-3", npcBId: "npc-4" },
+        { npcAId: "npc-5", npcBId: "npc-6" },
+      ]),
+    );
+    expect(next).toHaveLength(3);
+  });
+});
+
 describe("applyPendingUiEvents", () => {
   it("flushes deferred feed and toasts FIFO on speak idle", () => {
     const core: DeliberationCoreState = {
diff --git a/apps/web/src/hooks/useCouncilDeliberation.ts b/apps/web/src/hooks/useCouncilDeliberation.ts
index 7269971..8af4196 100644
--- a/apps/web/src/hooks/useCouncilDeliberation.ts
+++ b/apps/web/src/hooks/useCouncilDeliberation.ts
@@ -5,6 +5,7 @@ import {
   type CouncilDeliberationPublicState,
   type CouncilDeliberationVoteKind,
   type LinkedEdge,
+  normalizeEdgeIds,
   safeParseCouncilDeliberationSyncPayload,
 } from "@aetherlife/shared";
 
@@ -155,6 +156,42 @@ export function reduceDeliberationSync(
   return { core, deferred, immediateToasts, deliberationJustStarted };
 }
 
+/** Undirected pair key for linkedEdges union (D-MUTUAL-04). */
+export function linkedEdgePairKey(edge: LinkedEdge): string {
+  const { npcAId, npcBId } = normalizeEdgeIds(edge.npcAId, edge.npcBId);
+  return `${npcAId}|${npcBId}`;
+}
+
+/**
+ * Union incoming linkedEdges into prior roster hints by undirected pair.
+ * Does not clear unrelated prior hints (D-MUTUAL-04).
+ */
+export function mergeLinkedEdgesHint(
+  prev: LinkedEdge[],
+  incoming: LinkedEdge[],
+): LinkedEdge[] {
+  const byKey = new Map<string, LinkedEdge>();
+  for (const edge of prev) {
+    if (!edge?.npcAId || !edge?.npcBId || edge.npcAId === edge.npcBId) continue;
+    try {
+      const norm = normalizeEdgeIds(edge.npcAId, edge.npcBId);
+      byKey.set(linkedEdgePairKey(norm), norm);
+    } catch {
+      /* skip invalid */
+    }
+  }
+  for (const edge of incoming) {
+    if (!edge?.npcAId || !edge?.npcBId || edge.npcAId === edge.npcBId) continue;
+    try {
+      const norm = normalizeEdgeIds(edge.npcAId, edge.npcBId);
+      byKey.set(linkedEdgePairKey(norm), norm);
+    } catch {
+      /* skip invalid */
+    }
+  }
+  return [...byKey.values()];
+}
+
 export function applyPendingUiEvents(
   core: DeliberationCoreState,
   events: PendingUiEvent[],
@@ -228,6 +265,16 @@ export function useCouncilDeliberation(speakBusy = false) {
     });
   }, []);
 
+  const mergeLinkedEdgesHintPayload = useCallback((raw: unknown) => {
+    if (!raw || typeof raw !== "object") return;
+    const edges = (raw as { linkedEdges?: LinkedEdge[] }).linkedEdges;
+    if (!Array.isArray(edges) || edges.length === 0) return;
+    setCore((prev) => ({
+      ...prev,
+      linkedEdges: mergeLinkedEdgesHint(prev.linkedEdges, edges),
+    }));
+  }, []);
+
   useEffect(() => {
     const prevBusy = prevSpeakBusyRef.current;
     prevSpeakBusyRef.current = speakBusy;
@@ -283,6 +330,7 @@ export function useCouncilDeliberation(speakBusy = false) {
     toastQueue,
     chronicleUnread,
     mergeCouncilDeliberationSync,
+    mergeLinkedEdgesHint: mergeLinkedEdgesHintPayload,
     markChronicleVoteEntry,
     clearChronicleUnread,
     consumeVoteToast,
diff --git a/apps/web/src/hooks/useNpcRelationships.test.ts b/apps/web/src/hooks/useNpcRelationships.test.ts
new file mode 100644
index 0000000..35df09c
--- /dev/null
+++ b/apps/web/src/hooks/useNpcRelationships.test.ts
@@ -0,0 +1,132 @@
+/**
+ * Phase 28 useNpcRelationships (D-API-01, D-GRAPH-04).
+ * GET on tab open + relationshipSync dirty refetch ≤300ms.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { RelationshipEdgeBandPublic } from "@aetherlife/shared";
+import {
+  RELATIONSHIP_SYNC_DEBOUNCE_MS,
+  fetchNpcRelationshipEdges,
+  isRelationshipSyncPayload,
+  mergeRelationshipSync,
+  shouldDirtyRefetchRelationships,
+  type RelationshipRenderEdge,
+} from "./useNpcRelationships.js";
+
+const sampleEdges: RelationshipEdgeBandPublic[] = [
+  {
+    npcAId: "npc-1",
+    npcBId: "npc-2",
+    baseTag: "rival",
+    band: "hostile",
+    bandLabelZh: "敌对",
+    kindLabelZh: "宿敌",
+    currentStatus: ["紧张"],
+  },
+];
+
+describe("useNpcRelationships helpers", () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+  });
+
+  it("D-GRAPH-04: fetchNpcRelationshipEdges GETs band-mapped edges on open", async () => {
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ ok: true, edges: sampleEdges }),
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    const edges = await fetchNpcRelationshipEdges("room-1");
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    const [url, init] = fetchMock.mock.calls[0]!;
+    expect(String(url)).toContain("/rooms/room-1/npc-relationships");
+    expect(init?.headers).toBeDefined();
+    expect(edges).toEqual(sampleEdges);
+  });
+
+  it("D-GRAPH-02: render edge type / fetch result omits affection and trust", async () => {
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        ok: true,
+        edges: [
+          {
+            ...sampleEdges[0],
+            affection: 42,
+            trust: 77,
+          },
+        ],
+      }),
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    const edges = await fetchNpcRelationshipEdges("room-1");
+    const edge = edges[0] as RelationshipRenderEdge & {
+      affection?: number;
+      trust?: number;
+    };
+    expect(edge).toBeDefined();
+    expect("affection" in edge).toBe(false);
+    expect("trust" in edge).toBe(false);
+    expect(edge.band).toBe("hostile");
+    expect(edge.bandLabelZh).toBe("敌对");
+  });
+
+  it("isRelationshipSyncPayload accepts hint-only payload", () => {
+    expect(isRelationshipSyncPayload({ hasUpdate: true })).toBe(true);
+    expect(isRelationshipSyncPayload({ hasUpdate: true, latestSeq: 3 })).toBe(true);
+    expect(isRelationshipSyncPayload({ hasUpdate: "yes" })).toBe(false);
+    expect(isRelationshipSyncPayload(null)).toBe(false);
+  });
+
+  it("D-GRAPH-04: mergeRelationshipSync marks dirty on hasUpdate", () => {
+    const next = mergeRelationshipSync(
+      { hasUpdate: false, latestSeq: 1 },
+      { hasUpdate: true, latestSeq: 4 },
+    );
+    expect(next.hasUpdate).toBe(true);
+    expect(next.latestSeq).toBe(4);
+  });
+
+  it("D-GRAPH-04: dirty refetch only when tab focused", () => {
+    expect(shouldDirtyRefetchRelationships(true, true)).toBe(true);
+    expect(shouldDirtyRefetchRelationships(false, true)).toBe(false);
+    expect(shouldDirtyRefetchRelationships(true, false)).toBe(false);
+  });
+
+  it("debounce budget is ≤300ms", () => {
+    expect(RELATIONSHIP_SYNC_DEBOUNCE_MS).toBeLessThanOrEqual(300);
+    expect(RELATIONSHIP_SYNC_DEBOUNCE_MS).toBeGreaterThan(0);
+  });
+});
+
+describe("relationshipSync dirty refetch schedule", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  });
+
+  it("D-API-01 / D-GRAPH-04: hasUpdate while focused schedules refetch within debounce", async () => {
+    const { scheduleRelationshipDirtyRefetch } = await import("./useNpcRelationships.js");
+    const refetch = vi.fn();
+    const cancel = scheduleRelationshipDirtyRefetch(true, true, refetch);
+    expect(refetch).not.toHaveBeenCalled();
+    vi.advanceTimersByTime(RELATIONSHIP_SYNC_DEBOUNCE_MS);
+    expect(refetch).toHaveBeenCalledTimes(1);
+    cancel?.();
+  });
+
+  it("does not schedule refetch when tab is not focused", async () => {
+    const { scheduleRelationshipDirtyRefetch } = await import("./useNpcRelationships.js");
+    const refetch = vi.fn();
+    const cancel = scheduleRelationshipDirtyRefetch(false, true, refetch);
+    vi.advanceTimersByTime(RELATIONSHIP_SYNC_DEBOUNCE_MS + 50);
+    expect(refetch).not.toHaveBeenCalled();
+    expect(cancel).toBeNull();
+  });
+});
diff --git a/apps/web/src/hooks/useNpcRelationships.ts b/apps/web/src/hooks/useNpcRelationships.ts
new file mode 100644
index 0000000..ae79828
--- /dev/null
+++ b/apps/web/src/hooks/useNpcRelationships.ts
@@ -0,0 +1,253 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import {
+  type ColyseusRelationshipSyncPayload,
+  type RelationshipEdgeBandPublic,
+} from "@aetherlife/shared";
+import { playerApiHeaders } from "../lib/playerSession.js";
+
+const apiBase = import.meta.env.VITE_GAME_SERVER_URL || "/api";
+
+/** D-GRAPH-04: dirty refetch debounce budget (≤300ms). */
+export const RELATIONSHIP_SYNC_DEBOUNCE_MS = 300;
+
+/**
+ * Client render type — band-mapped only; never affection/trust (D-GRAPH-02).
+ * Alias of RelationshipEdgeBandPublic for UI clarity.
+ */
+export type RelationshipRenderEdge = Omit<
+  RelationshipEdgeBandPublic,
+  never
+> & {
+  affection?: never;
+  trust?: never;
+};
+
+type ListResponse = {
+  ok?: boolean;
+  edges?: unknown[];
+};
+
+type SyncState = {
+  hasUpdate: boolean;
+  latestSeq?: number;
+};
+
+/** Strip any leaked affection/trust ints before state (T-28-10-LEAK). */
+export function toRenderEdge(raw: unknown): RelationshipRenderEdge | null {
+  if (!raw || typeof raw !== "object") return null;
+  const row = raw as Record<string, unknown>;
+  if (typeof row.npcAId !== "string" || typeof row.npcBId !== "string") return null;
+  if (typeof row.baseTag !== "string") return null;
+  if (
+    row.band !== "hostile" &&
+    row.band !== "cool" &&
+    row.band !== "neutral" &&
+    row.band !== "warm" &&
+    row.band !== "close"
+  ) {
+    return null;
+  }
+  if (typeof row.bandLabelZh !== "string" || typeof row.kindLabelZh !== "string") {
+    return null;
+  }
+  if (!Array.isArray(row.currentStatus)) return null;
+  const edge: RelationshipRenderEdge = {
+    npcAId: row.npcAId,
+    npcBId: row.npcBId,
+    baseTag: row.baseTag,
+    band: row.band,
+    bandLabelZh: row.bandLabelZh,
+    kindLabelZh: row.kindLabelZh,
+    currentStatus: row.currentStatus.filter((s): s is string => typeof s === "string"),
+  };
+  return edge;
+}
+
+export function isRelationshipSyncPayload(
+  data: unknown,
+): data is ColyseusRelationshipSyncPayload {
+  if (!data || typeof data !== "object") return false;
+  const row = data as Record<string, unknown>;
+  if (typeof row.hasUpdate !== "boolean") return false;
+  if (
+    row.latestSeq !== undefined &&
+    (typeof row.latestSeq !== "number" || !Number.isFinite(row.latestSeq))
+  ) {
+    return false;
+  }
+  return true;
+}
+
+export function mergeRelationshipSync(
+  prev: SyncState,
+  payload: ColyseusRelationshipSyncPayload,
+): SyncState {
+  const latestSeq =
+    typeof payload.latestSeq === "number"
+      ? Math.max(prev.latestSeq ?? 0, payload.latestSeq)
+      : prev.latestSeq;
+  return {
+    hasUpdate: prev.hasUpdate || payload.hasUpdate,
+    latestSeq,
+  };
+}
+
+export function shouldDirtyRefetchRelationships(
+  tabFocused: boolean,
+  hasUpdate: boolean,
+): boolean {
+  return tabFocused && hasUpdate;
+}
+
+/**
+ * Schedule a debounced refetch when tab is focused and dirty.
+ * Returns cancel fn, or null when no schedule.
+ */
+export function scheduleRelationshipDirtyRefetch(
+  tabFocused: boolean,
+  hasUpdate: boolean,
+  refetch: () => void,
+  debounceMs = RELATIONSHIP_SYNC_DEBOUNCE_MS,
+): (() => void) | null {
+  if (!shouldDirtyRefetchRelationships(tabFocused, hasUpdate)) return null;
+  const id = setTimeout(() => {
+    refetch();
+  }, debounceMs);
+  return () => clearTimeout(id);
+}
+
+export async function fetchNpcRelationshipEdges(
+  roomId: string,
+  opts?: { signal?: AbortSignal },
+): Promise<RelationshipRenderEdge[]> {
+  if (!roomId) return [];
+  const url = `${apiBase}/rooms/${encodeURIComponent(roomId)}/npc-relationships`;
+  const res = await fetch(url, {
+    headers: playerApiHeaders(),
+    signal: opts?.signal,
+  });
+  if (!res.ok) {
+    throw new Error(`npc-relationships ${res.status}`);
+  }
+  const body = (await res.json()) as ListResponse;
+  if (!body.ok || !Array.isArray(body.edges)) {
+    throw new Error("npc-relationships invalid response");
+  }
+  const edges: RelationshipRenderEdge[] = [];
+  for (const raw of body.edges) {
+    const edge = toRenderEdge(raw);
+    if (edge) edges.push(edge);
+  }
+  return edges;
+}
+
+export function useNpcRelationships(
+  roomId: string,
+  roomConnected = false,
+  tabFocused = false,
+) {
+  const [edges, setEdges] = useState<RelationshipRenderEdge[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [hasUpdate, setHasUpdate] = useState(false);
+  const latestSeqRef = useRef<number | undefined>(undefined);
+  const requestSeqRef = useRef(0);
+  const loadedOnceRef = useRef(false);
+  const edgesRef = useRef<RelationshipRenderEdge[]>([]);
+  edgesRef.current = edges;
+
+  const applyFetched = useCallback((next: RelationshipRenderEdge[]) => {
+    setEdges(next);
+    setError(null);
+    setHasUpdate(false);
+    loadedOnceRef.current = true;
+  }, []);
+
+  const load = useCallback(
+    async (opts?: { signal?: AbortSignal }) => {
+      if (!roomId || !roomConnected) return;
+      const seq = ++requestSeqRef.current;
+      setLoading(true);
+      try {
+        const next = await fetchNpcRelationshipEdges(roomId, opts);
+        if (requestSeqRef.current !== seq) return;
+        applyFetched(next);
+      } catch (err) {
+        if (requestSeqRef.current !== seq) return;
+        if (opts?.signal?.aborted) return;
+        const message =
+          err instanceof Error && err.message
+            ? err.message
+            : "关系网暂时无法载入。请稍后重试，或确认已连上房间。";
+        setError(message);
+      } finally {
+        if (requestSeqRef.current === seq) {
+          setLoading(false);
+        }
+      }
+    },
+    [applyFetched, roomId, roomConnected],
+  );
+
+  /** Tab open → GET (D-GRAPH-04). */
+  useEffect(() => {
+    if (!tabFocused || !roomId || !roomConnected) return;
+    const ac = new AbortController();
+    void load({ signal: ac.signal });
+    return () => ac.abort();
+  }, [tabFocused, roomId, roomConnected, load]);
+
+  /** Dirty while focused → debounced refetch. */
+  useEffect(() => {
+    if (!shouldDirtyRefetchRelationships(tabFocused, hasUpdate)) return;
+    const cancel = scheduleRelationshipDirtyRefetch(tabFocused, hasUpdate, () => {
+      void load();
+    });
+    return () => {
+      cancel?.();
+    };
+  }, [tabFocused, hasUpdate, load]);
+
+  useEffect(() => {
+    if (roomId) return;
+    requestSeqRef.current = 0;
+    loadedOnceRef.current = false;
+    latestSeqRef.current = undefined;
+    setEdges([]);
+    setHasUpdate(false);
+    setError(null);
+    setLoading(false);
+  }, [roomId]);
+
+  const mergeRelationshipSyncCb = useCallback(
+    (payload: ColyseusRelationshipSyncPayload) => {
+      if (!isRelationshipSyncPayload(payload)) return;
+      setHasUpdate((prev) => {
+        const next = mergeRelationshipSync(
+          { hasUpdate: prev, latestSeq: latestSeqRef.current },
+          payload,
+        );
+        if (typeof next.latestSeq === "number") {
+          latestSeqRef.current = next.latestSeq;
+        }
+        return next.hasUpdate;
+      });
+    },
+    [],
+  );
+
+  const clearHasUpdate = useCallback(() => {
+    setHasUpdate(false);
+  }, []);
+
+  return {
+    edges,
+    loading,
+    error,
+    hasUpdate,
+    loadedOnce: loadedOnceRef.current,
+    load,
+    mergeRelationshipSync: mergeRelationshipSyncCb,
+    clearHasUpdate,
+  };
+}
diff --git a/apps/web/src/index.css b/apps/web/src/index.css
index 9250b29..1be8ecc 100644
--- a/apps/web/src/index.css
+++ b/apps/web/src/index.css
@@ -2129,6 +2129,185 @@ body {
   min-height: 0;
 }
 
+.relationship-graph-panel {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+  padding: 16px;
+  min-height: 0;
+  color: var(--shell-ink, #2c2416);
+}
+
+.relationship-graph-panel__title {
+  margin: 0;
+  font-size: 16px;
+  font-weight: 600;
+  line-height: 1.2;
+}
+
+.relationship-graph-panel__subtitle {
+  margin: 4px 0 0;
+  font-size: 12px;
+  line-height: 1.4;
+  color: var(--shell-muted, #7a6f5c);
+}
+
+.relationship-graph-panel__toolbar {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 8px;
+}
+
+.relationship-graph-panel__mode-toggle {
+  padding: 6px 10px;
+  border: 1px solid color-mix(in srgb, var(--shell-parchment) 55%, #8a7a60);
+  border-radius: 4px;
+  background: color-mix(in srgb, var(--shell-parchment) 70%, #fff);
+  font-size: 12px;
+  line-height: 1.4;
+  cursor: pointer;
+}
+
+.relationship-graph-panel__mode-toggle--active {
+  border-color: var(--shell-accent, #c9a227);
+  box-shadow: inset 0 0 0 1px var(--shell-accent, #c9a227);
+}
+
+.relationship-graph-panel__stale-hint {
+  margin: 0;
+  font-size: 12px;
+  color: var(--shell-muted, #7a6f5c);
+}
+
+.relationship-graph-panel__loading,
+.relationship-graph-panel__error,
+.relationship-graph-panel__empty-body {
+  margin: 0;
+  font-size: 14px;
+  line-height: 1.5;
+}
+
+.relationship-graph-panel__empty-title {
+  margin: 0 0 4px;
+  font-size: 16px;
+  font-weight: 600;
+}
+
+.relationship-graph-panel__canvas-wrap {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+}
+
+.relationship-graph-panel__svg {
+  width: 100%;
+  max-width: 360px;
+  margin: 0 auto;
+  background: color-mix(in srgb, var(--shell-parchment) 70%, #fff);
+  border: 1px solid color-mix(in srgb, var(--shell-parchment) 55%, #8a7a60);
+  border-radius: 4px;
+}
+
+.relationship-graph-panel__node {
+  fill: color-mix(in srgb, var(--shell-parchment) 70%, #fff);
+  stroke: color-mix(in srgb, var(--shell-parchment) 55%, #8a7a60);
+  stroke-width: 1;
+}
+
+.relationship-graph-panel__node--center {
+  fill: color-mix(in srgb, var(--shell-parchment) 55%, #fff);
+  stroke: var(--shell-accent, #c9a227);
+  stroke-width: 2;
+}
+
+.relationship-graph-panel__node-btn {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 32px;
+  height: 32px;
+  padding: 0;
+  border: none;
+  background: transparent;
+  cursor: pointer;
+}
+
+.relationship-graph-panel__node-label {
+  font-size: 11px;
+  font-weight: 600;
+  line-height: 1.2;
+  color: var(--shell-ink, #2c2416);
+  pointer-events: none;
+}
+
+.relationship-graph-panel__edge-list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.relationship-graph-panel__edge-row {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 8px;
+  font-size: 12px;
+  line-height: 1.4;
+}
+
+.relationship-graph-panel__edge-names {
+  font-size: 14px;
+}
+
+.relationship-graph-panel__band-chip {
+  display: inline-block;
+  padding: 2px 8px;
+  border-radius: 4px;
+  font-size: 12px;
+  line-height: 1.4;
+  border: 1px solid transparent;
+}
+
+.relationship-graph-panel__band-chip--hostile {
+  color: #b54a4a;
+  border-color: color-mix(in srgb, #b54a4a 35%, transparent);
+}
+
+.relationship-graph-panel__band-chip--cool {
+  color: #a89060;
+  border-color: color-mix(in srgb, #a89060 35%, transparent);
+}
+
+.relationship-graph-panel__band-chip--neutral {
+  color: var(--shell-muted, #7a6f5c);
+  border-color: color-mix(in srgb, var(--shell-muted, #7a6f5c) 35%, transparent);
+}
+
+.relationship-graph-panel__band-chip--warm {
+  color: #7a9a6e;
+  border-color: color-mix(in srgb, #7a9a6e 35%, transparent);
+}
+
+.relationship-graph-panel__band-chip--close {
+  color: var(--shell-accent, #c9a227);
+  border-color: color-mix(in srgb, var(--shell-accent, #c9a227) 35%, transparent);
+}
+
+.relationship-graph-panel__kind-label {
+  color: var(--shell-muted, #7a6f5c);
+}
+
+.relationship-graph-panel__status-chip {
+  padding: 2px 6px;
+  border-radius: 4px;
+  background: color-mix(in srgb, var(--shell-parchment) 70%, #fff);
+  font-size: 12px;
+}
+
 .world-history-panel--embedded {
   display: flex;
   flex-direction: column;
diff --git a/docs/BEGINNING-FIELDS.md b/docs/BEGINNING-FIELDS.md
index 3f9b3c1..0eff5d0 100644
--- a/docs/BEGINNING-FIELDS.md
+++ b/docs/BEGINNING-FIELDS.md
@@ -61,6 +61,7 @@ Web agent 摘要：[apps/web/AGENTS.md](../apps/web/AGENTS.md) · 回归 ISSUE-0
 
 - Tiled tile object（Object Layer 1）：**左下角** 锚点
 - 玩家 / NPC：**格心 X + 格南缘 Y**（与 sprite 脚底一致）
+- **Campfire 等 volume tileset**（`VOLUME_CLUSTER_TILESETS`）：相邻 tile object 共用**最南底边** sort Y，避免北侧火焰被 PLAYER 层盖住
 - 高大物件（树冠）：将来走 Tiled **Overhead** 层 + `YSORT_OVERHEAD_DEPTH`，不单点 Y-sort
 
 ---
diff --git a/docs/CONTRACTS.md b/docs/CONTRACTS.md
index 8d83d9d..8a73ee1 100644
--- a/docs/CONTRACTS.md
+++ b/docs/CONTRACTS.md
@@ -13,7 +13,7 @@ TS game-server、Python worker、LLM Prompt、`@aetherlife/game-actions` 之间
 | 层 | 契约 |
 |----|------|
 | **身份来源** | Colyseus `speak` → `playerId` → job payload `playerId` |
-| **状态读取** | speak 热路径：`GET /internal/rooms/:id/worker-state?skipNearbyLore=1`（默认）+ header `X-Player-Id` → `roomStateForInitiator` → `state.player` = 发起者实时格（无 memoryCounts）；NARRATIVE + lore markers 可 lazy `skipNearbyLore=0`；legacy/debug：`GET /rooms/:id/state` 仍可用 |
+| **状态读取** | speak 热路径：`GET /internal/rooms/:id/worker-state?skipNearbyLore=1`（默认）+ header `X-Player-Id` → `roomStateForInitiator` → `state.player` = 发起者实时格；`state.absoluteGameMinute` = 房间单调时钟（belief gate day-key / REL stamp）；无 memoryCounts；NARRATIVE + lore markers 可 lazy `skipNearbyLore=0`；legacy/debug：`GET /rooms/:id/state` 仍可用 |
 | **Pre-LLM 降级** | worker `fetch_state` 超时后返回进程内 stale snapshot（`_stale` / `_stale_age_ms`），**不得** hard-fail job；move 仍 `invalidateWorkerStateForPlayer` |
 | **Memory 热路径** | `GET .../memory-context`：`skipEmbed=1` 用于 CASUAL/SOCIAL_EDGE/NARRATIVE；RECALL 须 full embed；5s 进程内 cache；header `X-Speak-Hot-Path: 1` 优先 embed 队列 |
 | **Prompt** | 「我 / 下方 / 旁边」仅相对 **本次** `state.player`（见 `workers/.../prompt.py`） |
@@ -186,7 +186,7 @@ TS game-server、Python worker、LLM Prompt、`@aetherlife/game-actions` 之间
 | **种子** | 房间 **首次创建**（`getOrCreate`）异步 `seedCouncilRelationshipsIfNeeded`：从 registry `relationships[]` 映射 `base_tag` + 初始 `affection`/`trust`；**66 条边**（`COUNCIL_NPC_IDS` 全对）；幂等 `countRelationshipsForRoom >= 66` 跳过 |
 | **Registry 映射** | 种子读 registry 时用 `councilIndexEdgeIds`（席位序 npc-1…12）；**存储**仍用 `normalizeEdgeIds`（字符串序，满足 CHECK） |
 | **Worker 读** | `GET /internal/rooms/:roomId/npc-relationships`；`requireWorkerAuth`；可选 `?npcId=` + `limit` 返回 top-N by `|affection|` |
-| **Worker 写** | `POST /internal/rooms/:roomId/npc-relationships/apply-deltas`；body `{ deltas: RelationshipDeltaInput[], voteEpoch? }` → `{ linkedEdges }`；单次 `|affectionDelta| ≤ 15`；server clamp affection/trust；**仅** worker `world_vote` job 异步调用 — **禁止** Colyseus `onMessage` |
+| **Worker 写** | `POST /internal/rooms/:roomId/npc-relationships/apply-deltas`；body `{ deltas: RelationshipDeltaInput[], voteEpoch? }` → `{ linkedEdges }`；单次 `|affectionDelta| ≤ 15`；server clamp affection/trust；route **必须** stamp `lastInteractAbs` 为 `getRoomVoteState(roomId).absoluteGameMinute`；**仅** worker 异步调用 — **禁止** Colyseus `onMessage` |
 | **UI linkedEdges** | Worker **全量** apply-deltas 后，`councilDeliberationSync.linkedEdges` 仅广播 `filter_linked_edges_for_ui(top_k=8, min_abs=8)` 子集；名册 hint 用 broadcast 子集，**非** apply 响应全边 |
 | **Reset** | `POST /rooms/:id/reset` **不得**删除 `npc_relationships`（room-shared，与 `world_history` / `__council__` 同类保留） |
 | **UI** | 客户端 **无**公开 REST；`linkedEdges` 仅经 `councilDeliberationSync` 广播；名册 `council-roster-relationship-hint`（`linkedEdges` 上次 vote job）subtle hint only |
@@ -199,6 +199,25 @@ TS game-server、Python worker、LLM Prompt、`@aetherlife/game-actions` 之间
 
 ---
 
+## C-09b — Player relationship graph + sync + embedding [Phase 28]
+
+> **Additive to C-09.** Do **not** rewrite C-09 worker apply semantics. C-09 historical row「客户端 **无**公开 REST」remains as Phase 25 history; **C-09b supersedes that clause for Phase 28+** player graph surfaces. Worker apply-deltas / `requireWorkerAuth` stay under **C-09**.
+
+| 层 | 契约 |
+|----|------|
+| **公开读** | `GET /rooms/:roomId/npc-relationships` → **band-mapped** `RelationshipEdgeBandPublic[]`（`band` / `bandLabelZh` / `kindLabelZh` / `currentStatus` / npc ids）；**禁止**返回 `affection` / `trust` 整数（D-GRAPH-02 / D-API-01） |
+| **Auth** | `X-Player-Id` + `assertScopedPlayerRequest`（镜像 C-11 personal-timeline 公开读）；**无** public write |
+| **Colyseus** | `relationshipSync` payload `{ hasUpdate: boolean; latestSeq?: number }` — **hint-only invalidate**；客户端 refetch GET；**禁止**经 WS 推送边全文（D-API-01） |
+| **Worker 写** | 仍走 C-09 `POST .../npc-relationships/apply-deltas` + `requireWorkerAuth`；本契约不改变 delta clamp / voteEpoch 语义 |
+| **Embedding** | Async embed of `history_summary` + `current_status` text；affection **band** 仅作 metadata filter，**不**入向量（D-EMBED-02）；write path 与公开 GET 解耦 |
+| **Shared SSOT** | `relationshipBandFromAffection` / `relationshipBandLabelZh` / `toRelationshipEdgeBandPublic`；`COLYSEUS_SERVER_MESSAGES.relationshipSync` |
+
+**验证：** `pnpm --filter @aetherlife/shared test -- councilRelationships` · `pnpm --filter @aetherlife/shared build` · `pnpm --filter @aetherlife/game-server test -- npc-relationships` · `pnpm --filter @aetherlife/web test -- RelationshipGraphPanel useNpcRelationships` · `pnpm verify:phase28`（真实 LLM / `assertE2eRealLlm`）
+
+**锚点文件：** `packages/shared/src/councilRelationships.ts`, `packages/shared/src/colyseus.ts`, `docs/CONTRACTS.md`（本行）, `apps/game-server/src/routes/npc-relationships.ts`（player GET）, `apps/game-server/src/world/relationship-broadcast.ts`（`relationshipSync` + `mutualChatBubble`）, `apps/game-server/src/world/npc-relationships-repository.ts`（async embed）, `apps/web/src/hooks/useNpcRelationships.ts`, `apps/web/src/components/RelationshipGraphPanel.tsx`
+
+---
+
 ## C-10 — Deliberation pacing & job payload [Phase 25 plan 09]
 
 | 层 | 契约 |
diff --git a/docs/ISSUE-LOG.md b/docs/ISSUE-LOG.md
index 7d74c9b..31494e4 100644
--- a/docs/ISSUE-LOG.md
+++ b/docs/ISSUE-LOG.md
@@ -204,6 +204,13 @@
 114. **Personal-timeline job 入队须 durable claim**：`claimPersonalTimelineJobId` / worker `claim_personal_timeline_job_id`（SET NX，前缀 `aetherlife:personal-timeline:job-claimed:`）覆盖 polish/weekly/multi/rel/event **以及** dyad pair/ambient-slot；**禁止**仅靠进程内存 debounce（重启会重复 LPUSH → 重复 LLM 行）。传记 UI：fetch 失败须展示 error（勿静默空列表）；已缓存条目在 `personalTimelineSync` 时须后台 refetch。回归：`personal-timeline.claim.test.ts` · `personal-timeline-dyad.test.ts` · `usePersonalTimeline.test.ts` · `pnpm uat:phase27:persona-diary`。
 115. **Speak 多轮连贯（260720-m4b）**：interactive 路径 `llm_social_turn._build_social_messages` **必须**注入 `recent_turns` Human/AI 链（`append_recent_dialogue_messages`）；**禁止** help offer（`player_offers_help` /「我可以帮你」）走 SOCIAL_EDGE deterministic stub；`recent_turns` 非空时 **禁止** CASUAL/SOCIAL_EDGE fast lane（B1 例外：空历史纯问候）。`augment_retrieved_with_dialogue_turns` 须含 `npc:` 行。回归：`pytest tests/test_speak_intent.py tests/test_help_reply_by_npc.py tests/test_llm_social_memory.py tests/test_casual_fast_lane.py tests/test_recall_merge.py -q` · `pnpm --filter @aetherlife/shared test -- speakIntent` · `pnpm agent:verify`。
 
+### Phase 28 — Council relationship advanced（C-09b / EA-6）
+
+116. **Provoke/belief reject 禁止 A↔B delta**：`evaluate_belief_gate` / `run_belief_gate_speak` 在 `decision=reject` 时 **不得** `apply` npcA↔npcB affection；信任分仅来自 **initiator** 的 `npc_attitudes` / collective `effectiveScore`（禁止用 peer 态度）。Mutual-chat 记忆走 `__council__` / REL-07，**禁止**污染玩家 speak `npc_memories` 作用域。Idle decay **必须** `applyIdleDecayDeltas`（**禁止** `applyDeltaToRow` / interact bump）。同一 room/day/pair 上 **mutual-chat supersedes** ambient dyad pair budget：`GameRoom.onAmbientTick` **必须** `enqueueNpcMutualChatIfDue().then(dyad)`（禁止 fire-and-forget 并行）；`maybeEnqueueNpcMutualChat` **必须**在任何 `await enqueue` 前同步 claim 整批 pair。Frozen VIS-04 铭牌三文件（`entityLabels` / `ProximityNameplate` / `entitySprites`）与 speakBusy 方案 A **禁止** drive-by 改动。回归：`pytest tests/test_belief_gate.py tests/test_npc_mutual_chat.py tests/test_relationship_rag.py -q` · `pnpm --filter @aetherlife/game-server test -- npc-relationship-decay npc-mutual-chat npc-relationships` · `pnpm verify:phase28`（`pnpm dev:stack`，禁 `LLM_MOCK`）。
+117. **关系 apply-deltas 与 belief day-key 须带 room clock**：`POST .../npc-relationships/apply-deltas` **必须** `noteInteractAbs` 用 `getRoomVoteState(roomId).absoluteGameMinute`（**禁止** fallback `0` 导致 idle decay 误判）；`worker-state.state` **必须** 含 `absoluteGameMinute`；`day_key_from_snapshot` **优先** `absoluteGameMinute // 1440`（D-PLAYER-04/06 per-day cap）。回归：`npc-relationships.test.ts` apply-deltas stamp · `index.test.ts` worker-state clock · `test_belief_gate.py::test_day_key_from_snapshot_prefers_absolute_game_minute` · `test_manipulation_cap_resets_on_next_game_day`。
+118. **Decay stamp / belief cap 进程重启与长跑**：`maybeRunRelationshipDecay` 启动时 **必须** `hydrateInteractAbsFromEdges`（有 `last_interact_at`）+ `hydrateSeedAbsFromEdges`；`lastDecayMonthByRoom` 有 `REDIS_URL` 时持久化，防同月重复 decay。Belief `_pair_claims` / `_player_claims` / `_reject_counts` / `_trust_penalty_claims` 在 claim/note 时 **必须** prune 非当前 `day_key`。回归：`npc-relationship-decay.test.ts` hydrate · `test_belief_gate.py::test_prune_stale_day_keys_on_claim`。
+119. **Campfire 等多 tile volume 须共用南缘 Y-sort**：`HomeMapBackground` 对 `VOLUME_CLUSTER_TILESETS`（当前仅 `Campfire`）用 `clusterSouthSortWorldY` 把相邻 tile object 的 sort Y 抬到集群最南底边；**禁止**全局改 `YSORT_LAYER.PLAYER`/`OBJECT` 来「修」篝火。勿把 collection-of-images 道具加入该集合。回归：`entityLayout.test.ts` · 实机站北侧火焰须盖住腿。
+
 ## 记录
 
 ### ISSUE-001 — thinking 中切换 NPC Tab 后无法移动（UI 冻结）
@@ -2847,4 +2854,137 @@ Worker 主循环仅在 npc-turn 队列 **连续 5s 为空** 时才 `BLPOP` chunk
 
 ---
 
+### ISSUE-108 — apply-deltas / belief gate 缺 room clock（decay 误判 + cap 永锁 day-0）
+
+- **状态:** fixed
+- **发现:** 2026-07-21（Codex PR #22 review）
+- **阶段/范围:** Phase 28 · `internal-npc-relationships` · `worker-state` · `belief_gate.py`
+- **严重性:** major（关系 decay 语义 + provoke cap 防滥用）
+
+**复现**
+
+1. Worker 经 `POST .../apply-deltas` 写关系 delta → `lastInteractAbs` 恒为 `0`
+2. 游戏月 rollover 后 `maybeRunRelationshipDecay` 将刚互动的边判为 idle 并 decay
+3. Speak 路径 `day_key_from_snapshot` 读 `room_snapshot` 无 `gameMinute` → 恒 `day-0` → D-PLAYER-04 pair/player cap 与 D-PLAYER-06 reject penalty 在长跑 worker 内永不重置
+
+**根因**
+
+- `internal-npc-relationships` 未传 `absoluteGameMinute`；repository fallback `?? 0`
+- `buildWorkerStatePayload` 仅返回空间快照，不含单调时钟
+- `day_key_from_snapshot` 未读 `absoluteGameMinute`
+
+**修复**
+
+- apply-deltas route：`getRoomVoteState(roomId).absoluteGameMinute` stamp
+- worker-state：`state.absoluteGameMinute` 随 spatial snapshot 返回
+- `day_key_from_snapshot`：优先 `absoluteGameMinute // 1440`
+
+**验证**
+
+- `pnpm --filter @aetherlife/game-server test`（353 passed）
+- `cd workers/agent-worker && LLM_MOCK=1 uv run pytest tests/test_belief_gate.py -q`（14 passed）
+
+**防复发**
+
+- Guardrail #117；C-01 worker-state clock；C-09 apply-deltas stamp
+
+---
+
+### ISSUE-109 — PR #22 CodeRabbit 批量 CR：decay 上弹 / belief fallback 误接受 / mutual-chat claim 竞态等
+
+- **状态:** fixed
+- **发现:** 2026-07-21（CodeRabbit PR #22 review，10 条有效 + 2 条跳过）
+- **阶段/范围:** Phase 28 · mutual-chat / decay / belief gate / 关系图 UI
+- **严重性:** major（decay 语义 + belief 防滥用）
+
+**有效修复（10）**
+
+1. `npc-mutual-chat.ts`：pair claim 移到 `await enqueue` **之前**（同 tick ambient dyad 可见 supersession），失败/null 回滚
+2. `queue/npc-mutual-chat.ts`：`mockJobs.set` 仅无 `REDIS_URL` 时执行（防生产 Map 无限增长）
+3. `npc-relationship-decay.ts`：正向 affection **低于** band floor 时继续向 0 漂移，禁止 `Math.max(floor,…)` 上弹
+4. `ChatPage.tsx`：关系图 center/mode 仅在 tab **focus 转变**时重置（ref 记录 prev），会话中切 NPC 不清用户选择
+5. `RoomScene.stopEntityMotion`：改用 `hideMutualChatBubble`（原手动清 timer 会让气泡永久卡显）
+6. `RoomScene.refreshMutualChatBubbles`：`expiresAt <= now` 的 registry 残留 payload 跳过（scene 重建不重播）
+7. `belief_gate.default_llm_judge`：非 mock 未接线路径 accept → **reject**（`llm_judge_unwired`，Δ0）
+8. `test_npc_mutual_chat.py`：hint URL 过滤只留 `linked-edges-hint`；去掉 `or True` 恒真断言并捕获位置参数 text
+
+**跳过（2）**
+
+- `relationship_rag` 条件化 lazy embed：public payload 无 `hasEmbedding` 字段，且 server `ensureRelationshipEdgeEmbedding` 非 force 时已短路（有向量即 return false，不调 embed LLM）— 满足 finding 自述的保留条件
+- mutual-chat bubble LLM 内容过滤：worker 无既定 Python content-filter 路径（`ContentGuard` 在 ai-gateway，非 worker 依赖）；引入跨包审核路径超出最小修复，留待后续设计
+
+**验证**
+
+- `pnpm --filter @aetherlife/game-server test`（354 passed，含新增 decay 不上弹用例）
+- `pnpm --filter @aetherlife/web test`（192 passed）
+- `cd workers/agent-worker && LLM_MOCK=1 uv run pytest -q`（414 passed，含 fallback reject 用例）
+
+**防复发**
+
+- Guardrail #116 追加：belief gate 未接线 judge **必须** reject；decay floor 只对 ≥floor 的边生效
+
+---
+
+### ISSUE-110 — PR #22 CR 余项：mutual-chat 同 tick 串行 / decay 重启水化 / belief day prune
+
+- **状态:** fixed
+- **发现:** 2026-07-29（PR #22 CodeRabbit/Codex 余项复盘）
+- **阶段/范围:** Phase 28 · `GameRoom` · `npc-mutual-chat` · `npc-relationship-decay` · `belief_gate`
+- **严重性:** major（supersede 竞态 + 重启重复 decay）
+
+**修复**
+
+1. `GameRoom.onAmbientTick`：`enqueueNpcMutualChatIfDue().then(dyad)` — 禁止与 ambient dyad 并行 fire-and-forget
+2. `maybeEnqueueNpcMutualChat`：整批 pair **同步 claim** 后再 `await enqueue`
+3. `hydrateInteractAbsFromEdges` / `hydrateSeedAbsFromEdges` + Redis `lastDecayMonth` 持久化
+4. belief cap dict 按当前 `day_key` prune
+5. decay 测试 slice 收紧；去掉 `toRenderEdge` no-op key 循环
+
+**验证**
+
+- `pnpm --filter @aetherlife/game-server test -- npc-relationship-decay npc-mutual-chat`
+- `cd workers/agent-worker && LLM_MOCK=1 uv run pytest tests/test_belief_gate.py -q`
+- `pnpm --filter @aetherlife/web test -- useNpcRelationships`
+- `pnpm agent:verify`
+
+**防复发**
+
+- Guardrail #116（串行 supersede）· #118（hydrate + prune）
+
+---
+
+### ISSUE-111 — 站篝火北侧时火焰不盖腿（Y-sort）
+
+- **状态:** fixed
+- **发现:** 2026-07-29
+- **阶段/范围:** `apps/web` · `HomeMapBackground` / `entityLayout`
+- **严重性:** minor（视觉）
+
+**复现**
+
+1. `pnpm dev:stack` 进 home。
+2. 站在 Campfire **北侧**紧邻格（约 gy=29）。
+3. 玩家腿画在火焰前面（应被北侧火焰遮挡）。
+
+**根因**
+
+- Campfire 为 4 个 Tiled tile object：北排底边 world Y≈960，南排≈992。
+- 玩家脚底 sort Y 与北排底边对齐时，`YSORT_LAYER.PLAYER (+2)` 压过 `OBJECT (+1)` → 人在火前。
+
+**修复**
+
+- `clusterSouthSortWorldY`：相邻 volume 部件共用最南底边 sort Y。
+- `HomeMapBackground`：仅 `VOLUME_CLUSTER_TILESETS = {"Campfire"}` 走聚类；其它 object 仍按自身底边。
+
+**验证**
+
+- `pnpm --filter @aetherlife/web exec vitest run src/game/entityLayout.test.ts`
+- 实机：北侧站立时火焰盖住腿；其它道具 Y-sort 不变。
+
+**防复发**
+
+- Guardrail #119 · [BEGINNING-FIELDS.md](./BEGINNING-FIELDS.md) Y-sort 注记
+
+---
+
 <!-- 新问题上文追加，保持 ISSUE 编号递增 -->
diff --git a/package.json b/package.json
index f0329e3..3e97999 100644
--- a/package.json
+++ b/package.json
@@ -66,6 +66,7 @@
     "verify:phase25": "node scripts/verify-phase25.mjs",
     "verify:phase26": "node scripts/verify-phase26.mjs",
     "verify:phase27": "node scripts/verify-phase27.mjs",
+    "verify:phase28": "node scripts/verify-phase28.mjs",
     "uat:phase27:persona-diary": "node scripts/uat-phase27-persona-diary.mjs",
     "uat:phase26": "node scripts/uat-phase26-playwright.mjs",
     "uat:phase25:core-ui": "node scripts/uat-phase25-core-ui.mjs",
diff --git a/packages/npc-memory/migrations/0012_npc_relationships_embedding.sql b/packages/npc-memory/migrations/0012_npc_relationships_embedding.sql
new file mode 100644
index 0000000..93eccbd
--- /dev/null
+++ b/packages/npc-memory/migrations/0012_npc_relationships_embedding.sql
@@ -0,0 +1,4 @@
+-- Phase 28 D-EMBED-02/03: nullable edge embedding for Speak RAG (matches EMBED_DIMENSIONS=2048).
+-- Optional HNSW index deferred (MVP: ~66 edges/room).
+ALTER TABLE npc_relationships
+  ADD COLUMN IF NOT EXISTS embedding vector(2048);
diff --git a/packages/npc-memory/migrations/meta/_journal.json b/packages/npc-memory/migrations/meta/_journal.json
index 236ddb5..aa9ce07 100644
--- a/packages/npc-memory/migrations/meta/_journal.json
+++ b/packages/npc-memory/migrations/meta/_journal.json
@@ -71,6 +71,13 @@
       "when": 1751155200000,
       "tag": "0011_npc_personal_timeline",
       "breakpoints": true
+    },
+    {
+      "idx": 11,
+      "version": "7",
+      "when": 1751241600000,
+      "tag": "0012_npc_relationships_embedding",
+      "breakpoints": true
     }
   ]
 }
diff --git a/packages/npc-memory/src/schema.test.ts b/packages/npc-memory/src/schema.test.ts
new file mode 100644
index 0000000..961bde5
--- /dev/null
+++ b/packages/npc-memory/src/schema.test.ts
@@ -0,0 +1,33 @@
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { getTableColumns } from "drizzle-orm";
+import { EMBED_DIMENSIONS, npcMemories, npcRelationships } from "./schema.js";
+
+const migrationsDir = resolve(dirname(fileURLToPath(import.meta.url)), "../migrations");
+
+describe("npcRelationships embedding (D-EMBED-02/03)", () => {
+  it("locks EMBED_DIMENSIONS at 2048 for relationship vectors", () => {
+    expect(EMBED_DIMENSIONS).toBe(2048);
+  });
+
+  it("exports npcRelationships.embedding typed like npcMemories.embedding", () => {
+    const relCols = getTableColumns(npcRelationships);
+    const memCols = getTableColumns(npcMemories);
+    expect(relCols.embedding).toBeDefined();
+    expect(memCols.embedding).toBeDefined();
+    expect(relCols.embedding.name).toBe("embedding");
+    expect(relCols.embedding.getSQLType()).toBe(`vector(${EMBED_DIMENSIONS})`);
+    expect(relCols.embedding.getSQLType()).toBe(memCols.embedding.getSQLType());
+  });
+
+  it("migration 0012 adds nullable embedding vector(2048)", () => {
+    const sql = readFileSync(
+      resolve(migrationsDir, "0012_npc_relationships_embedding.sql"),
+      "utf8",
+    );
+    expect(sql).toMatch(/ALTER TABLE\s+npc_relationships/i);
+    expect(sql).toMatch(/ADD COLUMN IF NOT EXISTS\s+embedding\s+vector\(2048\)/i);
+  });
+});
diff --git a/packages/npc-memory/src/schema.ts b/packages/npc-memory/src/schema.ts
index 37ed12d..5d7ad46 100644
--- a/packages/npc-memory/src/schema.ts
+++ b/packages/npc-memory/src/schema.ts
@@ -163,6 +163,8 @@ export const npcRelationships = pgTable(
     lastInteractAt: timestamp("last_interact_at", { withTimezone: true }),
     currentStatus: jsonb("current_status").notNull().default([]),
     historySummary: text("history_summary").notNull().default(""),
+    /** Speak RAG / edge similarity; nullable until async embed (D-EMBED-02/03). */
+    embedding: vector2048("embedding"),
     updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
   },
   (table) => [
diff --git a/packages/shared/src/attitude.ts b/packages/shared/src/attitude.ts
index 6f366f5..302dabb 100644
--- a/packages/shared/src/attitude.ts
+++ b/packages/shared/src/attitude.ts
@@ -3,7 +3,11 @@ export type AttitudeBand = "hostile" | "wary" | "neutral" | "warm" | "allied";
 export const ATTITUDE_SCORE_MIN = -100;
 export const ATTITUDE_SCORE_MAX = 100;
 
-/** D-15 band thresholds on effectiveScore. */
+/**
+ * D-15 band thresholds on effectiveScore.
+ * Phase 28 关系网 reuses these cutoffs via relationshipBandFromAffection
+ * (maps wary→cool, allied→close; separate ZH labels in councilRelationships).
+ */
 export function bandFromEffectiveScore(score: number): AttitudeBand {
   if (score < -30) return "hostile";
   if (score < 0) return "wary";
diff --git a/packages/shared/src/colyseus.ts b/packages/shared/src/colyseus.ts
index 5c6e810..c1cbed5 100644
--- a/packages/shared/src/colyseus.ts
+++ b/packages/shared/src/colyseus.ts
@@ -38,6 +38,12 @@ export const COLYSEUS_SERVER_MESSAGES = {
   councilDeliberationSync: "councilDeliberationSync",
   /** Light personal-timeline hint (D-SYNC-01) — never full bodies. */
   personalTimelineSync: "personalTimelineSync",
+  /** Light relationship-graph hint (D-API-01) — never full edge bodies. */
+  relationshipSync: "relationshipSync",
+  /** One-shot NPC↔NPC mutual-chat bubble (D-MUTUAL-02) — not schema state. */
+  mutualChatBubble: "mutualChatBubble",
+  /** Roster linkedEdges hint outside deliberation (D-MUTUAL-04). */
+  relationshipLinkedHint: "relationshipLinkedHint",
 } as const;
 
 export type ColyseusMovePayload =
@@ -144,5 +150,24 @@ export type ColyseusPersonalTimelineSyncPayload = {
   latestSeq?: number;
 };
 
+/** Light relationship-graph update hint (D-API-01) — no edge bodies. */
+export type ColyseusRelationshipSyncPayload = {
+  hasUpdate: boolean;
+  latestSeq?: number;
+};
+
+/** One-shot mutual-chat speech bubble (D-MUTUAL-02) — text ≤20; no Colyseus schema field. */
+export type ColyseusMutualChatBubblePayload = {
+  npcId: string;
+  peerNpcId: string;
+  text: string;
+  expiresAt: number;
+};
+
+/** Linked-edge roster hint (D-MUTUAL-04) — ids only; merge into CouncilRosterPanel linkedEdges. */
+export type ColyseusRelationshipLinkedHintPayload = {
+  linkedEdges: Array<{ npcAId: string; npcBId: string }>;
+};
+
 /** Incremental council deliberation state for Council Tab feed / chip (Phase 25). */
 export type ColyseusCouncilDeliberationSyncPayload = CouncilDeliberationPublicState;
diff --git a/packages/shared/src/councilRelationships.test.ts b/packages/shared/src/councilRelationships.test.ts
new file mode 100644
index 0000000..66d3a11
--- /dev/null
+++ b/packages/shared/src/councilRelationships.test.ts
@@ -0,0 +1,78 @@
+import { describe, expect, it } from "vitest";
+import { bandLabelZh } from "./attitude.js";
+import {
+  relationshipBandFromAffection,
+  relationshipBandLabelZh,
+  relationshipEdgeBandPublicSchema,
+  toRelationshipEdgeBandPublic,
+  type RelationshipBand,
+  type RelationshipEdgePublic,
+} from "./councilRelationships.js";
+
+const ALL_BANDS: RelationshipBand[] = ["hostile", "cool", "neutral", "warm", "close"];
+
+describe("relationshipBandFromAffection", () => {
+  it("maps cutoff boundaries (same numeric cutoffs as bandFromEffectiveScore)", () => {
+    expect(relationshipBandFromAffection(-31)).toBe("hostile");
+    expect(relationshipBandFromAffection(-30)).toBe("cool");
+    expect(relationshipBandFromAffection(-1)).toBe("cool");
+    expect(relationshipBandFromAffection(0)).toBe("neutral");
+    expect(relationshipBandFromAffection(19)).toBe("neutral");
+    expect(relationshipBandFromAffection(20)).toBe("warm");
+    expect(relationshipBandFromAffection(49)).toBe("warm");
+    expect(relationshipBandFromAffection(50)).toBe("close");
+  });
+});
+
+describe("relationshipBandLabelZh", () => {
+  it("returns UI-SPEC 关系网 labels (not collective 戒备/同盟)", () => {
+    expect(relationshipBandLabelZh("hostile")).toBe("敌对");
+    expect(relationshipBandLabelZh("cool")).toBe("冷淡");
+    expect(relationshipBandLabelZh("neutral")).toBe("平常");
+    expect(relationshipBandLabelZh("warm")).toBe("亲近");
+    expect(relationshipBandLabelZh("close")).toBe("亲密");
+    for (const band of ALL_BANDS) {
+      expect(relationshipBandLabelZh(band)).not.toBe(bandLabelZh("wary"));
+      expect(relationshipBandLabelZh(band)).not.toBe(bandLabelZh("allied"));
+    }
+  });
+});
+
+describe("RelationshipEdgeBandPublic", () => {
+  const internalEdge: RelationshipEdgePublic = {
+    npcAId: "npc-1",
+    npcBId: "npc-2",
+    baseTag: "rival",
+    affection: -40,
+    trust: 10,
+    interactionCount: 3,
+    lastInteractAt: null,
+    currentStatus: ["tense"],
+    historySummary: "secret",
+    updatedAt: "2026-07-21T00:00:00.000Z",
+  };
+
+  it("omits affection and trust integers from public DTO", () => {
+    const pub = toRelationshipEdgeBandPublic(internalEdge);
+    expect(pub).not.toHaveProperty("affection");
+    expect(pub).not.toHaveProperty("trust");
+    expect(pub.npcAId).toBe("npc-1");
+    expect(pub.npcBId).toBe("npc-2");
+    expect(pub.band).toBe("hostile");
+    expect(pub.bandLabelZh).toBe("敌对");
+    expect(pub.kindLabelZh).toBeTruthy();
+    expect(pub.currentStatus).toEqual(["tense"]);
+    const parsed = relationshipEdgeBandPublicSchema.parse(pub);
+    expect("affection" in parsed).toBe(false);
+    expect("trust" in parsed).toBe(false);
+  });
+
+  it("rejects payloads that include affection or trust", () => {
+    const leak = {
+      ...toRelationshipEdgeBandPublic(internalEdge),
+      affection: -40,
+      trust: 10,
+    };
+    expect(relationshipEdgeBandPublicSchema.safeParse(leak).success).toBe(false);
+  });
+});
diff --git a/packages/shared/src/councilRelationships.ts b/packages/shared/src/councilRelationships.ts
index 0aff378..bdc3058 100644
--- a/packages/shared/src/councilRelationships.ts
+++ b/packages/shared/src/councilRelationships.ts
@@ -1,4 +1,6 @@
 import { z } from "zod";
+import { bandFromEffectiveScore, type AttitudeBand } from "./attitude.js";
+import { relationshipKindLabelZh } from "./council/relationshipLabels.js";
 import type { CouncilArchetype } from "./council/types.js";
 import { COUNCIL_NPC_IDS, type CouncilNpcId } from "./council/constants.js";
 
@@ -46,6 +48,83 @@ export type RelationshipEdgePublic = {
   updatedAt: string;
 };
 
+/**
+ * Player-facing affection bands for 关系网 (D-GRAPH-02 / UI-SPEC).
+ * Same numeric cutoffs as {@link bandFromEffectiveScore}; ids differ from
+ * collective AttitudeBand (`wary`→`cool`, `allied`→`close`).
+ */
+export type RelationshipBand = "hostile" | "cool" | "neutral" | "warm" | "close";
+
+const ATTITUDE_TO_RELATIONSHIP_BAND: Record<AttitudeBand, RelationshipBand> = {
+  hostile: "hostile",
+  wary: "cool",
+  neutral: "neutral",
+  warm: "warm",
+  allied: "close",
+};
+
+/** Map affection score → relationship band (reuses attitude numeric thresholds). */
+export function relationshipBandFromAffection(affection: number): RelationshipBand {
+  return ATTITUDE_TO_RELATIONSHIP_BAND[bandFromEffectiveScore(affection)];
+}
+
+/** UI-SPEC ZH labels for 关系网 — never collective 戒备/同盟. */
+export function relationshipBandLabelZh(band: RelationshipBand): string {
+  switch (band) {
+    case "hostile":
+      return "敌对";
+    case "cool":
+      return "冷淡";
+    case "neutral":
+      return "平常";
+    case "warm":
+      return "亲近";
+    case "close":
+      return "亲密";
+  }
+}
+
+/**
+ * Player GET DTO — band-mapped only; never includes affection/trust integers (D-GRAPH-02).
+ * Worker/internal still use {@link RelationshipEdgePublic}.
+ */
+export type RelationshipEdgeBandPublic = {
+  npcAId: string;
+  npcBId: string;
+  baseTag: string;
+  band: RelationshipBand;
+  bandLabelZh: string;
+  kindLabelZh: string;
+  currentStatus: string[];
+};
+
+export const relationshipEdgeBandPublicSchema = z
+  .object({
+    npcAId: z.string().min(1),
+    npcBId: z.string().min(1),
+    baseTag: z.string(),
+    band: z.enum(["hostile", "cool", "neutral", "warm", "close"]),
+    bandLabelZh: z.string().min(1),
+    kindLabelZh: z.string().min(1),
+    currentStatus: z.array(z.string()),
+  })
+  .strict();
+
+export function toRelationshipEdgeBandPublic(
+  edge: RelationshipEdgePublic,
+): RelationshipEdgeBandPublic {
+  const band = relationshipBandFromAffection(edge.affection);
+  return {
+    npcAId: edge.npcAId,
+    npcBId: edge.npcBId,
+    baseTag: edge.baseTag,
+    band,
+    bandLabelZh: relationshipBandLabelZh(band),
+    kindLabelZh: relationshipKindLabelZh(edge.baseTag),
+    currentStatus: edge.currentStatus,
+  };
+}
+
 export const relationshipDeltaInputSchema = z
   .object({
     npcAId: z.string().min(1),
diff --git a/packages/shared/src/index.ts b/packages/shared/src/index.ts
index dad4633..f077c41 100644
--- a/packages/shared/src/index.ts
+++ b/packages/shared/src/index.ts
@@ -147,6 +147,10 @@ export {
   type ColyseusMoveAckPayload,
   type ColyseusMovePayload,
   type ColyseusNpcJobDonePayload,
+  type ColyseusMutualChatBubblePayload,
+  type ColyseusPersonalTimelineSyncPayload,
+  type ColyseusRelationshipLinkedHintPayload,
+  type ColyseusRelationshipSyncPayload,
   type ColyseusSpeakPartialPayload,
   type ColyseusSpeakBusyPayload,
   type ColyseusSpeakIdlePayload,
@@ -369,10 +373,16 @@ export {
   normalizeEdgeIds,
   councilIndexEdgeIds,
   parseRelationshipDeltaInput,
+  relationshipBandFromAffection,
+  relationshipBandLabelZh,
   relationshipDeltaInputSchema,
+  relationshipEdgeBandPublicSchema,
   safeParseRelationshipDeltaInput,
+  toRelationshipEdgeBandPublic,
   type LinkedEdge,
+  type RelationshipBand,
   type RelationshipDeltaInput,
+  type RelationshipEdgeBandPublic,
   type RelationshipEdgePublic,
 } from "./councilRelationships.js";
 
diff --git a/scripts/verify-phase28.mjs b/scripts/verify-phase28.mjs
new file mode 100644
index 0000000..8619624
--- /dev/null
+++ b/scripts/verify-phase28.mjs
@@ -0,0 +1,319 @@
+/**
+ * Phase 28 E2E — Council relationship advanced ship gate (D-VERIFY-01).
+ *
+ * Flow: assertE2eRealLlm → health → dedicated room → wait band-mapped GET →
+ * force mutual-chat present (activity + bubble) → Playwright「关系网」band chips
+ * (no raw affection/trust integers).
+ *
+ * Speak RAG: covered by worker unit tests (LLM_MOCK OK) — not required live here.
+ * Decay + player caps: unit-only (D-VERIFY-02).
+ *
+ * Requires: pnpm dev:stack (no LLM_MOCK=1), real API keys in .env.
+ * Never run with LLM_MOCK=1 or dev:stack:mock — see docs/E2E-POLICY.md.
+ *
+ * Timeout: VERIFY_PHASE28_TIMEOUT_MS (default 900000).
+ */
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { assertE2eRealLlm } from "./lib/e2e-policy.mjs";
+import { engageDialogue } from "./lib/dialogue-engage.mjs";
+import { gameServerHttpBase, loadRootEnv } from "./lib/env.mjs";
+import { loadPlaywright } from "./lib/speak-browser-stack.mjs";
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+loadRootEnv(root);
+
+if (!process.env.WORLD_SEED) {
+  process.env.WORLD_SEED = "42";
+}
+
+const httpBase = gameServerHttpBase();
+const webBase = process.env.WEB_URL || "http://localhost:5173";
+const roomId = process.env.VERIFY_PHASE28_ROOM_ID || `verify-p28-${Date.now()}`;
+const webUrl = `${webBase}${webBase.includes("?") ? "&" : "?"}room=${encodeURIComponent(roomId)}`;
+const phaseTimeoutMs =
+  Number.parseInt(process.env.VERIFY_PHASE28_TIMEOUT_MS || "900000", 10) || 900_000;
+
+const BAND_LABELS = new Set(["敌对", "冷淡", "平常", "亲近", "亲密"]);
+const MUTUAL_REASON_RE = /交谈/;
+
+/** @returns {Record<string, string>} */
+function internalHeaders() {
+  const headers = { "Content-Type": "application/json" };
+  const token = process.env.INTERNAL_WORKER_TOKEN;
+  if (token) headers.Authorization = `Bearer ${token}`;
+  return headers;
+}
+
+function publicHeaders(playerId = "verify-p28-player") {
+  return { "X-Player-Id": playerId };
+}
+
+async function waitFor(fn, timeoutMs, label) {
+  const started = Date.now();
+  while (Date.now() - started < timeoutMs) {
+    try {
+      if (await fn()) return;
+    } catch {
+      // Transient fetch/UI errors — keep polling.
+    }
+    await new Promise((r) => setTimeout(r, 1500));
+  }
+  throw new Error(`timeout: ${label} (${timeoutMs}ms)`);
+}
+
+async function healthOk() {
+  const gsRes = await fetch(`${httpBase}/health`, { signal: AbortSignal.timeout(8000) });
+  if (!gsRes.ok) throw new Error(`game-server health ${gsRes.status}`);
+  const gsBody = await gsRes.json().catch(() => ({}));
+  if (gsBody.service !== "game-server" && gsBody.status !== "ok" && gsBody.ok !== true) {
+    throw new Error("game-server unexpected health body");
+  }
+  const webRes = await fetch(webBase, { signal: AbortSignal.timeout(8000) });
+  if (!webRes.ok) throw new Error(`web ${webBase} → ${webRes.status}`);
+}
+
+async function ensureRoom() {
+  const res = await fetch(`${httpBase}/rooms/${encodeURIComponent(roomId)}/state`, {
+    headers: publicHeaders("__legacy__"),
+    signal: AbortSignal.timeout(20_000),
+  });
+  if (!res.ok) throw new Error(`room state ${res.status}`);
+}
+
+async function fetchNpcRelationships() {
+  const res = await fetch(
+    `${httpBase}/rooms/${encodeURIComponent(roomId)}/npc-relationships`,
+    {
+      headers: publicHeaders("__legacy__"),
+      signal: AbortSignal.timeout(20_000),
+    },
+  );
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(`npc-relationships → ${res.status}: ${JSON.stringify(body).slice(0, 200)}`);
+  }
+  return Array.isArray(body.edges) ? body.edges : [];
+}
+
+async function fetchRoomState() {
+  const res = await fetch(`${httpBase}/rooms/${encodeURIComponent(roomId)}/state`, {
+    headers: publicHeaders("__legacy__"),
+    signal: AbortSignal.timeout(20_000),
+  });
+  if (!res.ok) throw new Error(`room state ${res.status}`);
+  return res.json();
+}
+
+/** D-GRAPH-02 / C-09b: band-mapped edges only — no affection/trust ints in payload. */
+function assertBandMappedEdges(edges) {
+  if (edges.length < 1) {
+    throw new Error("npc-relationships returned 0 edges (seed incomplete?)");
+  }
+  for (const edge of edges.slice(0, 20)) {
+    if ("affection" in edge || "trust" in edge) {
+      throw new Error(
+        `public GET leaked raw affection/trust: ${JSON.stringify(edge).slice(0, 200)}`,
+      );
+    }
+    if (!edge.band || !BAND_LABELS.has(String(edge.bandLabelZh || ""))) {
+      throw new Error(
+        `edge missing band/bandLabelZh: ${JSON.stringify(edge).slice(0, 200)}`,
+      );
+    }
+  }
+  console.log(
+    `[verify:phase28] npc-relationships band-mapped OK edges=${edges.length} sample=${edges[0].bandLabelZh}`,
+  );
+}
+
+/**
+ * Force mutual-chat presentation (hammer path) — activity + bubble smoke (D-MUTUAL-02).
+ * Live ambient enqueue may be slow; internal present is the deterministic E2E force.
+ */
+async function forceMutualChatPresent() {
+  const res = await fetch(
+    `${httpBase}/internal/rooms/${encodeURIComponent(roomId)}/npc-mutual-chat/present`,
+    {
+      method: "POST",
+      headers: internalHeaders(),
+      body: JSON.stringify({
+        npcAId: "npc-1",
+        npcBId: "npc-2",
+        npcAReasonZh: "与琳交谈中",
+        npcBReasonZh: "与艾交谈中",
+        bubbleText: "今日议事如何？",
+      }),
+      signal: AbortSignal.timeout(15_000),
+    },
+  );
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(
+      `npc-mutual-chat/present → ${res.status}: ${JSON.stringify(body).slice(0, 300)}`,
+    );
+  }
+  if (!body.ok || !body.bubble?.text) {
+    throw new Error(`present missing bubble: ${JSON.stringify(body).slice(0, 300)}`);
+  }
+  console.log(
+    `[verify:phase28] mutual-chat present OK bubble="${body.bubble.text}" expiresAt=${body.bubble.expiresAt}`,
+  );
+  return body.bubble;
+}
+
+async function assertMutualChatActivitySmoke(remainingMs) {
+  await forceMutualChatPresent();
+
+  await waitFor(
+    async () => {
+      const data = await fetchRoomState();
+      const npcs = data?.state?.npcs;
+      if (!Array.isArray(npcs)) return false;
+      const a = npcs.find((n) => n.id === "npc-1");
+      const b = npcs.find((n) => n.id === "npc-2");
+      if (!a || !b) return false;
+      return (
+        MUTUAL_REASON_RE.test(String(a.intentReasonZh || "")) &&
+        MUTUAL_REASON_RE.test(String(b.intentReasonZh || ""))
+      );
+    },
+    Math.min(30_000, Math.max(8_000, remainingMs())),
+    "npc-1/npc-2 intentReasonZh mutual-chat activity",
+  );
+
+  console.log(
+    "[verify:phase28] mutual-chat activity smoke OK (intentReasonZh 交谈中 on npc-1 + npc-2)",
+  );
+  console.log(
+    "[verify:phase28] note: speak RAG covered by workers/agent-worker/tests/test_relationship_rag.py (LLM_MOCK OK); optional live natural reference skipped",
+  );
+}
+
+/**
+ * Playwright: Drawer「关系网」tab + band chips; no raw integers in panel DOM (D-GRAPH-01/02).
+ */
+async function assertRelationshipGraphUi(remainingMs) {
+  const chromium = await loadPlaywright();
+  const browser = await chromium.launch({ headless: true });
+  try {
+    const page = await browser.newPage();
+    await page.goto(webUrl, { waitUntil: "domcontentloaded", timeout: 30_000 });
+
+    await page.locator('[data-testid="immersive-shell"]').waitFor({
+      state: "visible",
+      timeout: Math.min(60_000, remainingMs()),
+    });
+    await page.locator('[data-testid="phaser-parent"] canvas').first().waitFor({
+      state: "visible",
+      timeout: Math.min(60_000, remainingMs()),
+    });
+
+    const drawer = page.locator('[data-testid="shell-drawer"]');
+    if (!(await drawer.isVisible().catch(() => false))) {
+      // DialogueBar (关系网 entry) is only visible when dialogue-overlay is engaged.
+      await engageDialogue(page, { timeoutMs: Math.min(90_000, remainingMs()) });
+      await page.locator('[aria-label="关系网"]').click();
+    } else {
+      await page.locator('[data-testid="shell-drawer-tab-relationships"]').click();
+    }
+
+    await drawer.waitFor({ state: "visible", timeout: 15_000 });
+    await page.locator('[data-testid="shell-drawer-tab-relationships"]').waitFor({
+      state: "visible",
+      timeout: 10_000,
+    });
+    await page.locator('[data-testid="relationship-graph-panel"]').waitFor({
+      state: "visible",
+      timeout: Math.min(45_000, remainingMs()),
+    });
+
+    // Wait until edges render (seed + GET) — loading → chips or empty.
+    await waitFor(
+      async () => {
+        const chips = page.locator('[data-testid="relationship-graph-band-chip"]');
+        return (await chips.count()) >= 1;
+      },
+      Math.min(90_000, remainingMs()),
+      "relationship-graph-band-chip visible",
+    );
+
+    const chips = page.locator('[data-testid="relationship-graph-band-chip"]');
+    const chipCount = await chips.count();
+    const labels = [];
+    for (let i = 0; i < Math.min(chipCount, 12); i++) {
+      const text = ((await chips.nth(i).textContent()) || "").trim();
+      labels.push(text);
+      if (!BAND_LABELS.has(text)) {
+        throw new Error(`band chip unexpected label="${text}" (expected 敌对|冷淡|平常|亲近|亲密)`);
+      }
+    }
+
+    const panelText =
+      (await page.locator('[data-testid="relationship-graph-panel"]').innerText()) || "";
+    // D-GRAPH-02: no raw affection/trust scores in panel copy (band chips are ZH labels only).
+    const rawScoreHits = panelText.match(
+      /(?:affection|trust|好感度?|信任度?)\s*[=:：]?\s*-?\d+/gi,
+    );
+    if (rawScoreHits?.length) {
+      throw new Error(`关系网 panel leaked raw score text: ${rawScoreHits.join(", ")}`);
+    }
+    for (const label of labels) {
+      if (/\d/.test(label)) {
+        throw new Error(`band chip must be ZH label only, got "${label}"`);
+      }
+    }
+
+    const toggle = page.locator('[data-testid="relationship-graph-mode-toggle"]');
+    if ((await toggle.count()) > 0) {
+      await toggle.first().click();
+      console.log("[verify:phase28] relationship-graph-mode-toggle clicked");
+    }
+
+    console.log(
+      `[verify:phase28] 关系网 UI OK chips=${chipCount} labels=${labels.slice(0, 5).join(",")}`,
+    );
+  } finally {
+    await browser.close();
+  }
+}
+
+async function main() {
+  const t0 = Date.now();
+  assertE2eRealLlm("verify:phase28");
+  const remainingMs = () => Math.max(10_000, phaseTimeoutMs - (Date.now() - t0));
+
+  console.log(
+    `[verify:phase28] room=${roomId} http=${httpBase} web=${webUrl} timeoutMs=${phaseTimeoutMs}`,
+  );
+
+  await healthOk();
+  console.log("[verify:phase28] health ok");
+
+  await ensureRoom();
+  console.log("[verify:phase28] room ready");
+
+  // Seeds land async after getOrCreate (66 council edges).
+  await waitFor(
+    async () => {
+      const edges = await fetchNpcRelationships();
+      return edges.length >= 12;
+    },
+    Math.min(180_000, remainingMs()),
+    "npc-relationships ≥12 band edges seeded",
+  );
+  const edges = await fetchNpcRelationships();
+  assertBandMappedEdges(edges);
+
+  await assertMutualChatActivitySmoke(remainingMs);
+  await assertRelationshipGraphUi(remainingMs);
+
+  const elapsedSec = ((Date.now() - t0) / 1000).toFixed(1);
+  console.log(`[verify:phase28] PASS in ${elapsedSec}s`);
+}
+
+main().catch((err) => {
+  console.error("[verify:phase28] FAIL:", err instanceof Error ? err.message : err);
+  console.error("Ensure full stack: pnpm dev:stack (no LLM_MOCK). Game-server :2567, web :5173.");
+  process.exit(1);
+});
diff --git a/workers/agent-worker/src/council/belief_gate.py b/workers/agent-worker/src/council/belief_gate.py
new file mode 100644
index 0000000..b592a8b
--- /dev/null
+++ b/workers/agent-worker/src/council/belief_gate.py
@@ -0,0 +1,580 @@
+"""Player provoke / joint-adventure belief gate (D-PLAYER-01…06, EA-5/EA-6).
+
+Planner-locked cutoffs (Open Q2 / 28-01):
+  effectiveScore < -30 → hard reject without LLM
+  effectiveScore < 0  → LLM judgment with skeptical bias
+  effectiveScore >= 0 → LLM believe / reject / skeptical
+
+Trust source: npc_attitudes / collective effectiveScore for
+(room, activeNpc, initiatorPlayerId) only — NEVER npc_relationships (EA-5).
+
+Reject → no A↔B relationship delta (EA-6). Accepted player A↔B |Δ| clamped to 2–6.
+"""
+
+from __future__ import annotations
+
+import os
+import random
+import re
+from dataclasses import dataclass
+from typing import Any, Callable, Literal
+
+from src.council.registry import display_name
+from src.council.constants import COUNCIL_NPC_IDS
+
+# Planner-locked belief cutoffs
+HARD_REJECT_THRESHOLD = -30
+SKEPTICAL_BIAS_THRESHOLD = 0
+
+# D-PLAYER-03
+PLAYER_AB_DELTA_MIN = 2
+PLAYER_AB_DELTA_MAX = 6
+
+# D-PLAYER-06 micro trust penalty
+TRUST_MICRO_PENALTY_MIN = 1
+TRUST_MICRO_PENALTY_MAX = 3
+
+# D-PLAYER-04 dual caps
+PAIR_CAP_PER_DAY = 1
+PLAYER_CAP_PER_DAY = 3
+
+Decision = Literal["accept", "reject", "none"]
+RejectReason = Literal[
+    "hard_threshold",
+    "llm_reject",
+    "pair_cap",
+    "player_cap",
+    "not_manipulation",
+    "",
+]
+
+IC_REFUSAL_TEMPLATES = (
+    "这话我不太信。你们之间的事，我不便插手。",
+    "我不会按你说的去挑拨他们。请别再试了。",
+    "你的说辞说服不了我——我不会介入他们的关系。",
+)
+
+_PROVOKE_KEYWORDS = (
+    "挑拨",
+    "离间",
+    "对付",
+    "疏远",
+    "仇恨",
+    "反目",
+    "作对",
+    "陷害",
+)
+_JOINT_KEYWORDS = (
+    "一起去",
+    "共同冒险",
+    "一起冒险",
+    "陪我去",
+    "结伴",
+    "同行一趟",
+)
+
+# In-process dual-cap claims: (scope, day_key, id) → count
+_pair_claims: dict[tuple[str, str, str], int] = {}
+_player_claims: dict[tuple[str, str, str], int] = {}
+_reject_counts: dict[tuple[str, str, str, str], int] = {}
+_trust_penalty_claims: dict[tuple[str, str, str, str], int] = {}
+
+
+def clear_manipulation_caps_for_test() -> None:
+    _pair_claims.clear()
+    _player_claims.clear()
+    _reject_counts.clear()
+    _trust_penalty_claims.clear()
+
+
+def _prune_stale_day_keys(current_day_key: str) -> None:
+    """Drop in-process cap entries from prior game days (long-running worker)."""
+    for store in (_pair_claims, _player_claims):
+        stale = [key for key in store if key[1] != current_day_key]
+        for key in stale:
+            del store[key]
+    for store in (_reject_counts, _trust_penalty_claims):
+        stale = [key for key in store if key[1] != current_day_key]
+        for key in stale:
+            del store[key]
+
+
+@dataclass(frozen=True)
+class ManipulationIntent:
+    kind: Literal["provoke", "joint", "none"]
+    weight: float
+    npc_a_id: str | None = None
+    npc_b_id: str | None = None
+
+
+@dataclass(frozen=True)
+class BeliefJudgment:
+    decision: Literal["accept", "reject"]
+    reason: str = ""
+    proposed_delta: int = 4
+
+
+@dataclass
+class BeliefGateResult:
+    decision: Decision
+    reject_reason: RejectReason = ""
+    used_llm: bool = False
+    skeptical_bias: bool = False
+    affection_delta: int = 0
+    ic_refusal_reply: str = ""
+    npc_a_id: str | None = None
+    npc_b_id: str | None = None
+    kind: Literal["provoke", "joint", "none"] = "none"
+
+
+def clamp_player_ab_delta(delta: int) -> int:
+    """D-PLAYER-03: player-triggered edge |Δ| in 2–6."""
+    if delta == 0:
+        delta = PLAYER_AB_DELTA_MIN
+    sign = -1 if delta < 0 else 1
+    mag = abs(int(delta))
+    mag = max(PLAYER_AB_DELTA_MIN, min(PLAYER_AB_DELTA_MAX, mag))
+    return sign * mag
+
+
+def ic_refusal_reply(*, seed: str = "") -> str:
+    """Deterministic IC refusal for speak turn (UI-SPEC: in-dialogue only)."""
+    if not seed:
+        return IC_REFUSAL_TEMPLATES[0]
+    idx = sum(ord(c) for c in seed) % len(IC_REFUSAL_TEMPLATES)
+    return IC_REFUSAL_TEMPLATES[idx]
+
+
+def _name_to_id() -> dict[str, str]:
+    mapping: dict[str, str] = {}
+    for npc_id in COUNCIL_NPC_IDS:
+        name = display_name(npc_id)
+        if name:
+            mapping[name] = npc_id
+    return mapping
+
+
+def _normalize_pair(a: str, b: str) -> tuple[str, str]:
+    return (a, b) if a < b else (b, a)
+
+
+def detect_manipulation_intent(speak_text: str) -> ManipulationIntent:
+    """D-PLAYER-01/02: keyword + explicit「让 A … B」; joint = shared adventure phrasing."""
+    text = (speak_text or "").strip()
+    if not text:
+        return ManipulationIntent(kind="none", weight=0.0)
+
+    name_map = _name_to_id()
+    # Prefer longer names first when scanning, but assign A/B by first appearance in text.
+    appearances: list[tuple[int, str]] = []
+    for name, npc_id in sorted(name_map.items(), key=lambda x: -len(x[0])):
+        idx = text.find(name)
+        if idx >= 0 and npc_id not in {n for _, n in appearances}:
+            appearances.append((idx, npc_id))
+    appearances.sort(key=lambda x: x[0])
+    found_ids = [npc_id for _, npc_id in appearances]
+
+    # Explicit「让 A … B」— higher weight
+    explicit_match = re.search(r"让(.{1,12}?)(?:去|来)?(?:对付|疏远|离间|挑拨|为难)", text)
+    if explicit_match and len(found_ids) >= 2:
+        return ManipulationIntent(
+            kind="provoke",
+            weight=2.0,
+            npc_a_id=found_ids[0],
+            npc_b_id=found_ids[1],
+        )
+    if "让" in text and len(found_ids) >= 2 and any(k in text for k in _PROVOKE_KEYWORDS):
+        return ManipulationIntent(
+            kind="provoke",
+            weight=2.0,
+            npc_a_id=found_ids[0],
+            npc_b_id=found_ids[1],
+        )
+
+    if any(k in text for k in _PROVOKE_KEYWORDS):
+        a = found_ids[0] if found_ids else None
+        b = found_ids[1] if len(found_ids) > 1 else None
+        return ManipulationIntent(kind="provoke", weight=1.0, npc_a_id=a, npc_b_id=b)
+
+    if any(k in text for k in _JOINT_KEYWORDS):
+        a = found_ids[0] if found_ids else None
+        b = found_ids[1] if len(found_ids) > 1 else None
+        return ManipulationIntent(kind="joint", weight=1.0, npc_a_id=a, npc_b_id=b)
+
+    return ManipulationIntent(kind="none", weight=0.0)
+
+
+def resolve_player_npc_trust(
+    *,
+    room_id: str,
+    active_npc_id: str,
+    initiator_player_id: str,
+    peer_player_id: str | None = None,
+    fetch_effective_score: Callable[..., int] | None = None,
+    effective_score: int | None = None,
+) -> int:
+    """EA-5: player↔NPC trust via attitudes/collective — initiator playerId only.
+
+    ``peer_player_id`` is accepted only to assert callers do not use it for lookup.
+    """
+    del peer_player_id  # never used for trust (EA-5)
+    if effective_score is not None:
+        return int(effective_score)
+    if fetch_effective_score is None:
+        return 0
+    return int(
+        fetch_effective_score(
+            room_id=room_id,
+            npc_id=active_npc_id,
+            player_id=initiator_player_id,
+        )
+    )
+
+
+def default_llm_judge(
+    *,
+    speak_text: str,
+    effective_score: int,
+    skeptical_bias: bool,
+    llm_mock: bool | None = None,
+) -> BeliefJudgment:
+    """LLM believe/reject/skeptical JSON judgment. LLM_MOCK is deterministic."""
+    mock = llm_mock if llm_mock is not None else (
+        os.getenv("LLM_MOCK") == "1"
+    )
+    if mock:
+        # Skeptical bias → reject under mock; non-skeptical with score≥0 → accept
+        if skeptical_bias:
+            return BeliefJudgment(decision="reject", reason="skeptical_mock", proposed_delta=0)
+        if effective_score >= SKEPTICAL_BIAS_THRESHOLD:
+            return BeliefJudgment(decision="accept", reason="trust_mock", proposed_delta=4)
+        return BeliefJudgment(decision="reject", reason="low_trust_mock", proposed_delta=0)
+
+    # Real LLM judge not wired yet — guardrail-consistent reject, never silent accept.
+    del speak_text
+    if skeptical_bias and effective_score < 10:
+        return BeliefJudgment(decision="reject", reason="skeptical_fallback", proposed_delta=0)
+    return BeliefJudgment(decision="reject", reason="llm_judge_unwired", proposed_delta=0)
+
+
+def _pair_key(room_id: str, a: str, b: str) -> str:
+    na, nb = _normalize_pair(a, b)
+    return f"{room_id}:{na}:{nb}"
+
+
+def claim_manipulation_slot(
+    *,
+    room_id: str,
+    player_id: str,
+    npc_a_id: str,
+    npc_b_id: str,
+    day_key: str,
+) -> RejectReason | None:
+    """D-PLAYER-04: per-(A,B) 1/day + per-player 3/day. Returns reject reason or None."""
+    _prune_stale_day_keys(day_key)
+    pair = _pair_key(room_id, npc_a_id, npc_b_id)
+    pair_claim_key = (room_id, day_key, pair)
+    player_claim_key = (room_id, day_key, player_id)
+
+    if _pair_claims.get(pair_claim_key, 0) >= PAIR_CAP_PER_DAY:
+        return "pair_cap"
+    if _player_claims.get(player_claim_key, 0) >= PLAYER_CAP_PER_DAY:
+        return "player_cap"
+
+    _pair_claims[pair_claim_key] = _pair_claims.get(pair_claim_key, 0) + 1
+    _player_claims[player_claim_key] = _player_claims.get(player_claim_key, 0) + 1
+    return None
+
+
+def note_belief_reject(
+    *,
+    room_id: str,
+    player_id: str,
+    npc_id: str,
+    day_key: str,
+) -> int:
+    """Count repeated rejects same day for micro trust penalty (D-PLAYER-06)."""
+    _prune_stale_day_keys(day_key)
+    key = (room_id, day_key, player_id, npc_id)
+    _reject_counts[key] = _reject_counts.get(key, 0) + 1
+    return _reject_counts[key]
+
+
+def maybe_trust_micro_penalty(
+    *,
+    room_id: str,
+    player_id: str,
+    npc_id: str,
+    day_key: str,
+    apply_trust_delta: Callable[..., None] | None = None,
+) -> int:
+    """Post-reply only: repeated reject → player↔NPC trust |Δ| 1–3 with daily cap."""
+    key = (room_id, day_key, player_id, npc_id)
+    rejects = _reject_counts.get(key, 0)
+    if rejects < 2:
+        return 0
+    penalty_key = key
+    if _trust_penalty_claims.get(penalty_key, 0) >= 1:
+        return 0
+    delta = -random.randint(TRUST_MICRO_PENALTY_MIN, TRUST_MICRO_PENALTY_MAX)
+    _trust_penalty_claims[penalty_key] = 1
+    if apply_trust_delta is not None:
+        apply_trust_delta(
+            room_id=room_id,
+            npc_id=npc_id,
+            player_id=player_id,
+            delta=delta,
+        )
+    return delta
+
+
+def evaluate_belief_gate(
+    *,
+    initiator_player_id: str,
+    active_npc_id: str,
+    room_id: str,
+    speak_text: str,
+    proposed_a_id: str | None,
+    proposed_b_id: str | None,
+    effective_score: int,
+    day_key: str = "day-0",
+    llm_judge: Callable[..., BeliefJudgment] | None = None,
+    apply_ab_delta: Callable[..., None] | None = None,
+    intent: ManipulationIntent | None = None,
+) -> BeliefGateResult:
+    """Hybrid belief gate. Reject never calls apply_ab_delta (EA-6)."""
+    detected = intent or detect_manipulation_intent(speak_text)
+    if detected.kind == "none" and not (proposed_a_id and proposed_b_id):
+        return BeliefGateResult(decision="none", kind="none")
+
+    kind = detected.kind if detected.kind != "none" else "provoke"
+    npc_a = proposed_a_id or detected.npc_a_id
+    npc_b = proposed_b_id or detected.npc_b_id
+    if not npc_a or not npc_b or npc_a == npc_b:
+        # Need a pair for A↔B; still allow reject reply on hard threshold provoke
+        if detected.kind == "none":
+            return BeliefGateResult(decision="none", kind="none")
+
+    score = int(effective_score)
+    refusal = ic_refusal_reply(seed=f"{room_id}:{initiator_player_id}:{speak_text}")
+
+    # Hard reject — no LLM
+    if score < HARD_REJECT_THRESHOLD:
+        note_belief_reject(
+            room_id=room_id,
+            player_id=initiator_player_id,
+            npc_id=active_npc_id,
+            day_key=day_key,
+        )
+        return BeliefGateResult(
+            decision="reject",
+            reject_reason="hard_threshold",
+            used_llm=False,
+            skeptical_bias=False,
+            affection_delta=0,
+            ic_refusal_reply=refusal,
+            npc_a_id=npc_a,
+            npc_b_id=npc_b,
+            kind=kind,  # type: ignore[arg-type]
+        )
+
+    skeptical = score < SKEPTICAL_BIAS_THRESHOLD
+    judge_fn = llm_judge or default_llm_judge
+    judgment = judge_fn(
+        speak_text=speak_text,
+        effective_score=score,
+        skeptical_bias=skeptical,
+    )
+    used_llm = True
+
+    if judgment.decision == "reject":
+        note_belief_reject(
+            room_id=room_id,
+            player_id=initiator_player_id,
+            npc_id=active_npc_id,
+            day_key=day_key,
+        )
+        return BeliefGateResult(
+            decision="reject",
+            reject_reason="llm_reject",
+            used_llm=used_llm,
+            skeptical_bias=skeptical,
+            affection_delta=0,
+            ic_refusal_reply=refusal,
+            npc_a_id=npc_a,
+            npc_b_id=npc_b,
+            kind=kind,  # type: ignore[arg-type]
+        )
+
+    # Accept path — dual caps before apply
+    if not npc_a or not npc_b:
+        return BeliefGateResult(
+            decision="reject",
+            reject_reason="not_manipulation",
+            used_llm=used_llm,
+            skeptical_bias=skeptical,
+            affection_delta=0,
+            ic_refusal_reply=refusal,
+            kind=kind,  # type: ignore[arg-type]
+        )
+
+    cap_reject = claim_manipulation_slot(
+        room_id=room_id,
+        player_id=initiator_player_id,
+        npc_a_id=npc_a,
+        npc_b_id=npc_b,
+        day_key=day_key,
+    )
+    if cap_reject:
+        note_belief_reject(
+            room_id=room_id,
+            player_id=initiator_player_id,
+            npc_id=active_npc_id,
+            day_key=day_key,
+        )
+        return BeliefGateResult(
+            decision="reject",
+            reject_reason=cap_reject,
+            used_llm=used_llm,
+            skeptical_bias=skeptical,
+            affection_delta=0,
+            ic_refusal_reply=refusal,
+            npc_a_id=npc_a,
+            npc_b_id=npc_b,
+            kind=kind,  # type: ignore[arg-type]
+        )
+
+    delta = clamp_player_ab_delta(int(judgment.proposed_delta or 4))
+    if apply_ab_delta is not None:
+        apply_ab_delta(
+            room_id=room_id,
+            npc_a_id=npc_a,
+            npc_b_id=npc_b,
+            affection_delta=delta,
+            initiator_player_id=initiator_player_id,
+        )
+
+    return BeliefGateResult(
+        decision="accept",
+        reject_reason="",
+        used_llm=used_llm,
+        skeptical_bias=skeptical,
+        affection_delta=delta,
+        ic_refusal_reply="",
+        npc_a_id=npc_a,
+        npc_b_id=npc_b,
+        kind=kind,  # type: ignore[arg-type]
+    )
+
+
+def day_key_from_snapshot(room_snapshot: dict[str, Any] | None) -> str:
+    snap = room_snapshot or {}
+    # Prefer monotonic absoluteGameMinute (worker-state CR PR#22); fall back to wrapped gameMinute.
+    abs_minute = snap.get("absoluteGameMinute")
+    if abs_minute is not None:
+        minute = int(abs_minute)
+    else:
+        minute = int(snap.get("gameMinute") or snap.get("game_minute") or 0)
+    return f"day-{minute // 1440}"
+
+
+def run_belief_gate_speak(
+    state: dict[str, Any],
+    *,
+    settings: Any | None = None,
+    client: Any | None = None,
+    apply_ab_delta: Callable[..., None] | None = None,
+    llm_judge: Callable[..., BeliefJudgment] | None = None,
+    enqueue_rel07: Callable[..., list] | None = None,
+) -> dict[str, Any]:
+    """Interactive speak hook — run BEFORE compose_reply finalizes player-visible reply.
+
+    Never call from Colyseus onMessage speak. Reject forces IC refusal as reply_draft.
+    Accept applies A↔B via apply_ab_delta (or HTTP when client+settings provided).
+    """
+    from src.council.relationship_deltas import clamp_player_provoke_delta
+
+    player_message = (state.get("player_message") or "").strip()
+    intent = detect_manipulation_intent(player_message)
+    if intent.kind == "none":
+        return {**state, "manipulation_intent": "none"}
+
+    room_id = str(state.get("room_id") or "")
+    npc_id = str(state.get("npc_id") or "npc-1")
+    player_id = str(state.get("player_id") or "__legacy__")
+    score_raw = state.get("effective_score")
+    score = int(score_raw) if isinstance(score_raw, (int, float)) else 0
+    day_key = day_key_from_snapshot(state.get("room_snapshot"))
+
+    apply_fn = apply_ab_delta
+    if apply_fn is None and client is not None and settings is not None:
+        from src.graph.personal_timeline import (
+            DYAD_REL_MIN_ABS_DELTA,
+            apply_single_relationship_delta,
+            enqueue_rel07_bilateral_jobs,
+        )
+
+        def apply_fn(**kwargs: Any) -> None:
+            delta = clamp_player_provoke_delta(int(kwargs["affection_delta"]))
+            apply_single_relationship_delta(
+                client,
+                settings,
+                room_id=kwargs["room_id"],
+                npc_a_id=kwargs["npc_a_id"],
+                npc_b_id=kwargs["npc_b_id"],
+                affection_delta=delta,
+                history_append=f"玩家促成互动（Δ{delta:+d}）",
+            )
+            rel_fn = enqueue_rel07 or enqueue_rel07_bilateral_jobs
+            snap = state.get("room_snapshot") or {}
+            epoch = int(snap.get("absoluteGameMinute") or snap.get("gameMinute") or 0)
+            rel_fn(
+                room_id=kwargs["room_id"],
+                npc_a_id=kwargs["npc_a_id"],
+                npc_b_id=kwargs["npc_b_id"],
+                event_anchor_id=f"provoke-{day_key}-{kwargs['npc_a_id']}-{kwargs['npc_b_id']}",
+                affection_delta=delta,
+                aether_epoch_minute=epoch,
+                history_append=f"玩家促成互动（Δ{delta:+d}）",
+                min_abs_delta=DYAD_REL_MIN_ABS_DELTA,
+                settings=settings,
+            )
+
+    result = evaluate_belief_gate(
+        initiator_player_id=player_id,
+        active_npc_id=npc_id,
+        room_id=room_id,
+        speak_text=player_message,
+        proposed_a_id=intent.npc_a_id,
+        proposed_b_id=intent.npc_b_id,
+        effective_score=score,
+        day_key=day_key,
+        llm_judge=llm_judge,
+        apply_ab_delta=apply_fn,
+        intent=intent,
+    )
+
+    out = {
+        **state,
+        "manipulation_intent": intent.kind,
+        "belief_decision": result.decision,
+        "belief_rejected": result.decision == "reject",
+        "belief_ab_applied": result.decision == "accept" and result.affection_delta != 0,
+        "belief_day_key": day_key,
+    }
+    if result.decision == "reject":
+        refusal = result.ic_refusal_reply or ic_refusal_reply(seed=player_message)
+        out["reply_draft"] = refusal
+        out["reply"] = refusal
+        out["belief_ab_applied"] = False
+    return out
+
+
+def belief_gate_speak_node(
+    state: dict[str, Any],
+    *,
+    settings: Any,
+    client: Any,
+) -> dict[str, Any]:
+    """LangGraph node wrapper (httpx client injected by _with_client_node)."""
+    return run_belief_gate_speak(state, settings=settings, client=client)
diff --git a/workers/agent-worker/src/council/memory_context.py b/workers/agent-worker/src/council/memory_context.py
index 5d2b652..9014271 100644
--- a/workers/agent-worker/src/council/memory_context.py
+++ b/workers/agent-worker/src/council/memory_context.py
@@ -11,6 +11,10 @@
     fetch_personal_timeline_context,
     merge_personal_rag_into_canon,
 )
+from src.council.relationship_rag import (
+    fetch_relationship_rag_context,
+    merge_relationship_rag_into_canon,
+)
 from src.council.world_history_rag import (
     fetch_world_history_canon_context,
     format_canon_bullet,
@@ -74,6 +78,7 @@ def fetch_dual_rag_context(
         canon_entries=canon_entries,
     )
     personal_bullets: list[str] = []
+    relationship_bullets: list[str] = []
     if npc_id.startswith("npc-"):
         personal_bullets = fetch_personal_timeline_context(
             client,
@@ -83,9 +88,18 @@ def fetch_dual_rag_context(
             query,
         )
         canon_context = merge_personal_rag_into_canon(canon_context, personal_bullets)
+        relationship_bullets = fetch_relationship_rag_context(
+            client,
+            settings,
+            room_id,
+            npc_id,
+            query,
+        )
+        canon_context = merge_relationship_rag_into_canon(canon_context, relationship_bullets)
     return {
         "canon_context": canon_context,
         "canon_entries": canon_entries,
         "council_retrieved": retrieved,
         "personal_timeline_bullets": personal_bullets,
+        "relationship_rag_bullets": relationship_bullets,
     }
diff --git a/workers/agent-worker/src/council/relationship_deltas.py b/workers/agent-worker/src/council/relationship_deltas.py
index 95dc03d..5378f5d 100644
--- a/workers/agent-worker/src/council/relationship_deltas.py
+++ b/workers/agent-worker/src/council/relationship_deltas.py
@@ -271,3 +271,10 @@ def iter_rel07_trigger_deltas(deltas: list[RelationshipDelta]) -> list[Relations
 
 def linked_edges_from_deltas(deltas: list[RelationshipDelta]) -> list[dict[str, str]]:
     return [{"npcAId": d["npcAId"], "npcBId": d["npcBId"]} for d in deltas if d.get("affectionDelta")]
+
+
+def clamp_player_provoke_delta(delta: int) -> int:
+    """D-PLAYER-03: player provoke/joint edge |Δ| clamped to 2–6."""
+    from src.council.belief_gate import clamp_player_ab_delta
+
+    return clamp_player_ab_delta(delta)
diff --git a/workers/agent-worker/src/council/relationship_rag.py b/workers/agent-worker/src/council/relationship_rag.py
new file mode 100644
index 0000000..98d0bc7
--- /dev/null
+++ b/workers/agent-worker/src/council/relationship_rag.py
@@ -0,0 +1,339 @@
+"""Relationship edge Speak RAG (D-EMBED-01…04) — paraphrase discipline like personal_timeline_rag."""
+
+from __future__ import annotations
+
+import re
+import sys
+from typing import Any
+
+import httpx
+
+from src.config import Settings
+from src.council.constants import COUNCIL_NPC_IDS
+from src.council.registry import display_name
+
+_REL_FETCH_TIMEOUT_S = 8.0
+_MAX_REL_BULLETS = 2
+_PARAPHRASE_BODY_LEN = 48
+
+_TOPIC_KEYWORDS = frozenset(
+    {
+        "关系",
+        "同僚",
+        "议员",
+        "亲密",
+        "冷淡",
+        "敌对",
+        "同盟",
+        "旧怨",
+        "信任",
+        "交恶",
+        "疏远",
+        "议会",
+        "廷议",
+    }
+)
+
+
+def _game_headers(settings: Settings) -> dict[str, str]:
+    headers: dict[str, str] = {"X-Player-Id": "__legacy__"}
+    if settings.internal_worker_token:
+        headers["Authorization"] = f"Bearer {settings.internal_worker_token}"
+    return headers
+
+
+def _normalize_tokens(text: str) -> set[str]:
+    cleaned = re.sub(r"\s+", "", (text or "").lower())
+    tokens: set[str] = set()
+    for kw in _TOPIC_KEYWORDS:
+        if kw in cleaned:
+            tokens.add(kw)
+    for piece in re.findall(r"[\u4e00-\u9fff]{2,}", cleaned):
+        if len(piece) >= 2:
+            tokens.add(piece)
+    for npc_id in COUNCIL_NPC_IDS:
+        name = display_name(npc_id)
+        if name and name in (text or ""):
+            tokens.add(name)
+    return tokens
+
+
+def referenced_third_party_ids(query: str, active_npc_id: str) -> list[str]:
+    """NPC ids mentioned in query besides the speaking NPC (D-EMBED-04)."""
+    found: list[str] = []
+    for npc_id in COUNCIL_NPC_IDS:
+        if npc_id == active_npc_id:
+            continue
+        name = display_name(npc_id)
+        if npc_id in query or (name and name in query):
+            found.append(npc_id)
+    return found
+
+
+def topic_relevant_relationship(query: str, edges: list[dict[str, Any]]) -> bool:
+    q_tokens = _normalize_tokens(query)
+    if not q_tokens:
+        return False
+    corpus_parts: list[str] = []
+    for edge in edges:
+        corpus_parts.append(str(edge.get("historySummary") or ""))
+        for tag in edge.get("currentStatus") or []:
+            corpus_parts.append(str(tag))
+    corpus = " ".join(corpus_parts)
+    c_tokens = _normalize_tokens(corpus)
+    if q_tokens & c_tokens:
+        return True
+    if q_tokens & _TOPIC_KEYWORDS and c_tokens & _TOPIC_KEYWORDS:
+        return True
+    return False
+
+
+def _truncate(text: str, max_len: int) -> str:
+    stripped = (text or "").strip()
+    if len(stripped) <= max_len:
+        return stripped
+    return f"{stripped[: max_len - 1]}…"
+
+
+def peer_npc_id(edge: dict[str, Any], active_npc_id: str) -> str:
+    if edge.get("npcAId") == active_npc_id:
+        return str(edge.get("npcBId") or "")
+    if edge.get("npcBId") == active_npc_id:
+        return str(edge.get("npcAId") or "")
+    return str(edge.get("npcBId") or edge.get("npcAId") or "")
+
+
+def format_relationship_bullet(edge: dict[str, Any], active_npc_id: str) -> str:
+    """Paraphrase bullet — never dump full history_summary (D-RAG-01 style)."""
+    history = str(edge.get("historySummary") or "").strip()
+    status = [str(t) for t in (edge.get("currentStatus") or []) if str(t).strip()]
+    peer = peer_npc_id(edge, active_npc_id)
+    peer_name = display_name(peer) if peer in COUNCIL_NPC_IDS else peer
+    status_gist = "、".join(status[:2]) if status else ""
+    raw_gist = history or status_gist
+    gist = _truncate(raw_gist, _PARAPHRASE_BODY_LEN)
+    if history and history in gist and len(history) > _PARAPHRASE_BODY_LEN:
+        gist = _truncate(history, _PARAPHRASE_BODY_LEN)
+    if active_npc_id in (edge.get("npcAId"), edge.get("npcBId")):
+        return f"·与{peer_name}的关系：{gist}（意译，勿复读原文）"
+    # Cross-NPC analogy when edge does not include active NPC
+    a_name = display_name(str(edge.get("npcAId") or "")) or edge.get("npcAId")
+    b_name = display_name(str(edge.get("npcBId") or "")) or edge.get("npcBId")
+    return f"·{a_name}与{b_name}之间：{gist}（类比参考，勿复读原文）"
+
+
+def score_edge_for_query(query: str, edge: dict[str, Any], active_npc_id: str) -> int:
+    q_tokens = _normalize_tokens(query)
+    if not q_tokens:
+        return 0
+    blob = " ".join(
+        [
+            str(edge.get("historySummary") or ""),
+            " ".join(str(t) for t in (edge.get("currentStatus") or [])),
+            peer_npc_id(edge, active_npc_id),
+            display_name(peer_npc_id(edge, active_npc_id)) or "",
+        ]
+    )
+    e_tokens = _normalize_tokens(blob)
+    score = len(q_tokens & e_tokens)
+    if active_npc_id in (edge.get("npcAId"), edge.get("npcBId")):
+        score += 3
+    return score
+
+
+def select_relationship_edges(
+    query: str,
+    edges: list[dict[str, Any]],
+    active_npc_id: str,
+    *,
+    limit: int = _MAX_REL_BULLETS,
+) -> list[dict[str, Any]]:
+    if not topic_relevant_relationship(query, edges):
+        return []
+
+    active_edges = [
+        e for e in edges if active_npc_id in (e.get("npcAId"), e.get("npcBId"))
+    ]
+    cross_edges = [
+        e for e in edges if active_npc_id not in (e.get("npcAId"), e.get("npcBId"))
+    ]
+    third_parties = referenced_third_party_ids(query, active_npc_id)
+
+    ranked_active = sorted(
+        active_edges,
+        key=lambda e: score_edge_for_query(query, e, active_npc_id),
+        reverse=True,
+    )
+    selected: list[dict[str, Any]] = []
+    for edge in ranked_active:
+        if score_edge_for_query(query, edge, active_npc_id) <= 0 and not (
+            _normalize_tokens(str(edge.get("historySummary") or "")) & _TOPIC_KEYWORDS
+        ):
+            continue
+        selected.append(edge)
+        if len(selected) >= limit:
+            break
+
+    if len(selected) < limit and third_parties:
+        analogy_pool = [
+            e
+            for e in cross_edges
+            if any(tp in (e.get("npcAId"), e.get("npcBId")) for tp in third_parties)
+        ]
+        ranked_analogy = sorted(
+            analogy_pool,
+            key=lambda e: score_edge_for_query(query, e, active_npc_id),
+            reverse=True,
+        )
+        for edge in ranked_analogy:
+            if len(selected) >= limit:
+                break
+            selected.append(edge)
+
+    return selected[:limit]
+
+
+def fetch_relationship_edges(
+    client: httpx.Client,
+    settings: Settings,
+    room_id: str,
+    npc_id: str,
+    *,
+    limit: int = 12,
+) -> list[dict[str, Any]]:
+    base = settings.game_server_url.rstrip("/")
+    url = f"{base}/internal/rooms/{room_id}/npc-relationships"
+    try:
+        res = client.get(
+            url,
+            params={"npcId": npc_id, "limit": str(limit)},
+            headers=_game_headers(settings),
+            timeout=_REL_FETCH_TIMEOUT_S,
+        )
+        res.raise_for_status()
+        payload = res.json()
+        return list(payload.get("edges") or [])
+    except Exception as exc:
+        print(
+            f"relationship edges fetch failed room={room_id} npc={npc_id}: {exc}",
+            file=sys.stderr,
+        )
+        return []
+
+
+def request_lazy_edge_embed(
+    client: httpx.Client,
+    settings: Settings,
+    room_id: str,
+    npc_a_id: str,
+    npc_b_id: str,
+) -> bool:
+    """D-EMBED-03: lazy embed when speak selects edge without vector."""
+    base = settings.game_server_url.rstrip("/")
+    url = f"{base}/internal/rooms/{room_id}/npc-relationships/ensure-embedding"
+    try:
+        res = client.post(
+            url,
+            json={"npcAId": npc_a_id, "npcBId": npc_b_id},
+            headers=_game_headers(settings),
+            timeout=_REL_FETCH_TIMEOUT_S,
+        )
+        res.raise_for_status()
+        payload = res.json()
+        return bool(payload.get("embedded"))
+    except Exception as exc:
+        print(
+            f"relationship lazy embed failed room={room_id} {npc_a_id}/{npc_b_id}: {exc}",
+            file=sys.stderr,
+        )
+        return False
+
+
+def fetch_vector_ranked_edges(
+    client: httpx.Client,
+    settings: Settings,
+    room_id: str,
+    active_npc_id: str,
+    query: str,
+    *,
+    k: int = 5,
+) -> list[dict[str, Any]]:
+    base = settings.game_server_url.rstrip("/")
+    url = f"{base}/internal/rooms/{room_id}/npc-relationships/search-similar"
+    try:
+        res = client.post(
+            url,
+            json={"query": query, "activeNpcId": active_npc_id, "k": k},
+            headers=_game_headers(settings),
+            timeout=_REL_FETCH_TIMEOUT_S,
+        )
+        res.raise_for_status()
+        payload = res.json()
+        return list(payload.get("edges") or [])
+    except Exception as exc:
+        print(
+            f"relationship search-similar failed room={room_id} npc={active_npc_id}: {exc}",
+            file=sys.stderr,
+        )
+        return []
+
+
+def fetch_relationship_rag_context(
+    client: httpx.Client,
+    settings: Settings,
+    room_id: str,
+    active_npc_id: str,
+    query: str,
+) -> list[str]:
+    """Return 0–2 paraphrase bullets for speak (D-EMBED-01/04)."""
+    if not active_npc_id.startswith("npc-"):
+        return []
+
+    vector_hits = fetch_vector_ranked_edges(
+        client, settings, room_id, active_npc_id, query, k=_MAX_REL_BULLETS + 2
+    )
+    edges = fetch_relationship_edges(client, settings, room_id, active_npc_id)
+    if not edges and vector_hits:
+        edges = vector_hits
+
+    selected = select_relationship_edges(query, edges, active_npc_id)
+    if vector_hits and not selected:
+        selected = vector_hits[:_MAX_REL_BULLETS]
+    elif vector_hits:
+        # Prefer vector ordering for active-npc hits when topic matches
+        merged: list[dict[str, Any]] = []
+        seen: set[tuple[str, str]] = set()
+        for edge in vector_hits + selected:
+            key = (str(edge.get("npcAId")), str(edge.get("npcBId")))
+            if key in seen:
+                continue
+            seen.add(key)
+            merged.append(edge)
+        selected = merged[:_MAX_REL_BULLETS]
+
+    for edge in selected:
+        request_lazy_edge_embed(
+            client,
+            settings,
+            room_id,
+            str(edge.get("npcAId") or ""),
+            str(edge.get("npcBId") or ""),
+        )
+
+    bullets: list[str] = []
+    for edge in selected:
+        bullet = format_relationship_bullet(edge, active_npc_id)
+        if bullet:
+            bullets.append(bullet)
+    return bullets[:_MAX_REL_BULLETS]
+
+
+def merge_relationship_rag_into_canon(canon_context: str, relationship_bullets: list[str]) -> str:
+    trimmed = [b for b in relationship_bullets if b.strip()][:_MAX_REL_BULLETS]
+    if not trimmed:
+        return canon_context or ""
+    section = "\n".join(["议会关系网（自然引用，意译即可，勿复读原文）：", *trimmed])
+    base = (canon_context or "").strip()
+    if not base:
+        return section
+    return f"{base}\n{section}"
diff --git a/workers/agent-worker/src/graph/nodes/llm_social_turn.py b/workers/agent-worker/src/graph/nodes/llm_social_turn.py
index 1ad4085..73b56d1 100644
--- a/workers/agent-worker/src/graph/nodes/llm_social_turn.py
+++ b/workers/agent-worker/src/graph/nodes/llm_social_turn.py
@@ -584,6 +584,12 @@ def _invoke_tool_turn(
 def llm_social_turn(state: GraphState, *, settings: Settings | None = None) -> GraphState:
     cfg = settings or get_settings()
     player_message = state.get("player_message") or ""
+    # D-PLAYER-01/02: tag provoke/joint early; belief_gate_speak node gates before compose_reply.
+    from src.council.belief_gate import detect_manipulation_intent
+
+    manip = detect_manipulation_intent(player_message)
+    if manip.kind != "none":
+        state = {**state, "manipulation_intent": manip.kind}
     speak_intent = state.get("speak_intent") or ""
     room_snapshot = state.get("room_snapshot") or {}
     dialogue_context = build_dialogue_context(player_message, state.get("recent_turns"))
diff --git a/workers/agent-worker/src/graph/npc_loop.py b/workers/agent-worker/src/graph/npc_loop.py
index ce9917b..b40fc59 100644
--- a/workers/agent-worker/src/graph/npc_loop.py
+++ b/workers/agent-worker/src/graph/npc_loop.py
@@ -58,7 +58,9 @@
     estimate_speak_sentiment_delta,
     get_leaning_drift,
 )
+from src.council.belief_gate import belief_gate_speak_node, maybe_trust_micro_penalty
 from src.council.memory_context import fetch_dual_rag_context
+from src.collective.repository import CollectiveRepository
 from src.memory.client import (
     append_npc_memory,
     append_player_memory,
@@ -393,6 +395,12 @@ def refresh_collective_in_state(state: GraphState) -> GraphState:
 
 
 def compose_reply(state: GraphState) -> GraphState:
+    # Belief reject already forced IC refusal onto reply_draft (pre-reply gate).
+    if state.get("belief_rejected"):
+        refusal = (state.get("reply_draft") or state.get("reply") or "").strip()
+        if refusal:
+            return {**state, "reply": sanitize_npc_reply(refusal)}
+
     state = _finalize_hostile_gate(state)
     reply = (state.get("reply_draft") or state.get("reply") or "").strip()
     player_message = state.get("player_message") or ""
@@ -576,7 +584,7 @@ def wrapped(state: GraphState) -> GraphState:
 
 
 def build_npc_interactive_graph(settings: Settings | None = None):
-    """Player-visible path: social perceive → apply → refresh → tools → reply."""
+    """Player-visible path: social perceive → apply → refresh → tools → belief → reply."""
     cfg = settings or get_settings()
 
     graph = StateGraph(GraphState)
@@ -585,6 +593,7 @@ def build_npc_interactive_graph(settings: Settings | None = None):
     graph.add_node("apply_social_event", apply_social_event)
     graph.add_node("refresh_collective_in_state", refresh_collective_in_state)
     graph.add_node("apply_tools", _with_client_node(cfg, apply_tools))
+    graph.add_node("belief_gate_speak", _with_client_node(cfg, belief_gate_speak_node))
     graph.add_node("compose_reply", compose_reply)
 
     graph.set_entry_point("fetch_state_and_memory")
@@ -592,7 +601,8 @@ def build_npc_interactive_graph(settings: Settings | None = None):
     graph.add_edge("llm_social_turn", "apply_social_event")
     graph.add_edge("apply_social_event", "refresh_collective_in_state")
     graph.add_edge("refresh_collective_in_state", "apply_tools")
-    graph.add_edge("apply_tools", "compose_reply")
+    graph.add_edge("apply_tools", "belief_gate_speak")
+    graph.add_edge("belief_gate_speak", "compose_reply")
     graph.add_edge("compose_reply", END)
 
     # Single-shot invoke — no Postgres checkpoint (6× writes/speak; Supabase flake → E2E timeout).
@@ -684,11 +694,33 @@ def _maybe_apply_speak_leaning_drift(state: GraphState) -> None:
 
 
 def run_npc_memory_tail(state: GraphState, settings: Settings | None = None) -> GraphState:
-    """Post-reply memory: importance, reflect, summarize — must not block Colyseus done."""
+    """Post-reply memory: importance, reflect, summarize — must not block Colyseus done.
+
+    Repeated belief-reject micro trust penalty may run here (penalty only — never sole IC refusal).
+    """
     cfg = settings or get_settings()
     with create_http_client() as client:
         state = persist_turn_memory(state, settings=cfg, client=client)
         _maybe_apply_speak_leaning_drift(state)
+        if state.get("belief_rejected"):
+            day_key = str(state.get("belief_day_key") or "day-0")
+            repo = CollectiveRepository()
+
+            def _apply_trust(**kwargs: Any) -> None:
+                repo.apply_reputation_delta(
+                    kwargs["room_id"],
+                    kwargs["npc_id"],
+                    kwargs["player_id"],
+                    int(kwargs["delta"]),
+                )
+
+            maybe_trust_micro_penalty(
+                room_id=str(state.get("room_id") or ""),
+                player_id=_player_id(state),
+                npc_id=str(state.get("npc_id") or "npc-1"),
+                day_key=day_key,
+                apply_trust_delta=_apply_trust,
+            )
         state = maybe_collective_refine(state, settings=cfg)
         state = maybe_reflect_turn(state, settings=cfg, client=client)
         state = maybe_bulk_summarize_turn(state, settings=cfg, client=client)
diff --git a/workers/agent-worker/src/graph/npc_mutual_chat.py b/workers/agent-worker/src/graph/npc_mutual_chat.py
new file mode 100644
index 0000000..c8c77a6
--- /dev/null
+++ b/workers/agent-worker/src/graph/npc_mutual_chat.py
@@ -0,0 +1,271 @@
+"""NPC mutual-chat worker job (D-MUTUAL-02/04/06/07).
+
+Short LLM dialogue → apply-deltas → REL-07 at |Δ|≥4 → linkedEdges hint at |Δ|≥8
+→ dual activity + one-shot bubble presentation. Yields to speak like world-vote.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import sys
+from typing import Any, TypedDict
+
+import httpx
+
+from src.config import Settings, get_settings
+from src.council.constants import COUNCIL_MEMORY_PLAYER_ID, HISTORY_SUMMARY_DELTA_THRESHOLD
+from src.council.registry import display_name
+from src.council.relationship_deltas import RelationshipDelta, filter_linked_edges_for_ui
+from src.graph.lore_loop import _extract_json_object, _invoke_lore_llm
+from src.graph.personal_timeline import (
+    DYAD_REL_MIN_ABS_DELTA,
+    apply_single_relationship_delta,
+    enqueue_rel07_bilateral_jobs,
+    personal_timeline_llm_attempts,
+)
+from src.memory.client import append_player_memory
+from src.memory.importance import DEFAULT_IMPORTANCE
+
+NPC_MUTUAL_CHAT_JOBS_KEY = "aetherlife:npc-mutual-chat:jobs"
+MUTUAL_CHAT_BUBBLE_MAX_CHARS = 20
+MUTUAL_LINKED_HINT_MIN_ABS = HISTORY_SUMMARY_DELTA_THRESHOLD  # 8
+MUTUAL_REL07_MIN_ABS = DYAD_REL_MIN_ABS_DELTA  # 4
+
+_CONTROL_CHARS = re.compile(r"[\x00-\x1f\x7f]")
+
+
+class MutualDialogue(TypedDict, total=False):
+    lines: list[str]
+    bubbleText: str
+    affectionDelta: int
+    summaryZh: str
+    historyAppend: str
+
+
+def _game_headers(settings: Settings) -> dict[str, str]:
+    headers: dict[str, str] = {"Content-Type": "application/json"}
+    if settings.internal_worker_token:
+        headers["Authorization"] = f"Bearer {settings.internal_worker_token}"
+    return headers
+
+
+def clamp_bubble_text(text: str, *, max_chars: int = MUTUAL_CHAT_BUBBLE_MAX_CHARS) -> str:
+    cleaned = _CONTROL_CHARS.sub("", (text or "").strip())
+    if len(cleaned) <= max_chars:
+        return cleaned
+    return cleaned[:max_chars]
+
+
+def activity_reason_zh(peer_npc_id: str) -> str:
+    name = display_name(peer_npc_id) if peer_npc_id else peer_npc_id
+    return f"与{name}交谈中"
+
+
+def _mock_dialogue(*, npc_a_id: str, npc_b_id: str) -> MutualDialogue:
+    a = display_name(npc_a_id)
+    b = display_name(npc_b_id)
+    return {
+        "lines": [f"{a}：今日庭中风软。", f"{b}：正好叙话片刻。"],
+        "bubbleText": "今日庭中风软",
+        "affectionDelta": 5,
+        "summaryZh": f"{a}与{b}闲谈片刻",
+        "historyAppend": f"{a}与{b}闲谈亲近（Δ+5）",
+    }
+
+
+def generate_mutual_dialogue(
+    settings: Settings,
+    *,
+    npc_a_id: str,
+    npc_b_id: str,
+) -> MutualDialogue:
+    """Non-speak JSON path — never 智谱 (reuse personal-timeline provider chain)."""
+    if settings.llm_mock or os.getenv("LLM_MOCK") == "1":
+        return _mock_dialogue(npc_a_id=npc_a_id, npc_b_id=npc_b_id)
+
+    a_name = display_name(npc_a_id)
+    b_name = display_name(npc_b_id)
+    prompt = (
+        "你是生活模拟游戏的短对话写手。两名议会 NPC 在近旁偶遇闲谈。\n"
+        f"NPC_A={a_name}({npc_a_id}) NPC_B={b_name}({npc_b_id})。\n"
+        "只输出一个 JSON 对象，不要 markdown。字段：\n"
+        "lines(字符串数组，2–4 句短对白)；"
+        "bubbleText(≤20字，玩家可见气泡摘要)；"
+        "affectionDelta(整数，建议 -6..+8，偶遇闲谈常见 +1..+6)；"
+        "summaryZh(≤40字，议会记忆短记)；"
+        "historyAppend(≤80字，写入关系史)。\n"
+        "禁止暴力；禁止提及玩家；禁止 tool_calls。"
+    )
+
+    last_exc: BaseException | None = None
+    for provider, model in personal_timeline_llm_attempts(settings):
+        try:
+            raw = _invoke_lore_llm(settings, provider, model, prompt)
+            data = _extract_json_object(raw)
+            lines_raw = data.get("lines") or []
+            lines = [str(x).strip() for x in lines_raw if str(x).strip()][:4]
+            delta = int(data.get("affectionDelta") or 0)
+            delta = max(-15, min(15, delta))
+            bubble = clamp_bubble_text(str(data.get("bubbleText") or (lines[0] if lines else "")))
+            return {
+                "lines": lines or _mock_dialogue(npc_a_id=npc_a_id, npc_b_id=npc_b_id)["lines"],
+                "bubbleText": bubble,
+                "affectionDelta": delta,
+                "summaryZh": str(data.get("summaryZh") or "").strip()[:80],
+                "historyAppend": str(data.get("historyAppend") or "").strip()[:120],
+            }
+        except Exception as exc:
+            last_exc = exc
+            print(
+                f"mutual-chat LLM provider={provider} failed: {exc}",
+                file=sys.stderr,
+            )
+            continue
+    print(f"mutual-chat LLM failed, using mock fallback: {last_exc}", file=sys.stderr)
+    return _mock_dialogue(npc_a_id=npc_a_id, npc_b_id=npc_b_id)
+
+
+def post_mutual_chat_presentation(
+    client: httpx.Client,
+    settings: Settings,
+    *,
+    room_id: str,
+    npc_a_id: str,
+    npc_b_id: str,
+    bubble_text: str,
+) -> None:
+    url = (
+        f"{settings.game_server_url.rstrip('/')}/internal/rooms/{room_id}"
+        "/npc-mutual-chat/present"
+    )
+    body = {
+        "npcAId": npc_a_id,
+        "npcBId": npc_b_id,
+        "npcAReasonZh": activity_reason_zh(npc_b_id),
+        "npcBReasonZh": activity_reason_zh(npc_a_id),
+        "bubbleText": clamp_bubble_text(bubble_text),
+    }
+    res = client.post(url, json=body, headers=_game_headers(settings), timeout=20.0)
+    res.raise_for_status()
+
+
+def post_linked_edges_hint(
+    client: httpx.Client,
+    settings: Settings,
+    *,
+    room_id: str,
+    linked_edges: list[dict[str, str]],
+) -> None:
+    if not linked_edges:
+        return
+    url = (
+        f"{settings.game_server_url.rstrip('/')}/internal/rooms/{room_id}"
+        "/npc-mutual-chat/linked-edges-hint"
+    )
+    res = client.post(
+        url,
+        json={"linkedEdges": linked_edges},
+        headers=_game_headers(settings),
+        timeout=20.0,
+    )
+    res.raise_for_status()
+
+
+def maybe_append_council_summary(
+    client: httpx.Client,
+    settings: Settings,
+    *,
+    room_id: str,
+    npc_a_id: str,
+    summary_zh: str,
+) -> None:
+    text = (summary_zh or "").strip()
+    if not text:
+        return
+    append_player_memory(
+        client,
+        settings,
+        room_id,
+        text[:200],
+        npc_id=npc_a_id,
+        player_id=COUNCIL_MEMORY_PLAYER_ID,
+        importance=DEFAULT_IMPORTANCE,
+    )
+
+
+def process_npc_mutual_chat_job(
+    client: httpx.Client,
+    settings: Settings | None,
+    payload: dict[str, Any],
+) -> None:
+    cfg = settings or get_settings()
+    room_id = str(payload.get("roomId") or "").strip()
+    npc_a_id = str(payload.get("npcAId") or "").strip()
+    npc_b_id = str(payload.get("npcBId") or "").strip()
+    job_id = str(payload.get("jobId") or "")
+    epoch = int(payload.get("absoluteGameMinute") or 0)
+    if not room_id or not npc_a_id or not npc_b_id or npc_a_id == npc_b_id:
+        print(f"mutual-chat invalid payload jobId={job_id}; ignoring", file=sys.stderr)
+        return
+
+    dialogue = generate_mutual_dialogue(cfg, npc_a_id=npc_a_id, npc_b_id=npc_b_id)
+    affection = int(dialogue.get("affectionDelta") or 0)
+    history = str(dialogue.get("historyAppend") or "").strip()
+    bubble = clamp_bubble_text(str(dialogue.get("bubbleText") or ""))
+
+    apply_single_relationship_delta(
+        client,
+        cfg,
+        room_id=room_id,
+        npc_a_id=npc_a_id,
+        npc_b_id=npc_b_id,
+        affection_delta=affection,
+        history_append=history,
+    )
+
+    event_anchor_id = f"mc-{job_id or f'{room_id}-{npc_a_id}-{npc_b_id}-{epoch}'}"
+    rel_jobs = enqueue_rel07_bilateral_jobs(
+        room_id=room_id,
+        npc_a_id=npc_a_id,
+        npc_b_id=npc_b_id,
+        event_anchor_id=event_anchor_id,
+        affection_delta=affection,
+        aether_epoch_minute=epoch,
+        history_append=history,
+        min_abs_delta=MUTUAL_REL07_MIN_ABS,
+        settings=cfg,
+    )
+
+    if abs(affection) >= MUTUAL_LINKED_HINT_MIN_ABS:
+        delta: RelationshipDelta = {
+            "npcAId": npc_a_id,
+            "npcBId": npc_b_id,
+            "affectionDelta": affection,
+        }
+        linked = filter_linked_edges_for_ui([delta], min_abs=MUTUAL_LINKED_HINT_MIN_ABS)
+        if linked:
+            post_linked_edges_hint(client, cfg, room_id=room_id, linked_edges=linked)
+
+    post_mutual_chat_presentation(
+        client,
+        cfg,
+        room_id=room_id,
+        npc_a_id=npc_a_id,
+        npc_b_id=npc_b_id,
+        bubble_text=bubble,
+    )
+
+    maybe_append_council_summary(
+        client,
+        cfg,
+        room_id=room_id,
+        npc_a_id=npc_a_id,
+        summary_zh=str(dialogue.get("summaryZh") or ""),
+    )
+
+    print(
+        f"mutual-chat ok jobId={job_id} pair={npc_a_id}/{npc_b_id} "
+        f"Δ={affection:+d} rel_jobs={len(rel_jobs)} bubble={bubble!r}",
+        file=sys.stderr,
+    )
diff --git a/workers/agent-worker/src/graph/state.py b/workers/agent-worker/src/graph/state.py
index 4d4ae77..3aa1885 100644
--- a/workers/agent-worker/src/graph/state.py
+++ b/workers/agent-worker/src/graph/state.py
@@ -39,3 +39,8 @@ class GraphState(TypedDict, total=False):
     pending_actions: list[dict[str, Any]]
     reply: str
     trace_run_id: str | None
+    manipulation_intent: str
+    belief_decision: str
+    belief_rejected: bool
+    belief_ab_applied: bool
+    belief_day_key: str
diff --git a/workers/agent-worker/src/main.py b/workers/agent-worker/src/main.py
index a731109..3b34a25 100644
--- a/workers/agent-worker/src/main.py
+++ b/workers/agent-worker/src/main.py
@@ -20,6 +20,10 @@
 from src.graph.social_edge_fast_lane import run_social_edge_fast_lane
 from src.graph.world_vote import process_world_vote_job
 from src.graph.personal_timeline import process_personal_timeline_job
+from src.graph.npc_mutual_chat import (
+    NPC_MUTUAL_CHAT_JOBS_KEY,
+    process_npc_mutual_chat_job,
+)
 from src.graph.job_context import reset_job_context, set_job_context
 from src.llm.call_budget import (
     get_recorder,
@@ -39,6 +43,7 @@
 AMBIENT_INTENT_BRIDGE_LIST_KEY = "aetherlife:npc-ambient-intent:jobs"
 WORLD_VOTE_BRIDGE_LIST_KEY = "aetherlife:world-vote:jobs"
 PERSONAL_TIMELINE_BRIDGE_LIST_KEY = "aetherlife:personal-timeline:jobs"
+NPC_MUTUAL_CHAT_BRIDGE_LIST_KEY = NPC_MUTUAL_CHAT_JOBS_KEY
 BLPOP_TIMEOUT_S = 5
 LORE_BLPOP_TIMEOUT_S = 1
 AMBIENT_BLPOP_TIMEOUT_S = 1
@@ -192,6 +197,28 @@ def drain_one_personal_timeline_job(
     return True
 
 
+def drain_one_npc_mutual_chat_job(
+    r: redis.Redis, client: httpx.Client, settings: Settings
+) -> bool:
+    """Visible NPC↔NPC chat — yield to speak / npc-turn (D-MUTUAL-07)."""
+    if _is_speak_in_progress() or r.llen(BRIDGE_LIST_KEY) > 0:
+        return False
+    raw = r.rpop(NPC_MUTUAL_CHAT_BRIDGE_LIST_KEY)
+    if not raw:
+        return False
+    payload = _parse_bridge_payload(raw, queue="npc-mutual-chat")
+    if not payload:
+        return True
+    try:
+        process_npc_mutual_chat_job(client, settings, payload)
+    except Exception as exc:
+        print(
+            f"npc-mutual-chat job error jobId={payload.get('jobId')}: {exc}",
+            file=sys.stderr,
+        )
+    return True
+
+
 def drain_one_ambient_intent_job(r: redis.Redis, client: httpx.Client, settings: Settings) -> bool:
     if _is_speak_in_progress() or r.llen(BRIDGE_LIST_KEY) > 0:
         return False
@@ -483,6 +510,7 @@ def run_worker() -> None:
             if not item or not queue:
                 drain_one_world_vote_job(r, client, settings)
                 drain_one_personal_timeline_job(r, client, settings)
+                drain_one_npc_mutual_chat_job(r, client, settings)
                 continue
             _, raw = item
             payload = _parse_bridge_payload(raw, queue=queue)
@@ -518,6 +546,7 @@ def run_worker() -> None:
                 drain_one_ambient_intent_job(r, client, settings)
                 drain_one_world_vote_job(r, client, settings)
                 drain_one_personal_timeline_job(r, client, settings)
+                drain_one_npc_mutual_chat_job(r, client, settings)
                 continue
             if queue == "lore":
                 try:
@@ -526,6 +555,7 @@ def run_worker() -> None:
                     print(f"lore job error jobId={payload.get('jobId')}: {exc}", file=sys.stderr)
                 drain_one_world_vote_job(r, client, settings)
                 drain_one_personal_timeline_job(r, client, settings)
+                drain_one_npc_mutual_chat_job(r, client, settings)
                 continue
             try:
                 process_ambient_intent_job(client, settings, payload)
@@ -533,6 +563,7 @@ def run_worker() -> None:
                 print(f"ambient intent job error jobId={payload.get('jobId')}: {exc}", file=sys.stderr)
             drain_one_world_vote_job(r, client, settings)
             drain_one_personal_timeline_job(r, client, settings)
+            drain_one_npc_mutual_chat_job(r, client, settings)
 
 
 def main() -> None:
diff --git a/workers/agent-worker/tests/test_belief_gate.py b/workers/agent-worker/tests/test_belief_gate.py
new file mode 100644
index 0000000..d28b77a
--- /dev/null
+++ b/workers/agent-worker/tests/test_belief_gate.py
@@ -0,0 +1,449 @@
+"""Phase 28 belief gate for player provoke (D-PLAYER-01…06, D-VERIFY-02, EA-5/EA-6).
+
+Uses player↔NPC trust (npc_attitudes / collective effectiveScore), not npc_relationships.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+from unittest.mock import MagicMock
+
+import pytest
+
+from src.council import belief_gate as bg
+from src.council.belief_gate import TRUST_MICRO_PENALTY_MAX, TRUST_MICRO_PENALTY_MIN
+
+
+@pytest.fixture(autouse=True)
+def _clear_caps() -> None:
+    bg.clear_manipulation_caps_for_test()
+
+
+def test_belief_gate_hard_reject_below_minus_30() -> None:
+    """D-PLAYER-05: effectiveScore < -30 → hard reject, no LLM, no A↔B delta."""
+    llm_calls: list[dict[str, Any]] = []
+    apply_calls: list[dict[str, Any]] = []
+
+    def fake_llm(**kwargs: Any) -> bg.BeliefJudgment:
+        llm_calls.append(kwargs)
+        return bg.BeliefJudgment(decision="accept", reason="should not run")
+
+    def fake_apply(**kwargs: Any) -> None:
+        apply_calls.append(kwargs)
+
+    result = bg.evaluate_belief_gate(
+        initiator_player_id="player-1",
+        active_npc_id="npc-1",
+        room_id="room-a",
+        speak_text="让莫玄虚去对付阿斯托利亚",
+        proposed_a_id="npc-1",
+        proposed_b_id="npc-2",
+        effective_score=-40,
+        llm_judge=fake_llm,
+        apply_ab_delta=fake_apply,
+        day_key="day-1",
+    )
+    assert result.decision == "reject"
+    assert result.reject_reason == "hard_threshold"
+    assert result.used_llm is False
+    assert llm_calls == []
+    assert apply_calls == []
+    assert result.affection_delta == 0
+    assert result.ic_refusal_reply
+
+
+def test_belief_gate_skeptical_bias_below_zero() -> None:
+    """D-PLAYER-05: effectiveScore < 0 → LLM with skeptical bias."""
+    llm_calls: list[dict[str, Any]] = []
+
+    def fake_llm(**kwargs: Any) -> bg.BeliefJudgment:
+        llm_calls.append(kwargs)
+        return bg.BeliefJudgment(decision="reject", reason="skeptical")
+
+    result = bg.evaluate_belief_gate(
+        initiator_player_id="player-1",
+        active_npc_id="npc-1",
+        room_id="room-a",
+        speak_text="让莫玄虚去对付阿斯托利亚",
+        proposed_a_id="npc-1",
+        proposed_b_id="npc-2",
+        effective_score=-10,
+        llm_judge=fake_llm,
+        apply_ab_delta=lambda **_: None,
+        day_key="day-1",
+    )
+    assert result.used_llm is True
+    assert len(llm_calls) == 1
+    assert llm_calls[0]["skeptical_bias"] is True
+    assert result.decision == "reject"
+    assert result.affection_delta == 0
+
+
+def test_belief_reject_blocks_ab_delta_and_speaks_refusal() -> None:
+    """D-PLAYER-05/06: reject → no A↔B apply; in-character refusal."""
+    apply_calls: list[dict[str, Any]] = []
+
+    def fake_llm(**kwargs: Any) -> bg.BeliefJudgment:
+        return bg.BeliefJudgment(decision="reject", reason="不信")
+
+    def fake_apply(**kwargs: Any) -> None:
+        apply_calls.append(kwargs)
+
+    result = bg.evaluate_belief_gate(
+        initiator_player_id="player-1",
+        active_npc_id="npc-3",
+        room_id="room-a",
+        speak_text="让诸葛知危去疏远糖果",
+        proposed_a_id="npc-3",
+        proposed_b_id="npc-4",
+        effective_score=20,
+        llm_judge=fake_llm,
+        apply_ab_delta=fake_apply,
+        day_key="day-1",
+    )
+    assert result.decision == "reject"
+    assert apply_calls == []
+    assert result.affection_delta == 0
+    refusal = result.ic_refusal_reply
+    assert refusal
+    assert any(
+        token in refusal for token in ("不信", "不便", "插手", "挑拨", "请别", "说服不了", "介入")
+    )
+
+
+def test_belief_trust_lookup_uses_initiator_player_id_only() -> None:
+    """EA-5: trust keyed by initiator playerId — never peer player or npc_relationships."""
+    seen: list[dict[str, Any]] = []
+
+    def fake_lookup(**kwargs: Any) -> int:
+        seen.append(kwargs)
+        return 5
+
+    score = bg.resolve_player_npc_trust(
+        room_id="room-a",
+        active_npc_id="npc-1",
+        initiator_player_id="player-initiator",
+        peer_player_id="player-other",
+        fetch_effective_score=fake_lookup,
+    )
+    assert score == 5
+    assert len(seen) == 1
+    assert seen[0]["player_id"] == "player-initiator"
+    assert seen[0]["npc_id"] == "npc-1"
+    assert "peer" not in seen[0]
+    assert "relationship" not in str(seen[0]).lower()
+
+
+def test_belief_accept_clamps_player_ab_delta() -> None:
+    """D-PLAYER-03: accepted player A↔B deltas clamped to |Δ| 2–6."""
+    apply_calls: list[dict[str, Any]] = []
+
+    def fake_llm(**kwargs: Any) -> bg.BeliefJudgment:
+        return bg.BeliefJudgment(decision="accept", reason="ok", proposed_delta=15)
+
+    def fake_apply(**kwargs: Any) -> None:
+        apply_calls.append(kwargs)
+
+    result = bg.evaluate_belief_gate(
+        initiator_player_id="player-1",
+        active_npc_id="npc-1",
+        room_id="room-a",
+        speak_text="让莫玄虚去对付阿斯托利亚",
+        proposed_a_id="npc-1",
+        proposed_b_id="npc-2",
+        effective_score=40,
+        llm_judge=fake_llm,
+        apply_ab_delta=fake_apply,
+        day_key="day-1",
+    )
+    assert result.decision == "accept"
+    assert 2 <= abs(result.affection_delta) <= 6
+    assert len(apply_calls) == 1
+    assert 2 <= abs(int(apply_calls[0]["affection_delta"])) <= 6
+
+
+def test_explicit_phrasing_has_higher_provoke_weight() -> None:
+    """D-PLAYER-01: explicit「让 A … B」weighs higher than keyword-only."""
+    soft = bg.detect_manipulation_intent("你去挑拨一下他们的关系吧")
+    explicit = bg.detect_manipulation_intent("让莫玄虚去对付阿斯托利亚")
+    assert soft.kind in ("provoke", "joint", "none")
+    assert explicit.kind == "provoke"
+    assert explicit.weight > soft.weight
+    assert explicit.npc_a_id == "npc-1"
+    assert explicit.npc_b_id == "npc-2"
+
+
+def test_provoke_dual_caps_pair_and_player_day() -> None:
+    """D-PLAYER-04 / D-VERIFY-02: per-(A,B) 1/day + per-player 3 manipulations/day."""
+    apply_calls: list[dict[str, Any]] = []
+
+    def accept_llm(**kwargs: Any) -> bg.BeliefJudgment:
+        return bg.BeliefJudgment(decision="accept", reason="ok", proposed_delta=4)
+
+    def fake_apply(**kwargs: Any) -> None:
+        apply_calls.append(kwargs)
+
+    common = dict(
+        initiator_player_id="player-1",
+        active_npc_id="npc-1",
+        room_id="room-a",
+        speak_text="让莫玄虚去对付阿斯托利亚",
+        proposed_a_id="npc-1",
+        proposed_b_id="npc-2",
+        effective_score=50,
+        llm_judge=accept_llm,
+        apply_ab_delta=fake_apply,
+        day_key="day-cap",
+    )
+    first = bg.evaluate_belief_gate(**common)
+    assert first.decision == "accept"
+    assert len(apply_calls) == 1
+
+    second = bg.evaluate_belief_gate(**common)
+    assert second.decision == "reject"
+    assert second.reject_reason == "pair_cap"
+    assert len(apply_calls) == 1
+
+    # Different pair still allowed until player day cap (3)
+    for peer in ("npc-3", "npc-4"):
+        r = bg.evaluate_belief_gate(
+            **{
+                **common,
+                "proposed_b_id": peer,
+            }
+        )
+        assert r.decision == "accept", peer
+
+    assert len(apply_calls) == 3
+
+    fourth = bg.evaluate_belief_gate(
+        **{
+            **common,
+            "proposed_b_id": "npc-5",
+        }
+    )
+    assert fourth.decision == "reject"
+    assert fourth.reject_reason == "player_cap"
+    assert len(apply_calls) == 3
+
+
+def test_belief_gate_speak_node_reject_sets_ic_reply_without_apply(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Interactive path: reject → non-empty IC refusal; apply A↔B helper not called."""
+    apply_calls: list[dict[str, Any]] = []
+
+    monkeypatch.setattr(
+        bg,
+        "default_llm_judge",
+        lambda **kwargs: bg.BeliefJudgment(decision="reject", reason="nope"),
+    )
+
+    def fake_apply(**kwargs: Any) -> None:
+        apply_calls.append(kwargs)
+
+    state = {
+        "room_id": "room-a",
+        "npc_id": "npc-1",
+        "player_id": "player-1",
+        "player_message": "让莫玄虚去对付阿斯托利亚",
+        "effective_score": 25,
+        "reply_draft": "好的，我去办。",
+        "room_snapshot": {"gameMinute": 1500},
+    }
+    out = bg.run_belief_gate_speak(
+        state,
+        apply_ab_delta=fake_apply,
+        llm_judge=lambda **k: bg.BeliefJudgment(decision="reject", reason="nope"),
+    )
+    assert out.get("belief_rejected") is True
+    assert out.get("belief_ab_applied") is False
+    reply = (out.get("reply_draft") or out.get("reply") or "").strip()
+    assert reply
+    assert reply != "好的，我去办。"
+    assert apply_calls == []
+
+
+def test_belief_gate_speak_node_accept_applies_clamped_delta() -> None:
+    """Interactive accept → |Δ| in 2..6 via apply helper."""
+    apply_calls: list[dict[str, Any]] = []
+
+    def fake_apply(**kwargs: Any) -> None:
+        apply_calls.append(kwargs)
+
+    state = {
+        "room_id": "room-a",
+        "npc_id": "npc-1",
+        "player_id": "player-1",
+        "player_message": "让莫玄虚去对付阿斯托利亚",
+        "effective_score": 40,
+        "reply_draft": "我明白了。",
+        "room_snapshot": {"gameMinute": 200},
+    }
+    out = bg.run_belief_gate_speak(
+        state,
+        apply_ab_delta=fake_apply,
+        llm_judge=lambda **k: bg.BeliefJudgment(
+            decision="accept", reason="ok", proposed_delta=9
+        ),
+    )
+    assert out.get("belief_rejected") is not True
+    assert out.get("belief_ab_applied") is True
+    assert len(apply_calls) == 1
+    assert 2 <= abs(int(apply_calls[0]["affection_delta"])) <= 6
+    assert (out.get("reply_draft") or "").startswith("我明白了")
+
+
+def test_interactive_graph_wires_belief_before_compose_reply() -> None:
+    """Belief/provoke gate on interactive speak path — not solely memory tail."""
+    import inspect
+
+    from src.graph import npc_loop
+
+    src = inspect.getsource(npc_loop.build_npc_interactive_graph)
+    assert "belief_gate_speak" in src
+    assert 'add_edge("apply_tools", "belief_gate_speak")' in src
+    assert 'add_edge("belief_gate_speak", "compose_reply")' in src
+    tail_src = inspect.getsource(npc_loop.run_npc_memory_tail)
+    assert "maybe_trust_micro_penalty" in tail_src or "trust_micro" in tail_src
+    # Memory tail must not be the sole IC-refusal path
+    assert "ic_refusal_reply" not in tail_src or "belief_rejected" in tail_src
+
+
+def test_joint_path_has_no_quest_escort_fsm() -> None:
+    """D-PLAYER-02: joint adventure is light heuristic — no escort/quest FSM module."""
+    import importlib.util
+
+    for name in (
+        "src.council.quest_fsm",
+        "src.council.escort",
+        "src.graph.quest_escort",
+    ):
+        assert importlib.util.find_spec(name) is None
+    joint = bg.detect_manipulation_intent("我们一起去冒险吧")
+    assert joint.kind == "joint"
+
+
+def test_repeated_reject_micro_penalty_post_reply_only() -> None:
+    """D-PLAYER-06: micro trust penalty only after repeated rejects (memory-tail hook)."""
+    penalties: list[dict[str, Any]] = []
+
+    def apply_trust(**kwargs: Any) -> None:
+        penalties.append(kwargs)
+
+    # First reject — no penalty
+    bg.note_belief_reject(
+        room_id="room-a", player_id="p1", npc_id="npc-1", day_key="d1"
+    )
+    d1 = bg.maybe_trust_micro_penalty(
+        room_id="room-a",
+        player_id="p1",
+        npc_id="npc-1",
+        day_key="d1",
+        apply_trust_delta=apply_trust,
+    )
+    assert d1 == 0
+    assert penalties == []
+
+    bg.note_belief_reject(
+        room_id="room-a", player_id="p1", npc_id="npc-1", day_key="d1"
+    )
+    d2 = bg.maybe_trust_micro_penalty(
+        room_id="room-a",
+        player_id="p1",
+        npc_id="npc-1",
+        day_key="d1",
+        apply_trust_delta=apply_trust,
+    )
+    assert TRUST_MICRO_PENALTY_MIN <= abs(d2) <= TRUST_MICRO_PENALTY_MAX
+    assert d2 < 0
+    assert len(penalties) == 1
+    assert penalties[0]["player_id"] == "p1"
+    assert penalties[0]["npc_id"] == "npc-1"
+
+
+def test_default_llm_judge_non_mock_rejects_when_unwired() -> None:
+    """No real LLM judge wired → guardrail-consistent reject, never silent accept."""
+    j = bg.default_llm_judge(
+        speak_text="让莫玄虚去对付阿斯托利亚",
+        effective_score=50,
+        skeptical_bias=False,
+        llm_mock=False,
+    )
+    assert j.decision == "reject"
+    assert j.proposed_delta == 0
+
+
+def test_day_key_from_snapshot_prefers_absolute_game_minute() -> None:
+    """CR PR#22: worker-state carries absoluteGameMinute for per-day cap keys."""
+    assert bg.day_key_from_snapshot({"absoluteGameMinute": 2880}) == "day-2"
+    assert bg.day_key_from_snapshot({"absoluteGameMinute": 1439}) == "day-0"
+    # Legacy fallback when only wrapped gameMinute is present.
+    assert bg.day_key_from_snapshot({"gameMinute": 1500}) == "day-1"
+    assert bg.day_key_from_snapshot({}) == "day-0"
+
+
+def test_manipulation_cap_resets_on_next_game_day() -> None:
+    """D-PLAYER-04: pair cap is per game-day, not pinned to day-0 forever."""
+    day0 = bg.day_key_from_snapshot({"absoluteGameMinute": 500})
+    day1 = bg.day_key_from_snapshot({"absoluteGameMinute": 1440 + 100})
+    assert day0 != day1
+
+    assert (
+        bg.claim_manipulation_slot(
+            room_id="room-a",
+            player_id="p1",
+            npc_a_id="npc-1",
+            npc_b_id="npc-2",
+            day_key=day0,
+        )
+        is None
+    )
+    assert (
+        bg.claim_manipulation_slot(
+            room_id="room-a",
+            player_id="p1",
+            npc_a_id="npc-1",
+            npc_b_id="npc-2",
+            day_key=day0,
+        )
+        == "pair_cap"
+    )
+    # Next game day — slot available again.
+    assert (
+        bg.claim_manipulation_slot(
+            room_id="room-a",
+            player_id="p1",
+            npc_a_id="npc-1",
+            npc_b_id="npc-2",
+            day_key=day1,
+        )
+        is None
+    )
+
+
+def test_prune_stale_day_keys_on_claim() -> None:
+    bg.clear_manipulation_caps_for_test()
+    assert (
+        bg.claim_manipulation_slot(
+            room_id="room-prune",
+            player_id="p1",
+            npc_a_id="npc-1",
+            npc_b_id="npc-2",
+            day_key="day-0",
+        )
+        is None
+    )
+    # Claiming on a new day drops the prior day's in-process entries.
+    assert (
+        bg.claim_manipulation_slot(
+            room_id="room-prune",
+            player_id="p1",
+            npc_a_id="npc-1",
+            npc_b_id="npc-2",
+            day_key="day-1",
+        )
+        is None
+    )
+    assert all(key[1] == "day-1" for key in bg._pair_claims)
+    assert all(key[1] == "day-1" for key in bg._player_claims)
diff --git a/workers/agent-worker/tests/test_npc_mutual_chat.py b/workers/agent-worker/tests/test_npc_mutual_chat.py
new file mode 100644
index 0000000..b64ba48
--- /dev/null
+++ b/workers/agent-worker/tests/test_npc_mutual_chat.py
@@ -0,0 +1,258 @@
+"""Phase 28 npc-mutual-chat worker (D-MUTUAL-02/04/06/07)."""
+
+from __future__ import annotations
+
+from typing import Any
+from unittest.mock import MagicMock
+
+import pytest
+
+from src.config import Settings
+
+
+class FakeResponse:
+    def __init__(self, status_code: int = 200, data: dict | None = None):
+        self.status_code = status_code
+        self._data = data or {"ok": True}
+
+    def raise_for_status(self) -> None:
+        if self.status_code >= 400:
+            raise AssertionError(f"HTTP {self.status_code}")
+
+    def json(self) -> dict:
+        return self._data
+
+
+class FakeClient:
+    def __init__(self) -> None:
+        self.posts: list[dict[str, Any]] = []
+
+    def post(self, url: str, *args: Any, **kwargs: Any) -> FakeResponse:
+        self.posts.append({"url": url, "json": kwargs.get("json"), "headers": kwargs.get("headers")})
+        if "apply-deltas" in url:
+            deltas = (kwargs.get("json") or {}).get("deltas") or []
+            return FakeResponse(
+                data={
+                    "ok": True,
+                    "linkedEdges": [
+                        {"npcAId": d["npcAId"], "npcBId": d["npcBId"]} for d in deltas
+                    ],
+                }
+            )
+        return FakeResponse()
+
+
+def _payload(**overrides: Any) -> dict[str, Any]:
+    base: dict[str, Any] = {
+        "jobId": "mc-test-room-1-npc-1-npc-2",
+        "roomId": "test-room",
+        "npcAId": "npc-1",
+        "npcBId": "npc-2",
+        "dayIndex": 1,
+        "absoluteGameMinute": 1500,
+        "enqueuedAt": "2026-07-21T00:00:00Z",
+    }
+    base.update(overrides)
+    return base
+
+
+@pytest.fixture(autouse=True)
+def _mock_env(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("LLM_MOCK", "1")
+
+
+def test_mutual_chat_applies_deltas_and_thresholds(monkeypatch: pytest.MonkeyPatch) -> None:
+    """D-MUTUAL-04: all deltas to DB; |Δ|≥4 → REL-07; |Δ|≥8 → linkedEdges hint."""
+    import src.graph.npc_mutual_chat as mc
+    from src.graph.personal_timeline import clear_personal_timeline_job_claims_for_test
+
+    clear_personal_timeline_job_claims_for_test()
+    client = FakeClient()
+    settings = Settings(llm_mock=True, game_server_url="http://gs.test", internal_worker_token="tok")
+
+    # |Δ|=5 → REL-07 yes, linkedEdges hint no
+    monkeypatch.setattr(
+        mc,
+        "generate_mutual_dialogue",
+        lambda *_a, **_k: {
+            "lines": ["甲：今日庭中风软。", "乙：嗯，适合走走。"],
+            "bubbleText": "今日庭中风软",
+            "affectionDelta": 5,
+            "summaryZh": "二人闲谈片刻",
+            "historyAppend": "闲谈亲近（Δ+5）",
+        },
+    )
+    enqueued: list[dict[str, Any]] = []
+
+    def fake_rel07(**kwargs: Any) -> list[dict[str, Any]]:
+        min_abs = int(kwargs.get("min_abs_delta") or 8)
+        if abs(int(kwargs.get("affection_delta") or 0)) < min_abs:
+            return []
+        enqueued.append(kwargs)
+        return [{"jobId": "pt-rel-a"}, {"jobId": "pt-rel-b"}]
+
+    monkeypatch.setattr(mc, "enqueue_rel07_bilateral_jobs", fake_rel07)
+
+    filter_calls: list[dict[str, Any]] = []
+
+    def spy_filter(deltas: list, *, top_k: int = 8, min_abs: int = 8) -> list[dict[str, str]]:
+        filter_calls.append({"deltas": deltas, "top_k": top_k, "min_abs": min_abs})
+        return [{"npcAId": "npc-1", "npcBId": "npc-2"}]
+
+    monkeypatch.setattr(mc, "filter_linked_edges_for_ui", spy_filter)
+
+    mc.process_npc_mutual_chat_job(client, settings, _payload())
+
+    apply_posts = [p for p in client.posts if "apply-deltas" in p["url"]]
+    assert len(apply_posts) == 1
+    delta = apply_posts[0]["json"]["deltas"][0]
+    assert delta["affectionDelta"] == 5
+    assert {delta["npcAId"], delta["npcBId"]} == {"npc-1", "npc-2"}
+    assert apply_posts[0]["headers"]["Authorization"] == "Bearer tok"
+
+    assert len(enqueued) == 1
+    assert enqueued[0]["min_abs_delta"] == 4
+    assert enqueued[0]["affection_delta"] == 5
+
+    hint_posts = [p for p in client.posts if "linked-edges-hint" in p["url"]]
+    assert hint_posts == []
+    assert filter_calls == []
+
+    # |Δ|=8 → filter + hint POST required
+    clear_personal_timeline_job_claims_for_test()
+    client2 = FakeClient()
+    enqueued.clear()
+    filter_calls.clear()
+    monkeypatch.setattr(
+        mc,
+        "generate_mutual_dialogue",
+        lambda *_a, **_k: {
+            "lines": ["甲：多谢你的照应。", "乙：同袍何必客气。"],
+            "bubbleText": "多谢你的照应",
+            "affectionDelta": 8,
+            "summaryZh": "深谈后亲近",
+            "historyAppend": "深谈亲近（Δ+8）",
+        },
+    )
+    mc.process_npc_mutual_chat_job(client2, settings, _payload(jobId="mc-delta8"))
+
+    assert len(enqueued) == 1
+    assert filter_calls and filter_calls[0]["min_abs"] == 8
+    hint_posts2 = [p for p in client2.posts if "linked-edges-hint" in p["url"]]
+    assert len(hint_posts2) == 1
+    assert hint_posts2[0]["json"]["linkedEdges"] == [{"npcAId": "npc-1", "npcBId": "npc-2"}]
+
+    # |Δ|=3 → no REL-07, no hint
+    clear_personal_timeline_job_claims_for_test()
+    client3 = FakeClient()
+    enqueued.clear()
+    filter_calls.clear()
+    monkeypatch.setattr(
+        mc,
+        "generate_mutual_dialogue",
+        lambda *_a, **_k: {
+            "lines": ["甲：路过。", "乙：嗯。"],
+            "bubbleText": "路过",
+            "affectionDelta": 3,
+            "summaryZh": "擦肩",
+            "historyAppend": "擦肩（Δ+3）",
+        },
+    )
+    mc.process_npc_mutual_chat_job(client3, settings, _payload(jobId="mc-delta3"))
+    assert enqueued == []
+    assert filter_calls == []
+    assert not [p for p in client3.posts if "linked-edges-hint" in p["url"]]
+
+
+def test_mutual_chat_memory_stays_on_council_scope(monkeypatch: pytest.MonkeyPatch) -> None:
+    """D-MUTUAL-06: optional __council__ summary; never player speak cross-contamination."""
+    from src.council.constants import COUNCIL_MEMORY_PLAYER_ID
+    import src.graph.npc_mutual_chat as mc
+    from src.graph.personal_timeline import clear_personal_timeline_job_claims_for_test
+
+    clear_personal_timeline_job_claims_for_test()
+    client = FakeClient()
+    settings = Settings(llm_mock=True, game_server_url="http://gs.test")
+
+    memory_calls: list[dict[str, Any]] = []
+
+    def capture_append(*args: Any, **kwargs: Any) -> None:
+        memory_calls.append({"args": args, **kwargs})
+
+    monkeypatch.setattr(mc, "append_player_memory", capture_append)
+    monkeypatch.setattr(mc, "enqueue_rel07_bilateral_jobs", lambda **_k: [])
+    monkeypatch.setattr(
+        mc,
+        "generate_mutual_dialogue",
+        lambda *_a, **_k: {
+            "lines": ["甲：庭前一叙。", "乙：改日再叙。"],
+            "bubbleText": "庭前一叙",
+            "affectionDelta": 2,
+            "summaryZh": "议会闲谈短记",
+            "historyAppend": "闲谈",
+        },
+    )
+
+    mc.process_npc_mutual_chat_job(client, settings, _payload())
+
+    assert memory_calls, "optional __council__ summary should append once"
+    for call in memory_calls:
+        assert call.get("player_id") == COUNCIL_MEMORY_PLAYER_ID
+        assert call.get("player_id") != "player-1"
+        # append_player_memory(client, settings, room_id, text, ...) — text is positional.
+        args = call.get("args") or ()
+        text = str(args[3]) if len(args) > 3 else str(call.get("text", ""))
+        assert "player" not in text.lower()
+
+
+def test_mutual_chat_emits_activity_and_bubble_payload(monkeypatch: pytest.MonkeyPatch) -> None:
+    """D-MUTUAL-02: dual intentReasonZh + mutualChatBubble one-shot message."""
+    import src.graph.npc_mutual_chat as mc
+    from src.graph.personal_timeline import clear_personal_timeline_job_claims_for_test
+
+    clear_personal_timeline_job_claims_for_test()
+    client = FakeClient()
+    settings = Settings(llm_mock=True, game_server_url="http://gs.test")
+    monkeypatch.setattr(mc, "enqueue_rel07_bilateral_jobs", lambda **_k: [])
+    monkeypatch.setattr(
+        mc,
+        "generate_mutual_dialogue",
+        lambda *_a, **_k: {
+            "lines": ["甲：今日风清。", "乙：正好叙话。"],
+            "bubbleText": "今日风清正好叙话超过二十字截断",
+            "affectionDelta": 1,
+            "summaryZh": "短叙",
+            "historyAppend": "短叙",
+        },
+    )
+
+    mc.process_npc_mutual_chat_job(client, settings, _payload())
+
+    present = [p for p in client.posts if "npc-mutual-chat" in p["url"] and "present" in p["url"]]
+    assert len(present) == 1
+    body = present[0]["json"]
+    assert body["npcAId"] == "npc-1"
+    assert body["npcBId"] == "npc-2"
+    assert "交谈中" in body["npcAReasonZh"]
+    assert "交谈中" in body["npcBReasonZh"]
+    assert len(body["bubbleText"]) <= 20
+
+
+def test_drain_yields_when_speak_in_progress(monkeypatch: pytest.MonkeyPatch) -> None:
+    """D-MUTUAL-07: same defer spirit as world-vote / personal-timeline."""
+    import src.main as main_mod
+
+    r = MagicMock()
+    r.llen.return_value = 0
+    r.rpop.return_value = None
+    client = MagicMock()
+    settings = Settings(llm_mock=True)
+
+    monkeypatch.setattr(main_mod, "_is_speak_in_progress", lambda: True)
+    assert main_mod.drain_one_npc_mutual_chat_job(r, client, settings) is False
+    r.rpop.assert_not_called()
+
+    monkeypatch.setattr(main_mod, "_is_speak_in_progress", lambda: False)
+    r.llen.return_value = 2
+    assert main_mod.drain_one_npc_mutual_chat_job(r, client, settings) is False
+    r.rpop.assert_not_called()
diff --git a/workers/agent-worker/tests/test_relationship_rag.py b/workers/agent-worker/tests/test_relationship_rag.py
new file mode 100644
index 0000000..01e57a4
--- /dev/null
+++ b/workers/agent-worker/tests/test_relationship_rag.py
@@ -0,0 +1,158 @@
+"""Phase 28 relationship embedding RAG for speak (D-EMBED-01…04, D-VERIFY-01)."""
+
+from __future__ import annotations
+
+import pytest
+
+from src.config import Settings
+from src.council.relationship_rag import (
+    fetch_relationship_rag_context,
+    format_relationship_bullet,
+    referenced_third_party_ids,
+    select_relationship_edges,
+    topic_relevant_relationship,
+)
+
+
+class FakeResponse:
+    def __init__(self, status_code: int = 200, data: dict | None = None):
+        self.status_code = status_code
+        self._data = data or {"ok": True}
+
+    def raise_for_status(self):
+        if self.status_code >= 400:
+            raise AssertionError(f"HTTP {self.status_code}")
+
+    def json(self):
+        return self._data
+
+
+class FakeClient:
+    def __init__(
+        self,
+        *,
+        edges: list[dict] | None = None,
+        vector_edges: list[dict] | None = None,
+    ):
+        self.edges = edges or []
+        self.vector_edges = vector_edges or []
+        self.gets: list[tuple[str, dict]] = []
+        self.posts: list[tuple[str, dict]] = []
+
+    def get(self, url, *args, **kwargs):
+        self.gets.append((url, dict(kwargs.get("params") or {})))
+        if "npc-relationships" in url and "search-similar" not in url:
+            return FakeResponse(data={"ok": True, "edges": self.edges})
+        return FakeResponse()
+
+    def post(self, url, *args, **kwargs):
+        body = dict(kwargs.get("json") or {})
+        self.posts.append((url, body))
+        if "search-similar" in url:
+            return FakeResponse(data={"ok": True, "edges": self.vector_edges})
+        if "ensure-embedding" in url:
+            return FakeResponse(data={"ok": True, "embedded": True})
+        return FakeResponse()
+
+
+def _edge(
+    *,
+    npc_a: str,
+    npc_b: str,
+    history: str,
+    status: list[str] | None = None,
+):
+    return {
+        "npcAId": npc_a,
+        "npcBId": npc_b,
+        "historySummary": history,
+        "currentStatus": status or [],
+        "baseTag": "peer",
+        "affection": 0,
+        "trust": 50,
+    }
+
+
+@pytest.fixture
+def settings():
+    return Settings(game_server_url="http://game.test", internal_worker_token="tok")
+
+
+def test_relationship_rag_prefers_active_npc_edges(settings):
+    """D-EMBED-04: retrieve active NPC edges first for speak context."""
+    edges = [
+        _edge(npc_a="npc-1", npc_b="npc-2", history="旧日同盟，共议防务。"),
+        _edge(npc_a="npc-3", npc_b="npc-4", history="npc-3 与 npc-4 私交甚笃。"),
+        _edge(npc_a="npc-1", npc_b="npc-5", history="偶发口角，关系冷淡。"),
+    ]
+    selected = select_relationship_edges(
+        "你和 npc-2 的关系如何？旧日同盟",
+        edges,
+        "npc-1",
+    )
+    assert selected
+    assert all("npc-1" in (e["npcAId"], e["npcBId"]) for e in selected)
+    assert selected[0]["npcBId"] == "npc-2" or selected[0]["npcAId"] == "npc-2"
+
+
+def test_relationship_rag_third_party_analogy_paraphrase(settings):
+    """D-EMBED-04 / D-VERIFY-01: cross-NPC analogy when topic references third party (≤2 bullets)."""
+    long_history = (
+        "他们曾在廷议中因边境防务激烈争执，彼此记恨多年，"
+        "这段宿怨足以写满一整页编年史，不应被原样倾倒进 prompt。"
+    )
+    edges = [
+        _edge(npc_a="npc-1", npc_b="npc-2", history="我与 npc-2 仅点头之交。"),
+        _edge(npc_a="npc-3", npc_b="npc-4", history=long_history, status=["交恶"]),
+    ]
+    selected = select_relationship_edges(
+        "npc-3 和 npc-4 是不是关系很差？",
+        edges,
+        "npc-1",
+    )
+    assert 1 <= len(selected) <= 2
+    bullets = [format_relationship_bullet(e, "npc-1") for e in selected]
+    joined = "\n".join(bullets)
+    assert long_history not in joined
+    assert "类比" in joined or "关系" in joined
+    assert any("npc-3" in b or "npc-4" in b or "与" in b for b in bullets)
+
+
+def test_relationship_rag_lazy_embed_when_missing(settings):
+    """D-EMBED-03: lazy embed on speak if edge embedding is null."""
+    client = FakeClient(
+        edges=[
+            _edge(npc_a="npc-1", npc_b="npc-2", history="封印裂隙旧盟。", status=["同盟"]),
+        ]
+    )
+    bullets = fetch_relationship_rag_context(
+        client,
+        settings,
+        "room-1",
+        "npc-1",
+        "你和 npc-2 的同盟关系？",
+    )
+    assert len(bullets) <= 2
+    assert any("ensure-embedding" in url for url, _ in client.posts)
+    assert bullets
+    assert "封印" not in bullets[0] or "意译" in bullets[0]
+
+
+def test_bullets_are_paraphrase_not_full_history_dump():
+    raw = (
+        "我们曾在议会边境防务案上激烈争执，彼此记恨多年，"
+        "那些细节若被原样复读就会破坏 speak 的自然感。"
+    )
+    bullet = format_relationship_bullet(
+        _edge(npc_a="npc-1", npc_b="npc-2", history=raw, status=["交恶"]),
+        "npc-1",
+    )
+    assert bullet
+    assert raw not in bullet
+    assert "意译" in bullet or "勿" in bullet
+
+
+def test_topic_relevant_and_third_party_detection():
+    edges = [_edge(npc_a="npc-3", npc_b="npc-4", history="宿怨未消。", status=["敌对"])]
+    assert topic_relevant_relationship("npc-3 关系如何", edges) is True
+    assert "npc-3" in referenced_third_party_ids("提到 npc-3 的同僚", "npc-1")