@xia-sc/dsh-cc-studio 0.8.1 → 0.8.2

package/lib/index.js

@@ -570,22 +570,33 @@ function applyGroupOps(group, ops){
  * 生成【关系】段（纯函数）。默认只写出边（我 → 他）—— 卡片是以"我"为视角的；
  * includeIncoming 时追加一节「他们眼中的我」（扮演时知道对方怎么看我，是剧情张力来源，默认关）。
  */
+/**
+ * 出边口径（渲染与 outgoing 计数**共用这一处**，避免「预览说 N 条、实际写出 M 条」）。
+ * mutual（对等）边是双向的：不管它从哪一端写的，两端都该看到它 —— 所以「指向我的 mutual 边」
+ * 也算我的出边。⚠️ 曾经 outgoing 只认 `from === myNodeId`，而 incoming 又显式排除 mutual，
+ * 于是 mutual 边**两头都不落**、渲染时被静默丢弃（做的「对等关系」在导出的卡里彻底消失）。
+ */
+function outgoingEdgesOf(myNodeId, edges){
+  return (Array.isArray(edges) ? edges : []).filter(e => e.from === myNodeId || (e.direction === "mutual" && e.to === myNodeId));
+}
 function renderRelationsSection(myNodeId, nodes, edges, opts){
   const o = opts || {};
   const byId = new Map((Array.isArray(nodes) ? nodes : []).map(n => [n.id, n]));
   const nameOf = (id) => { const n = byId.get(id); return n ? (n.name || "未命名") : "（未知）"; };
   const all = (Array.isArray(edges) ? edges : []).filter(e => byId.has(e.from) && byId.has(e.to));
-  const outgoing = all.filter(e => e.from === myNodeId);
+  const outgoing = outgoingEdgesOf(myNodeId, all);
+  // incoming 仍排除 mutual：同一条对等关系不必在两节各说一遍（出边那节已带「，互向」标记）
   const incoming = all.filter(e => e.to === myNodeId && e.direction !== "mutual");
+  const otherOf = (e) => (e.from === myNodeId ? e.to : e.from);   // mutual 边可能是反向写着的，对方在 from 端
   const order = (t) => { const i = REL_TYPES.indexOf(t); return i < 0 ? REL_TYPES.length : i; };
   const fmt = (e, otherId) => "- " + nameOf(otherId) + "（" + relLabel(e) + "｜" + e.strength + "/5" + (e.direction === "mutual" ? "，互向" : "") + "）" + (e.note ? "：" + e.note : "");
-  const byTypeThenStrength = (other) => (a, b) => (order(a.type) - order(b.type)) || (b.strength - a.strength) || nameOf(a[other]).localeCompare(nameOf(b[other]));
+  const byTypeThenStrength = (other) => (a, b) => (order(a.type) - order(b.type)) || (b.strength - a.strength) || nameOf(other(a)).localeCompare(nameOf(other(b)));
   const lines = ["【关系】"];
   if(!outgoing.length) lines.push("- （暂无）");
-  else outgoing.slice().sort(byTypeThenStrength("to")).forEach(e => lines.push(fmt(e, e.to)));
+  else outgoing.slice().sort(byTypeThenStrength(otherOf)).forEach(e => lines.push(fmt(e, otherOf(e))));
   if(o.includeIncoming && incoming.length){
     lines.push("", "【他们眼中的我】");
-    incoming.slice().sort(byTypeThenStrength("from")).forEach(e => lines.push(fmt(e, e.from)));
+    incoming.slice().sort(byTypeThenStrength(e => e.from)).forEach(e => lines.push(fmt(e, e.from)));
   }
   return lines.join("\n");
 }
@@ -999,6 +1010,52 @@ async function groupMemberIds(groupId){
   const entries = await listLibraryEntries();
   return entries.filter(e => String(e.groupId || "") === gid).map(e => e.id);
 }
+/**
+ * 按名字找组（建组/改名时查重）：trim 后精确比对；带 exceptId 时排除自己（给自己改名不算撞车）。
+ * 两半同构 —— 界面和模型必须落到同一条规则上，否则会出现「模型建不了同名组、界面却建了两个」。
+ */
+function findGroupByName(groups, name, exceptId){
+  const want = String(name || "").trim();
+  if(!want) return null;
+  const eid = exceptId ? safeGroupId(exceptId) : "";
+  return (Array.isArray(groups) ? groups : []).find(g => g.id !== eid && String(g.name || "").trim() === want) || null;
+}
+/**
+ * 把一张已存卡放进分组（groupId 传空 = 移出）。与 lib/agent.js **逐字同构** —— 界面与模型必须落到
+ * 同一套行为上（否则会出现「模型放进去能复活旧节点、界面放进去却新建一个同名节点」这种分叉）。
+ * 入组时若组里还没有它的节点就自动补一个；卡曾因被删而降级的同名 orphan 节点会被**复活**（保住旧关系）。
+ * 移出**不删节点、不删关系**：那是用户建过的资产，挪回来时关系还在。
+ */
+async function assignCardToGroup(cardId, groupId){
+  const cid = String(cardId || "");
+  if(!cid) throw new Error("需要 cardId");
+  const entries = await listLibraryEntries();
+  const mine = entries.find(e => e.id === cid);
+  if(!mine) throw Object.assign(new Error("找不到角色卡: " + cid), { code: "ENOENT" });
+  const gid = (groupId === null || groupId === undefined || groupId === "") ? "" : safeGroupId(groupId);
+  if(!gid){
+    await patchLibraryMeta(cid, { groupId: null });
+    return { cardId: cid, cardName: mine.name, previousGroupId: (mine.groupId ? String(mine.groupId) : null), groupId: null, nodeId: null, revived: false };
+  }
+  const found = await readGroupRaw(gid);
+  if(!found) throw Object.assign(new Error("分组不存在: " + gid), { code: "not-found" });
+  const g = normalizeGroup(found.obj);
+  let node = g.nodes.find(n => n.kind === "card" && n.cardId === cid);
+  let revived = false;
+  if(!node){
+    node = g.nodes.find(n => n.kind === "card" && !n.cardId && n.orphanOf && n.orphanOf === String(mine.name || ""));
+    if(node){ node.cardId = cid; node.orphanOf = null; revived = true; }
+  }
+  if(!node){
+    node = { id: "n" + (g.nextNodeSeq++), kind: "card", cardId: cid, name: mine.name || "未命名角色", aliases: [], orphanOf: null };
+    g.nodes.push(node);
+    await writeGroup(g);
+  } else if(revived){
+    await writeGroup(g);
+  }
+  await patchLibraryMeta(cid, { groupId: gid });
+  return { cardId: cid, cardName: mine.name, previousGroupId: (mine.groupId ? String(mine.groupId) : null), groupId: gid, nodeId: node.id, groupRev: g.rev, revived };
+}
 /** 0.8.0：体检 / 渲染需要的卡片摘要（只读；卡不在库里就跳过）。 */
 async function libraryCardsFor(ids){
   const out = [];
@@ -1526,15 +1583,25 @@ function apply(ctx, config){
           const groups = await listGroups();
           const entries = await listLibraryEntries();
           const countOf = (gid) => entries.filter(e => String(e.groupId || "") === gid).length;
-          return ok({ groups: groups.map(g => ({
-            id: g.id, name: g.name, note: g.note,
-            nodeCount: g.nodes.length, edgeCount: g.edges.length,
-            memberCount: countOf(g.id), rev: g.rev, updatedAt: g.updatedAt,
-          })) });
+          const out = [];
+          for(const g of groups){
+            const b = await readBookRaw(g.id);   // 组级共享世界书摘要（UI 要在分组标题上显示「共享 N 条」）
+            out.push({
+              id: g.id, name: g.name, note: g.note,
+              nodeCount: g.nodes.length, edgeCount: g.edges.length,
+              memberCount: countOf(g.id), rev: g.rev, updatedAt: g.updatedAt,
+              hasBook: !!b, bookEntries: b ? normalizeBook(b.obj, g.id).data.entries.length : 0,
+            });
+          }
+          return ok({ groups: out });
         }
         case "cc_createGroup":{
           const name = String(args.name || "").trim().slice(0, 60);
           if(!name) return fail("invalid-name", "分组名不能为空");
+          // 0.8.0：同名分组默认拒绝 —— 否则侧栏里会出现两个「测试」，人和模型都分不清该往哪个放卡
+          // （工具半 cc_create_group 是同一套规则，那边另有 allowDuplicate 逃生门）
+          const dup = findGroupByName(await listGroups(), name, "");
+          if(dup && args.allowDuplicate !== true) return fail("duplicate-name", "已有同名分组「" + dup.name + "」（id " + dup.id + "）", { existingGroupId: dup.id });
           const g = await writeGroup({ id: newGroupId(), name, note: String(args.note || "").slice(0, 200), nodes: [], edges: [] });
           return ok({ group: g });
         }
@@ -1542,9 +1609,17 @@ function apply(ctx, config){
           const found = await readGroupRaw(args.id);
           if(!found) return fail("not-found", "分组不存在: " + String(args.id));
           const g = normalizeGroup(found.obj);
-          if(typeof args.name === "string" && args.name.trim()) g.name = args.name.trim().slice(0, 60);
-          if(typeof args.note === "string") g.note = args.note.slice(0, 200);
-          return ok({ group: await writeGroup(g) });
+          const changed = [];
+          if(typeof args.name === "string" && args.name.trim()){
+            const name = args.name.trim().slice(0, 60);
+            const dup = findGroupByName(await listGroups(), name, g.id);
+            if(dup && args.allowDuplicate !== true) return fail("duplicate-name", "已有同名分组「" + dup.name + "」（id " + dup.id + "）", { existingGroupId: dup.id });
+            if(name !== g.name){ g.name = name; changed.push("name"); }
+          }
+          if(typeof args.note === "string" && args.note.slice(0, 200) !== g.note){ g.note = args.note.slice(0, 200); changed.push("note"); }
+          // 无实际改动不写盘（同 N4 家规：空改动不该白涨 rev，否则别人手上的 rev 前提会被无变化打掉）
+          if(!changed.length) return ok({ group: g, changed: [] });
+          return ok({ group: await writeGroup(g), changed });
         }
         case "cc_deleteGroup":{
           const removed = await deleteGroupFile(args.id);
@@ -1556,29 +1631,23 @@ function apply(ctx, config){
             if(String(e.groupId || "") !== gid) continue;
             try{ await patchLibraryMeta(e.id, { groupId: null }); memberCleared += 1; }catch{}
           }
-          return ok({ deleted: removed, memberCleared });
+          // 0.9.0：组级共享世界书随组一起删（它属于这个组，留下就是孤儿文件）
+          const bookDeleted = await deleteBook(gid);
+          return ok({ deleted: removed, memberCleared, bookDeleted });
         }
         case "cc_setCardGroup":{
           const cardId = String(args.cardId || "");
           if(!cardId) return fail("invalid-card", "需要 cardId");
           const want = (args.groupId === null || args.groupId === undefined || args.groupId === "") ? null : safeGroupId(args.groupId);
-          if(want){
-            const found = await readGroupRaw(want);
-            if(!found) return fail("not-found", "分组不存在: " + want);
-            const g = normalizeGroup(found.obj);
-            // 入组时若还没有该卡的节点就自动补一个：用户只需要"把卡拉进组"，不必手工建节点
-            let node = g.nodes.find(n => n.kind === "card" && n.cardId === cardId);
-            if(!node){
-              const card = (await libraryCardsFor([cardId]))[0];
-              node = { id: "n" + (g.nextNodeSeq++), kind: "card", cardId, name: (card && card.name) || "未命名角色", aliases: [], orphanOf: null };
-              g.nodes.push(node);
-              await writeGroup(g);
-            }
-            await patchLibraryMeta(cardId, { groupId: want });
-            return ok({ cardId, groupId: want, nodeId: node.id });
+          // 走与工具半**同一份** assignCardToGroup：自动补节点、复活同名 orphan 节点、移出时保留节点与边
+          try{
+            const r = await assignCardToGroup(cardId, want);
+            return ok({ cardId: r.cardId, groupId: r.groupId, nodeId: r.nodeId, previousGroupId: r.previousGroupId, revived: r.revived === true });
+          }catch(e){
+            if(e && e.code === "ENOENT") return fail("not-found", "库里找不到这张卡: " + cardId);
+            if(e && e.code === "not-found") return fail("not-found", "分组不存在: " + want);
+            throw e;
           }
-          await patchLibraryMeta(cardId, { groupId: null });
-          return ok({ cardId, groupId: null });
         }
         case "cc_getGroup":{
           const found = await readGroupRaw(args.id);
@@ -1634,6 +1703,131 @@ function apply(ctx, config){
           }
           return ok({ changed, groupId: g.id, rev: g.rev, description: after });
         }
+        // ———————————————— 组级共享世界书（0.9.0）————————————————
+        // 一本书对一个分组，存 <主根>/cc-books/<groupId>.json（本身就是可发布的 lorebook_v3 JSON）。
+        case "cc_getBook":{
+          const gid = safeGroupId(args.groupId);
+          if(!gid) return fail("invalid-group", "需要 groupId");
+          const found = await readBookRaw(gid);
+          const cards = await bookCardsFor(await groupMemberIds(gid));
+          const scan = scanSharedEntries(cards);
+          const cardList = cards.map(c => ({ id: c.id, name: c.name, entries: (c.entries || []).length }));
+          if(!found) return ok({ exists: false, groupId: gid, cards: cardList, scan });
+          const book = normalizeBook(found.obj, gid);
+          return ok({ exists: true, groupId: gid, book, rev: bookRevOf(book),
+            tokens: estimateTokensLite(book.data.entries.map(e => e.content).join("\n")),
+            cards: cardList, scan });
+        }
+        case "cc_patchBook":{
+          const gid = safeGroupId(args.groupId);
+          if(!gid) return fail("invalid-group", "需要 groupId");
+          const found = await readBookRaw(gid);
+          const cur = found ? normalizeBook(found.obj, gid) : normalizeBook({ data: { name: String(args.name || "共享设定") } }, gid);
+          if(typeof args.expectedBookRev === "number" && args.expectedBookRev !== bookRevOf(cur)){
+            return fail("stale-rev", "共享世界书已被外部修改（期望 rev=" + args.expectedBookRev + "，实际 rev=" + bookRevOf(cur) + "）—— 先重新读取再改",
+              { staleRev: true, expectedBookRev: args.expectedBookRev, actualBookRev: bookRevOf(cur) });
+          }
+          const applied = [], rejected = [];
+          if(args.name !== undefined) cur.data.name = String(args.name).slice(0, 80);
+          if(args.description !== undefined) cur.data.description = String(args.description).slice(0, 300);
+          if(args.scan_depth !== undefined) cur.data.scan_depth = Math.max(1, Math.round(Number(args.scan_depth) || 4));
+          if(args.token_budget !== undefined) cur.data.token_budget = Math.max(100, Math.round(Number(args.token_budget) || 2000));
+          if(args.recursive_scanning !== undefined) cur.data.recursive_scanning = args.recursive_scanning === true;
+          ["name", "description", "scan_depth", "token_budget", "recursive_scanning"].forEach(k => { if(args[k] !== undefined) applied.push({ op: "setMeta", field: k }); });
+          (Array.isArray(args.ops) ? args.ops : []).forEach(op => {
+            const kind = String((op && op.op) || "");
+            if(kind === "addEntry"){
+              const e = makeBookEntry(op.entry);
+              if(!e.content.trim()){ rejected.push({ op, error: "content 不能为空" }); return; }
+              if(cur.data.entries.some(x => contentKeyOf(x) === contentKeyOf(e))){ rejected.push({ op, error: "同内容的条目已存在" }); return; }
+              if(cur.data.entries.length >= BOOK_MAX_ENTRIES){ rejected.push({ op, error: "条目数已达上限 " + BOOK_MAX_ENTRIES }); return; }
+              cur.data.entries.push(e);
+              applied.push({ op: kind, key: contentKeyOf(e), name: e.name });
+            } else if(kind === "updateEntry"){
+              const idx = cur.data.entries.findIndex(x => contentKeyOf(x) === String(op.contentKey || ""));
+              if(idx < 0){ rejected.push({ op, error: "找不到条目（contentKey 不匹配）" }); return; }
+              const patch = (op.patch && typeof op.patch === "object") ? op.patch : {};
+              cur.data.entries[idx] = makeBookEntry(Object.assign({}, cur.data.entries[idx], patch));
+              applied.push({ op: kind, key: contentKeyOf(cur.data.entries[idx]) });
+            } else if(kind === "removeEntry"){
+              // 支持两种定位：`index`（UI 列表直接用它）或 `contentKey`（模型读到的签名）
+              const byIndex = Number.isInteger(op.index) ? op.index : -1;
+              if(byIndex >= 0 && byIndex < cur.data.entries.length){
+                const gone = cur.data.entries.splice(byIndex, 1)[0];
+                applied.push({ op: kind, index: byIndex, key: contentKeyOf(gone) });
+                return;
+              }
+              const before = cur.data.entries.length;
+              cur.data.entries = cur.data.entries.filter(x => contentKeyOf(x) !== String(op.contentKey || ""));
+              if(cur.data.entries.length === before){ rejected.push({ op, error: "找不到条目（index / contentKey 都不匹配）" }); return; }
+              applied.push({ op: kind, key: String(op.contentKey) });
+            } else rejected.push({ op, error: "未知 op：" + kind });
+          });
+          if(!applied.length) return ok({ book: cur, rev: bookRevOf(cur), applied: [], rejected, changed: false });
+          const saved = await writeBook(gid, cur);
+          return ok({ book: saved, rev: bookRevOf(saved), applied, rejected, changed: true });
+        }
+        case "cc_promoteBook":{
+          const gid = safeGroupId(args.groupId);
+          if(!gid) return fail("invalid-group", "需要 groupId");
+          const found = await readBookRaw(gid);
+          const cur = found ? normalizeBook(found.obj, gid) : normalizeBook({}, gid);
+          const cards = await bookCardsFor(await groupMemberIds(gid));
+          const scan = scanSharedEntries(cards);
+          const known = new Map(scan.candidates.map(c => [c.signature, c]));
+          // 只认得扫描出来的候选：传了不存在的签名一律拒绝 —— 这是会**从多张卡里删条目**的操作，绝不猜
+          const requested = (Array.isArray(args.keys) && args.keys.length) ? args.keys.map(String) : scan.candidates.map(c => c.signature);
+          const unknownKeys = requested.filter(s => !known.has(s));
+          const use = requested.filter(s => known.has(s));
+          const plan = applyBookPromotion(cards, cur.data.entries, use);
+          const summary = (g) => ({ signature: g.signature, name: g.name, cards: g.cards.length, cardNames: g.cardNames, chars: g.chars, savedChars: g.savedChars, nameMismatch: g.nameMismatch, keysMismatch: g.keysMismatch, preview: g.preview });
+          if(args.apply !== true){
+            return ok({ dryRun: true, changed: false, wouldPromote: use.length, unknownKeys,
+              removedTotal: plan.removedTotal, perCard: plan.cards.map(c => ({ id: c.id, name: c.name, removed: c.removed, left: c.entries.length })),
+              candidates: scan.candidates.map(summary), stats: scan.stats, rev: bookRevOf(cur) });
+          }
+          const bookNext = Object.assign({}, cur, { data: Object.assign({}, cur.data, { entries: plan.bookEntries }) });
+          const saved = await writeBook(gid, bookNext);
+          const touched = [];
+          for(const c of plan.cards){
+            if(!c.removed) continue;
+            try{
+              const rawOne = await readLibraryRaw(c.id);
+              const obj = JSON.parse(rawOne.raw);
+              obj.draft.data.character_book = Object.assign({}, obj.draft.data.character_book, { entries: c.entries });
+              if(obj.meta){ obj.meta.loreCount = c.entries.length; obj.meta.updatedAt = nowSec(); }   // 只更新这两个字段，其余 meta 原样保留（B4 的教训：绝不重建 meta）
+              await writeFile(rawOne.path, JSON.stringify(obj, null, 2), "utf8");
+              touched.push({ id: c.id, name: c.name, removed: c.removed, left: c.entries.length });
+            }catch(e){ touched.push({ id: c.id, name: c.name, error: String(e && e.message || e) }); }
+          }
+          return ok({ dryRun: false, changed: true, promoted: plan.promoted.length, removedTotal: plan.removedTotal,
+            unknownKeys, bookRev: bookRevOf(saved), bookEntries: saved.data.entries.length, perCard: touched,
+            candidates: scan.candidates.map(summary), stats: scan.stats });
+        }
+        case "cc_applyBook":{
+          const gid = safeGroupId(args.groupId);
+          if(!gid) return fail("invalid-group", "需要 groupId");
+          const found = await readBookRaw(gid);
+          if(!found) return fail("not-found", "这个分组还没有共享世界书");
+          const cur = normalizeBook(found.obj, gid);
+          const k = draftKeyFrom(ctx, args);
+          const origin = readDraftOrigin(k);
+          const cardId = args.cardId ? String(args.cardId) : ((origin && origin.libraryId) || "");
+          if(!cardId) return fail("no-card", "没有指定 cardId，当前草稿也没有来源卡（先保存到侧边栏）");
+          const rawOne = await readLibraryRaw(cardId);
+          const obj = JSON.parse(rawOne.raw);
+          const cardEntries = (obj.draft && obj.draft.data && obj.draft.data.character_book && Array.isArray(obj.draft.data.character_book.entries))
+            ? obj.draft.data.character_book.entries : [];
+          const merged = mergeBookEntries(cur.data.entries, cardEntries);
+          if(args.dryRun === true){
+            return ok({ dryRun: true, cardId, wouldAdd: merged.added.length, bookEntries: cur.data.entries.length, cardEntries: cardEntries.length });
+          }
+          if(!merged.added.length) return ok({ cardId, added: 0, changed: false, loreCount: cardEntries.length });
+          obj.draft.data.character_book = Object.assign({}, obj.draft.data.character_book, { entries: merged.entries });
+          if(obj.meta){ obj.meta.loreCount = merged.entries.length; obj.meta.updatedAt = nowSec(); }
+          await writeFile(rawOne.path, JSON.stringify(obj, null, 2), "utf8");
+          return ok({ cardId, added: merged.added.length, changed: true, loreCount: merged.entries.length });
+        }
         case "cc_importFromPng":{
           const b64 = args.b64;
           if(typeof b64!=="string" || !b64) return fail("invalid-b64","b64 必填");
@@ -1748,6 +1942,201 @@ function apply(ctx, config){
   }), "dsh-cc-studio: POST "+RPC_CHANNEL+"/*");
 }
 
+// ——————————————————————————————————————————————————————————————
+// 组级共享世界书（0.9.0）：一份 JSON 整组共用，成员卡里只留角色私有条目
+//
+// 为什么：群聊卡的世界设定（年表/势力/地理/力量/日常）在每张成员卡里**逐字重复**。实测一组
+// 4 张卡共 20 条，其中 5 条是完全相同的同一份设定（约 4500 字符纯冗余），改一条要改 4 遍。
+// CCv3 规范本身给了两个依据：① Lorebook 可以**单独导出** —— `{ spec: "lorebook_v3", data: Lorebook }`；
+// ② `character_book` 是「角色专属」的那一本，规范明说它应当能与一个全局 lorebook **叠加**。
+// 所以把共享设定提到组级独立文件，客户端里绑成全局/世界书即可，成员卡不必再存。
+//
+// 存储：<主根>/cc-books/<groupId>.json —— **一本书对一个分组**；文件本身就是可直接发布的
+// lorebook_v3 JSON（拷出去别人就能用），插件自己的状态放 `data.extensions.cc`（规范允许）。
+// 条目字段与卡内 `character_book.entries` **完全同构** —— 提升/回填都是零转换搬运。
+// ——————————————————————————————————————————————————————————————
+const BOOK_SPEC = "lorebook_v3";
+const BOOK_MAX_ENTRIES = 200;
+
+function bookDirs(){ return dataRoots("cc-books"); }
+function bookDir(){ return bookDirs()[0]; }
+function bookPath(groupId){ return join(bookDir(), safeGroupId(groupId) + ".json"); }
+async function ensureBookDir(){ try{ await mkdir(bookDir(), { recursive: true }); }catch{} }
+
+/** 条目归一化：**只补缺、不裁剪** —— CCv3 要求应用把不认识的字段也原样保存（否则导入的书会被削掉）。 */
+function makeBookEntry(e){
+  const src = (e && typeof e === "object") ? e : {};
+  const out = Object.assign({}, src);
+  out.keys = Array.isArray(src.keys) ? src.keys.map(String) : [];
+  out.content = String(src.content == null ? "" : src.content);
+  out.enabled = src.enabled !== false;
+  out.insertion_order = Number.isFinite(Number(src.insertion_order)) ? Number(src.insertion_order) : 0;
+  out.constant = src.constant === true;
+  out.use_regex = src.use_regex === true;
+  if(typeof out.name !== "string") out.name = out.name == null ? "" : String(out.name);
+  if(!out.extensions || typeof out.extensions !== "object" || Array.isArray(out.extensions)) out.extensions = {};
+  return out;
+}
+/** 插件自己的状态挂在 data.extensions.cc（rev 与分组 id）—— 读取都走这里。 */
+function bookCcOf(obj){
+  const data = (obj && obj.data && typeof obj.data === "object") ? obj.data : {};
+  const ext = (data.extensions && typeof data.extensions === "object") ? data.extensions : {};
+  return (ext.cc && typeof ext.cc === "object") ? ext.cc : {};
+}
+function bookRevOf(obj){ const n = Number(bookCcOf(obj).rev); return Number.isFinite(n) && n > 0 ? Math.round(n) : 0; }
+/** 结构兜底：缺字段补默认、条目逐条归一；`data` 之外的未知顶层字段也保留。 */
+function normalizeBook(obj, groupId){
+  const src = (obj && typeof obj === "object") ? obj : {};
+  const raw = (src.data && typeof src.data === "object") ? src.data : (Array.isArray(src.entries) ? src : {});
+  const cc = bookCcOf(src);
+  const data = Object.assign({}, raw, {
+    name: String(raw.name || "").slice(0, 80),
+    description: String(raw.description || "").slice(0, 300),
+    scan_depth: Math.max(1, Math.round(Number(raw.scan_depth) || 4)),
+    token_budget: Math.max(100, Math.round(Number(raw.token_budget) || 2000)),
+    recursive_scanning: raw.recursive_scanning === true,
+    entries: (Array.isArray(raw.entries) ? raw.entries : []).slice(0, BOOK_MAX_ENTRIES).map(makeBookEntry),
+  });
+  const ext = Object.assign({}, (raw.extensions && typeof raw.extensions === "object") ? raw.extensions : {});
+  ext.cc = Object.assign({}, (ext.cc && typeof ext.cc === "object") ? ext.cc : {}, {
+    groupId: safeGroupId(groupId || cc.groupId),
+    rev: Math.max(0, Math.round(Number(cc.rev) || 0)),
+    updatedAt: Number(cc.updatedAt) || nowSec(),
+  });
+  data.extensions = ext;
+  return Object.assign({}, src, { spec: BOOK_SPEC, data });
+}
+/** 读盘：主根没有就回退旧根（与角色库/分组同一套规则）。 */
+async function readBookRaw(groupId){
+  const file = safeGroupId(groupId) + ".json";
+  for(const dir of bookDirs()){
+    try{
+      const raw = await readFile(join(dir, file), "utf8");
+      const obj = JSON.parse(raw);
+      if(obj && typeof obj === "object") return { raw, obj };
+    }catch{}
+  }
+  return null;
+}
+/** 写盘：rev 每次 +1（与 writeGroup 同一套乐观锁语义）。 */
+async function writeBook(groupId, book){
+  await ensureBookDir();
+  const gid = safeGroupId(groupId);
+  const prev = await readBookRaw(gid);
+  const cur = normalizeBook(book, gid);
+  cur.data.extensions.cc.rev = (prev ? bookRevOf(prev.obj) : 0) + 1;
+  cur.data.extensions.cc.updatedAt = nowSec();
+  await writeFile(bookPath(gid), JSON.stringify(cur, null, 2), "utf8");
+  return cur;
+}
+/** 删书：两个根里的同名副本都删（否则回退读会把刚删的书「复活」）。返回是否删到了。 */
+async function deleteBook(groupId){
+  const gid = safeGroupId(groupId);
+  if(!gid) return false;
+  let removed = 0;
+  for(const dir of bookDirs()){
+    try{ await unlink(join(dir, gid + ".json")); removed += 1; }
+    catch(e){ if(e && e.code !== "ENOENT") throw e; }
+  }
+  return removed > 0;
+}
+/**
+ * 内容签名：折叠空白后取 djb2 哈希 + 长度，用于「同一条设定」的快速比对 —— 只差换行/空格的两条
+ * 不该被当成两条（实测里自动条目与手工条目就常差这点空白）。
+ * ⚠️ 它只是**索引**：真正搬运/删除前一律再逐字比对内容（哈希碰撞绝不能变成删数据）。
+ */
+function contentKeyOf(entry){
+  const s = String((entry && entry.content) != null ? entry.content : "").replace(/\s+/g, " ").trim();
+  let h = 5381;
+  for(let i = 0; i < s.length; i++) h = ((h * 33) ^ s.charCodeAt(i)) >>> 0;
+  return "c" + h.toString(36) + "-" + s.length;
+}
+/** 成员卡的**完整**条目（去重要比内容，摘要不够）——与 libraryCardsFor 同源，多带 entries。 */
+async function bookCardsFor(ids){
+  const out = [];
+  for(const id of (Array.isArray(ids) ? ids : [])){
+    try{
+      const obj = JSON.parse((await readLibraryRaw(id)).raw);
+      const d = (obj && obj.draft && obj.draft.data) ? obj.draft.data : {};
+      const entries = Array.isArray(d.character_book && d.character_book.entries) ? d.character_book.entries : [];
+      out.push({
+        id: String(id),
+        name: String(d.name || (obj && obj.meta && obj.meta.name) || ""),
+        entries: entries.map(makeBookEntry),
+      });
+    }catch{}
+  }
+  return out;
+}
+/**
+ * 跨成员卡找「同一份设定」（纯函数）：按内容签名分组，出现在 **≥2 张卡**里的才算候选。
+ * 只报候选、不下结论 —— 同内容不同名、同名不同内容都如实标注，交给用户/模型拍板。
+ */
+function scanSharedEntries(cards){
+  const list = Array.isArray(cards) ? cards : [];
+  const seen = new Map();
+  list.forEach(c => {
+    (Array.isArray(c.entries) ? c.entries : []).forEach(e => {
+      if(!String((e && e.content) || "").trim()) return;   // 空内容不会进 prompt，不参与
+      const sig = contentKeyOf(e);
+      if(!seen.has(sig)) seen.set(sig, { signature: sig, content: String(e.content), name: String(e.name || ""), keys: (e.keys || []).map(String), constant: e.constant === true, chars: String(e.content).length, cards: [], cardNames: [], nameMismatch: false, keysMismatch: false });
+      const g = seen.get(sig);
+      if(g.cards.indexOf(c.id) < 0){ g.cards.push(c.id); g.cardNames.push(c.name); }
+      if(String(e.name || "") !== g.name) g.nameMismatch = true;
+      if(JSON.stringify((e.keys || []).map(String)) !== JSON.stringify(g.keys)) g.keysMismatch = true;
+    });
+  });
+  const candidates = [...seen.values()].filter(g => g.cards.length >= 2)
+    .sort((a, b) => b.cards.length - a.cards.length || b.chars - a.chars)
+    .map(g => Object.assign({}, g, { preview: g.content.slice(0, 80).replace(/\s+/g, " "), savedChars: g.chars * (g.cards.length - 1) }));
+  const totalEntries = list.reduce((n, c) => n + (Array.isArray(c.entries) ? c.entries.length : 0), 0);
+  return {
+    candidates,
+    stats: {
+      cards: list.length, totalEntries,
+      duplicatedEntries: candidates.reduce((n, g) => n + g.cards.length, 0),
+      savedChars: candidates.reduce((n, g) => n + g.savedChars, 0),
+    },
+  };
+}
+/** 把共享书的条目合并进一张卡的条目表（同内容已存在则跳过）—— 给不支持全局世界书的客户端兜底。 */
+function mergeBookEntries(bookEntries, cardEntries){
+  const have = new Set((Array.isArray(cardEntries) ? cardEntries : []).map(contentKeyOf));
+  const added = [];
+  (Array.isArray(bookEntries) ? bookEntries : []).forEach(e => {
+    const sig = contentKeyOf(e);
+    if(have.has(sig)) return;
+    have.add(sig);
+    added.push(makeBookEntry(e));
+  });
+  return { entries: (Array.isArray(cardEntries) ? cardEntries : []).map(makeBookEntry).concat(added), added };
+}
+/**
+ * 提升（纯函数）：把指定签名的条目写进共享书，并从**每一张**出现过它的成员卡里删掉。
+ * 只删内容逐字相同（折叠空白后相同）的那几条 —— 签名只用来筛，动手前再比对内容。
+ */
+function applyBookPromotion(cards, bookEntries, signatures){
+  const want = new Set((Array.isArray(signatures) ? signatures : []).map(String));
+  const book = (Array.isArray(bookEntries) ? bookEntries : []).map(makeBookEntry);
+  const have = new Set(book.map(contentKeyOf));
+  const promoted = [];
+  const nextCards = (Array.isArray(cards) ? cards : []).map(c => {
+    const kept = [];
+    let removed = 0;
+    (Array.isArray(c.entries) ? c.entries : []).forEach(e => {
+      const sig = contentKeyOf(e);
+      if(want.has(sig)){
+        if(!have.has(sig)){ have.add(sig); book.push(makeBookEntry(e)); promoted.push(sig); }
+        removed += 1;
+        return;
+      }
+      kept.push(makeBookEntry(e));
+    });
+    return { id: c.id, name: c.name, entries: kept, removed };
+  });
+  return { bookEntries: book, cards: nextCards, promoted, removedTotal: nextCards.reduce((n, c) => n + c.removed, 0) };
+}
+
 export { apply, inject, name, planPresetInstall, installCcPreset, supportsDeclaredPresets, presetTargetRoot, presetSourceRoot,
   draftKeyPartsFrom, draftContentSummary, listDraftSlotsOnDisk, migrateDraftDecision,
   // 落盘根与 lib 层 CRUD（供回归测试直接断言「DSH_HOME 优先 + 读时回退」）
@@ -1760,6 +2149,11 @@ export { apply, inject, name, planPresetInstall, installCcPreset, supportsDeclar
   groupDirs, groupDir, groupPath, safeGroupId, newGroupId, normalizeGroup, validateGroupOp, applyGroupOps,
   renderRelationsSection, spliceRelations, checkGroup, listGroups, readGroupRaw, writeGroup, deleteGroupFile,
   groupMemberIds, libraryCardsFor, patchLibraryMeta, orphanCardNodes, syncCardNodeName, estimateTokensLite,
+  // 0.8.0 分组管理：出边口径（渲染与计数共用）、建组查重、归位/建节点 —— 与工具半逐字同构，测试直接比对
+  outgoingEdgesOf, findGroupByName, assignCardToGroup,
+  // 0.9.0 组级共享世界书：落盘 + 纯函数（扫描/提升/回填），两半同构、条目与卡内 character_book 同形
+  BOOK_SPEC, bookDirs, bookDir, bookPath, makeBookEntry, normalizeBook, bookRevOf, readBookRaw, writeBook, deleteBook,
+  contentKeyOf, bookCardsFor, scanSharedEntries, mergeBookEntries, applyBookPromotion,
   REL_TYPES, REL_TYPE_LABELS, REL_BEGIN, REL_END };
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xia-sc/dsh-cc-studio",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "description": "CCv3 角色卡工坊：融合工坊 + CC 模式 + JSON/PNG/CHARX + 中英双语（跟随全局）",
   "keywords": [
     "dsh",
@@ -38,7 +38,7 @@
     "presets"
   ],
   "scripts": {
-    "test": "node tests/rpc-channel.test.mjs && node tests/preset-install.test.mjs && node tests/cc-detection.test.mjs && node tests/client-greetings.test.mjs && node tests/draft-slot-sync.test.mjs && node tests/nav-highlight.test.mjs && node tests/clear-card.test.mjs && node tests/export-entry.test.mjs && node tests/close-button.test.mjs && node tests/tools-contract.test.mjs && node tests/relations.test.mjs && node tests/data-root.test.mjs",
+    "test": "node tests/rpc-channel.test.mjs && node tests/preset-install.test.mjs && node tests/cc-detection.test.mjs && node tests/client-greetings.test.mjs && node tests/draft-slot-sync.test.mjs && node tests/nav-highlight.test.mjs && node tests/clear-card.test.mjs && node tests/export-entry.test.mjs && node tests/close-button.test.mjs && node tests/tools-contract.test.mjs && node tests/relations.test.mjs && node tests/relations-view.test.mjs && node tests/shared-book.test.mjs && node tests/data-root.test.mjs",
     "prepublishOnly": "npm test"
   },
   "dsh": {