cardbuddy 0.17.0 → 0.19.0

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

@@ -127,6 +127,25 @@ export function recordExport(dir, verified) {
   return next
 }
 
+/**
+ * 记录一次远端最新版本号（「卡片来源」tab 展示用，并由发布/拉取/拉取全部后持久化）。
+ * 与 recordExport 正交：recordExport 记录本地保存读回校验，本函数记录线上当前最高版本（IDC10004 maxVersion）。
+ * 无侧车（本地新建卡）时静默跳过。
+ * @param {string} dir  卡片目录
+ * @param {string|number|null} version  远端最新版本号；null 表示清除
+ */
+export function recordRemoteVersion(dir, version) {
+  const meta = readImportMeta(dir)
+  if (!meta) return null
+  const next = {
+    ...meta,
+    remoteVersion: version == null ? null : String(version),
+    remoteVersionAt: new Date().toISOString(),
+  }
+  writeImportMeta(dir, next)
+  return next
+}
+
 /**
  * dev server 中间件：GET /__import-meta/:id 暴露导入来源元数据（供 UI「来源」tab / AI skill 读取）。
  * 纯只读、no-store。

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

@@ -0,0 +1,100 @@
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { assertRemoteSource } from './cardSidecar.js'
+import { checkPushAllowed } from './cardListCache.js'
+import { log } from './logger.js'
+import { resolveSkillPathOrProject } from './skillPaths.js'
+
+/**
+ * finmall-card-sync 的批量同步脚本（发布复用），相对 skills/
+ * 与 cardSync.js 同款定位：发布只用到其中的 publishCard。
+ */
+const SYNC_SCRIPT_REL = 'finmall-card-sync/scripts/api_batch_sync.mjs'
+
+/**
+ * 顶栏「远端 → 卡片发布」的服务端处理：取远端最大版本号 +1 后发布上线（IDC10004 → IDC10016）。
+ * 复用 finmall-card-sync 的 publishCard（与「同步」「保存远端」「预览」共用同一后台 FinMall 会话）。
+ *
+ * 安全闸（与 /__preview 一致）：
+ *   - assertRemoteSource：本地自建、无 .import-meta.json 侧车的卡一律禁止发布，
+ *     避免把测试数据误发布到 FinMall 服务器。
+ *   - checkPushAllowed：卡片须存在于远端列表缓存（全量同步时刷新）；缓存为空（尚未同步）则放行。
+ *
+ * @param {{ root: string }} opts
+ * @returns {(req: import('http').IncomingMessage, res: import('http').ServerResponse, next: Function) => void}
+ */
+export function createPublishMiddleware({ root }) {
+  return function publishMiddleware(req, res, next) {
+    const pathname = decodeURIComponent((req.url || '').split('?')[0])
+    if (pathname !== '/__publish') return next()
+    if ((req.method || 'GET').toUpperCase() !== 'POST') return next()
+
+    let body = ''
+    req.setEncoding('utf8')
+    req.on('data', (c) => {
+      body += c
+      if (body.length > 4 * 1024 * 1024) req.destroy()
+    })
+    req.on('end', async () => {
+      let payload
+      try {
+        payload = JSON.parse(body || '{}')
+      } catch (e) {
+        res.statusCode = 400
+        res.setHeader('Content-Type', 'application/json')
+        return res.end(JSON.stringify({ error: 'invalid json', message: String(e.message) }))
+      }
+      if (!payload.schema || !payload.schema.pageId) {
+        res.statusCode = 400
+        res.setHeader('Content-Type', 'application/json')
+        return res.end(JSON.stringify({ error: 'missing schema.pageId', message: '需传入当前卡片 schema（含 pageId）' }))
+      }
+      // 远端来源硬闸：本地自建卡禁止发布（与 /__preview 同源）。
+      {
+        const src = assertRemoteSource(root, { pageId: payload.schema.pageId })
+        if (!src.ok) {
+          res.statusCode = 409
+          res.setHeader('Content-Type', 'application/json')
+          return res.end(JSON.stringify({ ok: false, error: 'local_card_no_source', message: src.reason }))
+        }
+      }
+      // 存在性闸门：发布前确认目标卡片在远端卡片列表缓存中（为空说明尚未同步，放行）。
+      {
+        const allow = checkPushAllowed(payload.schema.pageId)
+        if (!allow.allowed) {
+          res.statusCode = 409
+          res.setHeader('Content-Type', 'application/json')
+          return res.end(JSON.stringify({ ok: false, error: 'card_not_in_list', message: allow.reason }))
+        }
+      }
+      try {
+        const skillPath = resolveSkillPathOrProject(root, SYNC_SCRIPT_REL)
+        const { publishCard } = await import(pathToFileURL(skillPath).href)
+        const result = await publishCard(payload.schema)
+        log.ok('卡片发布完成', { cardId: payload.schema.pageId, nextVersion: result.nextVersion })
+        res.statusCode = 200
+        res.setHeader('Content-Type', 'application/json')
+        return res.end(JSON.stringify({ ok: true, maxVersion: result.maxVersion, nextVersion: result.nextVersion }))
+      } catch (e) {
+        log.error('卡片发布失败', e)
+        // 区分「凭据缺失」与「真正的发布错误」：前者让前端弹登录表单，而非裸抛 ENOENT。
+        const isNoCred =
+          e &&
+          /credentials\.json|credentials 不存在|NO_CREDENTIALS/.test(String(e && e.message))
+        res.statusCode = isNoCred ? 200 : 500
+        res.setHeader('Content-Type', 'application/json')
+        return res.end(
+          JSON.stringify(
+            isNoCred
+              ? {
+                  error: 'need_credentials',
+                  needCredentials: true,
+                  message: String(e && e.message),
+                }
+              : { error: 'publish failed', message: String(e && e.message) },
+          ),
+        )
+      }
+    })
+  }
+}

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

