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

package/lib/agent.js

@@ -12,7 +12,7 @@ const name = "dsh-cc-studio-agent";
 // 由来：第五轮实测里测试者第一遍跑出「四项全无变化」，其实只是**没重启 dsh** —— LLM 侧完全无法
 // 分辨「代码没改」和「改了但没加载」。有了这个字段，任何一次调用都能先确认自己测的是哪一版。
 // 发版时与 package.json 的 version 同步。
-const BUILD = "0.8.3";
+const BUILD = "0.9.1";
 const inject = ["tools", "agents"];
 
 function nowSec(){ return Math.floor(Date.now()/1000); }
@@ -525,7 +525,7 @@ function spliceRelations(description, section, meta){
   const head = desc.replace(/\s*$/, "");
   return (head + (head ? "\n\n" : "") + block).trim();
 }
-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 || [] });
@@ -557,12 +557,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);
-  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 } };
 }
 async function readGroupRaw(id){
   const file = safeGroupId(id) + ".json";
@@ -867,20 +876,52 @@ function looksLikeLegacyAuto(e){
   if(!e || !AUTO_NAMES.has(String(e.name||""))) return false;
   return /^\s*@@/.test(String(e.content||"")) || Array.isArray(e.keys) && e.keys.some(k => ["timeline","faction","geography","power","daily"].includes(String(k)));
 }
-function workflowStatus(draft){
+/**
+ * 工作流状态。第二个参数是**该组共享世界书**（`{ bookName, entries, tokens }`，没有就传 null/省略）。
+ *
+ * 第二轮报告 P0：共享书把一部分世界设定挪到了**组**上，而「≥5 条且至少 1 条共创」是**收尾判定** ——
+ * 只数卡内的话，「按推荐做法去重」的卡（重复条目提升进共享书、卡里只剩私密条目）反而永远判不合格：
+ * 用户完全照最佳实践做，系统判他不通过，只剩两条路（忍受失败 / 把冗余抄回卡里 —— 后者等于取消共享书）。
+ * 所以**达标判定走合计口径**，同时把卡内/共享两个数分开报出来，谁都不必去猜：
+ *   loreCount / manualLoreCount          = 卡内（写类工具的文案仍按它说，才不会被误读）
+ *   sharedLoreCount / sharedManualCount  = 共享书
+ *   loreTotal / manualLoreTotal          = 合计（`state.lore` 与 `readyToValidate` 认它）
+ */
+function workflowStatus(draft, shared){
   const d = draft && draft.data ? draft.data : {};
   const w = (d.extensions && d.extensions.cc_world) ? d.extensions.cc_world : {};
   const entries = (d.character_book && Array.isArray(d.character_book.entries)) ? d.character_book.entries : [];
   const loreCount = entries.length;
   const manualLoreCount = entries.filter(e => !isAutoEntry(e)).length;
+  const sharedEntries = (shared && Array.isArray(shared.entries)) ? shared.entries : [];
+  const sharedLoreCount = sharedEntries.length;
+  const sharedManualCount = sharedEntries.filter(e => !isAutoEntry(e)).length;
+  const loreTotal = loreCount + sharedLoreCount;
+  const manualLoreTotal = manualLoreCount + sharedManualCount;
   const worldFilled = WORLD_DIMS.filter(k => typeof w[k]==="string" && String(w[k]).trim().length>=6).length;
+  // 一行「世界书多少条」的说法：卡内 8 条就说「8 条」，卡内 3 + 共享 5 就说「8 条 = 卡内 3 + 共享书 5」。
+  const lorePhrase = sharedLoreCount
+    ? loreTotal + " 条 = 卡内 " + loreCount + " + 共享书 " + sharedLoreCount
+    : loreTotal + " 条";
+  // 第三轮报告：`constant` / `@@decorator` 这两条是**关于整本世界书**的检查，口径必须与
+  // `cc_lint_lorebook` 一致（卡内 + 共享书）—— 只数卡内会让「卡里没有 constant、共享书里有」的卡
+  // 每次都收到一条无意义的提醒，而误报会被训练成「忽略 warning」。
+  // 范围：**存在性**检查（有没有 constant / 有没有 @@）走合计；**逐条质量**检查（死 keys /
+  // 只有维度名的 keys / keys 与正文无交集）在 validate 里**只看卡内** —— 这是**有意**的分工（第五轮报告
+  // 实测确认过）：validate 是「这张卡」的收尾判定，列条目名不属于它。全量的逐条质量检查归
+  // `cc_lint_lorebook`（覆盖卡内 + 共享书，每条 issue 带 `source`），共享书自己那份由
+  // `cc_get_shared_book` 的 `lint` 段给出 —— 三处口径不同是分工，不是漏改（上一版这里曾把
+  // 「共享书走 cc_get_shared_book」写成事实，而那条线上当时并没有这个能力，这个错已修）。
+  const metrics = lorebookMetrics(entries, sharedEntries);   // 三段基础统计：一处实现（见该函数注释）
+  const constantEntries = { card: metrics.card.constant, shared: metrics.shared.constant, total: metrics.total.constant };
+  const sharedHasDecorator = metrics.shared.hasDecorator;
 
   const nameOk = !!String(d.name||"").trim();
   const descOk = !!String(d.description||"").trim();
   const characterState = (nameOk && descOk && String(d.personality||"").trim() && String(d.scenario||"").trim())
     ? "ok" : ((nameOk && descOk) ? "partial" : "missing");
   const worldState = worldFilled >= 3 ? "ok" : (worldFilled > 0 ? "partial" : "missing");
-  const loreState = (loreCount >= 5 && manualLoreCount >= 1) ? "ok" : (loreCount > 0 ? "partial" : "missing");
+  const loreState = (loreTotal >= 5 && manualLoreTotal >= 1) ? "ok" : (loreTotal > 0 ? "partial" : "missing");
   const gFirst = !!String(d.first_mes||"").trim();
   const gAlt = Array.isArray(d.alternate_greetings) ? d.alternate_greetings.length : 0;
   const gGroup = Array.isArray(d.group_only_greetings) ? d.group_only_greetings.length : 0;
@@ -893,11 +934,11 @@ function workflowStatus(draft){
     step = 3; next = "角色基础已齐，下一步必须 cc_patch_world：先与用户讨论世界观侧重（哪几维最想展开/有无私设）再补 5 维（≥3 项），**并为每一维自报触发词 loreKeys**（真实对话里用户会说的实体名，如 {geo:[\"旧校舍\",\"广播室\"]}）——不给的话自动条目只能用维度名当 key，永远命中不了";
   } else if(loreState !== "ok"){
     step = 4;
-    next = manualLoreCount === 0
-      ? "五维已齐，autoLorebook 已自动生成 "+loreCount+" 条基础条目，但它们以维度名当触发词、且不满足共创要求：下一步必须 cc_add_lorebook_entries，先与用户讨论触发词/常驻偏好，至少再补 1 条（总≥5 条、至少 1 constant、content 头部写 @@decorator）"
-      : "五维已齐，下一步必须 cc_add_lorebook_entries：与用户讨论触发词/常驻偏好后补到≥5 条（年表/势力/地理/力量/日常各 1，至少 1 constant，@@decorator），当前 "+loreCount+" 条（其中共创 "+manualLoreCount+" 条）";
+    next = manualLoreTotal === 0
+      ? "五维已齐，autoLorebook 已自动生成 "+loreTotal+" 条基础条目（"+lorePhrase+"），但它们以维度名当触发词、且不满足共创要求：下一步必须 cc_add_lorebook_entries，先与用户讨论触发词/常驻偏好，至少再补 1 条（合计≥5 条、至少 1 constant、content 头部写 @@decorator）"
+      : "五维已齐，下一步必须 cc_add_lorebook_entries：与用户讨论触发词/常驻偏好后补到合计≥5 条（年表/势力/地理/力量/日常各 1，至少 1 constant，@@decorator），当前 "+lorePhrase+"（其中共创 "+manualLoreTotal+" 条）";
   } else if(greetingsState !== "ok"){
-    step = 5; next = "世界书已齐（"+loreCount+" 条，其中共创 "+manualLoreCount+" 条），下一步必须 cc_patch_greetings：先问用户偏好的开场场景/关系阶段/群聊与私聊区分，再补问候语（first_mes + alternate≥2 + group≥1）";
+    step = 5; next = "世界书已齐（"+lorePhrase+"，其中共创 "+manualLoreTotal+" 条），下一步必须 cc_patch_greetings：先问用户偏好的开场场景/关系阶段/群聊与私聊区分，再补问候语（first_mes + alternate≥2 + group≥1）";
   } else {
     step = 6; next = "结构已齐，下一步必须 cc_validate 校验，valid=true 才可收尾；通过后提醒用户在工坊左下角「校验导出」入口打开导出页（JSON / PNG / CHARX），或点「★ 保存当前」落盘";
   }
@@ -906,21 +947,34 @@ function workflowStatus(draft){
     step,
     readyToValidate: step === 6,
     state,
-    worldFilled, loreCount, manualLoreCount,
+    worldFilled,
+    loreCount, manualLoreCount,                  // 卡内
+    sharedLoreCount, sharedManualCount,          // 共享书（没有就是 0）
+    loreTotal, manualLoreTotal,                  // 合计 —— `state.lore` 认的是这两个
+    sharedBook: sharedLoreCount ? { name: String((shared && shared.bookName) || ""), entries: sharedLoreCount, tokens: Number((shared && shared.tokens) || 0) } : null,
+    constantEntries,                             // { card, shared, total } —— 与 cc_lint_lorebook 同一口径
+    sharedHasDecorator,                          // 共享书里有没有 @@decorator（存在性检查用合计）
     next,
     // 0.6.0（R1/R2）：`hint` 只报**进度**，不再内嵌 `next` 全文 ——
     // 旧版 `hint = 进度 + " → " + next` 让同一句话在一份返回里出现三遍（hint 内嵌 next、message 又等于 hint）。
     // 终态（校验通过）也走同一个函数，所以 `hint` 不会再说「下一步必须 cc_validate」（那是第一轮 P0-3 的半修残留）。
-    hint: progressHint(step, state, worldFilled, loreCount, manualLoreCount, false),
+    hint: progressHint(step, state, worldFilled, loreCount, manualLoreCount, false, sharedLoreCount),
   };
 }
+/** 带共享书口径的工作流状态：**判定完成度**一律用它（纯纯汇报卡内条数的地方才继续用 workflowStatus）。
+ *  拿不到共享书（没有来源卡 / 没进组 / 该组还没建书）时，等价于只算卡内 —— 与旧行为完全一致。 */
+async function workflowFor(ctx, exec, draft){
+  let shared = null;
+  try{ shared = await sharedBookScopeFor(ctx, exec); }catch(e){ shared = null; }
+  return workflowStatus(draft, shared);
+}
 /** 一行进度摘要（**不含 next** —— 下一步是 workflow.next 的职责，别再复制一份）。 */
-function progressHint(step, state, worldFilled, loreCount, manualLoreCount, done){
+function progressHint(step, state, worldFilled, loreCount, manualLoreCount, done, sharedLoreCount){
   const mark = s => s==="ok" ? "✓" : (s==="partial" ? "◐" : "✗");
   return "工作流 " + step + "/" + (done ? 7 : 6)
     + " " + mark(state.character) + "角色"
     + " " + mark(state.world) + "五维(" + worldFilled + "/5)"
-    + " " + mark(state.lore) + "世界书(" + loreCount + (manualLoreCount > 0 ? ",共创" + manualLoreCount : "") + ")"
+    + " " + mark(state.lore) + "世界书(" + loreCount + (sharedLoreCount ? "+" + sharedLoreCount : "") + (manualLoreCount > 0 ? ",共创" + manualLoreCount : "") + ")"
     + " " + mark(state.greetings) + "问候语"
     + (done ? " · 已完成，可导出/保存" : "");
 }
@@ -935,6 +989,88 @@ function estimateTokens(text){
 function lorebookTokens(entries){
   return (Array.isArray(entries)? entries : []).reduce((n,e) => n + estimateTokens(e && e.content), 0);
 }
+/**
+ * 世界书的三段基础统计（**卡内 / 共享书 / 合计**）—— 一处实现，多处引用。
+ *
+ * 为什么收口（第四轮报告的教训）：共享书的条目/token 口径已经散落在 simulate / lint /
+ * group_check / preview_export / validate 五个工具里，于是连着两轮出现「改了四个、漏了第五个」
+ * 与「validate 改了、lint 漏了」——都是同一个语义写了两遍。基础统计收在这里（同
+ * `outgoingEdgesOf()` 之于渲染与计数），各工具只在其上做自己的派生（最坏情况、单次触发、预算占用…）。
+ *
+ * 同时给出两个**存在性**判断的合计口径：有没有 constant、有没有 `@@decorator` ——
+ * 这两条是「整本世界书」的性质，只数卡内会让「卡内没有、共享书里有」的组合被误报。
+ * ⚠️ **逐条质量**检查（死 keys / 只有维度名的 keys / keys 与正文无交集 / 触发词冲突）**不在这里**：
+ * 那是各工具自己决定范围的事 —— `cc_lint_lorebook` 的整改清单面向「你正在编辑的这张卡」，
+ * `cc_validate` 是卡的收尾判定，两者都只覆盖卡内条目（共享书的条目质量走 cc_get_shared_book 那条线）。
+ */
+function lorebookMetrics(cardEntries, sharedEntries){
+  const card = Array.isArray(cardEntries) ? cardEntries : [];
+  const shared = Array.isArray(sharedEntries) ? sharedEntries : [];
+  const seg = (list) => ({
+    entries: list.length,
+    tokens: lorebookTokens(list),
+    constant: list.filter(e => e && e.constant === true).length,
+    constantTokens: list.filter(e => e && e.constant === true).reduce((n, e) => n + estimateTokens(e && e.content), 0),
+    manual: list.filter(e => !isAutoEntry(e)).length,
+    hasDecorator: list.some(e => String((e && e.content) || "").includes("@@")),
+  });
+  return { card: seg(card), shared: seg(shared), total: seg(card.concat(shared)), all: card.concat(shared) };
+}
+/**
+ * 世界书条目的**逐条质量检查** —— 一把尺子，卡内与共享书共用。
+ *
+ * 四类：非 constant 却没 keys / keys 只有维度名 / keys 与正文无交集 / 触发词被多条条目共用。
+ *
+ * 为什么收口（第五轮报告）：这四类此前只写在 `cc_lint_lorebook` 里、只作用于**卡内**，当时的理由是
+ * 「共享书条目的质量走 `cc_get_shared_book` 那条线」—— 可那条线上**根本没有这个能力**（只有重复检测），
+ * 于是共享书成了没人体检的一格：往书里塞一条同时踩三类的坏条目，两个工具都不出声。
+ * 而共享书恰恰**比卡内更需要主动报**：它多卡共用（一条死 key 在**所有**成员卡上都不生效）、
+ * 又**没有「卡」这个载体**（用户不会顺手翻到它）。
+ *
+ * 用法：`auditLoreEntries([{ source:"card", entries }, { source:"shared", entries: sharedEntries }])`。
+ * 触发词冲突**跨来源一起算** —— 同一个词同时命中卡内与共享书的两条，是真实存在的 token 叠加。
+ * 每条 issue 带 `entries`（条目名，冲突类则是**冲突的触发词**）、`contentKeys`（便于直接定位改）、
+ * 与 `source`（`card` / `shared` / `mixed`）。
+ */
+function auditLoreEntries(groups){
+  const gs = (Array.isArray(groups) ? groups : []).map(g => ({
+    source: String((g && g.source) || "card"),
+    list: (g && Array.isArray(g.entries) ? g.entries : []).filter(e => e && e.enabled !== false),
+  }));
+  const all = gs.reduce((n, g) => n.concat(g.list), []);
+  const sourceOf = (e) => { for(const g of gs){ if(g.list.indexOf(e) >= 0) return g.source; } return "card"; };
+  const srcOf = (items) => { const out = []; items.forEach(e => { const s = sourceOf(e); if(out.indexOf(s) < 0) out.push(s); }); return out.length > 1 ? "mixed" : (out[0] || "card"); };
+  const issues = [];
+  const push = (level, code, message, items) => issues.push({ level, code, message,
+    entries: items.map(e => String((e && e.name) || "")).filter(Boolean),
+    contentKeys: items.map(contentKeyOf), source: srcOf(items) });
+  const isDimKey = k => AUTO_NAMES.has(String(k)) || ["timeline","faction","geography","power","daily"].includes(String(k));
+  const nonConst = all.filter(e => !e.constant);
+  const keyed = nonConst.filter(e => Array.isArray(e.keys) && e.keys.length > 0);
+  const noKeys = nonConst.filter(e => !Array.isArray(e.keys) || e.keys.length === 0);
+  if(noKeys.length) push("error", "no-keys", noKeys.length + " 条非 constant 条目没有 keys（永远触发不了）", noKeys);
+  const dimOnly = keyed.filter(e => e.keys.every(isDimKey));
+  if(dimOnly.length) push("error", "dim-only-keys", dimOnly.length + " 条条目的 keys 只有维度名，真实对话不会命中（可用 cc_simulate_trigger 验证）", dimOnly);
+  const notInContent = keyed.filter(e => !e.keys.some(k => String(e.content || "").indexOf(String(k)) >= 0));
+  if(notInContent.length) push("warn", "key-not-in-content", notInContent.length + " 条条目的 keys 在自身 content 里找不到（可能误填或内容已改）", notInContent);
+  const seen = new Map();
+  all.forEach(e => (Array.isArray(e.keys) ? e.keys : []).forEach(k => {
+    const kk = String(k).toLowerCase();
+    if(!seen.has(kk)) seen.set(kk, []);
+    const arr = seen.get(kk);
+    if(arr.indexOf(e) < 0) arr.push(e);
+  }));
+  const dup = [...seen.entries()].filter(p => p[1].length > 1);
+  if(dup.length){
+    const items = [];
+    dup.forEach(p => p[1].forEach(e => { if(items.indexOf(e) < 0) items.push(e); }));
+    issues.push({ level: "warn", code: "duplicate-keys",
+      message: dup.length + " 个触发词被多条条目共用（会同时触发，可能互相打架）",
+      entries: dup.map(p => p[0]),          // 与既有行为一致：这一项的 entries 是**冲突的触发词**
+      contentKeys: items.map(contentKeyOf), source: srcOf(items) });
+  }
+  return { issues, errorCount: issues.filter(i => i.level === "error").length };
+}
 /**
  * 最坏情况单次触发量（0.7.0，N2）。
  *
@@ -1063,7 +1199,7 @@ function apply(ctx){
       const draft = getDraft(ctx, exec);
       const k = keyFor(ctx, exec);
       const st = draftStatusFor(k, draft);
-      const wf = workflowStatus(draft);
+      const wf = await workflowFor(ctx, exec, draft);
       const warnings = [recoveredNotice(k, draft)].filter(Boolean);   // 新草稿提示由 tool() 包装统一注入（S2，只出一份）
       const fields = Array.isArray(args.fields) ? args.fields.map(String).filter(Boolean) : [];
       let outDraft = draft;
@@ -1126,7 +1262,7 @@ function apply(ctx){
       if(args.creator_notes!==undefined) assignIfChanged(cur.data, "creator_notes", String(args.creator_notes).slice(0,3000), changed);
       if(args.creator!==undefined) assignIfChanged(cur.data, "creator", String(args.creator).slice(0,120), changed);
       setDraft(ctx, cur, exec);
-      const wf = workflowStatus(cur);
+      const wf = await workflowFor(ctx, exec, cur);
       const warnings = [];
       if(recNote) warnings.push(recNote);
       // P1-4：patch 类默认不再回吐整份 draft —— 长卡下每改一个字段都要模型重读全卡，纯烧上下文。
@@ -1221,7 +1357,7 @@ function apply(ctx){
         if(w.daily) push("daily", "@@depth 5\n"+w.daily, 7);
       }
       setDraft(ctx, cur, exec);
-      const wf = workflowStatus(cur);
+      const wf = await workflowFor(ctx, exec, cur);
       const autoEntries = cur.data.character_book.entries.filter(isAutoEntry);
       const warnings = [];
       if(recNote) warnings.push(recNote);
@@ -1312,7 +1448,7 @@ function apply(ctx){
         });
       });
       setDraft(ctx, cur, exec);
-      const wf = workflowStatus(cur);
+      const wf = await workflowFor(ctx, exec, cur);
       const warnings = [];
       if(recNote) warnings.push(recNote);
       const res = { ok:true, added: args.entries.length, loreCount: wf.loreCount, manualLoreCount: wf.manualLoreCount,
@@ -1349,7 +1485,7 @@ function apply(ctx){
       // 重排 insertion_order
       cur.data.character_book.entries.forEach((e,i)=> e.insertion_order=i);
       setDraft(ctx, cur, exec);
-      const wf = workflowStatus(cur);
+      const wf = await workflowFor(ctx, exec, cur);
       const deleted = beforeCount - wf.loreCount;
       const warnings = [];
       if(beforeRec) warnings.push(beforeRec);
@@ -1396,7 +1532,7 @@ function apply(ctx){
       if(args.use_regex!==undefined) assignIfChanged(e, "use_regex", !!args.use_regex, changed);
       if(typeof args.priority==="number") assignIfChanged(e, "priority", args.priority, changed);
       setDraft(ctx, cur, exec);
-      const wf = workflowStatus(cur);
+      const wf = await workflowFor(ctx, exec, cur);
       const warnings = [];
       if(recNote) warnings.push(recNote);
       const res = { ok:true, entry:e, changed, loreCount: wf.loreCount,
@@ -1432,7 +1568,7 @@ function apply(ctx){
       if(Array.isArray(args.group_only_greetings)) cur.data.group_only_greetings = args.group_only_greetings.map(String).slice(0,10);
       if(args.mes_example!==undefined) cur.data.mes_example = String(args.mes_example).slice(0,5000);
       setDraft(ctx, cur, exec);
-      const wf = workflowStatus(cur);
+      const wf = await workflowFor(ctx, exec, cur);
       // 若世界书/五维未齐，警告但仍写入，让 validate 卡住
       const warnings = [];
       if(recNote) warnings.push(recNote);
@@ -1495,7 +1631,7 @@ function apply(ctx){
       setDraft(ctx,cur,exec);
       const k = keyFor(ctx, exec);
       writeOriginSync(k, obj.id, obj.meta.name);
-      const wf = workflowStatus(cur);
+      const wf = await workflowFor(ctx, exec, cur);
       const res = { ok:true, id:obj.id, meta:obj.meta, draftStatus: draftStatusFor(k, cur), workflow: wf,
         loreCount: wf.loreCount,
         message: "已载入「" + obj.meta.name + "」（id " + obj.id + "，世界书 " + wf.loreCount + " 条）。之后保存（不传 id）会更新这一张。" };
@@ -1561,7 +1697,7 @@ function apply(ctx){
       const k = keyFor(ctx, exec);
       if(args.confirm !== true){
         const cur = getDraft(ctx, exec);
-        const wf = workflowStatus(cur);
+        const wf = await workflowFor(ctx, exec, cur);
         return { ok:false, needsConfirm:true, workflow: wf,
           message:"重置会清空当前草稿的全部内容（角色/五维/世界书/问候语）且无法撤销。当前草稿：" + (String(cur.data.name||"").trim() || "（未命名）") + "，世界书 " + wf.loreCount + " 条。请先向用户说明并征求同意；同意后再以 confirm:true 重新调用。" };
       }
@@ -1574,7 +1710,7 @@ function apply(ctx){
       // S2（0.7.0）：成因是「有意重置」，不是「会话里突然没有草稿了」—— 清掉待告知标记，
       // 之后写入不再报「此前有未保存的内容可能已丢失」（第四轮实测：刚重置完就被吓一句，纯误报）。
       draftMeta(k).pendingFresh = null;
-      const wf = workflowStatus(fresh);
+      const wf = await workflowFor(ctx, exec, fresh);
       return { ok:true, reset:true, workflow: wf,
         message:"已重置为空白草稿（并解除与已存卡的来源关联，之后保存会新建一张）。" + wf.next };
     }
@@ -1609,7 +1745,7 @@ function apply(ctx){
       if(typeof args.token_budget==="number") assignIfChanged(book, "token_budget", Math.max(0, Math.round(args.token_budget)), changed);
       if(args.recursive_scanning!==undefined) assignIfChanged(book, "recursive_scanning", !!args.recursive_scanning, changed);
       setDraft(ctx, cur, exec);
-      const wf = workflowStatus(cur);
+      const wf = await workflowFor(ctx, exec, cur);
       const used = lorebookTokens(book.entries);
       const res = { ok:true, changed, book: { name:book.name, description:book.description, scan_depth:book.scan_depth, token_budget:book.token_budget, recursive_scanning:book.recursive_scanning },
         lorebookTokens: used, draftStatus: draftStatusFor(k, cur), workflow: wf,
@@ -1636,12 +1772,17 @@ function apply(ctx){
       const book = cur.data.character_book || {};
       const entries = Array.isArray(book.entries) ? book.entries : [];
       const texts = [];
+      // 0.9.0 报告：共享书里的条目在真实聊天里**同样会被触发**（客户端把全局书与卡内 character_book
+      // 叠加），所以模拟必须把它们一起算 —— 否则会把「会命中」报成「不会命中」（实测低估约 3 倍）。
+      const scope = await sharedBookScopeFor(ctx, exec);
+      const shared = scope.entries;
+      const pool = entries.map(e => ({ e: e, src: "card" })).concat(shared.map(e => ({ e: e, src: "shared" })));
       if(typeof args.text === "string" && args.text.trim()) texts.push(args.text);
       if(Array.isArray(args.texts)) args.texts.forEach(x => { if(typeof x === "string" && x.trim()) texts.push(x); });
       if(!texts.length) return { ok:false, error:"请用 text 或 texts 提供至少一句测试文本" };
       const hitsOf = (line) => {
         const lower = line.toLowerCase();
-        return entries.filter(e => {
+        return pool.filter(({ e }) => {
           if(!e || e.enabled === false) return false;
           if(e.constant) return true;                       // 常驻条目永远命中
           const keys = Array.isArray(e.keys) ? e.keys : [];
@@ -1655,19 +1796,30 @@ function apply(ctx){
       };
       const results = texts.map(line => {
         const hits = hitsOf(line);
+        const cardHits = hits.filter(h => h.src === "card").map(h => h.e);
+        const sharedHits = hits.filter(h => h.src === "shared").map(h => h.e);
         return {
-          text: line, hitCount: hits.length, tokens: lorebookTokens(hits),
-          hits: hits.map(e => ({ name: String(e.name||""), constant: !!e.constant, keys: Array.isArray(e.keys)?e.keys:[], priority: e.priority })),
-          missed: entries.filter(e => e.enabled !== false && hits.indexOf(e) < 0).map(e => String(e.name||"")),
+          text: line, hitCount: hits.length, tokens: lorebookTokens(hits.map(h => h.e)),
+          cardTokens: lorebookTokens(cardHits), sharedTokens: lorebookTokens(sharedHits),
+          hits: hits.map(h => ({ name: String(h.e.name||""), source: h.src, constant: !!h.e.constant,
+            keys: Array.isArray(h.e.keys)?h.e.keys:[], priority: h.e.priority })),
+          missed: pool.filter(p => p.e.enabled !== false && hits.indexOf(p) < 0)
+            .map(p => String(p.e.name||"") + (p.src === "shared" ? "（共享书）" : "")),
         };
       });
       const warnings = [];
-      if(entries.length && results.every(r => r.hitCount === 0)) warnings.push("这些测试句一条都没触发。若用户很可能这么说，说明世界书的 keys 需要改成实体名（cc_update_lorebook_entry 或下次 cc_patch_world 带 loreKeys）");
+      if(pool.length && results.every(r => r.hitCount === 0)) warnings.push("这些测试句一条都没触发。若用户很可能这么说，说明世界书的 keys 需要改成实体名（cc_update_lorebook_entry 或下次 cc_patch_world 带 loreKeys）");
       const never = entries.filter(e => e.enabled !== false && !e.constant && (!Array.isArray(e.keys) || e.keys.length === 0));
       if(never.length) warnings.push(never.length + " 条非 constant 条目没有 keys，永远触发不了：" + never.map(e=>String(e.name||"")).join("、"));
+      const totalTokens = lorebookTokens(entries.concat(shared));
       const res = { ok:true, simulated: results.length, results,
-        lorebookTokens: lorebookTokens(entries), scanDepth: book.scan_depth,
-        message: "模拟完成：" + results.map(r => "「" + r.text.slice(0,16) + "」→ 命中 " + r.hitCount + " 条（约 " + r.tokens + " token）").join("；") };
+        lorebookTokens: totalTokens,
+        tokenSplit: { card: lorebookTokens(entries), shared: lorebookTokens(shared), total: totalTokens },
+        sharedBook: shared.length ? { groupId: scope.groupId, name: scope.bookName, entries: shared.length, tokens: scope.tokens } : null,
+        scanDepth: book.scan_depth,
+        message: "模拟完成：" + results.map(r => "「" + r.text.slice(0,16) + "」→ 命中 " + r.hitCount + " 条（约 " + r.tokens + " token"
+            + (r.sharedTokens ? "，其中共享书 " + r.sharedTokens : "") + "）").join("；")
+          + (shared.length ? "。已把该组的共享世界书（" + shared.length + " 条 / 约 " + scope.tokens + " token）一并算入。" : "") };
       if(warnings.length) res.warnings = warnings;
       return res;
     }
@@ -1684,39 +1836,57 @@ function apply(ctx){
       const book = cur.data.character_book || {};
       const entries = Array.isArray(book.entries) ? book.entries : [];
       const issues = [];
-      const add = (level, message, names) => issues.push({ level, message, entries: names || [] });
-      const isDimKey = k => AUTO_NAMES.has(String(k)) || ["timeline","faction","geography","power","daily"].includes(String(k));
-      const noKeys = entries.filter(e => !e.constant && (!Array.isArray(e.keys) || e.keys.length === 0));
-      if(noKeys.length) add("error", noKeys.length + " 条非 constant 条目没有 keys（永远触发不了）", noKeys.map(e=>String(e.name||"")));
-      const dimOnly = entries.filter(e => !e.constant && Array.isArray(e.keys) && e.keys.length>0 && e.keys.every(isDimKey));
-      if(dimOnly.length) add("error", dimOnly.length + " 条条目的 keys 只有维度名，真实对话不会命中（可用 cc_simulate_trigger 验证）", dimOnly.map(e=>String(e.name||"")));
-      const notInContent = entries.filter(e => !e.constant && Array.isArray(e.keys) && e.keys.length>0 && !e.keys.some(k => String(e.content||"").indexOf(String(k))>=0));
-      if(notInContent.length) add("warn", notInContent.length + " 条条目的 keys 在自身 content 里找不到（可能误填或内容已改）", notInContent.map(e=>String(e.name||"")));
-      const seen = new Map();
-      entries.forEach(e => (Array.isArray(e.keys)? e.keys : []).forEach(k => { const kk=String(k).toLowerCase(); seen.set(kk, (seen.get(kk)||[]).concat(String(e.name||""))); }));
-      const dup = [...seen.entries()].filter(pair => pair[1].length > 1);
-      if(dup.length) add("warn", dup.length + " 个触发词被多条条目共用（会同时触发，可能互相打架）", dup.map(pair => pair[0]));
-      if(entries.length && !entries.some(e=>e.constant)) add("warn", "没有 constant 常驻条目：世界观基调只在命中触发词时才出现");
-      if(entries.length && entries.every(e=> !String(e.content||"").includes("@@"))) add("warn", "所有条目都没有 @@decorator（@@position/@@depth/@@activate），插入位置全用默认值");
-      const used = lorebookTokens(entries);
+      const add = (level, code, message, names, source) => issues.push({ level, code, message, entries: names || [], source: source || "card" });
+      // 0.9.0 报告：共享世界书是同一个世界观的一部分，聊天时与卡内 character_book **一起进 prompt**，
+      // 所以预算、最坏情况都得把它们并起来算；同时拆出「卡内 / 共享 / 合计」三段，免得又变成一笔糊涂账。
+      const scope = await sharedBookScopeFor(ctx, exec);
+      const shared = scope.entries;
+      const m = lorebookMetrics(entries, shared);   // 三段基础统计（一处实现，与 cc_validate 同一份）
+      const all = m.all;
+      const cardTokens = m.card.tokens;
+      const sharedTokens = m.shared.tokens;
+      const used = m.total.tokens;
+      // —— 逐条质量检查：卡内与共享书**都要查**，触发词冲突跨两者一起算 ——
+      // 第五轮报告修正了上一版写下的「边界」：那时说「共享书条目的质量走 cc_get_shared_book 那条线」，
+      // 可那条线上根本没有这个能力（只有重复检测），共享书于是成了没人体检的一格 —— 往书里塞一条同时
+      // 踩三类的坏条目，两个工具都不出声。共享书多卡共用、又没有「卡」这个载体，**比卡内更需要主动报**。
+      // 现在两边共用 auditLoreEntries 这一把尺子。
+      auditLoreEntries([{ source: "card", entries: entries }, { source: "shared", entries: shared }])
+        .issues.forEach(i => issues.push(i));
+      // 存在性检查走**合计**口径（卡内 + 共享书）—— 第四轮报告：这里此前只数卡内，于是同一份返回里
+      // 「constantEntries: 1」与「没有 constant 常驻条目」并列出现（计算已经改对了，判断没跟着换变量）。
+      if(all.length && !m.total.constant) add("warn", "no-constant", "没有 constant 常驻条目（卡内与共享书都没有）：世界观基调只在命中触发词时才出现", [], "mixed");
+      if(all.length && !m.total.hasDecorator) add("warn", "no-decorator", "所有条目都没有 @@decorator（@@position/@@depth/@@activate），插入位置全用默认值", [], "mixed");
       const budget = Number(book.token_budget||0) || 0;
-      if(budget>0 && used>budget) add("warn", "估算 " + used + " token，已超出 token_budget=" + budget);
+      if(budget>0 && used>budget){
+        add("warn", "over-budget", "估算 " + used + " token（卡内 " + cardTokens + " + 共享书 " + sharedTokens + "），已超出本卡 token_budget=" + budget
+          + (shared.length ? " —— 注意共享书是**独立一本**、由客户端分别管预算，调本卡预算盖不住它" : ""), [], "card");
+      }
       // N2（0.7.0）：总量与「单次触发」是两个独立风险，只报总量会让「调大预算」看起来像修好了。
-      const worst = worstCaseTrigger(entries);
-      const worstCase = { tokens: worst.tokens, constantTokens: worst.constantTokens, budget, entries: worst.entries, overBudget: budget > 0 && worst.tokens > budget };
+      const worst = worstCaseTrigger(all);
+      const worstCase = { tokens: worst.tokens, constantTokens: worst.constantTokens, budget, entries: worst.entries,
+        overBudget: budget > 0 && worst.tokens > budget, sharedEntries: shared.length };
       if(worstCase.overBudget){
-        add("warn", "最坏情况单次触发约 " + worst.tokens + " token（含常驻 " + worst.constantTokens + "，预算 " + budget + "）：「" + worst.entries.join(" + ") + "」一句话就吃光整份预算（调大 token_budget 盖不住这条）。", worst.entries);
+        add("warn", "worst-case-over-budget", "最坏情况单次触发约 " + worst.tokens + " token（含常驻 " + worst.constantTokens + "，预算 " + budget + "）：「" + worst.entries.join(" + ") + "」一句话就吃光整份预算（调大 token_budget 盖不住这条）。", worst.entries, "mixed");
       }
-      if(!String(book.name||"").trim()) add("warn", "世界书没有名字（character_book.name 为空，导出后是一本无名的书）");
+      if(!String(book.name||"").trim()) add("warn", "book-unnamed", "世界书没有名字（character_book.name 为空，导出后是一本无名的书）", [], "card");
+      if(shared.length && !String(scope.bookName||"").trim()) add("warn", "shared-book-unnamed", "该组的共享世界书没有名字（导出成 lorebook_v3 文件后别人不知道叫什么）—— 用 cc_patch_shared_book 的 name 参数命名", [], "shared");
       const errorCount = issues.filter(i => i.level === "error").length;
+      const lints = issues.filter(i => i.level === "error" || i.level === "warn").length;
       return { ok:true,
-        entries: entries.length, manualEntries: entries.filter(e => !isAutoEntry(e)).length,
-        constantEntries: entries.filter(e => e.constant).length,
-        lorebookTokens: used, tokenBudget: budget, worstCase,
+        entries: all.length,
+        entriesSplit: { card: entries.length, shared: shared.length, total: all.length },
+        manualEntries: m.card.manual,
+        constantEntries: m.total.constant,
+        lorebookTokens: used,
+        tokenSplit: { card: cardTokens, shared: sharedTokens, total: used },
+        sharedBook: shared.length ? { groupId: scope.groupId, name: scope.bookName, entries: shared.length, tokens: scope.tokens } : null,
+        tokenBudget: budget, worstCase,
         issues, errorCount, warningCount: issues.length - errorCount,
-        message: issues.length
+        message: (issues.length
           ? "体检发现 " + issues.length + " 个问题（" + errorCount + " 个会真的不工作）：" + issues.map(i=>i.message).join("；")
-          : "世界书体检通过：没有发现结构性问题。" };
+          : "世界书体检通过：没有发现结构性问题。")
+          + (shared.length ? "（含该组共享世界书 " + shared.length + " 条 / 约 " + sharedTokens + " token，共 " + lints + " 项在册）" : "") };
     }
   });
 
@@ -1797,7 +1967,7 @@ function apply(ctx){
       // ⚠️ 分组 rev 与草稿 rev 是两件事：expectedGroupRev 校验**图谱**，expectedRev（包装层）校验**草稿**。
       // 曾经两者同名，结果传分组 rev 会被包装层当成草稿 rev 拒掉（且错误文案说「草稿已被外部修改」，极具误导性）。
       if(typeof args.expectedGroupRev === "number" && args.expectedGroupRev !== g.rev){
-        return { ok:false, staleRev:true, expectedGroupRev: args.expectedGroupRev, actualRev: g.rev,
+        return { ok:false, staleGroupRev:true, expectedGroupRev: args.expectedGroupRev, actualRev: g.rev,
           group: { id: g.id, name: g.name, rev: g.rev },
           error: "分组「" + g.name + "」已被外部修改（期望 rev=" + args.expectedGroupRev + "，实际 rev=" + g.rev + "）—— 先 cc_get_relations 重新读一遍再改。" };
       }
@@ -1841,7 +2011,7 @@ function apply(ctx){
         return { ok:false, error:"分组「" + g.name + "」里没有这张卡的节点：先在工坊关系视图里把它加入分组（或用 cc_patch_relations 加一个 kind:\"card\" 的节点）。" };
       }
       if(typeof args.expectedGroupRev === "number" && args.expectedGroupRev !== g.rev){
-        return { ok:false, staleRev:true, expectedGroupRev: args.expectedGroupRev, actualRev: g.rev,
+        return { ok:false, staleGroupRev:true, expectedGroupRev: args.expectedGroupRev, actualRev: g.rev,
           error:"分组「" + g.name + "」已被外部修改（期望 rev=" + args.expectedGroupRev + "，实际 rev=" + g.rev + "）—— 先 cc_get_relations 重读再渲染。" };
       }
       const section = renderRelationsSection(r.myNode.id, g.nodes, g.edges, { includeIncoming: args.includeIncoming === true });
@@ -1864,7 +2034,7 @@ function apply(ctx){
         setDraft(ctx, cur, exec);
       }
       return { ok:true, changed, changedFields: changed ? ["description"] : [], outgoing, description: after,
-        group: { id: g.id, name: g.name, rev: g.rev }, workflow: workflowStatus(cur),
+        group: { id: g.id, name: g.name, rev: g.rev }, workflow: await workflowFor(ctx, exec, cur),
         message: (changed ? "已把 " + outgoing + " 条关系写进 description 的【关系】段" : "description 里已经是最新关系，无需改动")
           + "。注意：这只改了**当前草稿**，要落库请再调 cc_save_to_library（或让用户在工坊点「保存当前」）。" };
     }
@@ -1888,7 +2058,10 @@ function apply(ctx){
       const g = r.group;
       const memberIds = await groupMemberIds(g.id);
       const cards = await libraryCardsFor(memberIds);
-      const res = checkGroup(g, memberIds, cards);
+      // 0.9.0：体检的是**这个组**，所以读这个组的共享书（显式传 groupId 时它与当前卡所在组可能不同）
+      const bkFound = await readBookRaw(g.id);
+      const sharedEntries = bkFound ? normalizeBook(bkFound.obj, g.id).data.entries.filter(e => e && e.enabled !== false) : [];
+      const res = checkGroup(g, memberIds, cards, sharedEntries);
       const errorCount = res.issues.filter(i => i.level === "error").length;
       return { ok:true,
         group: { id: g.id, name: g.name, rev: g.rev },
@@ -2037,9 +2210,16 @@ function apply(ctx){
       const g = normalizeGroup(found.obj);
       const members = await groupMemberIds(gid);
       if(args.confirm !== true){
+        // 盘点必须把**共享世界书**也算进「会被删掉且不可恢复」的东西里（第二轮报告 4.1）：
+        // 那可能是用户花了很多时间整理的设定，而原先的破坏性提示只提了节点/关系。
+        const bf = await readBookRaw(gid);
+        const bookCount = bf ? normalizeBook(bf.obj, gid).data.entries.length : 0;
         return { ok:false, needConfirm:true,
           group: { id:g.id, name:g.name, nodeCount:g.nodes.length, edgeCount:g.edges.length, memberCount:members.length },
-          message:"「" + g.name + "」里有 " + g.nodes.length + " 个节点 / " + g.edges.length + " 条关系，删组会一起删掉且不可恢复；" + members.length + " 张成员卡不会被删，只会离开这个组。与用户确认后重调并带 confirm:true。" };
+          bookEntries: bookCount, hasBook: !!bf,
+          message:"「" + g.name + "」里有 " + g.nodes.length + " 个节点 / " + g.edges.length + " 条关系，删组会一起删掉且不可恢复；" + members.length + " 张成员卡不会被删，只会离开这个组。"
+            + (bf ? "本组另有共享世界书 " + bookCount + " 条（" + (String(normalizeBook(bf.obj, gid).data.name||"").trim() || "未命名") + "），也会一并删除且不可恢复。" : "")
+            + "与用户确认后重调并带 confirm:true。" };
       }
       const del = await deleteGroupWithMembers(gid);
       const bookDeleted = await deleteBook(gid);   // 0.9.0：组级共享世界书随组一起删（留下就是孤儿文件）
@@ -2105,11 +2285,13 @@ function apply(ctx){
 
   // ———————————————— 组级共享世界书（0.9.0）————————————————
   // 一组一份：世界设定（年表/势力/地理/力量/日常）提到共享书，成员卡里只留角色私有条目。
-  // 导出后是 CCv3 官方 lorebook_v3 JSON，在客户端里绑成全局世界书即可，多卡共用、零重复。
+  // 导出后有两种形态，各有各的读者（0.9.1 补）：CCv3 官方 lorebook_v3 JSON 给认这个规范的客户端；
+  // **SillyTavern 只认它自己的 `{entries:{…}}`**（ST 的 /api/worldinfo/import 首句就查顶层 entries，
+  // 拖 lorebook_v3 进去实测 400）—— 工坊导出页两枚按钮分别对应，别混着说。
 
   tool({
     name: "cc_get_shared_book",
-    description: "【共享书·查】读当前（或指定）分组的**组级共享世界书**（一组一份、整组共用），并报出「成员卡之间有多少条重复条目」—— 那些就是该提升到共享书的。共享书是独立文件（CCv3 官方 lorebook_v3 格式），导出后可在客户端里绑成全局世界书，于是每张成员卡里不必再存这些设定。",
+    description: "【共享书·查】读当前（或指定）分组的**组级共享世界书**（一组一份、整组共用），并报出「成员卡之间有多少条重复条目」—— 那些就是该提升到共享书的。共享书是独立文件，工坊导出页给两种形态：**CCv3 独立世界书**（`{spec:\"lorebook_v3\", data}`，给支持该规范的客户端绑成全局世界书）与 **SillyTavern 世界书**（`{entries:{…}}`）。⚠️ SillyTavern 的导入接口只认后者（它连 `lorebook_v3` 都不认，直接拖前者进去会被判 400 Bad Request）—— 所以「交给客户端」时要说清是哪种，别让用户拿到 CCv3 那份去导 ST。",
     parameters: {
       type:"object",
       properties:{
@@ -2126,26 +2308,44 @@ function apply(ctx){
       const g = r.group;
       const found = await readBookRaw(g.id);
       const cards = await bookCardsFor(await groupMemberIds(g.id));
-      const scan = scanSharedEntries(cards);
+      const book = found ? normalizeBook(found.obj, g.id) : null;
+      // 把**书**一起交给 scan —— 否则「卡内条目与共享书逐字重复」这一类（`cc_apply_shared_book` 回填进卡的副本）
+      // 谁都看不见：卡片之间没有重复、书里也没有重复，于是两个工具都说「没有重复」，而那几份副本就躺在卡里
+      // 等着和共享书双重插入（第二轮报告 P1）。
+      const scan = scanSharedEntries(cards, book ? book.data.entries : []);
       const duplicates = scan.candidates.map(c => ({ signature: c.signature, name: c.name, cardNames: c.cardNames,
         chars: c.chars, savedChars: c.savedChars, nameMismatch: c.nameMismatch, keysMismatch: c.keysMismatch, preview: c.preview }));
+      const bookDuplicates = scan.bookDupes.map(c => ({ kind: c.kind, signature: c.signature, name: c.name, cardNames: c.cardNames,
+        chars: c.chars, savedChars: c.savedChars, preview: c.preview }));
+      // 共享书**自己的**逐条质量检查（第五轮报告：这条线上此前只有重复检测，那四类检查在书上是空的）。
+      // 与 cc_lint_lorebook 共用同一把尺子（auditLoreEntries）—— 一份 issue 带 contentKeys，可直接改。
+      const bookLint = auditLoreEntries([{ source: "shared", entries: book ? book.data.entries : [] }]);
       const base = { ok:true, group:{ id:g.id, name:g.name, rev:g.rev }, exists: !!found,
-        bookRev: found ? bookRevOf(normalizeBook(found.obj, g.id)) : 0,
+        bookRev: book ? bookRevOf(book) : 0,
         cards: cards.map(c => ({ id:c.id, name:c.name, entries:(c.entries||[]).length })),
-        duplicates, duplicateStats: scan.stats };
+        duplicates, bookDuplicates, duplicateStats: scan.stats,
+        lint: { issues: bookLint.issues, errorCount: bookLint.errorCount, warningCount: bookLint.issues.length - bookLint.errorCount } };
       if(!found){
         return Object.assign(base, { message: "分组「" + g.name + "」还没有共享世界书。"
           + (scan.candidates.length
             ? "成员卡之间有 " + scan.candidates.length + " 条内容重复的条目（合计可省约 " + scan.stats.savedChars + " 字符）—— 用 cc_promote_shared_entries 提升到共享书，再从各卡里删掉。"
             : "成员卡之间也没有内容重复的条目。") });
       }
-      const book = normalizeBook(found.obj, g.id);
       const tokens = estimateTokens(book.data.entries.map(e => e.content).join("\n"));
       return Object.assign(base, {
         book: bookBrief(book, args.includeContent === true), tokens,
+        lastPromote: (book.data.extensions && book.data.extensions.cc && book.data.extensions.cc.lastPromote) || null,
         message: "共享世界书「" + book.data.name + "」共 " + book.data.entries.length + " 条（rev " + bookRevOf(book) + "，约 " + tokens + " token"
           + "，预算 " + book.data.token_budget + "）；分组里有 " + cards.length + " 张成员卡"
-          + (scan.candidates.length ? "，其中仍有 " + scan.candidates.length + " 条内容重复（可用 cc_promote_shared_entries 收进共享书）" : "，卡片间已无重复条目") + "。" });
+          + (scan.candidates.length ? "，卡片之间有 " + scan.candidates.length + " 条内容重复（可用 cc_promote_shared_entries 收进共享书）" : "，卡片之间已无重复条目")
+          + (scan.bookDupes.length
+            ? "；另有 " + scan.bookDupes.length + " 条在卡里与共享书**逐字重复**（共 " + scan.stats.bookDuplicatedEntries + " 份副本、约 " + scan.stats.bookSavedChars + " 字符）—— 共享书里已经有了，用 cc_promote_shared_entries 清掉卡里那几份即可（不会再往书里加）"
+            : "")
+          + (bookLint.issues.length
+            ? "；⚠️ **这本书自身有 " + bookLint.issues.length + " 个条目质量问题**（" + bookLint.issues.map(i => i.message).join("；")
+              + "）—— 共享书在**每一张**成员卡上都生效：一条死 key 等于在所有卡上都没写、一条维度名 key 等于在每张卡上白吃 token。按 lint.issues[].contentKeys 用 cc_patch_shared_book 直接改"
+            : "")
+          + "。" });
     }
   });
 
@@ -2173,7 +2373,7 @@ function apply(ctx){
         message:"当前卡还没入库或没加入分组，共享世界书无处可放 —— 先把它归到一组。" };
       const res = await patchSharedBook(r.group.id, args);
       if(!res.ok){
-        return { ok:false, staleRev: res.staleRev === true,
+        return { ok:false, staleBookRev: res.staleBookRev === true,
           expectedBookRev: res.expectedBookRev == null ? null : res.expectedBookRev,
           actualBookRev: res.actualBookRev == null ? null : res.actualBookRev,
           error: String(res.error || "") };
@@ -2209,19 +2409,35 @@ function apply(ctx){
       const res = await promoteSharedBook(r.group.id, args);
       if(!res.ok) return { ok:false, error: String(res.error || "") };
       if(res.dryRun){
-        return { ok:true, dryRun:true, wouldPromote: res.wouldPromote, unknownKeys: res.unknownKeys,
-          removedTotal: res.removedTotal, perCard: res.perCard, duplicates: res.candidates, stats: res.stats,
+        const nothing = !res.wouldPromote && !res.wouldClean;
+        return { ok:true, dryRun:true, wouldPromote: res.wouldPromote, wouldClean: res.wouldClean, unknownKeys: res.unknownKeys,
+          removedTotal: res.removedTotal, savedChars: res.savedChars, perCard: res.perCard, duplicates: res.candidates,
+          bookDuplicates: res.bookDuplicates, stats: res.stats,
           group:{ id:r.group.id, name:r.group.name }, bookRev: res.rev,
-          message: res.wouldPromote
-            ? "预览：将把 " + res.wouldPromote + " 条提升进共享世界书，并从成员卡里共删掉 " + res.removedTotal + " 条重复（可省约 " + res.stats.savedChars + " 字符）。确认后带 apply:true 重调。"
-            : "没有可提升的重复条目" + (res.unknownKeys.length ? "（" + res.unknownKeys.length + " 个 signature 不认识，已忽略）" : "") + "。" };
+          message: nothing
+            ? "没有可提升的重复条目" + (res.unknownKeys.length ? "（" + res.unknownKeys.length + " 个 signature 不认识，已忽略）" : "") + "。"
+            : "预览："
+              + (res.wouldPromote ? "把 " + res.wouldPromote + " 条提升进共享世界书，" : "")
+              + (res.wouldClean ? "清掉卡里 " + res.wouldClean + " 条与共享书逐字重复的副本（书里已经有了，不会再往书里加），" : "")
+              + "将从成员卡里共删掉 " + res.removedTotal + " 条（可省约 " + res.savedChars + " 字符）。确认后带 apply:true 重调。" };
       }
-      return { ok:true, dryRun:false, promoted: res.promoted, removedTotal: res.removedTotal, unknownKeys: res.unknownKeys,
+      // 库里已经删干净了，但**草稿是另一个副本** —— 顺手同步（见 syncDraftAfterPromote 的注释），
+      // 同步不了就退回警告，绝不静默地让重复在下次保存时复活。
+      const draftSync = await syncDraftAfterPromote(ctx, exec, r.group.id,
+        (res.perCard || []).filter(c => c && !c.error && c.removed > 0).map(c => c.id));
+      return {
+        ok:true, dryRun:false, promoted: res.promoted, cleaned: res.cleaned, removedTotal: res.removedTotal, unknownKeys: res.unknownKeys,
         bookRev: res.bookRev, bookEntries: res.bookEntries, perCard: res.perCard, stats: res.stats,
-        group:{ id:r.group.id, name:r.group.name },
+        bookDuplicates: res.bookDuplicates,
+        group:{ id:r.group.id, name:r.group.name }, draftSync,
         message: "已把 " + res.promoted + " 条设定提升进共享世界书（rev " + res.bookRev + "，共 " + res.bookEntries + " 条），并从成员卡里删掉 " + res.removedTotal + " 条重复："
           + res.perCard.map(c => c.name + " -" + (c.removed || 0)).join("、")
-          + "。导出时记得一并给客户端配这本共享世界书（工坊导出页可导出独立 JSON）。" };
+          + (res.cleaned ? "（其中 " + res.cleaned + " 条是共享书里早就有的副本，只做了清理）" : "")
+          + (draftSync.synced ? "。你正在编辑的草稿就是其中一张，已同步删掉 " + draftSync.removed + " 条 —— 接着保存不会把重复写回去。" : "")
+          + (draftSync.remaining ? "。⚠️ 当前草稿里还有 " + draftSync.remaining + " 条与共享书重复（" + draftSync.names.slice(0,5).join("、") + "）：这次只改了库里的卡，草稿里那份还在 —— 保存前先 cc_load_from_library 重新载入，否则重复会被原样写回卡里。" : "")
+          + "导出时记得一并给客户端配这本共享世界书（工坊导出页可导出独立 JSON）。",
+        warnings: draftSync.remaining ? ["这次提升只改了**库里的卡**，你正在编辑的那份草稿没被改动，里面仍有 " + draftSync.remaining + " 条与共享书逐字重复（" + draftSync.names.slice(0,5).join("、") + "）。接着 cc_save_to_library 会把它们原样写回卡里、重复照旧 —— 保存前先 cc_load_from_library 重新载入这张卡（或手动删掉这几条）。"] : undefined,
+      };
     }
   });
 
@@ -2276,12 +2492,27 @@ function apply(ctx){
       entries.forEach(e => { const c = String(e.content||""); WORLD_DIMS.forEach(k => { const t = String(w[k]||""); if(t && c.indexOf(t) >= 0) dupChars += t.length; }); });
       const exportedFields = ["name","nickname","tags","creator","character_version","description","personality","scenario","system_prompt","post_history_instructions","first_mes","alternate_greetings","group_only_greetings","mes_example","creator_notes","character_book","assets","creation_date","modification_date"];
       const bytes = Buffer.byteLength(json, "utf8");
+      // 0.9.0 报告：导出预览只说「卡内世界书」，用户会以为这就是全部 —— 而客户端实际加载时
+      // 是「卡内 character_book + 该组共享书」叠加，所以这里必须把共享书单列一行。
+      const scope = await sharedBookScopeFor(ctx, exec);
+      const shared = scope.entries;
+      const cardTokens = lorebookTokens(entries);
+      const sharedTokens = lorebookTokens(shared);
       return { ok:true,
-        bytes, tokens: estimateTokens(json), lorebookTokens: lorebookTokens(entries),
+        bytes, tokens: estimateTokens(json),
+        lorebookTokens: cardTokens + sharedTokens,
+        lorebookSplit: { card: cardTokens, shared: sharedTokens, total: cardTokens + sharedTokens },
+        sharedBook: shared.length ? { groupId: scope.groupId, name: scope.bookName, entries: shared.length, tokens: sharedTokens,
+          hint: "独立一本，工坊导出页可单独导出（CCv3 客户端拿「CCv3 独立世界书」，**SillyTavern 拿「SillyTavern 世界书」**）；若客户端不支持全局世界书，可在导出时并入本卡。导卡时（JSON / PNG / CHARX）会**自动在导出副本上**写 `data.extensions.world = <书名>`（ST 的角色↔世界书绑定），PNG 里同时写 `ccv3`（纯 CCv3）与 `chara`（V2 回填）两个块 —— 草稿与库里的卡一个字节都不动" } : null,
         exportedFields, extensionsExported: Object.keys(d.extensions || {}),
         worldDuplicatedChars: dupChars,
         loreCount: entries.length, manualLoreCount: entries.filter(e => !isAutoEntry(e)).length,
-        message: "预计导出 " + bytes + " 字节（约 " + estimateTokens(json) + " token），其中世界书 " + lorebookTokens(entries) + " token；五维（extensions.cc_world）会一起导出，与条目内容重复约 " + dupChars + " 字符。" };
+        message: "预计导出 " + bytes + " 字节（约 " + estimateTokens(json) + " token），其中本卡世界书 " + cardTokens + " token"
+          + (shared.length
+            ? "；**本卡所属组另有共享世界书「" + (String(scope.bookName||"").trim() || "未命名") + "」" + shared.length + " 条 / 约 " + sharedTokens
+              + " token** —— 客户端实际加载时两者叠加（合计 " + (cardTokens + sharedTokens) + " token），可单独导出该文件（**SillyTavern 要用「SillyTavern 世界书」那份**）或导出时并入本卡"
+            : "")
+          + "；五维（extensions.cc_world）会一起导出，与条目内容重复约 " + dupChars + " 字符。" };
     }
   });
 
@@ -2294,7 +2525,7 @@ function apply(ctx){
       const d = getDraft(ctx, exec);
       const k = keyFor(ctx, exec);
       const st = draftStatusFor(k, d);
-      const wf = workflowStatus(d);
+      const wf = await workflowFor(ctx, exec, d);
       const book = d.data.character_book || {};
       const entries = Array.isArray(book.entries) ? book.entries : [];
       const errors=[], warnings=[];
@@ -2305,9 +2536,13 @@ function apply(ctx){
       if(!Array.isArray(d.data.group_only_greetings) || d.data.group_only_greetings.length<1) errors.push("缺 group_only_greetings（至少 1 条必填）");
       if(wf.state.world !== "ok") errors.push("五维世界观未齐：需 timeline/factions/geo/power/daily 至少 3 项（当前 "+wf.worldFilled+"/5），请调 cc_patch_world");
       if(wf.state.lore !== "ok"){
-        errors.push(wf.manualLoreCount === 0
-          ? "世界书只有自动条目（"+wf.loreCount+" 条，全部由 autoLorebook 生成），未完成共创：请调 cc_add_lorebook_entries 至少补 1 条（总≥5 条）"
-          : "世界书未齐：需至少 5 条（当前 "+wf.loreCount+" 条），请调 cc_add_lorebook_entries 补到 5 条");
+        errors.push(wf.manualLoreTotal === 0
+          ? "世界书只有自动条目（合计 "+wf.loreTotal+" 条"+(wf.sharedLoreCount ? "，其中共享书 "+wf.sharedLoreCount+" 条" : "")+"，全部由 autoLorebook 生成），未完成共创：请调 cc_add_lorebook_entries 至少补 1 条（合计≥5 条）"
+          : "世界书未齐：卡内 "+wf.loreCount+" 条 + 共享书 "+wf.sharedLoreCount+" 条 = 合计 "+wf.loreTotal+" 条，需至少 5 条，请调 cc_add_lorebook_entries 补到 5 条");
+      } else if(wf.loreCount < 5){
+        // 达标靠的是组里那本共享书（第二轮报告 P0 的正解）：**不阻塞**，但必须把「导出时要带上它」说清楚 ——
+        // 否则用户把这张「卡内只有 3 条」的卡发出去，对方客户端没有共享书就等于世界书缺失。
+        warnings.push("本卡内只有 "+wf.loreCount+" 条世界书，达标靠的是本组共享世界书「"+(wf.sharedBook && String(wf.sharedBook.name||"").trim() ? wf.sharedBook.name : "未命名")+"」的 "+wf.sharedLoreCount+" 条（合计 "+wf.loreTotal+" 条）。**共享书不会跟着卡走**：导出时请把它一并交给客户端（工坊导出页有两枚按钮 —— 支持 `lorebook_v3` 的客户端拿「CCv3 独立世界书」，**SillyTavern 必须拿「SillyTavern 世界书」**，ST 的导入接口只认 `{entries:{…}}` 形态）；对方客户端不支持全局世界书时，在导出页勾选「并入本卡」。导卡时若该组有共享书，会**自动在导出副本上**写上 ST 的世界书绑定（`data.extensions.world = 书名`），PNG 里同时带 `ccv3` 与 `chara` 两个块。");
       }
       // —— 质量（P1-5：此前 valid=true 只代表「四件套非空」，给用户「卡没问题了」的错觉）——
       if(!String(d.data.scenario||"").trim()) warnings.push("scenario 为空，建议补充（缺失时模型只能靠 description 猜场景）");
@@ -2317,8 +2552,9 @@ function apply(ctx){
       if(!String(d.data.creator||"").trim()) warnings.push("data.creator 为空（导出后别人看不到作者）—— 用 cc_patch_character 的 creator 参数写入，或让用户在工坊「角色基础」里手动填。");
       if(!String(book.name||"").trim()) warnings.push("世界书没有名字（character_book.name 为空），导出后是一本无名的书；可用 cc_patch_book_meta 命名");
       if(!String(book.description||"").trim()) warnings.push("character_book.description 为空，建议一句话说明这本世界书的作用");
-      if(entries.length>0 && !entries.some(e=>e.constant)) warnings.push("世界书建议至少 1 条 constant 常驻条目（否则全靠触发词命中）");
-      if(entries.length>0 && entries.every(e=> !String(e.content||"").includes("@@"))) warnings.push("世界书条目建议带 @@decorator（@@position/@@depth/@@activate）");
+      // 存在性检查按**合计**口径（卡内 + 共享书）—— 见 workflowStatus 里 constantEntries 的注释
+      if(wf.loreTotal > 0 && wf.constantEntries.total === 0) warnings.push("世界书（卡内 + 共享书）没有任何 constant 常驻条目（否则全靠触发词命中）");
+      if(wf.loreTotal > 0 && !entries.some(e => String((e && e.content) || "").includes("@@")) && wf.sharedHasDecorator !== true) warnings.push("世界书条目建议带 @@decorator（@@position/@@depth/@@activate）");
       const deadKeys = entries.filter(e => !e.constant && (!Array.isArray(e.keys) || e.keys.length===0));
       if(deadKeys.length) warnings.push(deadKeys.length + " 条非 constant 条目没有 keys（永远触发不了）：" + deadKeys.map(e=>String(e.name||"未命名")).join("、"));
       const dimOnly = entries.filter(e => !e.constant && Array.isArray(e.keys) && e.keys.length>0 && e.keys.every(k => AUTO_NAMES.has(String(k)) || ["timeline","faction","geography","power","daily"].includes(String(k))));
@@ -2340,17 +2576,27 @@ function apply(ctx){
         done: valid,
         readyToValidate: !valid && wf.readyToValidate,
         next,
-        hint: progressHint(valid ? 7 : wf.step, wf.state, wf.worldFilled, wf.loreCount, wf.manualLoreCount, valid),
+        hint: progressHint(valid ? 7 : wf.step, wf.state, wf.worldFilled, wf.loreCount, wf.manualLoreCount, valid, wf.sharedLoreCount),
       });
       const warningsAll = [recoveredNotice(k, d)].filter(Boolean).concat(warnings);   // 新草稿提示同上，交给包装
+      const sharedUsed = (wf.sharedBook && Number(wf.sharedBook.tokens)) || 0;
       return { ok:true, valid, done: valid, errors, warnings: warningsAll,
         loreCount: wf.loreCount, manualLoreCount: wf.manualLoreCount, name: d.data.name,
-        lorebookTokens: used, tokenBudget: budget,
+        // 世界书的两个口径都报出来（第二轮报告 P0）：卡内 / 共享 / 合计 —— `cc_lint_lorebook` 早就是这个口径了，
+        // 「收尾判定」再只数卡内，等于让按最佳实践去重过的卡永远不合格。
+        sharedLoreCount: wf.sharedLoreCount, loreTotal: wf.loreTotal,
+        constantEntries: wf.constantEntries,
+        lorebookTokens: used + sharedUsed,
+        lorebookSplit: { card: used, shared: sharedUsed, total: used + sharedUsed },
+        sharedBook: wf.sharedBook,
+        tokenBudget: budget,
         draftStatus: st, workflow: wfDone,
         // R3（0.6.0）：message 不再拼接 next —— 那会让「校验通过 ✓」连说两遍（两个来源拼接未去重）。
         // 下一步只保留 workflow.next 一处。
         message: valid
-          ? "校验通过 ✓ 工作流完成（世界书 " + wf.loreCount + " 条 / 估算 " + used + " token）。"
+          ? "校验通过 ✓ 工作流完成（世界书 " + wf.loreTotal + " 条"
+            + (wf.sharedLoreCount ? " = 卡内 " + wf.loreCount + " + 共享书 " + wf.sharedLoreCount : "")
+            + " / 估算 " + (used + sharedUsed) + " token）。"
           : "校验未通过：" + errors.length + " 项待补。" };
     }
   });
@@ -2461,7 +2707,24 @@ async function bookCardsFor(ids){
   }
   return out;
 }
-function scanSharedEntries(cards){
+/**
+ * 新建共享书的默认名：`<组名>·共享设定`（拿不到组名才退回「共享设定」）。
+ * 第二轮报告 4.2：同一个人的多个组各建一本、全叫「共享设定」，导出成文件后根本分不清是哪一组。
+ * 两半同构（`tests/shared-book.test.mjs` 直接比对），改这里记得同步 `lib/index.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 => {
@@ -2478,10 +2741,26 @@ 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, stats: { cards: list.length, totalEntries,
+  return { 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) } };
+    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) } };
 }
 function mergeBookEntries(bookEntries, cardEntries){
   const have = new Set((Array.isArray(cardEntries) ? cardEntries : []).map(contentKeyOf));
@@ -2501,19 +2780,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) };
 }
 
 // —— 0.9.0：三个编排动作（与宿主半 cc_patchBook / cc_promoteBook / cc_applyBook 端点行为等价）——
@@ -2537,9 +2819,9 @@ async function patchSharedBook(groupId, args){
   const gid = safeGroupId(groupId);
   if(!gid) return { ok: false, error: "需要 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 { ok: false, staleRev: true, expectedBookRev: args.expectedBookRev, actualBookRev: bookRevOf(cur),
+    return { ok: false, staleBookRev: true, expectedBookRev: args.expectedBookRev, actualBookRev: bookRevOf(cur),
       error: "共享世界书已被外部修改（期望 rev=" + args.expectedBookRev + "，实际 rev=" + bookRevOf(cur) + "）—— 先 cc_get_shared_book 重新读一遍再改。" };
   }
   const applied = [], rejected = [];
@@ -2586,21 +2868,44 @@ async function promoteSharedBook(groupId, args){
   const gid = safeGroupId(groupId);
   if(!gid) return { ok: false, error: "需要 groupId" };
   const found = await readBookRaw(gid);
-  const cur = found ? normalizeBook(found.obj, gid) : normalizeBook({}, gid);
+  let cur;
+  if(found){ cur = normalizeBook(found.obj, gid); }
+  else cur = 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]));
-  const requested = (Array.isArray(args.keys) && args.keys.length) ? args.keys.map(String) : scan.candidates.map(c => c.signature);
+  // 候选有两类：① 卡与卡之间重复（提升进书）；② 卡内条目与**共享书**逐字重复（书里已经有，只需清理卡内副本）。
+  // ② 是 `cc_apply_shared_book` 回填卡之后的必然产物：卡里那份与共享书会**双重插入**，而此前两个工具都看不见它
+  // （卡片之间没重复、书里也没重复）—— 第二轮报告 P1。
+  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).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: true, dryRun: true, changed: false, wouldPromote: use.length, unknownKeys, removedTotal: plan.removedTotal,
+    return { ok: true, 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), stats: scan.stats, rev: bookRevOf(cur) };
+      candidates: scan.candidates.map(summary), bookDuplicates: scan.bookDupes.map(summary), stats: scan.stats, rev: bookRevOf(cur) };
   }
-  const saved = await writeBook(gid, Object.assign({}, cur, { data: Object.assign({}, cur.data, { entries: plan.bookEntries }) }));
+  // 这次删掉的条目里，有多少是「提升」（卡内副本搬进书）之外的**纯清理**（书里早就有）—— 报告 P1 要的可对账字段。
+  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);
+  // 记下「这次提升省了多少」——报告 4.3：去重完再查时 savedChars 已经是 0，收益就查不到了；
+  // 存进 extensions.cc.lastPromote，让 cc_get_shared_book 能一直回显。
+  const ccExt = Object.assign({}, (cur.data.extensions && cur.data.extensions.cc) || {}, {
+    lastPromote: { savedChars: plan.savedChars, removed: plan.removedTotal, promoted: plan.promoted.length, cleaned, at: nowSec() },
+  });
+  const saved = await writeBook(gid, Object.assign({}, cur, {
+    data: Object.assign({}, cur.data, {
+      entries: plan.bookEntries,
+      extensions: Object.assign({}, cur.data.extensions, { cc: ccExt }),
+    }),
+  }));
   const touched = [];
   for(const c of plan.cards){
     if(!c.removed) continue;
@@ -2613,9 +2918,77 @@ async function promoteSharedBook(groupId, args){
       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: true, 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 };
+  return { ok: true, dryRun: false, changed: true, promoted: plan.promoted.length, cleaned, removedTotal: plan.removedTotal, savedChars: plan.savedChars, unknownKeys,
+    bookRev: bookRevOf(saved), bookEntries: saved.data.entries.length, perCard: touched,
+    candidates: scan.candidates.map(summary), bookDuplicates: scan.bookDupes.map(summary), stats: scan.stats };
+}
+// —— 提升之后的「草稿同步」（用户报告的第 1 条）——
+// 为什么必须有这一步：`cc_promote_shared_entries` 改的是**库里的卡**，而模型正在编辑的是**草稿**
+// ——两个副本。库里那张卡的重复条目被删掉了，草稿里却还原样留着，模型接着调 cc_save_to_library
+// 就会把重复**原样写回卡里**：刚做完的去重等于白做，而且全程零提示（测试里能直接看到
+// 「simulate 同时命中 年表@card 与 年表@shared」就是这个状态）。
+//
+// 判据与库里那一次**完全相同**：内容已经进了共享书、且**逐字相符**。内容签名只用来筛候选，
+// 绝不按哈希删数据（哈希碰撞不能变成删用户内容）——内容被改过的那几条一律不动，只报告。
+/** 草稿里「与共享书逐字重复」的条目（`dupes`）与其余条目（`kept`）。纯函数，便于直接测。 */
+function draftBookDupes(draftEntries, bookEntries){
+  const book = new Map();
+  (Array.isArray(bookEntries) ? bookEntries : []).forEach(e => {
+    const content = String((e && e.content) == null ? "" : e.content);
+    if(!content.trim()) return;
+    const sig = contentKeyOf(e);
+    if(!book.has(sig)) book.set(sig, content);
+  });
+  const dupes = [], kept = [];
+  (Array.isArray(draftEntries) ? draftEntries : []).forEach(e => {
+    const content = String((e && e.content) == null ? "" : e.content);
+    if(content.trim() && book.get(contentKeyOf(e)) === content) dupes.push(e);
+    else kept.push(e);
+  });
+  return { dupes, kept };
+}
+/**
+ * 提升执行后同步草稿：若**当前草稿的来源卡正是这次被删过条目的卡之一**，就把草稿里那几条一起删掉。
+ *
+ * 两条出口：
+ *  - `synced:true`  → 已同步（`removed` 条），模型可以放心 `cc_save_to_library`；
+ *  - `remaining>0`  → 草稿里仍有 N 条与共享书重复（来源卡不适用，或内容被改过逐字比对不中）
+ *    —— **不动手**，只把条数报回去，由调用方给出「保存前先 cc_load_from_library 重新载入」的警告。
+ *
+ * 并发安全：`getDraft()` 会以盘上 rev 为准自动重载，而「读草稿 → 过滤 → `setDraft`」之间
+ * **没有任何 await**，所以别人的写入不会被半路覆盖（要么它在我读之前完成、要么在我写之后）。
+ */
+async function syncDraftAfterPromote(ctx, exec, groupId, promotedCardIds){
+  const ids = (Array.isArray(promotedCardIds) ? promotedCardIds : []).map(String).filter(Boolean);
+  const gid = safeGroupId(groupId) || String(groupId || "");
+  const k = keyFor(ctx, exec);
+  const origin = readOriginSync(k);
+  const myCardId = (origin && origin.libraryId) ? String(origin.libraryId) : "";
+  const applicable = !!myCardId && ids.indexOf(myCardId) >= 0;
+  const found = gid ? await readBookRaw(gid) : null;
+  if(!found) return { applicable, synced:false, removed:0, remaining:0, names:[], cardId: myCardId || null };
+  const book = normalizeBook(found.obj, gid);
+  let draft;
+  try{ draft = getDraft(ctx, exec); }
+  catch(e){ return { applicable, synced:false, removed:0, remaining:0, names:[], cardId: myCardId || null, error: String((e && e.message) || e) }; }
+  const cb = (draft && draft.data && draft.data.character_book) || {};
+  const entries = Array.isArray(cb.entries) ? cb.entries : [];
+  const overlap = draftBookDupes(entries, book.data.entries);
+  const names = overlap.dupes.map(e => String((e && e.name) || "").trim() || "（未命名）");
+  if(!overlap.dupes.length) return { applicable, synced:false, removed:0, remaining:0, names:[], cardId: myCardId || null };
+  if(!applicable) return { applicable:false, synced:false, removed:0, remaining: overlap.dupes.length, names, cardId: myCardId || null };
+  try{
+    const data = draft.data;
+    const next = Object.assign({}, draft, { data: Object.assign({}, data, {
+      character_book: Object.assign({}, cb, { entries: overlap.kept }),
+    }) });
+    setDraft(ctx, next, exec);   // 走同一套落盘 + rev 递增（N4：内容没变则一次都不写）
+    return { applicable:true, synced:true, removed: overlap.dupes.length, remaining:0, names:[], cardId: myCardId };
+  }catch(e){
+    return { applicable:true, synced:false, removed:0, remaining: overlap.dupes.length, names, cardId: myCardId, error: String((e && e.message) || e) };
+  }
 }
+
 /** 回填：把共享书条目合并进某张卡（同内容已存在则跳过）—— 给不支持全局世界书的客户端兜底。 */
 async function applySharedBook(groupId, cardId, dryRun){
   const gid = safeGroupId(groupId);
@@ -2637,6 +3010,38 @@ async function applySharedBook(groupId, cardId, dryRun){
   return { ok: true, cardId, added: merged.added.length, changed: true, loreCount: merged.entries.length };
 }
 
+/**
+ * 度量类工具的统一口径：世界设定现在有一部分活在**组级共享书**里，所以任何「这张卡有多少条 /
+ * 多少 token」的统计都必须把它算上，并拆成 **卡内 / 共享 / 合计** 三段。
+ *
+ * 为什么单列一个函数：LLM 侧实测报告指出 —— 共享书改变了**数据的位置**，却没有改变工具的**度量口径**；
+ * 四个「读」类工具（simulate / lint / group_check / preview_export）全都默认「卡内 character_book
+ * 就是全部」，于是 simulate 把「会命中」判成「不会命中」（实测低估约 3 倍），lint 的 worstCase
+ * 漏掉共享书里的 constant 条目，group_check 的群聊固定开销也只算了一半。
+ *
+ * 没有来源卡 / 没有分组 / 该组还没有书 → 一律返回空（调用方无需自己判空）。
+ */
+async function sharedBookScopeFor(ctx, exec){
+  const k = keyFor(ctx, exec);
+  const origin = readOriginSync(k);
+  const cardId = (origin && origin.libraryId) ? String(origin.libraryId) : "";
+  const empty = { cardId, groupId: "", bookName: "", rev: 0, entries: [], tokens: 0, constantTokens: 0 };
+  if(!cardId) return empty;
+  const mine = (await listLibraryEntries()).find(e => e.id === cardId);
+  const gid = (mine && mine.groupId) ? String(mine.groupId) : "";
+  if(!gid) return empty;
+  const found = await readBookRaw(gid);
+  if(!found) return Object.assign({}, empty, { groupId: gid });
+  const book = normalizeBook(found.obj, gid);
+  const entries = book.data.entries.filter(e => e && e.enabled !== false);
+  return {
+    cardId, groupId: gid, bookName: book.data.name, rev: bookRevOf(book), entries,
+    tokens: lorebookTokens(entries),
+    constantTokens: entries.filter(e => e.constant).reduce((n, e) => n + estimateTokens(e && e.content), 0),
+    lastPromote: (book.data.extensions && book.data.extensions.cc && book.data.extensions.cc.lastPromote) || null,
+  };
+}
+
 export { apply, inject, name, safeDraftFile, draftDirs, libDirs, dataRoots, originPath, readOriginSync, writeOriginSync,
   // 人物关系图谱（0.8.0）：导出纯函数与落盘根，供 tests/relations.test.mjs 与宿主半逐字比对同构实现
   groupDirs, groupDir, groupPath, safeGroupId, normalizeGroup, validateGroupOp, applyGroupOps,
@@ -2648,4 +3053,6 @@ export { apply, inject, name, safeDraftFile, draftDirs, libDirs, dataRoots, orig
   BOOK_SPEC, bookDirs, bookDir, bookPath, makeBookEntry, normalizeBook, bookRevOf, readBookRaw, writeBook, deleteBook,
   contentKeyOf, bookCardsFor, scanSharedEntries, mergeBookEntries, applyBookPromotion,
   bookEntryBrief, bookBrief, patchSharedBook, promoteSharedBook, applySharedBook,
+  // 提升后的草稿同步（用户报告的第 1、2 条）：纯函数 + 同步动作，测试直接比对行为
+  draftBookDupes, syncDraftAfterPromote,
   REL_TYPES, REL_TYPE_LABELS, REL_BEGIN, REL_END };