cardbuddy 0.26.0 → 0.26.2

package/dist/preview-editor/index.html

@@ -8,8 +8,8 @@
     <link rel="icon" type="image/png" sizes="16x16" href="/assets/favicon-16-Cg6Nrosk.png" />
     <link rel="icon" type="image/png" sizes="32x32" href="/assets/favicon-32-B_1744sp.png" />
     <link rel="apple-touch-icon" sizes="180x180" href="/assets/apple-touch-icon-BQcES9QK.png" />
-    <script type="module" crossorigin src="/assets/index-Bn5gP68-.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CeoWrec1.css">
+    <script type="module" crossorigin src="/assets/index-DD2MA6i_.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BGqgV1Dw.css">
   </head>
   <body>
     <div id="app"></div>

package/dist/vendored/server/core/cardSync.js

@@ -71,11 +71,8 @@ function logSyncSummary(summary, requestLabel) {
     for (const s of summary.synced) {
       const f = s.files || {}
       // 空白卡（远端无 schemaValue）：标注落盘策略，避免误读成「抓到了完整 schema」。
-      const tag = s.blank
-        ? s.keptLocal
-          ? ' [空白卡·保留本地]'
-          : ' [空白卡·新建空白 schema]'
-        : ''
+      // 全量覆盖语义下本地旧内容一律丢弃，不再有「保留本地」分支。
+      const tag = s.blank ? ' [空白卡·按远端重建]' : ''
       lines.push(
         `• ${s.id}${s.title ? `（${s.title}）` : ''}${tag}  schema=${fmtBytes(f.schema)} data=${fmtBytes(f.data)} cover=${fmtBytes(f.cover)}`
       )

package/dist/vendored/skills/dsl-card-generator/references/rules.md

@@ -45,7 +45,7 @@
 - **Input 回写只写 rt.state**：Input 的 value 绑定 $key 时，渲染层兜底 `rt.state[key] = v`（**只写 rt.state、绝不写 rt.rootScope**，故打字不触发"保存到本地"脏标记）。
 - **读写约定**：运行态变量（含用户输入/绑定派生值）一律用 this.state 读、写走 this.setData；this.data 仅用于读 Input 绑定键的实时输入值；持久卡片态存 this.state；任何应重渲染的改动后调 this.setData(...)。**调试交互绝不调 setRootData**——否则会污染"保存到本地"基线。
 - **事件代码必须 `var self = this` 起手（指针安全铁律）**：每个 customAction 的 `function.code` / `compiled` **第一行**写 `var self = this;`。**任何嵌套函数（addEventListener 回调、`Array.map/forEach/find` 回调、setTimeout、ynet.callJSAPI 回调等）里访问组件实例一律用 `self`，禁止用 `this`**——`this` 在回调里会被运行时重绑（指向全局 / 事件源 / undefined），直接 `this.setData` 会指向错误对象，导致静默失效或 `this is undefined` 报错。顶层（非嵌套）直接调用可用 `this`，但统一用 `self` 最稳、零歧义。**生成事件代码默认就按此写，不要等出错再改。** export-proven：holdFinancialProducts 根 `onReady` 写 `var self = this; ... this.addEventListener('globalSet', (e) => self.$set(e.data.key, e.data.value))`；recipes.md §4 / §7 同构。
-- **List/Grid item 事件改绑定数据必须 globalSet 透传（铁律）**：ListLayout/GridLayout 的 item（slotScope）事件里禁止直接改绑定数据（this.setData/setRootData/直接 state 赋值）——必须 `this.postMessage('globalSet', patch)`（patch 与 setData 入参逐字一致），并先在根节点 onReady `addEventListener('globalSet')` 注册监听、监听里用闭包 self 代 `setData(patch)`；其他节点事件可直接 setData。lint `r54` ERROR 拦截「item 直改」与「用 globalSet 但根无监听」。固定范式见 recipes.md §4 / recipe_snippets/globalSet.json。
+- **List/Grid item 事件改绑定数据必须 globalSet 透传（铁律）**：ListLayout/GridLayout 的 item（slotScope）事件里禁止直接改绑定数据（this.setData/setRootData/直接 state 赋值）——必须 `this.postMessage('globalSet', patch)`（patch 与 setData 入参逐字一致），并先在根节点 onReady `addEventListener('globalSet')` 注册监听、监听里用闭包 self 代 `setData(patch)`；其他节点事件可直接 setData。lint `r54` ERROR 拦截「item 直改」与「用 globalSet 但根无监听」；判定覆盖 item 模板（`slotScope`）子树内的**所有节点**（不止 item 根），`that` / `self` / `_this` 别名与 `this` 等价计入。固定范式见 recipes.md §4 / recipe_snippets/globalSet.json。
 - **slotScope item 字段在事件脚本里直读（铁律 r55）**：slotScope:true 的 List/Grid item 事件脚本里，当前 item 字段**直接 `this.state.<field>` 读取**（如 `var q = this.state.query;`）——作用域展开是平台保证，**不是**需要兜底判断的不确定行为；禁止写 `if (x === undefined && this.state.$$)` 之类的「$$ 兜底」。事件脚本（customAction）里**禁止出现任何 `$$`**（含 `this.state.$$`、`$$.field`）；`$$` 只在**表达式**里引用整个 item 时才允许（R50 另管 `$$.field` 冗余）。lint `r55-event-no-dollar-dollar` ERROR 拦截。
 - **调 JSAPI 直接裸调 ynet（铁律 r56）**：事件脚本里调 JSAPI 一律 `ynet.callJSAPI(name, params, cb)`——ynet 由平台注入为全局；**禁止 `window.ynet` 前缀**，也**禁止 `typeof window !== 'undefined' && window.ynet && window.ynet.callJSAPI` 之类存在性守卫**（把平台保证误当不确定行为的冗余错写；49 张导出卡全量裸调为证）。lint `r56-jsapi-no-window-guard` ERROR 拦截。
 - **生成代码必须严格带 `;`（语句结束符不省略）**：customAction 的 `function.code` / `compiled` 里**每条 JS 语句结尾都要写分号，禁止依赖 ASI（自动分号插入）省略**。`return` / 换行 / 对象字面量 / 数组字面量等场景省略分号会触发 ASI 陷阱（如 `return\n{...}` 被解析成 `return;` 直接返回 undefined）；且导出卡（49+ 卡 `compiled` 全量带分号）风格不一致会让 `diff_card.mjs` 更难比对。**生成时默认每条语句结尾补 `;`，不要"省着写"。** export-proven：holdFinancialProducts / creditCardBill 等所有导出卡 `compiled` 均全量带分号。

package/dist/vendored/skills/dsl-card-generator/scripts/lint_card.mjs

@@ -101,11 +101,25 @@ Options:
 /* ------------------------------------------------------------------ */
 /* 节点遍历                                                            */
 /* ------------------------------------------------------------------ */
-function walk(node, visitor, parent = null) {
+/**
+ * slot.slotScope 判定：正常是布尔 true，但存量卡里有 2 处写成字符串 'true'，一并兼容
+ */
+function isSlotScope(slot) {
+  const v = (slot || {}).slotScope
+  return v === true || v === 'true'
+}
+
+/**
+ * @param {object} node
+ * @param {(node:object, parent:object|null, inSlotScope:boolean)=>void} visitor
+ * @param {object|null} parent 父节点（实参传递，不往 schema 上挂字段，避免污染 JSON.stringify）
+ * @param {boolean} inSlotScope 是否位于 ListLayout/GridLayout 的 item 模板（slot.slotScope === true）子树内
+ */
+function walk(node, visitor, parent = null, inSlotScope = false) {
   if (!node || typeof node !== 'object') return
-  visitor(node, parent)
-  if (Array.isArray(node.components)) for (const c of node.components) walk(c, visitor, node)
-  for (const s of node.slots || []) for (const c of s.components || []) walk(c, visitor, node)
+  visitor(node, parent, inSlotScope)
+  if (Array.isArray(node.components)) for (const c of node.components) walk(c, visitor, node, inSlotScope)
+  for (const s of node.slots || []) for (const c of s.components || []) walk(c, visitor, node, inSlotScope || isSlotScope(s))
 }
 
 /** 获取默认插槽直接子节点（兼容 Root.components 与普通节点 slots[0].components） */
@@ -1329,13 +1343,14 @@ export function lint(schema, data) {
     const f = fn.find((x) => x.itemKey === 'function') || {}
     return String((f.itemValue || {}).code || (f.itemValue || {}).compiled || '')
   }
-  const MUTATE_RE = /this\.(setData|setRootData)\(|this\.(state|data)\.[\w$.]+\s*=[^=]/
-  walk(view, (n, parent) => {
-    let scoped = false
-    for (let cur = n; cur; cur = cur.__lintParent) {
-      if (cur.__lintSlotScope) { scoped = true; break }
-    }
-    if (!scoped) return
+  // 别名与 collectBindings 保持一致：脚本里常用 that/self/_this 承接 this（部分由低代码编译器生成）
+  const ALIAS = '(?:this|self|that|_this)'
+  const MUTATE_RE = new RegExp(
+    `\\b${ALIAS}\\s*\\.\\s*(?:setData|setRootData)\\s*\\(`
+    + `|\\b${ALIAS}\\s*\\.\\s*(?:state|data)(?:\\.[\\w$]+)+\\s*=[^=]`,
+  )
+  walk(view, (n, parent, inSlotScope) => {
+    if (!inSlotScope) return
     if (n.className === 'ListLayout' || n.className === 'GridLayout') return
     const cid = n.componentId || '(root)'
     for (const ea of n.eventactions || []) {
@@ -1350,7 +1365,7 @@ export function lint(schema, data) {
         })
       }
     }
-  }, true)
+  })
   // R54-b: 用了 globalSet 透传但根节点 onReady 没注册监听 → 消息石沉大海
   const allCode = []
   let rootOnReadyCode = ''

package/dist/vendored/skills/platform-card-sync/scripts/api_batch_sync.mjs

@@ -1,4 +1,4 @@
-import { mkdir, stat, writeFile, readFile, readdir } from 'node:fs/promises';
+import { mkdir, stat, writeFile, readdir, rm } from 'node:fs/promises';
 import { createHash } from 'node:crypto';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
@@ -208,8 +208,9 @@ export async function syncCards(opts = {}) {
   const session = await ensurePlatformSession();
   const browser = session.browser;
   const summary = { success: true, synced: [], failed: [], duplicates: [] };
-  // 重复 schema 检测：记录每张卡 schema 的 MD5，若不同 code 命中相同 schema 说明抓取仍串卡。
-  const schemaHashes = new Map();
+  // duplicates 保留为空数组仅为兼容既有结果结构（前端 / CLI 都读这个字段）。
+  // 不再按「不同卡拿到字节相同的 schema」判串卡：同模板创建、内容清空、空白骨架
+  // 都会产生相同 schema，属合法状态；内容相似度推不出「抓错了卡」。
 
   try {
     const context = browser.contexts()[0];
@@ -247,12 +248,11 @@ export async function syncCards(opts = {}) {
         if (cardCodeSet && !cardCodeSet.has(card.id)) continue;
         log.info('同步中', { page: `${pageNo}/${totalPages}`, index, id: card.id, title: card.title });
         try {
-          const files = await syncCard(page, card, { outRoot, appId, workspaceId, summary, schemaHashes, importMeta });
+          const files = await syncCard(page, card, { outRoot, appId, workspaceId, importMeta });
           // 空白卡不算失败，但要在结果里显式标记，避免与「抓到完整 schema」混为一谈。
           summary.synced.push({
             page: pageNo, index, id: card.id, title: card.title, files,
             blank: !!files.blank,
-            keptLocal: !!files.keptLocal,
           });
         } catch (error) {
           summary.success = false;
@@ -1691,9 +1691,10 @@ async function fetchCardSchema(page, card, { appId, workspaceId }) {
     log.warn('远端响应体为空，按空白卡处理', { id: card.id, cardId: card.cardId });
     return null;
   }
-  // 防串卡：服务端会回显 cardId，与请求不一致说明拿到了别的卡片，宁可失败也不写盘。
+  // 抓错卡的唯一直接证据：服务端回显的主键必须等于本次请求主键。
+  // 这是主键级校验，保留为硬闸；内容相似、pageId 缺失等都不构成「串卡」证据。
   if (body.cardId && String(body.cardId) !== String(card.cardId)) {
-    throw new Error(`${card.id} 响应 cardId=${body.cardId} 与请求 cardId=${card.cardId} 不一致，已中止以防串卡。`);
+    throw new Error(`${card.id} 响应主键不匹配：请求 cardId=${card.cardId}，响应 cardId=${body.cardId}，已中止本卡落盘`);
   }
   if (!body.schemaValue) {
     log.warn('远端无 schemaValue，判定为空白卡', { id: card.id, cardId: card.cardId });
@@ -1827,92 +1828,117 @@ function filestoreToUrl(value) {
   return platformConfig.filestoreUrl(value);
 }
 
-async function syncCard(page, card, { outRoot, appId, workspaceId, summary, schemaHashes, importMeta }) {
+/**
+ * 全量覆盖：同步 = 用远端状态重建整张卡，先清空卡目录内的既有产物再写入。
+ *
+ * 旧实现会「保留本地 schema/data、只改 pageId 一个字段」、本地已有封面就跳过下载，
+ * 目录里的旧封面、旧侧车、多余文件也从不清理 —— 那不是覆盖，是打补丁。
+ * 现在除 .history（本地编辑历史，唯一恢复点）外的所有条目一律删除：
+ * schema.json / data.json / 所有封面 / .import-meta.json / 其它残留
+ * 都会由本次远端数据重新生成，不继承任何本地状态。
+ *
+ * 调用时机必须在 fetchCardSchema 成功之后：远端数据没到手就清目录，
+ * 一次网络失败会把本地卡毁成空目录。
+ *
+ * @returns {Promise<number>} 被清除的条目数
+ */
+export async function resetCardDir(cardDir) {
+  const entries = await readdir(cardDir, { withFileTypes: true }).catch(() => []);
+  let removed = 0;
+  for (const entry of entries) {
+    if (entry.name === '.history') continue;
+    await rm(path.join(cardDir, entry.name), { recursive: true, force: true });
+    removed++;
+  }
+  return removed;
+}
+
+/**
+ * 同步落盘：把 schema.pageId 规范为本次列表给出的 cardId。
+ *
+ * 这不是「只改一个字段」的补丁：卡片目录已由 resetCardDir 全量重建，
+ * 此处处理的是远端数据自身的问题 —— IDC10012 返回的 schemaValue 里可能带着
+ * 模板或旧实例的 pageId（实测 creditCardPayment：schema.pageId=10000818，
+ * 而 IDC10001 列表 cardId=10000874）。保存链路 saveCardToRemote 用 schema.pageId
+ * 作为 IDC10010 的 body.cardId，推送闸门 server/core/cardSave.js 又要求它等于
+ * 侧车 cardId；留着旧值会让这张卡永远推不上去（409 pageId_mismatch）。
+ * 因此以「这张卡本次的身份」即列表 cardId 为准，与 buildBlankSchema 一致。
+ *
+ * 抓错卡的判定不使用本函数：唯一主键级证据是 fetchCardSchema 里
+ *「IDC10012 回显 cardId ≠ 请求 cardId」，内容相似与 pageId 差异都不构成串卡证据。
+ *
+ * @returns {{rewritten:boolean, from:string, to:string}}
+ */
+export function alignSchemaPageId(schema, card) {
+  const from = schema.pageId == null ? '' : String(schema.pageId).trim();
+  const cardId = card.cardId == null ? '' : String(card.cardId).trim();
+  if (!cardId || from === cardId) return { rewritten: false, from, to: from };
+  schema.pageId = cardId;
+  return { rewritten: true, from, to: cardId };
+}
+
+async function syncCard(page, card, { outRoot, appId, workspaceId, importMeta }) {
   const cardDir = path.join(outRoot, card.id);
   await mkdir(cardDir, { recursive: true });
   const schema = await fetchCardSchema(page, card, { appId, workspaceId });
-  // 空白卡（远端从未保存过 schema）：合法状态，走专门的落盘分支，不再整批失败。
+  // 全量覆盖：远端数据到手后才重建目录（拉取失败时本地卡片保持原样）。
+  await resetCardDir(cardDir);
+  // 空白卡（远端从未保存过 schema）：合法状态，同样按远端状态全量重建。
   if (!schema) {
     return syncBlankCard(page, card, { cardDir, appId, workspaceId, importMeta });
   }
-  // 推送前一致性闸门（基于实测不变量：IDC10001 列表 cardId ≡ schema 内 pageId）。
-  // 若二者不等，说明抓取的 schema 与该实例错位（串卡 / 模板错挂），落盘后推送会按错 pageId 打错卡。
-  // 直接抛错由调用方记入 failed 并中止本卡落盘，避免错位 pageId 进入本地与远端。
-  if (card.cardId != null && String(schema.pageId) !== String(card.cardId)) {
-    throw new Error(`${card.id} pageId 错位：列表 cardId=${card.cardId} ≠ schema.pageId=${schema.pageId}，疑似串卡，已拒绝落盘`);
-  }
-  const coverPath = await saveCover(page, card, cardDir);
-  // 注意：schema 内部的 pageId 一律以「远端拉取」的为准，原样落盘，不做覆盖。
-  // 远端返回的 pageId 是远端编辑器维护的权威页面/模板 ID，落盘后随 schema 一并保留，
-  // 供保存（IDC10010）/预览（IDC10015/10020/10021）链路按此主键打到线上。
-  // 重复 schema 检测：若不同 code 抓到了字节完全相同的 schema，说明仍串卡，
-  // 记录到 duplicates 并把整体结果标为失败，便于重抓时立即发现而非事后排查。
-  const schemaHash = createHash('md5').update(JSON.stringify(schema)).digest('hex');
-  const dupOf = schemaHashes.get(schemaHash);
-  if (dupOf && dupOf !== card.id) {
-    summary.duplicates.push({ id: card.id, dupOf, hash: schemaHash.slice(0, 8) });
-    summary.success = false;
-    log.warn('检测到重复 schema（疑似串卡）', { id: card.id, dupOf, hash: schemaHash.slice(0, 8) });
+  // 目录已重建，这里处理的是远端数据自带的旧实例 pageId（详见函数注释）。
+  const { rewritten, from, to } = alignSchemaPageId(schema, card);
+  if (rewritten) {
+    log.info('schema.pageId 已按列表 cardId 规范', { id: card.id, from: from || '(空)', to });
   }
-  schemaHashes.set(schemaHash, card.id);
+  // 先写核心文件，再取封面：封面下载失败不至于把卡目录留成空壳。
   const schemaPath = path.join(cardDir, 'schema.json');
   await writeFile(schemaPath, JSON.stringify(schema, null, 2), 'utf8');
   const dataPath = path.join(cardDir, 'data.json');
   await writeFile(dataPath, JSON.stringify(buildDataFromSchema(schema), null, 2), 'utf8');
-  const [cover, schemaInfo, data] = await Promise.all([
-    stat(coverPath), stat(schemaPath), stat(dataPath),
+  let coverPath = null;
+  if (card.coverUrl) {
+    try {
+      coverPath = await saveCover(page, card, cardDir);
+    } catch (e) {
+      log.warn('预览图下载失败（不影响卡片全量覆盖落盘）', { id: card.id, error: String(e && e.message) });
+    }
+  }
+  const [schemaInfo, data, cover] = await Promise.all([
+    stat(schemaPath), stat(dataPath), coverPath ? stat(coverPath).catch(() => null) : Promise.resolve(null),
   ]);
   await writeImportSidecar(cardDir, {
     appId,
     workspaceId,
     card,
     importMeta,
-    files: { schema: schemaInfo.size, data: data.size, cover: cover.size },
+    files: { schema: schemaInfo.size, data: data.size, cover: cover ? cover.size : 0 },
   });
-  return { cover: cover.size, schema: schemaInfo.size, data: data.size };
+  return { cover: cover ? cover.size : 0, schema: schemaInfo.size, data: data.size };
 }
 
 /**
  * 空白卡落盘：远端从未保存过 schema（IDC10012 无 schemaValue），但卡片实例真实存在。
- * 规则（用户确认）：
- *   1) 本地已有同名卡片 → 以本地 schema.json / data.json 为准，远端空白绝不覆盖；
- *   2) 本地已有同名预览图 → 跳过下载；否则照常同步；
- *   3) pageId 必须与远端列表返回的 cardId 一致（保存 IDC10010 / 预览 10015·10020·10021
- *      全链路按这个数字主键定位线上卡片，错位会打到别的卡上）。
- * 本地无任何卡片时，落一份最小合法空白 schema，保证目录可被编辑器/预览正常加载。
+ * 全量覆盖语义：目录已由 resetCardDir 清空，这里不读本地、不保留任何旧内容，
+ * 直接按远端状态落一份最小合法空白 schema + 空 data，pageId 取列表 cardId
+ * （保存 IDC10010 / 预览 10015·10020·10021 全链路按这个数字主键定位线上卡片）。
+ * 远端「空白」就是本地「空白」，不再拿本地旧卡去填。
  */
 async function syncBlankCard(page, card, { cardDir, appId, workspaceId, importMeta }) {
   const schemaPath = path.join(cardDir, 'schema.json');
   const dataPath = path.join(cardDir, 'data.json');
-  const localSchema = await readJsonIfValid(schemaPath);
-  const localData = await readJsonIfValid(dataPath);
-  const keptLocal = !!localSchema;
-
-  // 本地有实体卡片：保留本地内容；否则建最小空白骨架。
-  const schema = localSchema || buildBlankSchema(card);
-  const data = localData || (keptLocal ? buildDataFromSchema(schema) : {});
-
-  // pageId 对齐远端 cardId：只改这一个字段，其余本地内容原样保留。
-  const pageIdRewritten = String(schema.pageId ?? '') !== String(card.cardId);
-  if (pageIdRewritten) schema.pageId = String(card.cardId);
-
-  if (!keptLocal || pageIdRewritten) {
-    await writeFile(schemaPath, JSON.stringify(schema, null, 2), 'utf8');
-  }
-  if (!localData) {
-    await writeFile(dataPath, JSON.stringify(data, null, 2), 'utf8');
-  }
+  const schema = buildBlankSchema(card);
+  await writeFile(schemaPath, JSON.stringify(schema, null, 2), 'utf8');
+  await writeFile(dataPath, JSON.stringify({}, null, 2), 'utf8');
 
-  // 预览图：本地已有同名图则跳过，否则下载（无可用图源时静默跳过，不算失败）。
-  let coverPath = await findExistingCover(cardDir, card.id);
-  let coverSkipped = !!coverPath;
-  let coverError = '';
-  if (!coverPath && card.coverUrl) {
+  // 预览图一律按远端重新下载；无图源或下载失败不阻断卡片落盘。
+  let coverPath = null;
+  if (card.coverUrl) {
     try {
       coverPath = await saveCover(page, card, cardDir);
     } catch (e) {
-      coverError = String(e && e.message);
-      log.warn('空白卡预览图同步失败（不影响卡片落盘）', { id: card.id, error: coverError });
+      log.warn('空白卡预览图同步失败（不影响卡片落盘）', { id: card.id, error: String(e && e.message) });
     }
   }
 
@@ -1931,10 +1957,6 @@ async function syncBlankCard(page, card, { cardDir, appId, workspaceId, importMe
     schema: schemaInfo.size,
     data: dataInfo.size,
     blank: true,
-    keptLocal,
-    pageIdRewritten,
-    coverSkipped,
-    coverError,
   };
 }
 
@@ -2002,32 +2024,6 @@ function buildBlankSchema(card) {
   };
 }
 
-/** 读本地 JSON；文件不存在或解析失败返回 null（不抛，交给调用方决定降级策略）。 */
-async function readJsonIfValid(filePath) {
-  try {
-    return JSON.parse(await readFile(filePath, 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-const IMAGE_EXTS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.svg']);
-
-/** 找本地已有的同名预览图（<cardId>.<ext>）；没有返回 null。 */
-async function findExistingCover(cardDir, id) {
-  let entries = [];
-  try {
-    entries = await readdir(cardDir);
-  } catch {
-    return null;
-  }
-  for (const name of entries) {
-    const ext = path.extname(name).toLowerCase();
-    if (IMAGE_EXTS.has(ext) && path.basename(name, ext) === id) return path.join(cardDir, name);
-  }
-  return null;
-}
-
 /**
  * 导入来源可追溯（Phase E）：把这张卡从哪来 / 何时导入 / 落盘在哪写进侧车 .import-meta.json。
  * 侧车独立于 schema.json/data.json，绝不污染 DSL 产品数据；找不到 server 模块时静默跳过。
@@ -2137,9 +2133,8 @@ if (isMain) {
       `已同步：${summary.synced.length} 张`,
       `失败：${summary.failed.length} 张`,
       `空白卡片：${blanks.length} 张`,
-      `重复 schema：${summary.duplicates.length} 项`,
       ...(blanks.length
-        ? [`空白明细：${blanks.map((b) => `${b.id}${b.keptLocal ? '(保留本地)' : '(新建空白)'}`).join('、')}`]
+        ? [`空白明细：${blanks.map((b) => `${b.id}(按远端重建空白)`).join('、')}`]
         : []),
       ...(summary.failed.length
         ? [`失败明细：${summary.failed.map((f) => f.id || '(unknown)').join('、')}`]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cardbuddy",
-  "version": "0.26.0",
+  "version": "0.26.2",
   "description": "Local dev service for the CardBuddy card editor — decouples card CRUD (sync/save/validate/render-status/screenshot) from the static public editor, so the editor can be deployed to any static host while each developer runs a local service against their own card source.",
   "type": "module",
   "bin": {