@@ -4,7 +4,7 @@ import { pathToFileURL } from 'node:url'
 import { fileURLToPath } from 'node:url'
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 
-import { recordExport } from './cardImportMeta.js'
+import { recordExport, markDirty } from './cardImportMeta.js'
 import { checkPushAllowed } from './cardListCache.js'
 import { assertRemoteSource, findCardDir } from './cardSidecar.js'
 import { log } from './logger.js'
@@ -107,8 +107,13 @@ export function createSaveMiddleware({ root }) {
         if (root) {
           try {
             const dir = findCardDir(root, { pageId: schema.pageId })
-            if (dir) await recordExport(dir, verified)
-            else console.warn(`[__save] 未找到 pageId=${schema.pageId} 对应的本地卡片目录，跳过导出元数据`)
+            if (dir) {
+              await recordExport(dir, verified)
+              // 推送成功即与远端对齐：清除「偏离导入镜像」标记（来源 tab 据此提示）。
+              // 注：本地磁盘（含编辑）仍可能 ≠ 当初导入镜像，此处语义转为「已与远端同步」，
+              // 符合用户预期——推送到远端后不应再被标为「偏离」。
+              await markDirty(dir, false)
+            } else console.warn(`[__save] 未找到 pageId=${schema.pageId} 对应的本地卡片目录，跳过导出元数据`)
           } catch (e) {
             log.warn('写导出元数据失败（不影响保存结果）', { error: e && e.message })
           }

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

@@ -0,0 +1,93 @@
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { findCardDir } from './cardSidecar.js'
+import { readImportMeta, recordRemoteVersion } from './cardImportMeta.js'
+import { log } from './logger.js'
+import { resolveSkillPathOrProject } from './skillPaths.js'
+
+const SYNC_SCRIPT_REL = 'finmall-card-sync/scripts/api_batch_sync.mjs'
+
+/**
+ * 调试面板「卡片来源」tab 的远端最新版本持久化（POST，fetch + persist）：POST /__card-version/:id
+ *
+ * 语义：
+ *   - body 带 { version }：直接把该版本号写入 .import-meta.json（如发布后已知 nextVersion），不再远端查询。
+ *   - 否则：实时查询 IDC10004 的 maxVersion（线上当前最高版本），写入 .import-meta.json 后返回。
+ *
+ * 触发时机由前端控制，不再在打开来源 tab 时自动查询（避免每次切 tab 都拉起后台 Chrome）：
+ *   - 卡片发布（doPublish 成功，带 nextVersion）
+ *   - 拉取 / 拉取全部（runSync 成功，实时查询）
+ *   - 用户在来源 tab 点「刷新」（主动触发，实时查询）
+ *
+ * 安全闸（与 /__publish 同源）：仅「已同步导入卡」（有 .import-meta.json 侧车且含 cardId）可写；
+ * 本地自建卡 / 未同步卡返回 409 local_card_no_source。
+ *
+ * @param {{ root: string }} opts
+ * @returns {(req: import('http').IncomingMessage, res: import('http').ServerResponse, next: Function) => void}
+ */
+export function createCardVersionMiddleware({ root }) {
+  return function cardVersionMiddleware(req, res, next) {
+    const pathname = decodeURIComponent((req.url || '').split('?')[0])
+    const m = pathname.match(/^\/__card-version\/([^/]+)$/)
+    if (!m) return next()
+    if ((req.method || 'GET').toUpperCase() !== 'POST') return next()
+
+    const id = decodeURIComponent(m[1])
+    const dir = findCardDir(root, { code: id })
+    const meta = dir ? readImportMeta(dir) : null
+    if (!meta || !meta.cardId) {
+      res.statusCode = 409
+      res.setHeader('Content-Type', 'application/json')
+      return res.end(
+        JSON.stringify({
+          ok: false,
+          error: 'local_card_no_source',
+          message: '该卡片为本地自建、无远端同步来源（缺少 .import-meta.json 侧车），无法记录远端版本。',
+        }),
+      )
+    }
+
+    // 解析请求体（允许空 / { version }）
+    let body = ''
+    req.setEncoding('utf8')
+    req.on('data', (c) => {
+      body += c
+      if (body.length > 64 * 1024) req.destroy()
+    })
+    req.on('end', async () => {
+      let payload = {}
+      try {
+        payload = JSON.parse(body || '{}')
+      } catch {
+        /* 空 / 非法体当作无 version */
+      }
+      try {
+        let maxVersion = payload.version != null ? String(payload.version) : null
+        if (maxVersion == null) {
+          // 未带版本号：实时查询 IDC10004 的 maxVersion
+          const skillPath = resolveSkillPathOrProject(root, SYNC_SCRIPT_REL)
+          const { fetchCardLatestVersion } = await import(pathToFileURL(skillPath).href)
+          const r = await fetchCardLatestVersion(meta.cardId)
+          maxVersion = r.maxVersion
+        }
+        recordRemoteVersion(dir, maxVersion)
+        log.ok('记录远端最新版本', { cardId: meta.cardId, maxVersion })
+        res.statusCode = 200
+        res.setHeader('Content-Type', 'application/json')
+        res.end(JSON.stringify({ ok: true, maxVersion }))
+      } catch (e) {
+        // 区分「凭据缺失」与「真正的查询错误」：前者让前端提示登录，而非裸抛 ENOENT。
+        const isNoCred = e && /credentials\.json|credentials 不存在|NO_CREDENTIALS/.test(String(e && e.message))
+        res.statusCode = isNoCred ? 200 : 500
+        res.setHeader('Content-Type', 'application/json')
+        res.end(
+          JSON.stringify(
+            isNoCred
+              ? { error: 'need_credentials', needCredentials: true, message: String(e && e.message) }
+              : { error: 'version persist failed', message: String(e && e.message) },
+          ),
+        )
+      }
+    })
+  }
+}

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

@@ -58,6 +58,46 @@ export function mergeServerTurn(chatDir, cardId, msg) {
   return writeHistory(chatDir, cardId, kept)
 }
 
+/**
+ * 浏览器 POST 整表时的「合并校对」：服务端已按 turnId 写过权威消息，这里只补浏览器独有的东西。
+ *
+ * 铁律：**已收尾的回合，服务端那份永远赢** —— 不是「客户端自认不是权威才丢」，而是
+ * 「只要盘上已有该 turnId 的权威消息，客户端同 turnId 的任何副本一律丢弃」。
+ *
+ * 为什么不能用 `!m.serverAuthored` 当条件（2026-10-09 实测修掉的缺陷）：
+ * 客户端 `revive()` 会把 `serverAuthored: true` 还原到内存消息上，`serialize()` 又原样写回。
+ * 于是浏览器 POST 上来的副本**也带着 serverAuthored=true**，旧条件
+ * `srvTurns.has(turnId) && !m.serverAuthored` 永远为假 → 副本被 `put()` 按 id 覆盖权威消息。
+ * 而 `serialize()` 是**有损白名单**（刻意剥掉 base64 截图 / 流式态），于是这次覆盖必然丢字段。
+ * 现场：greetingRecommend 第一回合 usage（缓存命中率）与 17 条 toolCall 的 truncated 全部消失，
+ * 摘要条退化成「未提供」、工具行不再显示截断提示。**服务端日志里数据是全的** ——
+ * 说明不是采集问题，是落盘被覆盖。
+ *
+ * @param {any[]} stored 已落盘的消息（服务端权威侧）
+ * @param {any[]} incoming 浏览器 POST 上来的整表
+ * @returns {any[]} 合并结果，按 ts 稳定排序
+ */
+export function mergeIncomingMessages(stored, incoming) {
+  const storedMsgs = Array.isArray(stored) ? stored : []
+  // 盘上已收尾的回合：这些 turnId 的任何浏览器副本都不许覆盖权威消息
+  const settled = new Set(storedMsgs.filter((m) => m && m.serverAuthored && m.turnId).map((m) => m.turnId))
+  const byId = new Map()
+  const anon = []
+  const put = (m) => {
+    if (!m || typeof m !== 'object') return
+    if (m.id) byId.set(m.id, m)
+    else anon.push(m)
+  }
+  for (const m of storedMsgs) put(m)
+  for (const m of Array.isArray(incoming) ? incoming : []) {
+    if (!m || typeof m !== 'object') continue
+    // 已收尾回合的客户端副本：无论它自称什么，一律丢掉（上面已说明为什么不能信它的标记）
+    if (m.role === 'assistant' && m.turnId && settled.has(m.turnId)) continue
+    put(m)
+  }
+  return [...byId.values(), ...anon].sort((x, y) => (Number(x.ts) || 0) - (Number(y.ts) || 0))
+}
+
 export function writeHistory(chatDir, cardId, messages) {
   const file = historyFile(chatDir, cardId)
   if (!file) return { ok: false, error: 'missing-card-id' }

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

@@ -11,6 +11,8 @@
  * 接收 viteServer 参数透传；无 SSR 需求的场景可传 null（这两个端点会返回明确错误）。
  */
 import { createSyncMiddleware, createPreviewMiddleware, createLoginCredentialsMiddleware } from './cardSync.js'
+import { createPublishMiddleware } from './cardPublish.js'
+import { createCardVersionMiddleware } from './cardVersion.js'
 import { createSliceUploadMiddleware } from './sliceUpload.js'
 import { createCardFilesMiddleware, refreshCardList } from './cardFiles.js'
 import { createSaveMiddleware } from './cardSave.js'
@@ -42,6 +44,8 @@ export {
   createSyncMiddleware,
   createPreviewMiddleware,
   createLoginCredentialsMiddleware,
+  createPublishMiddleware,
+  createCardVersionMiddleware,
   createSliceUploadMiddleware,
   createCardFilesMiddleware,
   createSaveMiddleware,
@@ -88,6 +92,12 @@ export function mountCoreMiddlewares(app, { root, viteServer = null, upstream =
   app.use(createSyncMiddleware({ root }))
   app.use(createPreviewMiddleware({ root }))
   app.use(createLoginCredentialsMiddleware({ root }))
+  // 卡片发布（顶栏「远端 → 卡片发布」）：取远端最大版本号 +1 后发布上线（IDC10004 → IDC10016），
+  // 复用 finmall-card-sync 的 publishCard，与同步/保存/预览共用同一后台 FinMall 会话。
+  app.use(createPublishMiddleware({ root }))
+  // 卡片来源 tab 的「远端最新版本」查询（只读）：GET /__card-version/:id 取 IDC10004 的 maxVersion，
+  // 复用 finmall-card-sync 的 fetchCardLatestVersion，与发布/同步/保存共用同一后台 FinMall 会话。
+  app.use(createCardVersionMiddleware({ root }))
   // 切图上传（顶栏「远端 → 切图上传」）：把当前卡引用的 src/slices 切图传到 FinMall 图片库，
   // 写 src/slices/manifest.json 映射并把卡片里的 /slices/ 引用改写为 @filestore/ 线上地址。
   // 仅在用户点击时触发，没有任何自动上传路径。

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

@@ -1164,6 +1164,140 @@ export function persistReport(result, { sp, dp, irPath, reset = false, design =
   }
 }
 
+/**
+ * 报告摘要：给 stdout（= 模型上下文）用，全文已在 persistReport 里落盘。
+ *
+ * 为什么必须摘要（2026-10-09 实测）：原版 `JSON.stringify(result, null, 2)` 把整份报告灌进上下文，
+ * 单轮 6~15KB，而模型每轮的决策依据只有「gate 过了没有 / match 多少 / 差在哪个节点」。
+ * 体积大头全在它不需要的东西上：
+ *   - `contributors.elements[]`：每个热区逐节点度量（rect/h/hSibling/designH/flags），
+ *     而提示词自己写着「一轮只改 contributors[0].elements[0]」—— 后面的热区本轮根本不看；
+ *   - `elements[]`（--elements 的逐元素实测）、`fidelity.missing[]`/`invented[]` 的全文清单：
+ *     门禁只判 `.length === 0`，逐条文案对「该不该改样式」没有增量信息；
+ *   - `geometry.collapsed[]`/`overWrapped[]` 全文、`lint.warningDetails`、`preflight.details`。
+ * 15 轮迭代 = 9~22 万字符常驻，且每轮都重发（宿主把历史工具结果原样带回）⇒ 上下文斜率被它单独拉高。
+ *
+ * 摘要必须保留的字段（S5 全部决策都基于这些，删一条就会「照着不存在的结论调像素」）：
+ *   ok / gate（含 checks.failed.verdict.stage）/ pixelDiff.match / pixelDiff.size.heightDelta
+ *   / best / stalled / rounds / conclusion / contributors[0] / structuralGaps
+ *   / contentOffset1x+hint / widthMismatch / geometry.counts / 各 errors 计数
+ *   / readiness / diffImage / renderImage / report（全文路径，供 --detail 或 fs_read 取全文）
+ *
+ * 削峰的边界（刻意保留的「第一条 + 计数」）：
+ *   - contributors 只留 [0]，其余热区只报个数；
+ *   - missing / invented / collapsed 等清单只留**前 3 条文本 + 总数**——
+ *     前几条往往就是漏得最刺眼的（最长文案 / 最显眼的标题），模型据此能定位；要看全量有 report 路径。
+ */
+export function summarizeReport(result) {
+  if (!result || typeof result !== 'object') return result
+  // 幂等：已封装的摘要原样放过。宿主侧会对旧版未封装的全量报告做兜底裁剪，
+  // 二次裁剪会把 {total,sample} 当数组处理、把内容清空 —— 这是「封装过就别再动」的硬约束。
+  if (result.summary === true) return result
+  const r = result
+  const pd = r.pixelDiff
+  /**
+   * 清单类字段：留前 3 条 + 总数（不是只留计数 —— 模型要靠具体文案判断漏了什么）。
+   * 容忍两种输入：数组（全量）与 {total,sample}（已封装）—— 后者原样返回。
+   */
+  const list = (arr, map = (x) => x) => {
+    if (arr && !Array.isArray(arr) && typeof arr === 'object') return arr.total != null || arr.sample ? arr : undefined
+    const a = Array.isArray(arr) ? arr : []
+    if (!a.length) return undefined
+    return { total: a.length, sample: a.slice(0, 3).map(map), more: a.length > 3 ? `…另 ${a.length - 3} 条（见 report 全文）` : undefined }
+  }
+
+  const out = {
+    ok: r.ok,
+    cardId: r.cardId,
+    // 全文落盘路径放第一行：模型要看被削掉的内容时有确定入口，不必重跑 --detail
+    report: r.report,
+    conclusion: r.conclusion,
+    rounds: r.rounds,
+    best: r.best,
+    stalled: r.stalled,
+    gate: r.gate,
+    iterationReset: r.iterationReset,
+    appliedSets: r.appliedSets,
+    validate: r.validate
+      ? { errors: r.validate.errors, warnings: r.validate.warnings, envError: r.validate.envError, details: r.validate.details }
+      : undefined,
+    lint: r.lint
+      ? {
+          errors: r.lint.errors,
+          warnings: r.lint.warnings,
+          infos: r.lint.infos,
+          details: r.lint.details,
+          warningDetails: r.lint.warningDetails,
+        }
+      : undefined,
+    preflight: r.preflight
+      ? { errors: r.preflight.errors, details: list(r.preflight.details, (d) => (typeof d === 'string' ? d : d?.message || JSON.stringify(d))) }
+      : undefined,
+    readiness: r.readiness,
+    widthMismatch: r.widthMismatch,
+    contentOffset1x: r.contentOffset1x,
+    contentOffsetHint: r.contentOffsetHint,
+    // 像素主体：只留决策要用的三件（match / 尺寸差 / 热区），inkBox / diffPixels / totalPixels 是中间量
+    pixelDiff: pd
+      ? {
+          match: pd.match,
+          diffRatio: pd.diffRatio,
+          size: pd.size,
+          contentOffset: pd.contentOffset,
+          structuralGaps: pd.structuralGaps,
+          // 热区本身已在 contributors 里归因过，这里只留坐标供「还有哪些区没归因」的自查
+          hotspots: Array.isArray(pd.hotspots) ? pd.hotspots.slice(0, 3) : pd.hotspots,
+          hotspotsTotal: Array.isArray(pd.hotspots) ? pd.hotspots.length : pd.hotspotsTotal,
+        }
+      : undefined,
+    structuralGaps: r.structuralGaps,
+    // 分项归因：只留首条热区（提示词钦定「一轮只改 contributors[0].elements[0]」），其余只报个数
+    contributors: Array.isArray(r.contributors) ? r.contributors.slice(0, 1) : r.contributors,
+    contributorsTotal: Array.isArray(r.contributors) ? r.contributors.length : r.contributorsTotal,
+    contributorsNote: r.contributorsNote,
+    geometry: r.geometry
+      ? {
+          counts: r.geometry.counts,
+          collapsed: list(r.geometry.collapsed),
+          outOfCard: list(r.geometry.outOfCard),
+          overWrapped: r.geometry.counts?.overWrapped != null ? undefined : list(r.geometry.overWrapped),
+        }
+      : undefined,
+    geometryNote: r.geometryNote,
+    fidelity: r.fidelity
+      ? {
+          total: r.fidelity.total,
+          matched: r.fidelity.matched,
+          missing: list(r.fidelity.missing),
+          invented: list(r.fidelity.invented),
+          slices: r.fidelity.slices,
+          symbols: r.fidelity.symbols,
+          shapes: r.fidelity.shapes,
+        }
+      : undefined,
+    render: r.render,
+    designImage: r.designImage,
+    diffImage: r.diffImage,
+    renderImage: r.renderImage,
+    diffImageNote: r.diffImageNote,
+    elapsedMs: r.elapsedMs,
+  }
+  if (r.error || r.message) {
+    out.error = r.error
+    out.message = r.message
+  }
+  // 被削掉的字段名写清楚：模型必须知道「摘要 ≠ 全量」，否则会把「没提到」误读成「不存在」
+  // fs_read 现在支持 offset 续读（尾巴会给下一段起点），所以「读全文」的正解是照着 offset 读到底，
+  // 而不是一遍 fs_read —— 一遍只拿得到一屏。
+  out.summaryNote =
+    '本报告为摘要（contributors 只留首条热区、要素/几何清单只留前 3 条 + 总数、逐元素度量已省略）；' +
+    '需要全量明细用 fs_read 读 report 路径（长报告会带下一段 offset，照抄续读），或重跑加 --detail。'
+  // 幂等标记：宿主侧（ai-chat.js）会对未封装的旧版全量报告做一次兜底裁剪，
+  // 见标记后它会原样放过 —— 否则二次裁剪会把已封装的 {total,sample} 当数组处理、把内容清空。
+  out.summary = true
+  return out
+}
+
 /* ── 核心管线 ──────────────────────────────────────────────── */
 async function runPipeline({ ir: irPath, out: outDir, design: designPath, width, session, alwaysDiffImage, withElements, sets, specPath, skipPreflight, slicesDir: slicesDirArg, reset: resetFlag, noReadiness: noReadinessArg }) {
   const t0 = performance.now()
@@ -1476,7 +1610,7 @@ async function runPipeline({ ir: irPath, out: outDir, design: designPath, width,
 
 /* ── CLI ───────────────────────────────────────────────────── */
 function parseArgs(argv) {
-  const out = { ir: '', out: '', design: '', width: 0, keepAlive: false, diffImage: false, elements: false, sets: [], spec: '', gate: false, id: '', skipPreflight: false, slicesDir: '', reset: false, noReadiness: false }
+  const out = { ir: '', out: '', design: '', width: 0, keepAlive: false, diffImage: false, elements: false, sets: [], spec: '', gate: false, id: '', skipPreflight: false, slicesDir: '', reset: false, noReadiness: false, detail: false }
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i]
     if (a === '--ir') out.ir = argv[++i] || ''
@@ -1488,6 +1622,8 @@ function parseArgs(argv) {
     else if (a === '--slices-dir') out.slicesDir = argv[++i] || ''
     else if (a === '--id') out.id = argv[++i] || ''
     else if (a === '--gate') out.gate = true
+    // stdout 默认只回摘要（省上下文）；--detail 才回全量报告（模型真要看逐元素度量时才加）
+    else if (a === '--detail') out.detail = true
     else if (a === '--no-preflight') out.skipPreflight = true
     // 逃生门：跳过 S4.9 内容就绪门禁（debug 用；正常流程**不该**用它）
     else if (a === '--no-readiness') out.noReadiness = true
@@ -1625,7 +1761,7 @@ async function main() {
   }
 
   if (!args.ir || !args.out) {
-    console.error('用法: node iterate.mjs --ir <IR.json> --out <cardDir> [--design <design.png>] [--width 343]')
+    console.error('用法: node iterate.mjs --ir <IR.json> --out <cardDir> [--design <design.png>] [--width 343] [--detail]')
     process.exit(1)
   }
 
@@ -1644,7 +1780,8 @@ async function main() {
     noReadiness: args.noReadiness,
   })
 
-  console.log(JSON.stringify(result, null, 2))
+  // 默认摘要：stdout = 模型上下文，全量报告已落盘在 report 字段指向的文件（见 summarizeReport 头注）
+  console.log(JSON.stringify(args.detail ? result : summarizeReport(result)))
   if (!result.ok) process.exit(1)
   // 门禁未达标不算脚本失败（报告照常回喂），但退出码要让调用方一眼看出没收敛
   if (result.gate && result.gate.passed === false) process.exitCode = 2

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

@@ -403,6 +403,107 @@ export async function previewCardRemote(schema, { skeletonScreen = '', publish =
   }
 }
 
+/**
+ * 远端发布：取当前卡片远端最大版本号 +1，发布上线为新版本。
+ * 链路（对齐 ubomp 发布流程，仅两步）：
+ *   1) IDC10004.do 取当前卡片最大版本号 maxVersion；
+ *   2) IDC10016.do 以 maxVersion+1 作为新版本号发布（发布的是远端「当前已保存」的卡片内容——
+ *      故发布前应先用「推送当前卡」把本地内容保存到远端，否则会发布陈旧内容）。
+ * 会话由 ensureFinMallSession 自动保证；与 saveCardToRemote / syncCards / previewCardRemote
+ * 共用同一套已登录后台 Chrome，命中会话/权限失效（BLEC0006 等）时自动清 session 重登重试一次。
+ *
+ * @param {object} schema 当前卡片 schema（需含 pageId）
+ * @returns {Promise<{maxVersion:string, nextVersion:string, response:object}>}
+ */
+export async function publishCard(schema) {
+  if (!schema || !schema.pageId) {
+    throw new Error('schema 缺少 pageId，无法确定要发布的卡片（IDC10016.do 需要 cardId）。')
+  }
+  const appId = finmallConfig.appId
+  const workspaceId = finmallConfig.workspaceId
+  const cardId = String(schema.pageId)
+  const session = await ensureFinMallSession()
+  const browser = session.browser
+  try {
+    const context = browser.contexts()[0]
+    const page = context?.pages().find((p) => p.url().includes('finmall.com')) || context?.pages()[0]
+    if (!page) throw new Error('未能在后台 Chrome 中找到 FinMall 页面，请先运行 finmall-session-navigator 登录。')
+    await page.bringToFront()
+
+    // 1) 取当前最大版本号
+    const maxResp = await finmallPostWithHeal(
+      page,
+      `/ubomp-web/IDC10004.do?sassAppId=${appId}&sassWorkspaceId=${workspaceId}`,
+      { cardId, pageNo: 1, pageSize: 1, sassAppId: appId, sassWorkspaceId: workspaceId },
+      'IDC10004.do',
+    )
+    const maxVersion = String(maxResp && maxResp.maxVersion != null ? maxResp.maxVersion : '0')
+    const maxNum = Number(maxVersion)
+    const nextVersion = String(Number.isFinite(maxNum) ? maxNum + 1 : 1)
+    log.info('发布前取最大版本', { cardId, maxVersion, nextVersion })
+
+    // 2) 以 maxVersion+1 发布（发布类型/平台等参数对齐 ubomp 发布弹窗的默认值）
+    const response = await finmallPostWithHeal(
+      page,
+      `/ubomp-web/IDC10016.do?sassAppId=${appId}&sassWorkspaceId=${workspaceId}`,
+      {
+        cardId,
+        version: nextVersion,
+        platformStatus: JSON.stringify(['iOS', 'Android', 'HarmonyOS']),
+        publishType: '2',
+        publishMode: '1',
+        whitelistIds: '',
+        realGreyEndtime: '',
+        greyNum: '1',
+        memo: '',
+        greyConfigInfo: '[]',
+        sassAppId: appId,
+        sassWorkspaceId: workspaceId,
+      },
+      'IDC10016.do',
+    )
+    log.ok('卡片发布完成', { cardId, nextVersion })
+    return { maxVersion, nextVersion, response }
+  } finally {
+    try { await browser.disconnect() } catch { /* ignore */ }
+  }
+}
+
+/**
+ * 取远端「当前卡片最新版本号」：IDC10004 返回 maxVersion（该卡线上已发布的最高版本）。
+ * 供 UI「卡片来源」tab 展示「远端最新版本」，让用户一眼看到线上当前版本。
+ * 只读、不发布；与 publishCard 共用同一后台 FinMall 会话（ensureFinMallSession + finmallPostWithHeal）。
+ * @param {string|number} cardId
+ * @returns {Promise<{ maxVersion: string }>}
+ */
+export async function fetchCardLatestVersion(cardId) {
+  if (cardId == null) {
+    throw new Error('缺少 cardId，无法查询远端版本（IDC10004.do 需要 cardId）。')
+  }
+  const appId = finmallConfig.appId
+  const workspaceId = finmallConfig.workspaceId
+  const id = String(cardId)
+  const session = await ensureFinMallSession()
+  const browser = session.browser
+  try {
+    const context = browser.contexts()[0]
+    const page = context?.pages().find((p) => p.url().includes('finmall.com')) || context?.pages()[0]
+    if (!page) throw new Error('未能在后台 Chrome 中找到 FinMall 页面，请先运行 finmall-session-navigator 登录。')
+    await page.bringToFront()
+    const maxResp = await finmallPostWithHeal(
+      page,
+      `/ubomp-web/IDC10004.do?sassAppId=${appId}&sassWorkspaceId=${workspaceId}`,
+      { cardId: id, pageNo: 1, pageSize: 1, sassAppId: appId, sassWorkspaceId: workspaceId },
+      'IDC10004.do',
+    )
+    const maxVersion = String(maxResp && maxResp.maxVersion != null ? maxResp.maxVersion : '0')
+    log.info('查询远端最新版本', { cardId: id, maxVersion })
+    return { maxVersion }
+  } finally {
+    try { await browser.disconnect() } catch { /* ignore */ }
+  }
+}
+
 // —— 保存落库校验辅助 ——
 
 /** 稳定序列化：对象键排序、带 id/key/className/name 的数组元素按该键排序，避免服务端字段重排导致指纹误判。 */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cardbuddy",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "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": {