@xia-sc/dsh-cc-studio 0.8.3 → 0.9.0

package/lib/client.js

@@ -79,6 +79,7 @@ window.__ModuleLoader__.load({
       "book.promoteHint":"把这 N 条搬进共享书，并从每张卡里删掉 —— 导出前先做这一步，卡里就不再有重复。",
       "book.promotePreview":"将提升 {n} 条、从各卡共删 {m} 条重复",
       "book.promoteDone":"已提升 {n} 条（删掉 {m} 条重复）",
+      "book.promoteSyncedDraft":"已同步当前草稿，删掉 {n} 条重复（否则保存时会把它们写回去）",
       "book.exportBook":"导出共享世界书 JSON",
       "book.exported":"已导出 {name}",
       "book.applyCard":"合并进当前卡",
@@ -311,6 +312,8 @@ window.__ModuleLoader__.load({
       "store.loadedCard":"已载入：{name} · {n} lore（ID:{id}，再次保存将更新此卡）",
       "store.errLoadFailed":"载入失败",
       "store.confirmDelete":"确定删除该角色？此操作不可撤销。",
+      "relations.confirmDeleteGroup":"确定删除这个分组？分组里的节点与关系、以及该组的共享世界书（若有）会一起删掉，且不可恢复。成员卡不会被删除，只会离开这个组。",
+      "book.dupBook":"另有 {n} 条在成员卡里与共享书逐字重复（回填进卡的副本）—— 提升时会一并清掉卡里那几份，不会再往书里加。",
       "store.deleted":"已删除",
       "store.errDeleteFailed":"删除失败",
       "store.needLoadFirst":"请先载入一张卡后再重命名",
@@ -390,6 +393,7 @@ window.__ModuleLoader__.load({
       "book.promoteHint":"Move these N entries into the shared book and delete them from every card — do this before exporting and the cards hold no duplicates.",
       "book.promotePreview":"Will promote {n} and delete {m} duplicates across the cards",
       "book.promoteDone":"Promoted {n} (removed {m} duplicates)",
+      "book.promoteSyncedDraft":"Current draft synced — removed {n} duplicates (saving would have written them back)",
       "book.exportBook":"Export shared lorebook JSON",
       "book.exported":"Exported {name}",
       "book.applyCard":"Merge into the current card",
@@ -621,6 +625,8 @@ window.__ModuleLoader__.load({
       "store.loadedCard":"Loaded: {name} · {n} lore (ID:{id}, saving again will update this card)",
       "store.errLoadFailed":"Load failed",
       "store.confirmDelete":"Delete this character? This cannot be undone.",
+      "relations.confirmDeleteGroup":"Delete this group? Its nodes, relations and the group's shared lorebook (if any) go with it, and this cannot be undone. Member cards are not deleted — they just leave the group.",
+      "book.dupBook":"{n} more entries in the member cards are byte-identical to the shared book (copies merged into the cards) — promoting also cleans those up, without adding anything to the book.",
       "store.deleted":"Deleted",
       "store.errDeleteFailed":"Delete failed",
       "store.needLoadFirst":"Load a card before renaming",
@@ -1090,6 +1096,40 @@ window.__ModuleLoader__.load({
         }catch(e){ set({lastMsg:String(e && e.message || e)}); }
         set({bookBusy:null});
       }
+      /**
+       * 提升之后同步**界面里的草稿**（与工具半 syncDraftAfterPromote 同一套判据）。
+       *
+       * 宿主半 `cc_promoteBook` 删的是**库里的卡**，界面里这份草稿是另一个副本 —— 不同步的话，
+       * 用户接着点「保存当前」就会把刚删掉的重复条目原样写回去，去重白做且毫无提示。
+       * 三条自律：① 只对「这次真的被删过条目、且正是当前编辑的那张卡」动手；
+       * ② 只认**内容逐字相符**（用户在界面里改过内容的条目一律不动）；
+       * ③ 共享书没读到（state.book 为空）时什么都不做 —— 宁可不同步，也不猜着删。
+       */
+      function syncDraftAfterPromote(v){
+        try{
+          var cid = String(state.currentLibraryId||"");
+          if(!cid) return 0;
+          var touched = ((v && Array.isArray(v.perCard)) ? v.perCard : []).filter(function(c){
+            return c && !c.error && c.removed > 0 && String(c.id) === cid;
+          });
+          if(!touched.length) return 0;
+          var bk = state.book;
+          var bookEntries = (bk && bk.book && bk.book.data && Array.isArray(bk.book.data.entries)) ? bk.book.data.entries : [];
+          var contents = {};
+          bookEntries.forEach(function(e){ var c = String((e && e.content)==null? "" : e.content); if(c.trim()) contents[c] = true; });
+          var d = state.draft;
+          var entries = (d && d.data && d.data.character_book && Array.isArray(d.data.character_book.entries)) ? d.data.character_book.entries : [];
+          var removed = 0;
+          entries.forEach(function(e){ if(contents[String((e && e.content)==null? "": e.content)]) removed++; });
+          if(!removed) return 0;
+          updateDraft(function(data){
+            var cb = data.character_book;
+            if(!cb || !Array.isArray(cb.entries)) return;
+            cb.entries = cb.entries.filter(function(e){ return !contents[String((e && e.content)==null? "": e.content)]; });
+          });
+          return removed;
+        }catch(e){ return 0; }
+      }
       /** 提升去重：`apply` 为假时只扫描预览（宿主半默认也是 dryRun，两边都不写盘）。 */
       async function promoteBook(keys, apply){
         var gid = String(state.currentGroupId||"");
@@ -1099,11 +1139,16 @@ window.__ModuleLoader__.load({
           var res = await rpc("cc_promoteBook", {groupId: gid, apply: !!apply, keys: (keys && keys.length)? keys : undefined});
           if(res && res.ok && res.value){
             var v = res.value;
-            set({lastMsg: v.dryRun
+            var msg = v.dryRun
               ? t("book.promotePreview",{n:String(v.wouldPromote||0), m:String(v.removedTotal||0)})
-              : t("book.promoteDone",{n:String(v.promoted||0), m:String(v.removedTotal||0)})});
+              : t("book.promoteDone",{n:String(v.promoted||0), m:String(v.removedTotal||0)});
+            set({lastMsg: msg});
             await loadBook(gid);
-            if(!v.dryRun){ await refreshLibrary(); await loadGroup(gid); }
+            if(!v.dryRun){
+              var synced = syncDraftAfterPromote(v);   // 必须在 loadBook 之后：那时 state.book 才是提升后的新书
+              if(synced) set({lastMsg: msg + " · " + t("book.promoteSyncedDraft",{n:String(synced)})});
+              await refreshLibrary(); await loadGroup(gid);
+            }
           } else set({lastMsg:String((res && res.error && res.error.message) || "")});
         }catch(e){ set({lastMsg:String(e && e.message || e)}); }
         set({bookBusy:null});
@@ -1156,7 +1201,9 @@ window.__ModuleLoader__.load({
         set({relBusy:null});
       }
       async function deleteGroup(id){
-        try{ if(typeof window!=="undefined" && window.confirm && !window.confirm(t("store.confirmDelete"))) return; }catch(e){}
+        // 删组的确认文案要**专用**（原来复用了「确定删除该角色？」）—— 而且必须提共享世界书：
+        // 那是用户可能整理了很久的东西，删掉不可恢复（第二轮报告 4.1 的同一条信息完整性要求）。
+        try{ if(typeof window!=="undefined" && window.confirm && !window.confirm(t("relations.confirmDeleteGroup"))) return; }catch(e){}
         set({relBusy:"del"});
         try{
           var res = await rpc("cc_deleteGroup", {id: id});
@@ -1837,6 +1884,9 @@ window.__ModuleLoader__.load({
         var gidB = String(s.currentGroupId||"");
         var bookReady = !!(bk && bk.exists && bk.book);
         var dup = (bk && bk.scan && bk.scan.candidates) ? bk.scan.candidates : [];
+        // 第二类重复：卡里的条目与共享书**逐字相同**（`cc_apply_shared_book` 回填进卡的副本）。
+        // 界面从前也看不见它 —— 卡片间没重复、书里也没重复，于是那几份副本静静躺着准备双重插入。
+        var dupeBook = (bk && bk.scan && bk.scan.bookDupes) ? bk.scan.bookDupes : [];
         main=h("div",null,
           h("div",{style:S.readCard},
             h("h3",{style:S.readTitle}, t("book.title"),
@@ -1915,6 +1965,9 @@ window.__ModuleLoader__.load({
                             h("button",{type:"button", style:Object.assign({}, S.btn, {padding:"4px 12px", fontSize:12}), onMouseDown:stopFocusSteal,
                               disabled: !!(s.bookBusy==="scan"||s.bookBusy==="promote"),
                               onClick:function(){ store.promoteBook(null, true); }}, (s.bookBusy==="promote")? "…" : t("book.promote")))))),
+                  dupeBook.length
+                    ? h("div",{style:{fontSize:11, color:"#ffc46b", marginTop:8, lineHeight:1.7}}, t("book.dupBook", {n:String(dupeBook.length)}))
+                    : null,
                   s.lastMsg? h("div",{style:{marginTop:10, fontSize:12, color:"var(--dsw-alias-label-secondary)", lineHeight:1.7}}, s.lastMsg):null),
           (gidB && bookReady) ? h("div",{style:S.readCard},
             h("h3",{style:S.readTitle}, t("export.book.title")),

package/lib/index.js

@@ -622,7 +622,7 @@ function spliceRelations(description, section, meta){
  * 跨卡体检（纯函数）。members / cards 由调用方给：
  *   members = 组内卡的 id 列表；cards = [{id, name, description, constantTokens, tokenBudget}]
  */
-function checkGroup(group, members, cards){
+function checkGroup(group, members, cards, sharedEntries){
   const g = normalizeGroup(group);
   const issues = [];
   const add = (level, code, message, refs) => issues.push({ level, code, message, refs: refs || [] });
@@ -655,12 +655,21 @@ function checkGroup(group, members, cards){
   if(unrendered.length) add("warn", "unrendered", unrendered.length + " 张成员卡的 description 里还没有【关系】段（关系目前只存在于图谱里，导出的卡看不到）", unrendered);
   if(stale.length) add("warn", "stale-render", stale.length + " 张成员卡的【关系】段落后于图谱（标记里的 rev 与当前 rev 不一致），建议重新渲染", stale);
   // 群聊版的「单次触发」陷阱：每张卡的 constant 每轮都进上下文，卡越多固定开销越大
-  const constTokens = memberCards.reduce((n, c) => n + (Number(c.constantTokens) || 0), 0);
+  const cardConst = memberCards.reduce((n, c) => n + (Number(c.constantTokens) || 0), 0);
+  // 0.9.0 报告：共享世界书的 constant 条目在群聊里**同样每轮插入**（独立一本、由客户端叠加），
+  // 所以「群聊每轮固定开销」必须是 卡内 + 共享 的合计 —— 只报卡内会低报一半。与工具半同构。
+  const sharedConst = (Array.isArray(sharedEntries) ? sharedEntries : [])
+    .filter(e => e && e.enabled !== false && e.constant)
+    .reduce((n, e) => n + estimateTokensLite(e && e.content), 0);
+  const constTokens = cardConst + sharedConst;
   const minBudget = memberCards.length ? memberCards.reduce((n, c) => Math.min(n, Number(c.tokenBudget) || 1200), Infinity) : 1200;
-  if(memberCards.length > 1 && constTokens > minBudget * 0.8){
-    add("warn", "constant-budget", "群聊每轮固定开销偏高：成员卡常驻条目合计约 " + constTokens + " token（已达最小预算 " + minBudget + " 的 " + Math.round(constTokens / minBudget * 100) + "%）");
+  if((memberCards.length > 1 || sharedConst > 0) && constTokens > minBudget * 0.8){
+    add("warn", "constant-budget", "群聊每轮固定开销偏高：成员卡常驻 " + cardConst
+      + (sharedConst ? " + 共享书常驻 " + sharedConst : "") + " = 合计约 " + constTokens
+      + " token（已达最小预算 " + minBudget + " 的 " + Math.round(constTokens / minBudget * 100) + "%）");
   }
-  return { issues, stats: { nodes: g.nodes.length, edges: g.edges.length, members: memberCards.length, constantTokens: constTokens, minBudget } };
+  return { issues, stats: { nodes: g.nodes.length, edges: g.edges.length, members: memberCards.length,
+    constantTokens: { card: cardConst, shared: sharedConst, total: constTokens }, minBudget } };
 }
 
 /** 读分组：主根优先，回退旧根（与角色库同规）。 */
@@ -1661,7 +1670,7 @@ function apply(ctx, config){
           if(!found) return fail("not-found", "分组不存在: " + String(args.id));
           const cur = normalizeGroup(found.obj);
           if(typeof args.expectedRev === "number" && args.expectedRev !== cur.rev){
-            return fail("stale-rev", "分组已被外部修改（期望 rev=" + args.expectedRev + "，实际 rev=" + cur.rev + "）—— 先重新读取再改", { staleRev: true, expectedRev: args.expectedRev, actualRev: cur.rev });
+            return fail("stale-rev", "分组已被外部修改（期望 rev=" + args.expectedRev + "，实际 rev=" + cur.rev + "）—— 先重新读取再改", { staleGroupRev: true, expectedRev: args.expectedRev, actualRev: cur.rev });
           }
           const applied = applyGroupOps(cur, args.ops);
           if(!applied.applied.length) return ok({ group: cur, applied: [], rejected: applied.rejected, changed: false });
@@ -1674,7 +1683,10 @@ function apply(ctx, config){
           const g = normalizeGroup(found.obj);
           const memberIds = await groupMemberIds(g.id);
           const cards = await libraryCardsFor(memberIds);
-          return ok(Object.assign({ groupId: g.id, rev: g.rev, name: g.name }, checkGroup(g, memberIds, cards)));
+          // 0.9.0：把该组的共享世界书也端给体检 —— 它的 constant 条目在群聊里同样每轮插入
+          const bkFound = await readBookRaw(g.id);
+          const sharedEntries = bkFound ? normalizeBook(bkFound.obj, g.id).data.entries.filter(e => e && e.enabled !== false) : [];
+          return ok(Object.assign({ groupId: g.id, rev: g.rev, name: g.name }, checkGroup(g, memberIds, cards, sharedEntries)));
         }
         case "cc_renderRelations":{
           // 渲染进**当前草稿**（与工具半共用同一份草稿文件）；要落库仍需再存一次
@@ -1710,10 +1722,11 @@ function apply(ctx, config){
           if(!gid) return fail("invalid-group", "需要 groupId");
           const found = await readBookRaw(gid);
           const cards = await bookCardsFor(await groupMemberIds(gid));
-          const scan = scanSharedEntries(cards);
+          const book = found ? normalizeBook(found.obj, gid) : null;
+          // 把书一起交给 scan → 认得出「卡内条目与共享书逐字重复」那一类（报告 P1）
+          const scan = scanSharedEntries(cards, book ? book.data.entries : []);
           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 });
@@ -1722,10 +1735,10 @@ function apply(ctx, config){
           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);
+          const cur = found ? normalizeBook(found.obj, gid) : await newBookFor(gid, args.name);
           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) });
+              { staleBookRev: true, expectedBookRev: args.expectedBookRev, actualBookRev: bookRevOf(cur) });
           }
           const applied = [], rejected = [];
           if(args.name !== undefined) cur.data.name = String(args.name).slice(0, 80);
@@ -1771,20 +1784,27 @@ function apply(ctx, config){
           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 cur = found ? normalizeBook(found.obj, gid) : await newBookFor(gid);   // 默认名 `<组名>·共享设定`（报告 4.2）
           const cards = await bookCardsFor(await groupMemberIds(gid));
-          const scan = scanSharedEntries(cards);
-          const known = new Map(scan.candidates.map(c => [c.signature, c]));
+          // 候选两类：卡间重复（提升进书）+ 卡内条目与共享书逐字重复（书里已有，只清卡内副本）—— 见 agent 半同一处注释
+          const scan = scanSharedEntries(cards, cur.data.entries);
+          const known = new Map(scan.candidates.concat(scan.bookDupes).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 requested = (Array.isArray(args.keys) && args.keys.length) ? args.keys.map(String)
+            : scan.candidates.map(c => c.signature).concat(scan.bookDupes.map(c => c.signature));
           const unknownKeys = requested.filter(s => !known.has(s));
           const use = requested.filter(s => known.has(s));
+          const bookSigs = new Set(cur.data.entries.map(contentKeyOf));
+          const promoteSigs = use.filter(s => !bookSigs.has(s));
+          const cleanSigs = use.filter(s => bookSigs.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 });
+          const summary = (g) => ({ kind: g.kind || "card-vs-card", signature: g.signature, name: g.name, cards: g.cards.length, cardNames: g.cardNames,
+            chars: g.chars, savedChars: g.savedChars, nameMismatch: g.nameMismatch === true, keysMismatch: g.keysMismatch === true, 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) });
+            return ok({ dryRun: true, changed: false, wouldPromote: promoteSigs.length, wouldClean: cleanSigs.length, unknownKeys,
+              removedTotal: plan.removedTotal, savedChars: plan.savedChars,
+              perCard: plan.cards.map(c => ({ id: c.id, name: c.name, removed: c.removed, left: c.entries.length })),
+              candidates: scan.candidates.map(summary), bookDuplicates: scan.bookDupes.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);
@@ -1800,9 +1820,11 @@ function apply(ctx, config){
               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,
+          const promotedCopies = cards.reduce((n, c) => n + (Array.isArray(c.entries) ? c.entries.filter(e => promoteSigs.indexOf(contentKeyOf(e)) >= 0).length : 0), 0);
+          const cleaned = Math.max(0, plan.removedTotal - promotedCopies);
+          return ok({ dryRun: false, changed: true, promoted: plan.promoted.length, cleaned, removedTotal: plan.removedTotal,
             unknownKeys, bookRev: bookRevOf(saved), bookEntries: saved.data.entries.length, perCard: touched,
-            candidates: scan.candidates.map(summary), stats: scan.stats });
+            candidates: scan.candidates.map(summary), bookDuplicates: scan.bookDupes.map(summary), stats: scan.stats });
         }
         case "cc_applyBook":{
           const gid = safeGroupId(args.groupId);
@@ -2072,7 +2094,24 @@ async function bookCardsFor(ids){
  * 跨成员卡找「同一份设定」（纯函数）：按内容签名分组，出现在 **≥2 张卡**里的才算候选。
  * 只报候选、不下结论 —— 同内容不同名、同名不同内容都如实标注，交给用户/模型拍板。
  */
-function scanSharedEntries(cards){
+/**
+ * 新建共享书的默认名：`<组名>·共享设定`（拿不到组名才退回「共享设定」）。
+ * 第二轮报告 4.2：同一个人的多个组各建一本、全叫「共享设定」，导出成文件后根本分不清是哪一组。
+ * 两半同构（`tests/shared-book.test.mjs` 直接比对），改这里记得同步 `lib/agent.js`。
+ */
+function defaultBookName(groupName){
+  const n = String(groupName == null ? "" : groupName).trim();
+  return n ? n + "·共享设定" : "共享设定";
+}
+/** 新建一本空共享书（名字优先用调用方给的，否则 `<组名>·共享设定`）。两半同构。 */
+async function newBookFor(gid, explicitName){
+  const want = String(explicitName == null ? "" : explicitName).trim();
+  if(want) return normalizeBook({ data: { name: want } }, gid);
+  let gname = "";
+  try{ const gf = await readGroupRaw(gid); if(gf) gname = normalizeGroup(gf.obj).name; }catch{}
+  return normalizeBook({ data: { name: defaultBookName(gname) } }, gid);
+}
+function scanSharedEntries(cards, bookEntries){
   const list = Array.isArray(cards) ? cards : [];
   const seen = new Map();
   list.forEach(c => {
@@ -2089,13 +2128,29 @@ function scanSharedEntries(cards){
   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) }));
+  // 第二轮报告 P1：还有一类重复是「卡 ↔ 共享书」—— `cc_apply_shared_book` 回填进卡里的副本。
+  // 它和「卡间重复」的**动作不同**：书里已经有了，只需把卡里那份删掉，不必再往书里搬。
+  // 判据同样是**逐字相符**（签名只用来筛候选）；回填过的、手工抄进卡的都算。
+  const bookDupes = [];
+  (Array.isArray(bookEntries) ? bookEntries : []).forEach(be => {
+    const content = String((be && be.content) == null ? "" : be.content);
+    const g = content.trim() ? seen.get(contentKeyOf(be)) : null;
+    if(!g || g.content !== content) return;
+    bookDupes.push({ kind: "card-vs-book", signature: g.signature, name: String((be && be.name) || g.name || ""),
+      content, keys: (be.keys || []).map(String), chars: content.length,
+      cards: g.cards.slice(), cardNames: g.cardNames.slice(),
+      preview: content.slice(0, 80).replace(/\s+/g, " "), savedChars: content.length * g.cards.length });
+  });
   const totalEntries = list.reduce((n, c) => n + (Array.isArray(c.entries) ? c.entries.length : 0), 0);
   return {
-    candidates,
+    candidates, bookDupes,
     stats: {
       cards: list.length, totalEntries,
       duplicatedEntries: candidates.reduce((n, g) => n + g.cards.length, 0),
       savedChars: candidates.reduce((n, g) => n + g.savedChars, 0),
+      bookDuplicatedEntries: bookDupes.reduce((n, g) => n + g.cards.length, 0),
+      bookDupeCount: bookDupes.length,
+      bookSavedChars: bookDupes.reduce((n, g) => n + g.savedChars, 0),
     },
   };
 }
@@ -2122,19 +2177,22 @@ function applyBookPromotion(cards, bookEntries, signatures){
   const promoted = [];
   const nextCards = (Array.isArray(cards) ? cards : []).map(c => {
     const kept = [];
-    let removed = 0;
+    let removed = 0, removedChars = 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;
+        removedChars += String(e.content == null ? "" : e.content).length;
         return;
       }
       kept.push(makeBookEntry(e));
     });
-    return { id: c.id, name: c.name, entries: kept, removed };
+    return { id: c.id, name: c.name, entries: kept, removed, removedChars };
   });
-  return { bookEntries: book, cards: nextCards, promoted, removedTotal: nextCards.reduce((n, c) => n + c.removed, 0) };
+  return { bookEntries: book, cards: nextCards, promoted,
+    removedTotal: nextCards.reduce((n, c) => n + c.removed, 0),
+    savedChars: nextCards.reduce((n, c) => n + c.removedChars, 0) };
 }
 
 export { apply, inject, name, planPresetInstall, installCcPreset, supportsDeclaredPresets, presetTargetRoot, presetSourceRoot,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xia-sc/dsh-cc-studio",
-  "version": "0.8.3",
+  "version": "0.9.0",
   "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/relations-view.test.mjs && node tests/shared-book.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/promote-draft-sync.test.mjs && node tests/data-root.test.mjs",
     "prepublishOnly": "npm test"
   },
   "dsh": {