@lark-apaas/coding-steering 0.1.38 → 0.1.39-alpha.20260824122813

package/steering/design-html/skills/pptx-style-extract/scripts/draft.py

@@ -5,22 +5,18 @@
 
 产出 <stage1-outdir>/l-out/：
     BRIEF.md          唯一必读简报：事实 + 草案依据 + 待判断清单
-    vision-group-*.jpg 候选图与所在页语境拼版
-    asset-vision-groups.json 候选来源、位置与预算索引
-    manifest.yaml / frontmatter.yaml / layout-controls.yaml / layouts.yaml / body.md
-                                                        判断单与坐标事实，可直接进 package.py
+    contact-sheet.png 候选图拼版（带编号，一次看完所有图）
+    manifest.yaml / frontmatter.yaml / layouts.yaml / body.md   四件草案，可直接进 package.py
 
 草案里所有数值都来自 extract.json；凡是需要「像人一样看」才能定的，写成 `TODO:` 行
 （package.py 见 TODO 即 FAIL），由 L 层改掉。
 """
 import argparse
 import copy
-import glob
 import json
 import os
 import re
 import shutil
-import subprocess
 import sys
 from collections import Counter, defaultdict
 
@@ -33,18 +29,7 @@ OPAQUE_ENOUGH = 128    # 能当背景的最低不透明度：低于半透明就
                        # 那是叠加装饰不是背景
 FILL_MANY = 5          # 「被大量当填充铺开」的次数下限，用于区分卡片底与偶发用色
 BG_CONTENT_CAP = 5     # 内容页背景收几张：再多消费端也挑不过来，超出的写进 TODO 交人取舍
-SHEET_BATCH = 12       # 每张联系表最多 12 个候选；候选不截断，超出就继续生成下一张
-CONTEXT_BATCH = 8      # 每张整页语境表最多 8 页；同页只渲染一次
-# 与 studio_server_faas 的批量 vision 图数预算保持一致。单页大组允许 1 张整页图 +
-# 9 张候选；多个小页合组时，所有整页图和候选图合计最多 5 张。
-SINGLE_PAGE_IMAGE_BUDGET = 10
-MULTI_PAGE_IMAGE_BUDGET = 5
-# Skill 侧的总输入上限：限制模型需要读取的拼版数量和总视觉图数，而不是偷偷截断
-# 中间产物。首页、尾页优先；其余超限候选在 gaps 中显式说明。
-VISUAL_PACK_CAP = 5
-VISUAL_INPUT_CAP = 30
-VISUAL_PREVIEW_MAX_EDGE = 1200
-VISUAL_JPEG_QUALITY = 82
+SHEET_CAP = 12         # 联系表展示上限；进包的资产不受它约束，一张都不截
 
 HERE = os.path.dirname(os.path.abspath(__file__))
 SKILL_ROOT = os.path.dirname(HERE)
@@ -613,13 +598,7 @@ def lh_of(t):
 
 # ---------------------------------------------------------------- 资产
 def probe_image(path):
-    info = {
-        'w': None,
-        'h': None,
-        'alpha_mean': None,
-        'near_blank': False,
-        'near_white_ratio': None,
-    }
+    info = {'w': None, 'h': None, 'alpha_mean': None, 'near_blank': False}
     try:
         from PIL import Image
     except Exception:
@@ -627,69 +606,15 @@ def probe_image(path):
     try:
         im = Image.open(path)
         info['w'], info['h'] = im.size
-        preview = im.convert('RGBA').resize((64, 64))
-        pixels = (preview.get_flattened_data()
-                  if hasattr(preview, 'get_flattened_data') else preview.getdata())
-        px = list(pixels)
-        alpha = [item[3] for item in px]
         if im.mode in ('RGBA', 'LA') or 'transparency' in im.info:
-            info['alpha_mean'] = sum(alpha) / len(alpha)
+            px = im.convert('RGBA').getchannel('A').resize((64, 64)).tobytes()
+            info['alpha_mean'] = sum(px) / len(px)
             info['near_blank'] = info['alpha_mean'] < 13  # <5% 不透明度
-        visible = [item for item in px if item[3] >= 32]
-        if visible:
-            near_white = [item for item in visible
-                          if item[0] >= 235 and item[1] >= 235 and item[2] >= 235]
-            info['near_white_ratio'] = round(len(near_white) / float(len(visible)), 3)
     except Exception:
         pass
     return info
 
 
-def needs_asset_judgment(candidate):
-    """局部图和半透明满屏叠加层需要看图定性；不透明满屏图按背景处理。"""
-    effective_alpha = candidate.get('effective_alpha_mean')
-    if not candidate.get('fullscreen'):
-        return True
-    alpha = (effective_alpha if effective_alpha is not None
-             else (candidate.get('probe') or {}).get('alpha_mean'))
-    return alpha is not None and 13 <= alpha < OPAQUE_ENOUGH
-
-
-def fullscreen_effective_alpha(data, outdir, shapes):
-    """满屏图片的实际平均 alpha，包含图片文件 alpha 与 OOXML 形状透明度。"""
-    media_out = {row.get('media'): row.get('out') for row in data.get('media') or []
-                 if row.get('media') and row.get('out')}
-    probed = {}
-    effective = {}
-    for shape in shapes:
-        media = shape.get('media')
-        if (shape.get('kind') != 'pic' or not media
-                or shape.get('w_pct', 0) < 95 or shape.get('h_pct', 0) < 95):
-            continue
-        if media not in probed:
-            out = media_out.get(media)
-            probe = probe_image(os.path.join(outdir, out)) if out else {}
-            probed[media] = probe.get('alpha_mean')
-        source_alpha = probed[media]
-        if source_alpha is None:
-            source_alpha = 255.0
-        try:
-            opacity = float(shape.get('opacity', 1.0))
-        except (TypeError, ValueError):
-            opacity = 1.0
-        alpha = source_alpha * max(0.0, min(opacity, 1.0))
-        effective[media] = min(effective.get(media, 255.0), alpha)
-    return effective
-
-
-def fullscreen_overlay_media(data, outdir, shapes):
-    """需要模型判断的满屏叠加层媒体。"""
-    return {
-        media for media, alpha in fullscreen_effective_alpha(data, outdir, shapes).items()
-        if 13 <= alpha < OPAQUE_ENOUGH
-    }
-
-
 def bg_busy_map(path, canvas, cells=12):
     """把背景图切成网格，报每格的**局部对比度**（该格内亮度极差）。
 
@@ -767,8 +692,7 @@ def copy_logo_candidates(outdir, logo_pool):
     return rows
 
 
-def draft_assets(d, outdir, bg_needed=(), cover_media=None, bg_under=None,
-                 effective_alpha=None):
+def draft_assets(d, outdir, bg_needed=(), cover_media=None, bg_under=None):
     imgs = {i['media']: i for i in d['images']}
     cluster_of = {}
     for c in d.get('media_clusters', []):
@@ -785,35 +709,16 @@ def draft_assets(d, outdir, bg_needed=(), cover_media=None, bg_under=None,
         boxes = img.get('boxes') or []
         top = max(boxes, key=lambda b: b.get('count', 0)) if boxes else {}
         parts = top.get('parts') or []
-        placements, seen_placements = [], set()
-        for cluster in boxes:
-            box = cluster.get('box') or {}
-            rounded = [round(box.get(key, 0)) for key in ('x', 'y', 'w', 'h')]
-            for part in cluster.get('parts') or []:
-                if '/slides/' in part:
-                    row = {'slide': slide_no(part), 'box': rounded}
-                elif '/slideLayouts/' in part:
-                    row = {'layout': os.path.basename(part), 'box': rounded}
-                else:
-                    continue
-                key = (row.get('slide'), row.get('layout'), tuple(rounded))
-                if key not in seen_placements:
-                    seen_placements.add(key)
-                    placements.append(row)
-        placements.sort(key=lambda row: (
-            row.get('slide', 9999), row.get('layout', ''), tuple(row['box'])))
-        slides = sorted({row['slide'] for row in placements if row.get('slide')})
+        slides = sorted({slide_no(p) for p in parts if '/slides/' in p})
         cands.append({
             'media': m['media'], 'file': os.path.basename(out_rel), 'out': out_rel,
             'bytes': m.get('bytes'), 'n': img.get('n', m.get('used_n', 0)),
             'has_compressed': bool(m.get('compressed_out')),
             'fullscreen': bool(img.get('fullscreen')), 'w_pct': img.get('max_w_pct', 0),
             'box': top.get('box') or {}, 'slides': slides,
-            'placements': placements,
             'layer_only': bool(parts) and not slides,
             'repeat': bool(img.get('repeat_fixed')),
             'cluster': cluster_of.get(m['media']),
-            'effective_alpha_mean': (effective_alpha or {}).get(m['media']),
             'probe': probe, 'reasons': m.get('reasons', []),
         })
 
@@ -840,18 +745,14 @@ def draft_assets(d, outdir, bg_needed=(), cover_media=None, bg_under=None,
     bg_i = 0
     canvas_w, canvas_h = d['canvas']['px']
     for c in kept:
-        effective_am = c.get('effective_alpha_mean')
-        if (c['fullscreen'] and (c['probe'].get('near_blank')
-                                 or (effective_am is not None and effective_am < 13))):
-            rejected.append((c, '近全透明（alpha 均值 %.0f/255），PPT 里看不见'
-                             % (effective_am if effective_am is not None
-                                else c['probe']['alpha_mean'])))
+        if c['probe'].get('near_blank'):
+            rejected.append((c, '近全透明（alpha 均值 %.0f/255），PPT 里看不见' % c['probe']['alpha_mean']))
             continue
         # 铺满 ≠ 能当背景。背景的定义性属性是**遮盖**：它得挡住底下的东西。一张大半透明
         # 的图铺满整页也遮不住任何像素，它在 PPT 里是叠在幻灯片底色上的一层装饰（顶部
         # 光晕之类），底色才是真背景。实测某模板一张 alpha 均值 30/255、72% 完全透明的
         # 顶部光晕被当成满屏背景收进包，消费端每页铺它，顶部就多出一条原稿没有的浓色带。
-        am = effective_am if effective_am is not None else c['probe'].get('alpha_mean')
+        am = c['probe'].get('alpha_mean')
         if c['fullscreen'] and am is not None and am < OPAQUE_ENOUGH:
             rejected.append((c, 'alpha 均值只有 %.0f/255，遮不住底下的东西——'
                              '它是叠在底色上的装饰层，不是背景' % am))
@@ -915,13 +816,13 @@ def draft_assets(d, outdir, bg_needed=(), cover_media=None, bg_under=None,
     for i, (corner, c) in enumerate(logo_pool):
         b = c['box']
         if i == 0:
-            # 贴角、重复只能说明“像 logo”，不能替模型判定。比如一张产品功能角标也会
-            # 同时满足这些结构特征；先作为候选保留在联系表与图片槽中，由模型定为 logo
-            # 或 content，避免把内容图直接带进风格包。
-            rejected.append((c, '贴角重复小图候选（%.0fx%.0f @ %.0f,%.0f，出现 %d 次，'
-                                '离画布边 %.0f%%），结合样张判断 logo 或 content'
-                                % (b.get('w', 0), b.get('h', 0), b.get('x', 0), b.get('y', 0),
-                                   c['n'], corner * 50)))
+            assets.append({'id': 'logo-primary', 'kind': 'logo', 'role': None, 'src': c,
+                           'use_full': False, 'on_bg': on_bg_of(c)})
+            todos.append('看联系表确认 `%s` 真是品牌 logo（%.0fx%.0f @ %.0f,%.0f，出现 %d 次，'
+                         '离画布边 %.0f%%，是所有小图里最贴角的一张）；'
+                         '不是就把 manifest 的 logo-primary 换成别的候选或整条删掉'
+                         % (c['file'], b.get('w', 0), b.get('h', 0), b.get('x', 0), b.get('y', 0),
+                            c['n'], corner * 50))
         else:
             rejected.append((c, '重复小图（%.0fx%.0f @ %.0f,%.0f），贴角程度 %.0f%% 不如首选'
                              % (b.get('w', 0), b.get('h', 0), b.get('x', 0), b.get('y', 0),
@@ -953,41 +854,6 @@ def draft_assets(d, outdir, bg_needed=(), cover_media=None, bg_under=None,
     return assets, rejected, todos, alias, {c['media']: c for c in kept}
 
 
-def cover_background_media(archetypes):
-    """只从模板明确命名的 cover 页型读取封面背景。"""
-    return next((archetype['bg_raw'] for archetype in archetypes
-                 if archetype['name'] == 'cover'), None)
-
-
-def background_decor(background, canvas):
-    """把可直接重放的 PPT 背景声明落到 layouts.md 的最底层装饰。
-
-    图片背景继续走 `background:` 资产引用；纯色和线性渐变没有可复制的素材文件，
-    但同样是页型视觉的一部分，必须随页型输出。path 渐变不能由 CSS 线性渐变准确表达，
-    保留给图片/渲染链路而不伪造。
-    """
-    if not isinstance(background, dict):
-        return None
-    if background.get('type') not in ('solid', 'gradient'):
-        return None
-    if background.get('path'):
-        return None
-    css = _load_query()._recipe_css(background, None, [], [])
-    css = [re.sub(r'\s*\n\s*', ' ', value).strip() for value in css if value]
-    if not css:
-        return None
-    width, height = canvas
-    return {'box': [0, 0, width, height], 'geom': 'rect', 'css': '; '.join(css),
-            'trace': 'canvas-background'}
-
-
-def background_identity(background):
-    """返回可用于聚类和审计的稳定背景标识，不改变背景的原始表达。"""
-    if isinstance(background, dict):
-        return json.dumps(background, sort_keys=True, separators=(',', ':'))
-    return background
-
-
 # ---------------------------------------------------------------- 版式聚类
 DECOR_MIN = 40.0
 
@@ -1085,21 +951,19 @@ def slot_style(s):
     不会写进消费者产物。
     """
     txt = s.get('text') or {}
-    inherited = dict((txt.get('lstStyle') or {}).get('lvl1pPr') or {})
-    ls = {}
+    ls = dict((txt.get('lstStyle') or {}).get('lvl1pPr') or {})
     # 四层逐级兜底，按 OOXML 的就近原则：run rPr → 段落 defRPr → 段落 pPr → lstStyle。
     # 只枚举前几层会整份漏掉——有的导出器把字号全写在 run rPr 上，lstStyle 一个都没有。
     for para in (txt.get('paragraphs') or []):
-        srcs = [r for r in (para.get('runs') or [])]
+        srcs = [r.get('rPr') or {} for r in (para.get('runs') or [])]
         srcs.append(para.get('defRPr') or {})
         srcs.append({k: v for k, v in para.items() if k not in ('runs', 'defRPr')})
         for src in srcs:
             for k, v in (src or {}).items():
                 if v is not None:
                     ls.setdefault(k, v)
-    for k, v in inherited.items():
-        if v is not None:
-            ls.setdefault(k, v)
+        if ls.get('sz_px'):
+            break
     if not ls.get('sz_px'):
         # 仍无声明：退到整形状里出现过的最大字号（generic walk），仍是文件里的值
         anysz = shape_sz(s)
@@ -1118,16 +982,9 @@ def slot_style(s):
             css_number(insets.get('lIns', 0) or 0),
         ))
     if ls.get('sz_px'):
-        # normAutofit 的 fontScale 是模板让大字装进小框的手段——不乘它，消费端拿到的是
-        # 未缩放字号，字比框高，渐变裁切会把溢出的底部切成透明。缺省 1.0（无 autofit / 无缩放）。
-        scale = body.get('font_scale')
-        raw = ls['sz_px'] * scale if scale else ls['sz_px']
-        size = round(raw)
+        size = round(ls['sz_px'])
         css.append('font-size: %dpx' % size)
         out['_font_size'] = size
-    typeface = ls.get('ea') or ls.get('latin') or ls.get('cs')
-    if typeface:
-        css.append('font-family: %s' % font_css([typeface]))
     weight = ls.get('weight') or (700 if ls.get('bold') else None)
     if weight:
         css.append('font-weight: %s' % weight)
@@ -1163,13 +1020,10 @@ def slot_style(s):
             'l': 'left', 'ctr': 'center', 'r': 'right', 'just': 'justify',
         }.get(align, align))
     line_spacing = ls.get('lnSpc') or {}
-    # normAutofit 的 lnSpcReduction 与 fontScale 同时把行距压缩，一起缩才装得进原框。
-    reduction = body.get('ln_spc_reduction') or 0
     if line_spacing.get('mult'):
-        mult = line_spacing['mult'] * 1.2 * (1 - reduction)
-        css.append('line-height: %s' % css_number(mult))
+        css.append('line-height: %s' % css_number(line_spacing['mult'] * 1.2))
     elif line_spacing.get('px'):
-        css.append('line-height: %spx' % css_number(line_spacing['px'] * (1 - reduction)))
+        css.append('line-height: %spx' % css_number(line_spacing['px']))
     anchor = body.get('anchor')
     if anchor in ('ctr', 'b'):
         css += ['display: flex', 'flex-direction: column',
@@ -1240,9 +1094,6 @@ def layouts_from_template(d, shapes, cW, cH):
     lay_of_slide = (d.get('reference_graph') or {}).get('layout_of_slide') or {}
     used_n = Counter(lay_of_slide.values())
     slide_of_layout = {lp: sp for sp, lp in lay_of_slide.items() if used_n[lp] == 1}
-    sample_pages_of_layout = defaultdict(list)
-    for slide_part, layout_part in lay_of_slide.items():
-        sample_pages_of_layout[layout_part].append(slide_no(slide_part))
     default_theme = topo.get('default')
     multi = len(topo.get('themes') or []) > 1
 
@@ -1255,7 +1106,7 @@ def layouts_from_template(d, shapes, cW, cH):
         phs.sort(key=lambda s: ((s['box'].get('y') or 0), (s['box'].get('x') or 0)))
         slots, seen_kind = [], set()
         for s in phs:
-            t = PH_TO_TYPE.get((s.get('ph') or {}).get('type'), 'body')
+            t = PH_TO_TYPE.get((s['ph'] or {}).get('type'), 'body')
             if t in ('slide-number', 'footer') and not shape_text(s):
                 continue                      # 空 chrome 占位符不是实际元素
             b = s['box']
@@ -1299,17 +1150,7 @@ def layouts_from_template(d, shapes, cW, cH):
             slots, bgm = instance_override(
                 shapes, inst, slots, bgm, cW, cH, composites)
         taken = {tuple(s['box']) for s in slots}
-        decor = []
-        inherited_background = l.get('background')
-        direct_background = next(
-            (slide.get('background') for slide in d.get('slides') or []
-             if slide.get('part') == inst and slide.get('background')),
-            None)
-        background = direct_background or inherited_background
-        background_layer = background_decor(background, (cW, cH))
-        if background_layer:
-            decor.append(background_layer)
-        decor += collect_decor(shapes, inst or l['part'], taken, (cW, cH))
+        decor = collect_decor(shapes, inst or l['part'], taken, (cW, cH))
         named_role = role_of_name(l.get('name'))
         rows.append({'zh': clean_layout_name(l.get('name')),
                      'role': named_role or 'content', 'role_guessed': named_role is None,
@@ -1345,8 +1186,6 @@ def layouts_from_template(d, shapes, cW, cH):
                      # 版式名认不出 role 时不装作有把握：置信度降到 low，让 L 层看图定
                      'pic_n': 0, 'confidence': 'low' if r.get('role_guessed') else 'high',
                      'theme': r['theme'] if multi else None,
-                     '_layout_part': r['part'],
-                     '_sample_pages': sorted(sample_pages_of_layout.get(r['part']) or []),
                      'source': 'layout:' + r['part'].split('/')[-1]})
     return arch
 
@@ -1462,79 +1301,13 @@ def inherited_text_shapes(layout_shapes, slide_shapes):
     return out
 
 
-def slide_image_marks(data, included_fullscreen=()):
-    """从图片普查补齐形状图片填充；它们没有独立 pic 节点，但仍有媒体与坐标。"""
-    allowed_fullscreen = set(included_fullscreen)
-    out = defaultdict(list)
-    for image in data.get('images') or []:
-        media = image.get('media')
-        if not media or (image.get('fullscreen') and media not in allowed_fullscreen):
-            continue
-        for cluster in image.get('boxes') or []:
-            box = cluster.get('box')
-            if not box or not box.get('w'):
-                continue
-            for part in cluster.get('parts') or []:
-                if '/slides/' not in part and '/slideLayouts/' not in part:
-                    continue
-                out[part].append({'media': media, 'box': box})
-    return out
-
-
-def add_template_image_marks(archetypes, data, included_fullscreen=()):
-    """把版式和实例页的图片填充补进 form=3 页型。"""
-    marks_by_part = slide_image_marks(data, included_fullscreen)
-    layout_of_slide = (data.get('reference_graph') or {}).get('layout_of_slide') or {}
-    by_layout = {archetype.get('_layout_part'): archetype for archetype in archetypes}
-    for part, marks in marks_by_part.items():
-        layout_part = layout_of_slide.get(part, part)
-        archetype = by_layout.get(layout_part)
-        if not archetype:
-            continue
-        seen = {
-            (slot.get('media'), tuple(slot.get('box') or ()))
-            for slot in archetype.get('slots') or []
-            if slot.get('media')
-        }
-        for mark in marks:
-            box = mark['box']
-            rounded = [round(box.get(key, 0)) for key in ('x', 'y', 'w', 'h')]
-            key = (mark['media'], tuple(rounded))
-            if key in seen:
-                continue
-            seen.add(key)
-            archetype['slots'].append({
-                'role': 'logo',
-                'type': 'pic',
-                'sz': 0,
-                'txt': '',
-                'media': mark['media'],
-                'box': rounded,
-            })
-
-
-def preserve_image_bearing_groups(kept, ranked):
-    """有图片实例的孤例保留自己的页型，避免把资产绑定到近似但错误的版式。"""
-    return kept + [
-        group for group in ranked
-        if group not in kept and any(page.get('marks') for page in group[1])
-    ]
-
-
-def draft_layouts(d, outdir, effective_alpha=None):
+def draft_layouts(d, outdir):
     with open(os.path.join(outdir, 'ref', 'shapes.json'), encoding='utf-8') as stream:
         shapes = json.load(stream)['shapes']
     cW, cH = d['canvas']['px']
-    if effective_alpha is None:
-        effective_alpha = fullscreen_effective_alpha(d, outdir, shapes)
-    overlay_media = {
-        media for media, alpha in effective_alpha.items()
-        if 13 <= alpha < OPAQUE_ENOUGH
-    }
     if (d.get('form_hint') or {}).get('form') == 3:
         arch = layouts_from_template(d, shapes, cW, cH)
         if len(arch) >= 3:
-            add_template_image_marks(arch, d, overlay_media)
             return arch, [], []
     by_slide = defaultdict(list)
     by_layout = defaultdict(list)
@@ -1543,22 +1316,18 @@ def draft_layouts(d, outdir, effective_alpha=None):
             by_slide[s['part']].append(s)
         elif s.get('layer') == 'layout':
             by_layout[s['part']].append(s)
-    image_marks = slide_image_marks(d, overlay_media)
 
     bg_of_slide, layout_of_slide = {}, {}
-    background_of_layout = {
-        row['part']: row.get('background') for row in d.get('layouts') or []
-    }
     for s in d.get('slides', []):
         bg = s.get('background')
-        bg_of_slide[s['part']] = background_identity(bg)
+        bg_of_slide[s['part']] = json.dumps(bg, sort_keys=True) if isinstance(bg, dict) else bg
         layout_of_slide[s['part']] = s.get('layout')
     # 版式层的满屏底图（form=2 常态：底图挂在 layout 上）
     composites = d.get('background_composites') or {}
-    bg_media_of_layout = {}
+    bg_of_layout = {}
     for s in shapes:
         if s.get('layer') == 'layout' and is_bleed(s) and s.get('media'):
-            bg_media_of_layout[s['part']] = s['media']
+            bg_of_layout[s['part']] = s['media']
 
     pages = []
     for part, sh in sorted(by_slide.items(), key=lambda kv: slide_no(kv[0])):
@@ -1566,7 +1335,7 @@ def draft_layouts(d, outdir, effective_alpha=None):
         layout_shapes = by_layout.get(layout_part) or []
         bg_media = top_bleed_media(sh)
         if bg_media is None:
-            bg_media = bg_media_of_layout.get(layout_part)
+            bg_media = bg_of_layout.get(layout_part)
         rendered_bg = (composites.get(part)
                        or composites.get(layout_part)
                        or bg_media)
@@ -1591,32 +1360,13 @@ def draft_layouts(d, outdir, effective_alpha=None):
             })
         texts.sort(key=lambda t: (-t['sz'], t['box'].get('y', 0)))
         visible_shapes = layout_shapes + sh
-        pics = []
-        for shape in visible_shapes:
-            if shape.get('kind') != 'pic':
-                continue
-            if shape.get('w_pct', 0) < 95 or shape.get('media') in overlay_media:
-                pics.append(shape)
+        pics = [s for s in visible_shapes if s.get('kind') == 'pic' and s.get('w_pct', 0) < 95]
         # 小图元素（logo / 角标 / 装饰）逐页记位置，供 archetype 落 slots
         marks = [{'media': s['media'], 'box': s['box']} for s in pics
-                 if s.get('media') and (s.get('box') or {}).get('w')]
-        seen_marks = {
-            (mark['media'], round(mark['box'].get('x', 0)), round(mark['box'].get('y', 0)))
-            for mark in marks
-        }
-        for mark in image_marks.get(part) or []:
-            key = (mark['media'], round(mark['box'].get('x', 0)),
-                   round(mark['box'].get('y', 0)))
-            if key not in seen_marks:
-                seen_marks.add(key)
-                marks.append(mark)
-        background = next((s.get('background') for s in d.get('slides') or []
-                           if s.get('part') == part and s.get('background')), None)
-        background = background or background_of_layout.get(layout_part)
+                 if s.get('media') and (s.get('box') or {}).get('w') and s.get('w_pct', 0) < 30]
         pages.append({'part': part, 'no': slide_no(part), 'bg_media': bg_media,
                       'rendered_bg': rendered_bg,
-                      'bg_color': bg_of_slide.get(part), 'background': background,
-                      'texts': texts, 'pic_n': len(pics),
+                      'bg_color': bg_of_slide.get(part), 'texts': texts, 'pic_n': len(pics),
                       'marks': marks, 'shape_n': len(visible_shapes), 'layout': layout_part})
 
     # 页型的**角色**（封面 / 章节页 / 内容页……）不在这里判：那是看图才能下的结论，
@@ -1629,7 +1379,6 @@ def draft_layouts(d, outdir, effective_alpha=None):
         n = len(p['texts'])
         return 0 if n <= q1 else (1 if n <= q2 else 2)
 
-    last_page_no = max((p['no'] for p in pages), default=None)
     groups = defaultdict(list)
     for p in pages:
         if p['no'] == 1:
@@ -1637,40 +1386,28 @@ def draft_layouts(d, outdir, effective_alpha=None):
             # 并进别的组就会被代表页顶掉、坐标全丢。这只是不合并，不代表它是封面。
             groups[('__first__', -1)] = [p]
             continue
-        if p['no'] == last_page_no:
-            # 末页也单独保留完整结构：它可能是封底，也可能只是最后一张内容页，脚本
-            # 不替模型下结论。和首页一样，拆组只避免它被聚类代表页吞掉。
-            groups[('__last__', -2)] = [p]
-            continue
-        background_key = background_identity(
-            p.get('rendered_bg') or p.get('bg_media')
-            or p.get('background') or p.get('bg_color')
-        ) or 'none'
-        groups[(background_key, density_band(p))].append(p)
+        groups[(p['bg_media'] or p['bg_color'] or 'none', density_band(p))].append(p)
 
     ranked = sorted(groups.items(), key=lambda kv: (-len(kv[1]), kv[1][0]['no']))
     # 首页所在的组一定收——deck 的第一页是模板的门面，孤例也不能被名额挤掉。
     # 这只保证它进包，它是不是封面由看图的人定。
     first = [g for g in ranked if g[0][0] == '__first__']
-    last = [g for g in ranked if g[0][0] == '__last__']
-    kept = first + last + [
-        g for g in ranked
-        if g not in first and g not in last and len(g[1]) >= 2
-    ][:max(0, 8 - len(first) - len(last))]
+    kept = first + [g for g in ranked if g not in first and len(g[1]) >= 2][:8 - len(first)]
     for g in ranked:                      # 名额没用满就把最大的孤例页也收进来
         if len(kept) >= 8:
             break
         if g not in kept:
             kept.append(g)
-    # 图片用途必须与它实际所在的版式绑定。若把图片孤例并到“最接近”页型，装饰会被
-    # 绑定到错误布局；是否为内容图、logo 墙或装饰由后续模型看图判断，不按图片数量猜。
-    kept = preserve_image_bearing_groups(kept, ranked)
     leftover = sorted(p['no'] for g in ranked if g not in kept for p in g[1])
 
     archetypes = []
-    for gi, ((_background_key, _band), ps) in enumerate(kept, 1):
+    for gi, ((bg_raw, _band), ps) in enumerate(kept, 1):
         rep = max(ps, key=lambda p: len(p['texts']))
-        bg_raw = rep.get('rendered_bg') or rep.get('bg_media')
+        if bg_raw == '__first__':
+            bg_raw = rep['bg_media'] or rep['bg_color'] or 'none'
+        rendered_bg = rep.get('rendered_bg')
+        if rendered_bg:
+            bg_raw = rendered_bg
         name = 'layout-%d' % gi
         # 标题按「位置 + 跨度」认，不按字号——big-number 类的巨号数值常比标题还大
         # 标题 = 该页最靠上的那批文本里最宽的一块。不按「画布前 28%」这类固定比例切：
@@ -1713,25 +1450,20 @@ def draft_layouts(d, outdir, effective_alpha=None):
                     '_placeholder': t.get('placeholder'),
                 })
             slots.append(row)
-        # 同组页面上的图片元素按素材+位置去重后落候选 slots。内容图去掉具体资产引用，
-        # 保留通用图片槽；装饰图绑定资产，避免非代表页上的装饰没有进入 layouts。
+        # 代表页上的小图元素按位置去重后落 slots（同一 logo 在不同页型位置不同）
         seen_mark = set()
-        for page in ps:
-            for mk in page.get('marks') or []:
-                b = mk['box']
-                key = (mk['media'], round(b.get('x', 0)), round(b.get('y', 0)))
-                if key in seen_mark:
-                    continue
-                seen_mark.add(key)
-                slots.append({'role': 'logo', 'type': 'pic', 'sz': 0, 'txt': '',
-                              'media': mk['media'],
-                              'box': [round(b.get('x', 0)), round(b.get('y', 0)),
-                                      round(b.get('w', 0)), round(b.get('h', 0))]})
+        for mk in rep.get('marks') or []:
+            b = mk['box']
+            key = (mk['media'], round(b.get('x', 0)), round(b.get('y', 0)))
+            if key in seen_mark:
+                continue
+            seen_mark.add(key)
+            slots.append({'role': 'logo', 'type': 'pic', 'sz': 0, 'txt': '',
+                          'media': mk['media'],
+                          'box': [round(b.get('x', 0)), round(b.get('y', 0)),
+                                  round(b.get('w', 0)), round(b.get('h', 0))]})
         taken = {tuple(s['box']) for s in slots}
         decor = []
-        background_layer = background_decor(rep.get('background'), (cW, cH))
-        if background_layer:
-            decor.append(background_layer)
         seen_decor = set()
         for source_part in (rep.get('layout'), rep['part']):
             for item in collect_decor(shapes, source_part, taken, (cW, cH)):
@@ -1743,20 +1475,6 @@ def draft_layouts(d, outdir, effective_alpha=None):
                            'decor': decor,
                            'pages': sorted(p['no'] for p in ps), 'rep': rep['no'],
                            'pic_n': rep['pic_n'],
-                           '_source_layouts': sorted({
-                               p['layout'] for p in ps if p.get('layout')
-                           }),
-                           '_source_backgrounds': sorted({
-                               background_identity(
-                                   p.get('rendered_bg') or p.get('bg_media')
-                                   or p.get('background') or p.get('bg_color')
-                               )
-                               for p in ps
-                               if (p.get('rendered_bg') or p.get('bg_media')
-                                   or p.get('background') or p.get('bg_color'))
-                           }),
-                           '_text_n': len(rep['texts']),
-                           '_last_page_candidate': rep['no'] == last_page_no,
                            'confidence': 'high' if len(ps) >= 3 else
                                          ('medium' if len(ps) == 2 else 'low')})
     return archetypes, pages, leftover
@@ -1770,19 +1488,13 @@ def layout_sheet(outdir, archetypes, path):
     reps = [x for x in reps if x is not None]
     if not reps:
         return None
+    import subprocess
+    r = subprocess.run([sys.executable, os.path.join(HERE, 'render_pages.py'), outdir,
+                        '--pages', 'layouts' if use_layout else 'slides',
+                        '--only', ','.join(map(str, reps)), '--no-html'],
+                       capture_output=True, text=True)
     png_dir = os.path.join(outdir, 'ref', 'rebuild', 'png')
-    kind = 'layout' if use_layout else 'slide'
-    missing = [no for no in reps
-               if not os.path.exists(os.path.join(png_dir, '%s-%s.png' % (kind, no)))]
-    if missing:
-        import subprocess
-        r = subprocess.run([sys.executable, os.path.join(HERE, 'render_pages.py'), outdir,
-                            '--pages', 'layouts' if use_layout else 'slides',
-                            '--only', ','.join(map(str, missing)), '--no-html'],
-                           capture_output=True, text=True)
-        if r.returncode:
-            return None
-    if not os.path.isdir(png_dir):
+    if r.returncode or not os.path.isdir(png_dir):
         return None
     try:
         from PIL import Image, ImageDraw
@@ -1798,7 +1510,7 @@ def layout_sheet(outdir, archetypes, path):
         x = pad + (i % cols) * (cw + pad)
         y = pad + (i // cols) * (ch + pad + lab)
         no = a.get('rep_layout') if use_layout else a.get('rep')
-        f = os.path.join(png_dir, '%s-%s.png' % (kind, no))
+        f = os.path.join(png_dir, '%s-%s.png' % ('layout' if use_layout else 'slide', no))
         if os.path.exists(f):
             im = Image.open(f).convert('RGB')
             im.thumbnail((cw, ch))
@@ -1815,7 +1527,7 @@ def layout_sheet(outdir, archetypes, path):
     return path
 
 
-def contact_sheet(outdir, cands, path, start_index=1):
+def contact_sheet(outdir, cands, path):
     try:
         from PIL import Image, ImageDraw
     except Exception:
@@ -1845,548 +1557,19 @@ def contact_sheet(outdir, cands, path, start_index=1):
             dr.text((x + 8, y + 8), 'unreadable', fill=(200, 0, 0))
         dr.rectangle([x, y, x + cell, y + cell], outline=(120, 120, 128))
         dr.text((x + 2, y + cell + 4), '[%d] %s  %dx%d  used=%d'
-                % (c.get('_candidate_index', start_index + idx), c['file'],
-                   c['probe'].get('w') or 0,
-                   c['probe'].get('h') or 0, c['n']),
+                % (idx + 1, c['file'], c['probe'].get('w') or 0, c['probe'].get('h') or 0, c['n']),
                 fill=(20, 20, 24))
     sheet.save(path, optimize=True)
     return path
 
 
-def contact_sheets(outdir, cands, ldir):
-    paths = []
-    legacy = os.path.join(ldir, 'contact-sheet.png')
-    if os.path.exists(legacy):
-        os.remove(legacy)
-    for start in range(0, len(cands), SHEET_BATCH):
-        batch = cands[start:start + SHEET_BATCH]
-        path = os.path.join(ldir, 'contact-sheet-%d.png' % (start // SHEET_BATCH + 1))
-        if contact_sheet(outdir, batch, path, start + 1):
-            paths.append(path)
-    if paths:
-        shutil.copy2(paths[0], legacy)
-    return paths
-
-
-def asset_vision_contexts(candidates):
-    """把同一素材的每个归纳页型实例放进对应语境，不只展示最早出现的页面。"""
-    contexts = []
-    for candidate in candidates:
-        placements = candidate.get('placements') or []
-        instance_placements = [row for row in placements if row.get('slide')]
-        if not instance_placements:
-            row = dict(candidate)
-            row['source_placements'] = placements
-            contexts.append(row)
-            continue
-        seen = set()
-        id_counts = Counter()
-        for placement in instance_placements:
-            box = tuple(placement['box'])
-            layout = placement.get('archetype')
-            key = (layout, box) if layout else (placement['slide'], box)
-            if key in seen:
-                continue
-            seen.add(key)
-            row = dict(candidate)
-            base_id = '%s-s%d' % (candidate['id'], placement['slide'])
-            id_counts[base_id] += 1
-            row['id'] = (base_id if id_counts[base_id] == 1
-                         else '%s-%d' % (base_id, id_counts[base_id]))
-            row['placements'] = [placement]
-            row['slides'] = [placement['slide']]
-            row['layout'] = layout
-            row['source_placements'] = placements
-            contexts.append(row)
-    return contexts
-
-
-def _group_input_count(group):
-    # 与 FaaS 一致：每页桶预留一张页面语境图；无实例页的版式候选也占一个图位。
-    page_count = len([page for page in group['pages'] if page > 0]) or 1
-    return len(group['candidates']) + page_count
-
-
-def build_asset_vision_groups(candidates):
-    """按 FaaS 的 10/5 图数预算，把候选按所在页组合成视觉判断批次。"""
-    buckets = defaultdict(list)
-    for candidate in asset_vision_contexts(candidates):
-        page = next((row['slide'] for row in candidate.get('placements') or []
-                     if row.get('slide')), 0)
-        buckets[page].append(candidate)
-
-    groups, queued = [], []
-
-    def flush_small_pages():
-        if not queued:
-            return
-        current, current_pages, inputs = [], [], 0
-        for page, page_candidates in queued:
-            page_inputs = 1 + len(page_candidates)
-            if current and inputs + page_inputs > MULTI_PAGE_IMAGE_BUDGET:
-                groups.append({'pages': current_pages, 'candidates': current})
-                current, current_pages, inputs = [], [], 0
-            current.extend(page_candidates)
-            current_pages.append(page)
-            inputs += page_inputs
-        if current:
-            groups.append({'pages': current_pages, 'candidates': current})
-        del queued[:]
-
-    for page in sorted(buckets):
-        page_candidates = buckets[page]
-        page_inputs = 1 + len(page_candidates)
-        if page_inputs > MULTI_PAGE_IMAGE_BUDGET:
-            flush_small_pages()
-            per_group = SINGLE_PAGE_IMAGE_BUDGET - 1
-            for start in range(0, len(page_candidates), per_group):
-                groups.append({
-                    'pages': [page],
-                    'candidates': page_candidates[start:start + per_group],
-                })
-            continue
-        queued.append((page, page_candidates))
-    flush_small_pages()
-
-    for index, group in enumerate(groups, 1):
-        group['id'] = 'vision-%d' % index
-        group['input_count'] = _group_input_count(group)
-    return groups
-
-
-def select_asset_vision_groups(groups, slide_count):
-    """受总预算约束选择视觉批次：首页和尾页的所有可容纳分批优先于中间页。"""
-    if not groups:
-        return [], []
-    first_page = 1
-    last_page = slide_count or max(
-        (page for group in groups for page in group['pages'] if page > 0), default=0)
-    selected, selected_ids, inputs = [], set(), 0
-
-    def add(group):
-        nonlocal inputs
-        if (group['id'] in selected_ids or len(selected) >= VISUAL_PACK_CAP
-                or inputs + group['input_count'] > VISUAL_INPUT_CAP):
-            return False
-        selected.append(group)
-        selected_ids.add(group['id'])
-        inputs += group['input_count']
-        return True
-
-    # 首尾页先于中间页保留全部可容纳分批。交错加入避免首页多批先占满总预算，尾页
-    # 连首批都进不去；单页 deck 不重复扫描。
-    priority_batches = [
-        [group for group in groups if page in group['pages']]
-        for page in dict.fromkeys((first_page, last_page))
-    ]
-    for batch_index in range(max(map(len, priority_batches), default=0)):
-        for batches in priority_batches:
-            if batch_index < len(batches):
-                add(batches[batch_index])
-
-    # 首尾的第一个批次已经保证；剩余按页码保留前段内容，优先丢弃尾页之前的后段。
-    remainder = sorted(
-        (group for group in groups if group['id'] not in selected_ids),
-        key=lambda group: (
-            min((page for page in group['pages'] if page > 0), default=999999),
-            group['id'],
-        ),
-    )
-    for group in remainder:
-        add(group)
-
-    selected.sort(key=lambda group: (
-        min((page for page in group['pages'] if page > 0), default=999999), group['id']))
-    omitted = [group for group in groups if group['id'] not in selected_ids]
-    return selected, omitted
-
-
-def _safe_remove(pattern):
-    for path in glob.glob(pattern):
-        try:
-            os.remove(path)
-        except OSError:
-            pass
-
-
-def _fit_image(image, width, height):
-    copy = image.copy()
-    copy.thumbnail((width, height))
-    return copy
-
-
-def _draw_checkerboard(draw, box, size=14):
-    x, y, w, h = box
-    for row in range(0, h, size):
-        for col in range(0, w, size):
-            if (row // size + col // size) % 2 == 0:
-                draw.rectangle([x + col, y + row, x + col + size - 1, y + row + size - 1],
-                               fill=(214, 214, 218))
-
-
-def _candidate_is_visual_risk(candidate):
-    probe = candidate.get('probe') or {}
-    alpha = candidate.get('effective_alpha_mean')
-    if alpha is None:
-        alpha = probe.get('alpha_mean')
-    return ((alpha is not None and alpha < 230)
-            or (probe.get('near_white_ratio') or 0) >= 0.7)
-
-
-def _paste_candidate_preview(sheet, draw, image, box, dark=False):
-    x, y, w, h = box
-    if dark:
-        draw.rectangle([x, y, x + w, y + h], fill=(54, 54, 58))
-    else:
-        _draw_checkerboard(draw, box)
-    preview = _fit_image(image.convert('RGBA'), w - 8, h - 8)
-    px = x + (w - preview.width) // 2
-    py = y + (h - preview.height) // 2
-    sheet.paste(preview, (px, py), preview)
-
-
-def _placement_text(candidate):
-    rows = []
-    for placement in candidate.get('placements') or []:
-        box = placement['box']
-        if placement.get('slide'):
-            rows.append('s%d@%d,%d,%d,%d' % (
-                placement['slide'], box[0], box[1], box[2], box[3]))
-        else:
-            rows.append('%s@%d,%d,%d,%d' % (
-                placement.get('layout') or 'layout', box[0], box[1], box[2], box[3]))
-    return ';'.join(rows)
-
-
-def _save_visual_sheet(sheet, path):
-    if max(sheet.size) > VISUAL_PREVIEW_MAX_EDGE:
-        ratio = VISUAL_PREVIEW_MAX_EDGE / float(max(sheet.size))
-        sheet = sheet.resize((max(1, round(sheet.width * ratio)),
-                              max(1, round(sheet.height * ratio))))
-    sheet.save(path, 'JPEG', quality=VISUAL_JPEG_QUALITY, optimize=True, progressive=True)
-
-
-def render_asset_vision_pages(outdir, pages):
-    """视觉判断必须有页面语境；截图失败时中止草案而非让模型盲判。"""
-    if not pages:
-        return None
-    result = subprocess.run(
-        [sys.executable, os.path.join(HERE, 'render_pages.py'), outdir,
-         '--pages', 'slides', '--only', ','.join(map(str, pages)), '--no-html'],
-        capture_output=True, text=True,
-    )
-    png_dir = os.path.join(outdir, 'ref', 'rebuild', 'png')
-    missing = [
-        page for page in pages
-        if not os.path.isfile(os.path.join(png_dir, 'slide-%d.png' % page))
-    ]
-    if result.returncode or missing:
-        detail = (result.stderr or result.stdout or '').strip().splitlines()
-        raise RuntimeError(
-            '视觉判断所需页面截图生成失败%s%s' % (
-                '（缺第%s页）' % '、'.join(map(str, missing)) if missing else '',
-                '：' + detail[-1] if detail else '',
-            )
-        )
-    return png_dir
-
-
-class VisionContextError(RuntimeError):
-    pass
-
-
-def has_pillow():
-    try:
-        from PIL import Image  # noqa: F401
-    except Exception:
-        return False
-    return True
-
-
-def asset_vision_group_sheet(outdir, group, png_dir, path):
-    """把一组整页语境和候选图做成可索引拼版；每张候选保持独立卡片。"""
-    try:
-        from PIL import Image, ImageDraw
-    except Exception:
-        return None
-
-    candidates = group['candidates']
-    page_count = len([page for page in group['pages'] if page > 0])
-    page_w, page_h = 440, 248
-    cell, pad, label_h = 220, 16, 42
-    asset_cols = 3
-    asset_rows = max(1, (len(candidates) + asset_cols - 1) // asset_cols)
-    page_rows = max(1, (page_count + 1) // 2) if page_count else 0
-    page_cols = min(2, page_count) if page_count else 0
-    width = max(2 * (page_w + pad) + pad if page_cols else 0,
-                asset_cols * (cell + pad) + pad)
-    header_h = 28
-    page_area_h = (page_rows * (page_h + label_h + pad) + pad) if page_rows else 0
-    asset_top = header_h + page_area_h
-    height = asset_top + asset_rows * (cell + label_h + pad) + pad
-    sheet = Image.new('RGB', (width, height), (245, 245, 247))
-    draw = ImageDraw.Draw(sheet)
-    draw.text((pad, 7), '%s  inputs=%d  pages=%s' % (
-        group['id'], group['input_count'],
-        ','.join(map(str, group['pages'])) or 'layout'), fill=(20, 20, 24))
-
-    for index, page in enumerate([page for page in group['pages'] if page > 0]):
-        x = pad + (index % 2) * (page_w + pad)
-        y = header_h + (index // 2) * (page_h + label_h + pad)
-        source = (os.path.join(png_dir, 'slide-%d.png' % page)
-                  if png_dir else None)
-        if source and os.path.exists(source):
-            try:
-                image = Image.open(source).convert('RGB')
-                image = _fit_image(image, page_w, page_h)
-                sheet.paste(image, (x + (page_w - image.width) // 2,
-                                    y + (page_h - image.height) // 2))
-            except Exception as exc:
-                raise VisionContextError('视觉判断所需页面截图不可读取：第%d页' % page) from exc
-        else:
-            raise VisionContextError('视觉判断所需页面截图缺失：第%d页' % page)
-        draw.rectangle([x, y, x + page_w, y + page_h], outline=(120, 120, 128))
-        draw.text((x + 2, y + page_h + 5), '[page %d] context for candidates below' % page,
-                  fill=(20, 20, 24))
-
-    for index, candidate in enumerate(candidates):
-        x = pad + (index % asset_cols) * (cell + pad)
-        y = asset_top + (index // asset_cols) * (cell + label_h + pad)
-        image_path = os.path.join(outdir, candidate['out'])
-        try:
-            image = Image.open(image_path)
-            if _candidate_is_visual_risk(candidate):
-                half = (cell - 3) // 2
-                _paste_candidate_preview(sheet, draw, image, (x, y, half, cell))
-                _paste_candidate_preview(sheet, draw, image, (x + half + 3, y, cell - half - 3, cell),
-                                         dark=True)
-            else:
-                _paste_candidate_preview(sheet, draw, image, (x, y, cell, cell))
-        except Exception:
-            draw.text((x + 8, y + 8), 'unreadable', fill=(200, 0, 0))
-        draw.rectangle([x, y, x + cell, y + cell], outline=(120, 120, 128))
-        probe = candidate.get('probe') or {}
-        alpha = candidate.get('effective_alpha_mean')
-        if alpha is None:
-            alpha = probe.get('alpha_mean')
-        risk = (' a=%s w=%s' % (
-            '?' if alpha is None else round(alpha),
-            '?' if probe.get('near_white_ratio') is None
-            else round(probe['near_white_ratio'] * 100),
-        )) if _candidate_is_visual_risk(candidate) else ''
-        draw.text((x + 2, y + cell + 3), '[%s] %s %dx%d%s' % (
-            candidate['id'], candidate['file'], probe.get('w') or 0, probe.get('h') or 0, risk),
-            fill=(20, 20, 24))
-        first = (candidate.get('placements') or [{}])[0]
-        total_placements = len(candidate.get('source_placements') or
-                               candidate.get('placements') or [])
-        if first.get('slide'):
-            box = first['box']
-            draw.text((x + 2, y + cell + 18), 's%d @%d,%d %dx%d seen=%d' % (
-                first['slide'], box[0], box[1], box[2], box[3],
-                total_placements), fill=(20, 20, 24))
-        else:
-            draw.text((x + 2, y + cell + 18), 'layout x%d' % len(candidate.get('placements') or []),
-                      fill=(20, 20, 24))
-    _save_visual_sheet(sheet, path)
-    return path
-
-
-def emit_asset_vision_groups(outdir, candidates, slide_count, ldir):
-    """生成受预算约束的拼版和结构化索引，返回已选/未选组。"""
-    groups = build_asset_vision_groups(candidates)
-    selected, omitted = select_asset_vision_groups(groups, slide_count)
-    _safe_remove(os.path.join(ldir, 'vision-group-*.jpg'))
-    _safe_remove(os.path.join(ldir, 'contact-sheet-*.png'))
-    _safe_remove(os.path.join(ldir, 'contact-sheet.png'))
-    _safe_remove(os.path.join(ldir, 'asset-context-sheet-*.png'))
-
-    paths = []
-    if not has_pillow():
-        omitted = groups
-        selected = []
-    else:
-        pages = sorted({page for group in selected for page in group['pages'] if page > 0})
-        png_dir = render_asset_vision_pages(outdir, pages)
-        try:
-            for index, group in enumerate(selected, 1):
-                path = os.path.join(ldir, 'vision-group-%d.jpg' % index)
-                if asset_vision_group_sheet(outdir, group, png_dir, path):
-                    paths.append(path)
-                    group['sheet'] = os.path.basename(path)
-            if selected and len(paths) != len(selected):
-                raise RuntimeError('视觉判断拼版生成失败')
-        except VisionContextError:
-            raise
-        except Exception:
-            _safe_remove(os.path.join(ldir, 'vision-group-*.jpg'))
-            selected, omitted, paths = [], groups, []
-    if paths:
-        # 旧流程只认 contact-sheet.png；保留首个视觉组的 PNG 别名，新的 BRIEF 不再要求读它。
-        try:
-            from PIL import Image
-            legacy = os.path.join(ldir, 'contact-sheet-1.png')
-            Image.open(paths[0]).convert('RGB').save(legacy, 'PNG', optimize=True)
-            shutil.copy2(legacy, os.path.join(ldir, 'contact-sheet.png'))
-        except Exception:
-            pass
-
-    def serialize(group):
-        return {
-            'id': group['id'],
-            'sheet': group.get('sheet'),
-            'pages': group['pages'],
-            'input_count': group['input_count'],
-            'candidates': [{
-                'id': candidate['id'],
-                'source_media': candidate['file'],
-                'source_px': [candidate['probe'].get('w'), candidate['probe'].get('h')],
-                'bytes': candidate.get('bytes'),
-                'repeat_count': candidate.get('n'),
-                'fullscreen': candidate.get('fullscreen'),
-                'effective_alpha_mean': candidate.get('effective_alpha_mean'),
-                'near_white_ratio': candidate['probe'].get('near_white_ratio'),
-                'placements': candidate.get('placements') or [],
-                'source_placements': candidate.get('source_placements') or
-                                     candidate.get('placements') or [],
-            } for candidate in group['candidates']],
-        }
-
-    index = {
-        'version': 2,
-        'limits': {
-            'single_page_image_budget': SINGLE_PAGE_IMAGE_BUDGET,
-            'multi_page_image_budget': MULTI_PAGE_IMAGE_BUDGET,
-            'pack_cap': VISUAL_PACK_CAP,
-            'input_cap': VISUAL_INPUT_CAP,
-        },
-        'selected': [serialize(group) for group in selected],
-        'omitted': [serialize(group) for group in omitted],
-    }
-    with open(os.path.join(ldir, 'asset-vision-groups.json'), 'w', encoding='utf-8') as stream:
-        json.dump(index, stream, ensure_ascii=False, indent=2)
-        stream.write('\n')
-    return selected, omitted, paths
-
-
-def asset_context_sheets(outdir, cands, ldir):
-    """按候选主所在页去重拼整页语境，供模型识别 logo 墙和装饰用途。"""
-    reviewed = [c for c in cands if needs_asset_judgment(c)]
-    pages = []
-    seen = set()
-    for c in reviewed:
-        page = next((no for no in c.get('slides') or [] if no and no != 9999), None)
-        if page is not None and page not in seen:
-            seen.add(page)
-            pages.append(page)
-    if not pages:
-        return []
-    import subprocess
-    result = subprocess.run(
-        [sys.executable, os.path.join(HERE, 'render_pages.py'), outdir,
-         '--pages', 'slides', '--only', ','.join(map(str, pages)), '--no-html'],
-        capture_output=True, text=True,
-    )
-    png_dir = os.path.join(outdir, 'ref', 'rebuild', 'png')
-    if result.returncode or not os.path.isdir(png_dir):
-        return []
-    try:
-        from PIL import Image, ImageDraw
-    except Exception:
-        return []
-    paths = []
-    candidate_ids = defaultdict(list)
-    for index, c in enumerate(cands, 1):
-        if not needs_asset_judgment(c):
-            continue
-        for page in c.get('slides') or []:
-            if page in seen:
-                candidate_ids[page].append(index)
-    for start in range(0, len(pages), CONTEXT_BATCH):
-        batch = pages[start:start + CONTEXT_BATCH]
-        cols, cw, ch, pad, lab = 2, 480, 270, 16, 22
-        rows = (len(batch) + cols - 1) // cols
-        sheet = Image.new('RGB', (cols * (cw + pad) + pad,
-                                  rows * (ch + pad + lab) + pad), (245, 245, 247))
-        draw = ImageDraw.Draw(sheet)
-        for offset, page in enumerate(batch):
-            x = pad + (offset % cols) * (cw + pad)
-            y = pad + (offset // cols) * (ch + pad + lab)
-            source = os.path.join(png_dir, 'slide-%d.png' % page)
-            if os.path.exists(source):
-                image = Image.open(source).convert('RGB')
-                image.thumbnail((cw, ch))
-                sheet.paste(image, (x, y))
-            draw.rectangle([x, y, x + cw, y + ch], outline=(120, 120, 128))
-            draw.text((x + 2, y + ch + 5), 'slide %d  candidates=%s'
-                      % (page, ','.join(map(str, candidate_ids[page]))),
-                      fill=(20, 20, 24))
-        path = os.path.join(ldir, 'asset-context-sheet-%d.png'
-                            % (start // CONTEXT_BATCH + 1))
-        sheet.save(path, optimize=True)
-        paths.append(path)
-    return paths
-
-
 # ---------------------------------------------------------------- 落盘
 def write(p, s):
     with open(p, 'w', encoding='utf-8') as f:
         f.write(s)
 
 
-def bound_visual_candidates(candidates, archetypes):
-    """只把最终有图片槽的候选交给判断单；其余仍留在联系表供视觉核对。"""
-    bound_files = {
-        s.get('source_media')
-        for a in archetypes
-        for s in a.get('slots') or []
-        if s.get('source_media')
-    }
-    return [c for c in candidates if c.get('file') in bound_files]
-
-
-def visual_slot_candidates(candidates, archetypes):
-    """把候选绑定到最终槽位；页面截图只作该槽位的视觉语境。"""
-    source_candidates = {
-        candidate.get('file'): candidate
-        for candidate in bound_visual_candidates(candidates, archetypes)
-    }
-    rows, seen = [], set()
-    for archetype in archetypes:
-        pages = set(archetype.get('pages') or archetype.get('_sample_pages') or [])
-        for slot in archetype.get('slots') or []:
-            source = slot.get('source_media')
-            raw_box = slot.get('box')
-            candidate = source_candidates.get(source)
-            if not pages or not candidate or not raw_box or not needs_asset_judgment(candidate):
-                continue
-            box = [round(value) for value in raw_box]
-            key = (source, archetype['name'], tuple(box))
-            if key in seen:
-                continue
-            seen.add(key)
-            source_placements = candidate.get('placements') or []
-            matching = [
-                placement for placement in source_placements
-                if tuple(placement.get('box') or ()) == tuple(box)
-                and placement.get('slide') in pages
-            ]
-            if not matching:
-                continue
-            slide = matching[0]['slide']
-            row = dict(candidate)
-            row['placements'] = [{
-                'slide': slide,
-                'box': box,
-                'archetype': archetype['name'],
-            }]
-            row['slides'] = [slide] if slide else []
-            row['source_placements'] = source_placements
-            rows.append(row)
-    return rows
-
-
-def emit_manifest(d, assets, vision_groups, ldir, archetypes=()):
+def emit_manifest(d, assets, ldir):
     L = ['version: alpha',
          'name: TODO-style-name        # 英文 kebab，体现气质，不要用文件名',
          'name_zh: TODO中文名',
@@ -2407,37 +1590,6 @@ def emit_manifest(d, assets, vision_groups, ldir, archetypes=()):
                 L.append('    on-bg: %s' % (a.get('on_bg') or 'light'))
             if a['use_full']:
                 L.append('    use_full: true')
-    if vision_groups:
-        L += [
-            'asset_vision_groups:',
-            '  # 每项对应拼版中的一个候选实例；同源图在不同页型/位置可分别定性。',
-            '  # 取值与 FaaS 对齐：logo|slogan|background|texture|icon|decorative|illustration|photo|chart|screenshot|footer-copyright|page-number|watermark|content-image|unknown。',
-        ]
-        for group in vision_groups:
-            for candidate in group['candidates']:
-                placement = (candidate.get('placements') or [{}])[0]
-                L.append('  - id: %s' % candidate['id'])
-                L.append('    source_media: %s' % q(candidate['file']))
-                if placement.get('box'):
-                    L.append('    box: %s' % placement['box'])
-                L.append('    visual_kind: TODO-visual-kind-%s   # %s；视觉组 %s'
-                         % (candidate['id'], candidate['id'], group['id']))
-        L += [
-            'asset_decisions:',
-            '  # 仅在不在视觉预算内的图片、或需要覆盖已有判断时追加。',
-            '  # 位置例外写 box；同图同坐标跨页型不同，再补 layout。',
-            '  # - {source_media: example.png, visual_kind: chart}',
-            '  # - {source_media: example.png, layout: layout-2, box: [0, 0, 100, 100], visual_kind: decorative}',
-        ]
-    if any(decor.get('trace') == 'canvas-background'
-           for archetype in archetypes
-           for decor in archetype.get('decor') or []):
-        canvas = d['canvas']['px']
-        L += [
-            'derived:',
-            '  - value: "[0, 0, %d, %d]"' % (canvas[0], canvas[1]),
-            '    reason: "PPT 背景铺满画布"',
-        ]
     write(os.path.join(ldir, 'manifest.yaml'), '\n'.join(L) + '\n')
 
 
@@ -2534,11 +1686,6 @@ def draft_flow(a, facts, canvas):
         cur.append(items[i + 1])
     regions.append(cur)
 
-    # 整页左右边距 = 所有内容的横向外包络，作为各区带的缺省。
-    lefts = [s['box'][0] for s in items]
-    rights = [s['box'][0] + s['box'][2] for s in items]
-    page_margin = [min(lefts), cW - max(rights)]
-
     out = []
     for reg in regions:
         if not reg:
@@ -2561,17 +1708,8 @@ def draft_flow(a, facts, canvas):
             if len(rows) > 1:
                 row_gap = round(rows[1][0]['box'][1]
                                 - (rows[0][0]['box'][1] + rows[0][0]['box'][3]))
-            region = {'kind': 'grid', 'cols': cols, 'gap': [max(col_gap, 0), max(row_gap, 0)],
-                      'items': rows[0]}
-            # 卡片组的横向范围常和整页不同（标题贴左、卡片居中）。整页边距是所有元素的
-            # 外包络，直接套给居中卡片组会把它拉偏成左对齐。区带范围和整页明显不一致时，
-            # 落这个区带自己的左右边距，消费端把网格放进它再填 1fr。按落盘的整数比较，
-            # 亚像素噪声不触发多余的区带边距。
-            reg_margin = [min(s['box'][0] for s in rows[0]),
-                          cW - max(s['box'][0] + s['box'][2] for s in rows[0])]
-            if [int(reg_margin[0]), int(reg_margin[1])] != [int(page_margin[0]), int(page_margin[1])]:
-                region['margin'] = reg_margin
-            out.append(region)
+            out.append({'kind': 'grid', 'cols': cols, 'gap': [max(col_gap, 0), max(row_gap, 0)],
+                        'items': rows[0]})
         elif len(rows) == len(reg):
             # 每行一个元素 = 真的竖着排
             inner = 0
@@ -2586,7 +1724,9 @@ def draft_flow(a, facts, canvas):
         out.append({'kind': 'free', 'items': fixed})
     if len(out) < 2:
         return None
-    return {'top': items[0]['box'][1], 'margin': page_margin,
+    lefts = [s['box'][0] for s in items]
+    rights = [s['box'][0] + s['box'][2] for s in items]
+    return {'top': items[0]['box'][1], 'margin': [min(lefts), cW - max(rights)],
             'gap': round(cut), 'regions': out}
 
 
@@ -2735,70 +1875,7 @@ def structure_facts(archetypes, d, shapes):
     return out, recipes
 
 
-LAYOUT_CONTROL_KEYS = {
-    'names', 'roles', 'text_roles', 'layout_modes', 'bg_rules',
-}
-
-
-def emit_layout_controls(layout_lines, ldir, text_role_candidates, flow_archetypes):
-    """从兼容用的 layouts.yaml 分出模型只需编辑的判断区。
-
-    旧判断单把控制项和每个 slot 的坐标正文混在一起。模型为补一个角色读取整份文件，
-    在版式很多的模板上会把时间耗在无须判断的数值上。仍保留旧文件给既有调用方；
-    新文件只承载最终可覆盖它的五个顶层判断区。
-    """
-    blocks, current = {}, None
-    for line in layout_lines:
-        match = re.match(r'^([A-Za-z_][\w-]*):', line)
-        if match:
-            current = match.group(1)
-            if current in LAYOUT_CONTROL_KEYS:
-                blocks[current] = [line]
-            continue
-        if current in blocks:
-            blocks[current].append(line)
-
-    controls = [
-        '# 版式判断控制区 —— 只读并编辑本文件；不要打开或修改 layouts.yaml。',
-        '# package.py 会用本文件覆盖 layouts.yaml 的同名判断区，后者仅保留坐标事实与兼容输入。',
-        '# 可编辑顶层键仅为 names / roles / text_roles / layout_modes / bg_rules。',
-    ]
-    for key in ('names', 'roles'):
-        if key in blocks:
-            controls.extend([''] + blocks[key])
-    if text_role_candidates:
-        controls += [
-            '',
-            'text_roles:',
-            '# 默认文字槽都是 body；仅把确认属于 title|subtitle|header|footer 的例外填为',
-            '#   <id>: title（不要给普通正文补 body）。候选对应的原始槽位在下列注释中。',
-        ]
-        for role_id, slot in text_role_candidates:
-            controls.append('# %s：%s' % (
-                role_id, (slot.get('txt') or '（无样本文字）')[:60]))
-    if flow_archetypes:
-        controls += [
-            '',
-            'layout_modes:',
-            '# 默认 slots。只有样张明确需要内容随高度重排时，取消注释并填 `<页型>: flow`。',
-        ]
-        controls.extend('# %s: flow' % archetype['name'] for archetype in flow_archetypes)
-    if 'bg_rules' in blocks:
-        controls += [
-            '',
-            '# 只编辑本草案已列出的真实图片背景；它们都已被 layouts 中的 background: 引用。',
-            '# 纯色、渐变、外框、几何装饰和透明叠层不新建 bg_rules；没有本段就保持没有。',
-        ] + blocks['bg_rules']
-    write(os.path.join(ldir, 'layout-controls.yaml'), '\n'.join(controls) + '\n')
-
-
 def emit_layouts(archetypes, ldir, busy_hints=None, facts=None, recipes=None):
-    sampled_archetypes = {
-        id(archetype) for archetype in archetypes
-        if (archetype.get('rep') is not None
-            or archetype.get('pages')
-            or archetype.get('_sample_pages'))
-    }
     prefilled = sum(1 for a in archetypes if a.get('zh'))
     L = ['# 判断单草案 —— package.py 读它产出 layouts.md，deck 的版式坐标从 layouts.md 读。',
          '# 只改 names / roles / text_roles / layout_modes / bg_rules 五段（都是扁平键值，'
@@ -2826,16 +1903,11 @@ def emit_layouts(archetypes, ldir, busy_hints=None, facts=None, recipes=None):
         for a in need_role:
             szs = sorted({round(s['sz']) for s in a['slots'] if s.get('sz')}, reverse=True)
             L.append('  %s: TODO角色   # 代表页 %s，共 %d 页；文字块 %d 个，字号 %s；'
-                     '图片 %d 张%s%s'
+                     '图片 %d 张%s'
                      % (a['name'], a['rep'], len(a['pages']),
                         len([s for s in a['slots'] if not s.get('asset')]),
                         '/'.join(str(x) for x in szs[:5]) or '未声明',
-                        a.get('pic_n') or 0, '；有满屏底图' if a.get('bg_raw') else '',
-                        '；末页候选，结合样张判断 closing 或实际角色'
-                        if a.get('_last_page_candidate') else ''))
-    # 普通正文先保持 body：它是安全且可消费的默认值。标题/页眉/页脚的少量例外依然
-    # 要由模型看样张后写入 text_roles；把每一个正文槽都做成 TODO 会迫使模型逐行复述
-    # 近百个显然的 body，挤占真正的视觉判断时间。
+                        a.get('pic_n') or 0, '；有满屏底图' if a.get('bg_raw') else ''))
     text_role_ids = {}
     for a in archetypes:
         index = 0
@@ -2845,12 +1917,23 @@ def emit_layouts(archetypes, ldir, busy_hints=None, facts=None, recipes=None):
             index += 1
             text_role_ids[id(slot)] = '%s-text-%d' % (a['name'], index)
     if text_role_ids:
-        L.append('# 文字槽默认均为 body。看样张后，只把确实属于 title|subtitle|header|footer 的'
-                 '例外追加到 text_roles:；不要为普通正文逐条补 body。')
+        L.append('text_roles:   # 取值 title|subtitle|header|footer|body；只改角色，不删槽')
+        for a in archetypes:
+            for slot in a.get('slots') or []:
+                role_id = text_role_ids.get(id(slot))
+                if not role_id:
+                    continue
+                L.append('  %s: TODO文本角色   # 来源 %s；占位符 %s；样例 %s；'
+                         'box %s；字号 %s；css %s'
+                         % (role_id, slot.get('_source_layer') or '-',
+                            slot.get('_placeholder') or '-', q(slot.get('txt') or ''),
+                            slot.get('box'), round(slot.get('sz') or 0),
+                            q(slot.get('css') or '未声明')))
     flow_archetypes = [a for a in archetypes if a.get('flow')]
     if flow_archetypes:
-        L.append('# 同时有 flow 与 slots 时默认保留 slots，保证固定构图可消费。'
-                 '只有样张明确需要内容随高度重排时，才在 layout_modes: 中写 <页型>: flow。')
+        L.append('layout_modes:   # 取值 flow|slots；内容会变的内容页优先 flow，固定构图页用 slots')
+        for a in flow_archetypes:
+            L.append('  %s: TODO布局模式   # 依据见 layouts 段该页型上方的结构事实' % a['name'])
     # 禁放区是**背景图**的属性，不是页型的属性——按背景资产分组，页型再多也不涨
     bgs = []
     for a in archetypes:
@@ -2879,18 +1962,10 @@ def emit_layouts(archetypes, ldir, busy_hints=None, facts=None, recipes=None):
                 y1 = max(b[1] + b[3] for b in boxes)
                 L.append('    text_safe: [%d, %d, %d, %d]   # 由该背景各页型的槽位并集算出'
                          % (x0, y0, x1 - x0, y1 - y0))
-            elif any(id(archetype) in sampled_archetypes
-                     for archetype in archetypes if archetype['bg'] == bg):
-                L.append('    text_safe: TODO安全文字区[x,y,w,h]（该背景下没有任何槽位可依据）')
             else:
-                L.append('    text_safe: [0, 0, 0, 0]   # 未见对应样张，没有可依据的文字区')
-            if any(id(archetype) in sampled_archetypes
-                   for archetype in archetypes if archetype['bg'] == bg):
-                L.append('    avoid: TODO禁放区列表；无禁放区写 []，有则写 [{box: [x,y,w,h], reason: "..."}]')
-                L.append('    pairing_rule: "TODO这张背景上标题/正文/图表要避让哪些区域"')
-            else:
-                L.append('    avoid: []   # 未见对应样张，不额外推断禁放区')
-                L.append('    pairing_rule: "未见对应样张；沿用该页型已有槽位"')
+                L.append('    text_safe: TODO安全文字区[x,y,w,h]（该背景下没有任何槽位可依据）')
+            L.append('    avoid: TODO禁放区列表；无禁放区写 []，有则写 [{box: [x,y,w,h], reason: "..."}]')
+            L.append('    pairing_rule: "TODO这张背景上标题/正文/图表要避让哪些区域"')
     L.append('layouts:')
     for a in archetypes:
         fx = (facts or {}).get(a['name']) or {}
@@ -2935,10 +2010,6 @@ def emit_layouts(archetypes, ldir, busy_hints=None, facts=None, recipes=None):
                     L.append('        - kind: grid')
                     L.append('          cols: %d' % r['cols'])
                     L.append('          gap: [%d, %d]' % tuple(r['gap']))
-                    if r.get('margin'):
-                        L.append('          margin: [%d, %d]  # 本区带自己的左右边距，'
-                                 '和整页 margin 不同（居中卡片组不跟标题的左边距）'
-                                 % tuple(r['margin']))
                 elif r['kind'] == 'free':
                     L.append('        - kind: free   # 推不出规整结构，按 slots 的坐标摆')
                 else:
@@ -2966,9 +2037,6 @@ def emit_layouts(archetypes, ldir, busy_hints=None, facts=None, recipes=None):
                                 extra += ', css: "%s"' % str(child['css']).replace('"', "'")
                             if child.get('asset'):
                                 extra += ', asset: %s' % child['asset']
-                            if child.get('source_media'):
-                                extra += ', source_media: %s' % child['source_media']
-                                extra += ', source_box: %s' % child['box']
                             L.append('                - {role: %s, type: %s%s}'
                                      % (child['role'], child['type'], extra))
                         continue
@@ -2987,10 +2055,6 @@ def emit_layouts(archetypes, ldir, busy_hints=None, facts=None, recipes=None):
                         extra += ', css: "%s"' % str(s['css']).replace('"', "'")
                     if s.get('asset'):
                         extra += ', asset: %s' % s['asset']
-                    if s.get('source_media'):
-                        extra += ', source_media: %s' % s['source_media']
-                        if r['kind'] != 'free':
-                            extra += ', source_box: %s' % s['box']
                     L.append('            - {role: %s, type: %s%s}' % (s['role'], s['type'], extra))
         L.append('    slots:')
         for s in a['slots']:
@@ -3000,8 +2064,6 @@ def emit_layouts(archetypes, ldir, busy_hints=None, facts=None, recipes=None):
             extra = ''
             if s.get('asset'):
                 extra += ', asset: %s' % s['asset']
-            if s.get('source_media'):
-                extra += ', source_media: %s' % s['source_media']
             if s.get('css') is not None:
                 extra += ', css: "%s"' % str(s['css']).replace('"', "'")
             L.append('      - {role: %s, box: %s, type: %s%s}'
@@ -3013,19 +2075,9 @@ def emit_layouts(archetypes, ldir, busy_hints=None, facts=None, recipes=None):
                          % (dcr['box'], dcr['geom'], dcr['css'].replace('"', "'")))
         L.append('    confidence: %s' % a.get('confidence', 'medium'))
     write(os.path.join(ldir, 'layouts.yaml'), '\n'.join(L) + '\n')
-    emit_layout_controls(L, ldir, [
-        (text_role_ids[id(slot)], slot)
-        for archetype in archetypes
-        for slot in archetype.get('slots') or []
-        if id(archetype) in sampled_archetypes and id(slot) in text_role_ids
-    ], [
-        archetype for archetype in flow_archetypes
-        if id(archetype) in sampled_archetypes
-    ])
-
-
-def emit_body(d, tokens, fonts, roles, assets, archetypes, exceptions, cusage, ldir,
-              has_asset_candidates=False):
+
+
+def emit_body(d, tokens, fonts, roles, assets, archetypes, exceptions, cusage, ldir):
     """design.md 正文。
 
     每条规则只出现一次——同一条散在 Fast Path / Usage / Background Safety /
@@ -3034,6 +2086,7 @@ def emit_body(d, tokens, fonts, roles, assets, archetypes, exceptions, cusage, l
     """
     canvas = d['canvas']['px']
     cover = next((a for a in assets if a['id'] == 'bg-cover'), None)
+    logo = next((a for a in assets if a['kind'] == 'logo'), None)
     imp, webs = import_line(fonts)
     sidecar = '`layouts.md`'
 
@@ -3043,10 +2096,6 @@ def emit_body(d, tokens, fonts, roles, assets, archetypes, exceptions, cusage, l
               % len(archetypes)) if (d.get('form_hint') or {}).get('form') == 3 else
              ('%d 页样张归纳出 %d 种页型。' % (d['counts']['slides'], len(archetypes))))
     L += ['', '## Usage', '',
-          '**生成前必须完整阅读本 `design.md` 和 %s，确认全部页型后再开始搭页。**'
-          '不能只看摘要、前几个页型或 `## Layouts` 清单；后续页型同样可能定义背景、'
-          '安全区、资产和固定元素。' % sidecar,
-          '',
           '搭一页 PPT 六步，中间四步的数据都在 %s：' % sidecar, '']
     L += ['1. **定画布** —— 舞台按 `layouts.md` 的 `canvas` 设成 %d×%d，'
           '别套用默认尺寸：源模板的长宽比不一定是 16:9，套错了整页坐标全偏。'
@@ -3055,19 +2104,15 @@ def emit_body(d, tokens, fonts, roles, assets, archetypes, exceptions, cusage, l
           '2. **挑页型** —— 在 %s 里按用途选一个 archetype（清单见下面 Layouts 段）。'
           '页数多于页型时，挑最接近的一个原样套用它的 slot：用不到的槽删掉，'
           '内容比槽多就按同类槽的间距等距加，**坐标一律沿用该页型给的那套，不要自己另起网格**。'
-          '每个生成页面的 `<section>` 都写 `data-pptx-layout="<页型名>"`，'
-          '交付前据此核验该页型绑定的背景与图片资产均已使用，且没有跨页型误用。' % sidecar,
+          % sidecar,
           '3. **按页型给的形态落元素** —— 页型给 `flow` 就用流式，给 `slots` 就用绝对，'
           '两者只会出现一个。'
-          '**flow**：整块用一个纵向 flex 容器，`top` 是它的起始 y，`margin` 是整块的左右边距，'
+          '**flow**：整块用一个纵向 flex 容器，`top` 是它的起始 y，`margin` 是左右边距，'
           '`gap` 是区带之间的间距；`regions` 从上往下依次排，**每个区带的高度由它自己的'
           '内容决定，不要写死高度**——上面的区带内容变多时，下面的自然被推下去，这正是'
           '这套表达要解决的事。区带内部：`kind: grid` 用 `grid-template-columns: repeat(cols, 1fr)` '
           '配 `gap: [行间距, 列间距]`；`kind: stack` 用纵向 flex 配 `gap`；`kind: free` '
-          '按 item 自带的 `box` 绝对定位。区带自带 `margin: [左, 右]` 时用它的、'
-          '覆盖整块的 `margin`（模板里居中的卡片组和贴左的标题横向范围本就不同）；'
-          '没带就用整块的 `margin`。`grid` 在自己这份左右边距里再 `repeat(cols, 1fr)`。'
-          '`grid` 里的 `role: group` 是一张卡片：'
+          '按 item 自带的 `box` 绝对定位。`grid` 里的 `role: group` 是一张卡片：'
           'group 的 `css` 用于外层容器，内部 `items` 按顺序纵向排布并使用 group 的 `gap`。'
           '每个 `role: container` 的项是容器，把它的 `css` 逐项原样写进 style，内容放进去；'
           '其中没有 `border-radius` 就按 `0`，不得自行补圆角。',
@@ -3075,13 +2120,8 @@ def emit_body(d, tokens, fonts, roles, assets, archetypes, exceptions, cusage, l
           '`[x, y, w, h]`（%dx%d 画布上的绝对像素），机械展开成 `left/top/width/height`；'
           'slot 的 `css` 是模板排版属性已转译好的声明串，原样写进 style，不要另选字号、'
           '内边距、颜色或对齐。'
-          '带 `asset` 的 slot 是固定图片实例：元素写 `data-pptx-asset="<asset id>"`，'
-          '引用复制后的原资产，并把 `box` 直接写成 inline '
-          '`position:absolute;left:<x>px;top:<y>px;width:<w>px;height:<h>px`。'
-          '元素必须可见，不得省略或换图，也不得隐藏或只在 CSS 里伪装引用；'
-          '这个页型没有 `asset` 槽，这一页就不出现该资产。'
-          '页型的 `background` 是图片资产时遵循同一实例契约，`box` 使用全画布 '
-          '`[0, 0, %d, %d]`。' % (canvas[0], canvas[1], canvas[0], canvas[1]),
+          '带 `asset` 的 slot 是图片元素（logo、角标），把该资产放在它自己的 `box` 里；'
+          '这个页型没有 `asset` 槽，这一页就不出现该资产。' % (canvas[0], canvas[1]),
           '5. **铺装饰几何** —— 页型的 `decor` 是这一页的图形骨架（图标托底的圆、'
           '卡片、分隔线）：每条渲染成一个绝对定位空元素，`box` 给位置，`css` 逐项原样写进 '
           'style；没有 `border-radius` 就按 `0`。只有 `geom: ellipse` 另加 '
@@ -3094,7 +2134,7 @@ def emit_body(d, tokens, fonts, roles, assets, archetypes, exceptions, cusage, l
           '7. **保持标题结构** —— 有合适页型可参考时，沿用该页型已有的标题层级与局部 '
           '`css`；只渲染该页型已有的文字槽，背景中已经可见的固定标题不再创建文本，'
           '页型没有 `subtitle` 槽就不新增副标题。没有合适参考时，按本包整体视觉组织标题。']
-    if assets or has_asset_candidates:
+    if assets:
         L += ['', '资产文件（背景由页型的 `background` 字段指定，'
               '图片资产的位置由该页型 `slots` 里带 `asset` 的槽给出）：', '',
               '{{ASSET_TABLE}}', '',
@@ -3128,7 +2168,15 @@ def emit_body(d, tokens, fonts, roles, assets, archetypes, exceptions, cusage, l
         L.append('- 封面页铺满 `bg-cover`，整幅覆盖 %dx%d 画布。' % (canvas[0], canvas[1]))
     if any(a['role'] == 'content' for a in assets):
         L.append('- 内容页的背景由该页型的 `background` 字段指定，整幅铺满。')
-    L.append('{{LOGO_RULES}}')
+    if logo:
+        # 点名哪几个页型带 logo。只说「位置去 slots 里查」的话，读起来像是每个页型都有
+        # 这个槽、去查就行——而「不放」是靠该页型 slots 里缺这一项来表达的，要消费端
+        # 自己做否定式推理才能得出。正面点名比让它去发现缺席可靠。
+        with_logo = [a['name'] for a in archetypes
+                     if any(str(s.get('asset') or '') == logo['id'] for s in a['slots'])]
+        L.append('- `%s` 只出现在这些页型上：%s；其余页型不放。位置取该页型 `slots` 里 '
+                 '`role: logo` 那一项的 `box`，原样使用该文件、保持原比例。'
+                 % (logo['id'], '、'.join('`%s`' % x for x in with_logo) or '（无）'))
     L += ['- 坐标、字号、色值、资产位置以 %s 为准；本文件的 Colors / Typography 是可用值的清单。'
           % sidecar,
           '- 强调色族以 Colors 和 %s 的 slot CSS 为主；必要时可以使用 Colors 之外的颜色，'
@@ -3152,20 +2200,9 @@ def emit_body(d, tokens, fonts, roles, assets, archetypes, exceptions, cusage, l
 
 
 def emit_brief(d, ctx, ldir):
-    (tokens, rest, fonts, roles, assets, rejected, todos, archetypes, cands, sheets,
-     selected_vision_groups, omitted_vision_groups, leftover, lsheet) = ctx
+    (tokens, rest, fonts, roles, assets, rejected, todos, archetypes, cands, sheet,
+     leftover, lsheet, sheet_n) = ctx
     canvas = d['canvas']['px']
-    def sample_pages(archetype):
-        return archetype.get('pages') or archetype.get('_sample_pages') or []
-
-    sampled_archetypes = [
-        archetype for archetype in archetypes
-        if archetype.get('rep') is not None or sample_pages(archetype)
-    ]
-    template_only_archetypes = [
-        archetype for archetype in archetypes
-        if archetype not in sampled_archetypes
-    ]
     L = ['# 抽取简报（第 1/3 步产物；改完草案跑 package.py 出包）', '',
          '源：`%s`  画布 %dx%d  %d 页 / %d 版式  主题 %s  form=%s'
          % (d['source']['filename'], canvas[0], canvas[1], d['counts']['slides'],
@@ -3175,9 +2212,9 @@ def emit_brief(d, ctx, ldir):
     # 待判断清单从草案实时扫 TODO 生成，不写死：写死的清单会和草案对不上——
     # 既漏掉后加的段（模型读到一半才发现还有活），又在草案已预填时还催人去填。
     HINT = {'manifest.yaml': '看两张图定气质',
-            'layout-controls.yaml': '看 layout-sheet.png；只改这个控制区',
+            'layouts.yaml': '看 layout-sheet.png；layouts 段本身不要动',
             'body.md': 'Colors 用途列草案已填好，觉得不对再改'}
-    for fn in ('manifest.yaml', 'body.md', 'layout-controls.yaml', 'frontmatter.yaml'):
+    for fn in ('manifest.yaml', 'body.md', 'layouts.yaml', 'frontmatter.yaml'):
         path = os.path.join(ldir, fn)
         if not os.path.exists(path):
             continue
@@ -3200,34 +2237,21 @@ def emit_brief(d, ctx, ldir):
                     '（%s）' % hint if hint else ''))
     for t in todos:
         L.append('- ' + t)
-    L += ['', '## 资产判断（按视觉组一次看完）', '',
-          ('视觉判断拼版：%s。每张都含候选独立卡与所在页截图；只读这些拼版，不逐张打开素材。'
-           % '、'.join('`l-out/%s`' % os.path.basename(path) for path in sheets))
-          if sheets else '（未生成视觉拼版；不要给图片候选定性，已按内容图保留位置并在 gaps 说明。）',
-          '`l-out/asset-vision-groups.json` 记录每张候选的原图尺寸、所有页内位置和尺寸；'
-          '透明/近白候选在拼版中同时给棋盘格和深灰底预览。',
-          '按每个候选实例填 `asset_vision_groups.visual_kind`；同源图在不同页型/位置可不同。'
-          '第三方 logo 墙属于 `content-image`，不是 deck 的 `logo`。',
-          '',
-          '| ID | 文件 | 原图 | 出现 | 页 | 所有位置 |', '|---|---|---|---|---|---|']
+    L += ['', '## 联系表（一次看完所有候选图）', '',
+          '`l-out/contact-sheet.png`  —— 图格编号对应下表前几行；看完再决定 logo / 封面归属。' if sheet
+          else '（Pillow 不可用，未生成联系表；逐张看 `media-out/`）', '',
+          '| # | 文件 | 尺寸 | 出现 | 满屏 | 页 | 草案判定 |', '|---|---|---|---|---|---|---|']
     decided = {a['src']['file']: a['id'] for a in assets}
     why = {c['file']: r for c, r in rejected}
-    selected_candidates = {
-        candidate['file']: candidate
-        for group in selected_vision_groups
-        for candidate in group['candidates']
-    }
-    for c in selected_candidates.values():
-        L.append('| `%s` | `%s` | %sx%s | %d | %s | `%s` |' % (
-            c['id'], c['file'], c['probe'].get('w') or '?', c['probe'].get('h') or '?',
-            c['n'], ','.join(map(str, c['slides'])) or 'layout', _placement_text(c)))
-    if omitted_vision_groups:
-        omitted_pages = sorted({
-            page for group in omitted_vision_groups for page in group['pages'] if page > 0
-        })
+    for i, c in enumerate(cands, 1):
+        L.append('| %d | `%s` | %sx%s | %d | %s | %s | %s |' % (
+            i, c['file'], c['probe'].get('w') or '?', c['probe'].get('h') or '?', c['n'],
+            'Y' if c['fullscreen'] else '', ','.join(map(str, c['slides'][:6])) or 'layout',
+            decided.get(c['file']) or ('✗ ' + why.get(c['file'], '未采纳'))))
+    if len(cands) > sheet_n:
         L.append('')
-        L.append('未进视觉预算：%s；对应 slot 默认保留内容图片位置，不会自动升为风格资产。'
-                 % ('第%s页' % '、'.join(map(str, omitted_pages)) if omitted_pages else '版式候选'))
+        L.append('拼版图只含前 %d 张（第 %d 行之后的没有图格）。要看后面某张，'
+                 '按文件名直接看 `media-out/`。' % (sheet_n, sheet_n))
     L += ['', '## 颜色（草案 token 已写进 frontmatter.yaml）', '',
           '| token | hex | 出现 |', '|---|---|---|']
     for name, r in tokens:
@@ -3243,55 +2267,24 @@ def emit_brief(d, ctx, ldir):
     L.append('')
     L.append('字号轴：' + '、'.join('%s=%dpx(n=%d)' % (k, round(v['sz_px']), v['n'])
                                  for k, v in roles.items()))
-    L += ['', '## 版式聚类（判断项在 layout-controls.yaml，坐标事实在 layouts.yaml）', '',
-          ('`l-out/layout-sheet.png` 是各页型代表页的重建图——**看它给页型起名**，'
-           '不用再逐页查 shapes。' if sampled_archetypes else
-           '`l-out/layout-sheet.png` 是模板版式层的重建图；用它看整体视觉即可，'
-           '没有对应样张的版式已按模板名称预填，不逐项改名或判角色。')
-          if lsheet else '（未生成版式图，按下面的 slot 原文命名）', '',
+    L += ['', '## 版式聚类（草案已写进 layouts.yaml）', '',
+          '`l-out/layout-sheet.png` 是各页型代表页的重建图——**看它给页型起名**，'
+          '不用再逐页查 shapes。' if lsheet else '（未生成版式图，按下面的 slot 原文命名）', '',
           '| archetype | 页数 | 代表页 | 背景 | slot 数 |', '|---|---|---|---|---|']
-    for a in sampled_archetypes:
-        pages = sample_pages(a)
-        representative = a.get('rep') or (pages[0] if pages else None)
+    for a in archetypes:
         L.append('| `%s` | %d | %s | %s | %d |' % (
-            a['name'], len(pages), representative, a['bg'] or '（无资产底图）', len(a['slots'])))
-    if template_only_archetypes:
-        L.append('')
-        L.append('另有 %d 个模板声明版式没有对应样张：名称、角色和坐标已预填并会进入最终包；'
-                 '除非当前样张直接证明不对，不需要逐项判断。'
-                 % len(template_only_archetypes))
-    sampled_pages = {
-        page: archetype
-        for archetype in sampled_archetypes
-        for page in sample_pages(archetype)
-    }
-    first_page = 1
-    last_page = d['counts']['slides']
-    if first_page in sampled_pages:
-        first_archetype = sampled_pages[first_page]
-        L.append('')
-        L.append('第 1 页实际使用页型：`%s`。若样张确为封面，只在 `roles.%s` 填 `cover`，'
-                 '不要按页型名称猜。'
-                 % (first_archetype['name'], first_archetype['name']))
-    if last_page != first_page and last_page in sampled_pages:
-        last_archetype = sampled_pages[last_page]
-        L.append('第 %d 页实际使用页型：`%s`。若样张确为封底，只在 `roles.%s` 填 `closing`，'
-                 '不要按页型名称猜。'
-                 % (last_page, last_archetype['name'], last_archetype['name']))
+            a['name'], len(a['pages']), a['rep'], a['bg'] or '（无资产底图）', len(a['slots'])))
     if leftover:
         L += ['', '未归入 archetype 的页：%s —— 都是单页孤例，需要就自己补一个 archetype。'
               % ', '.join(map(str, leftover))]
-    L += ['', '有样张页型的 slot 原文（据此起中文页型名，并在 text_roles 判断文本角色）：', '']
-    for a in sampled_archetypes:
-        pages = sample_pages(a)
-        representative = a.get('rep') or (pages[0] if pages else None)
-        L.append('- `%s`（第 %s 页，覆盖 %s）' % (a['name'], representative, pages))
+    L += ['', '各 archetype 的 slot 原文（据此起中文页型名，并在 text_roles 判断文本角色）：', '']
+    for a in archetypes:
+        L.append('- `%s`（第 %s 页，覆盖 %s）' % (a['name'], a['rep'], a['pages']))
         for s in a['slots']:
             L.append('  - %s %spx 「%s」' % (s['role'], round(s['sz']), s['txt']))
     L += ['', '## 下一步', '',
-          '1. 并行看全部 `vision-group-*.jpg` 和 `layout-sheet.png`；'
-          '2. 先填 asset_vision_groups，再用少量 asset_decisions 写例外，最后一次批量改完其它 TODO；'
-          '3. 只改 `layout-controls.yaml` 的版式判断项，再跑 `package.py`。']
+          '1. 看 `contact-sheet.png` 和 `layout-sheet.png`；'
+          '2. 用一次批量编辑/patch 改掉四份草案里的 TODO；3. 跑 `package.py`。']
     write(os.path.join(ldir, 'BRIEF.md'), '\n'.join(L) + '\n')
 
 
@@ -3309,22 +2302,50 @@ def main(argv=None):
     cusage = color_usage(all_shapes, d)
     tokens, rest, rows = draft_colors(d, cusage)
     fonts = draft_fonts(d)
-    effective_alpha = fullscreen_effective_alpha(d, outdir, all_shapes)
-    archetypes, pages, leftover = draft_layouts(d, outdir, effective_alpha)
-    # 只有模板已声明 cover 页型时才能直读它的封面背景。首页和末页会单独保留样张，
-    # 但它们的角色仍由模型看图判断，不能因为页码就自动升格为 cover / closing。
-    cover_media = cover_background_media(archetypes)
+    archetypes, pages, leftover = draft_layouts(d, outdir)
+    # 封面底图：form=3 的页型键就是角色名（cover/section/...），直接按名字取。
+    # form=2 按样张聚类，键是 layout-1..N，永远匹配不上 'cover'——实测 vo-lite 因此
+    # 一张 role: cover 都没有，封面主视觉被标成 bg-content-1，消费端拿不到封面资产，
+    # design.md 的「封面底图必用 cover 资产」这条硬规则无从满足。回退到覆盖第 1 页的
+    # 那个页型：deck 的第 1 页就是封面，这是版式无关的事实。
+    cover_media = next((a['bg_raw'] for a in archetypes if a['name'] == 'cover'), None)
+    if not cover_media:
+        cover_media = next((a['bg_raw'] for a in archetypes
+                            if 1 in (a.get('pages') or ())), None)
     exported_media = {m['media'] for m in d.get('media', []) if m.get('exported')}
     bg_needed = {a['bg_raw'] for a in archetypes if a['bg_raw'] in exported_media}
     bg_under = {p['no']: p.get('rendered_bg') or p['bg_media'] for p in pages}
-    assets, rejected, todos, alias, pool = draft_assets(
-        d, outdir, bg_needed, cover_media, bg_under, effective_alpha)
+    assets, rejected, todos, alias, pool = draft_assets(d, outdir, bg_needed, cover_media, bg_under)
     media_to_asset = {a['src']['media']: a['id'] for a in assets}
     for m, w in (alias or {}).items():
         if w in media_to_asset:
             media_to_asset.setdefault(m, media_to_asset[w])
 
+    # 版式里那些贴在装饰容器上的小图（图标托底圆里的图标之类）：不进包的话，消费端只看到
+    # 一个空圆，只能自己编图形。它们是版式的一部分，按 icon 收进来。
+    ICON_CAP = 12
+    ICON_BUDGET = 3 * 1024 * 1024      # 图标是小件，占包体不该超过背景
     cW, cH = d['canvas']['px']
+    icon_i, icon_bytes = 0, 0
+    for a in archetypes:
+        for s in a['slots']:
+            m = s.get('media')
+            if not m or media_to_asset.get(m) or media_to_asset.get(alias.get(m, m)):
+                continue
+            c = pool.get(alias.get(m, m)) or pool.get(m)
+            if not c or not c.get('out') or icon_i >= ICON_CAP:
+                continue
+            if icon_bytes + (c.get('bytes') or 0) > ICON_BUDGET:
+                continue
+            if s['box'][2] > cW * 0.25 or s['box'][3] > cH * 0.25:
+                continue                # 不是图标，是内容配图，交给消费端自备
+            icon_i += 1
+            icon_bytes += c.get('bytes') or 0
+            aid = 'icon-%d' % icon_i
+            assets.append({'id': aid, 'kind': 'icon', 'role': None, 'src': c, 'use_full': False})
+            media_to_asset[c['media']] = aid
+            media_to_asset[m] = aid
+    dropped_slots = []
     for a in archetypes:
         a['bg'] = media_to_asset.get(a['bg_raw'])
         # 版式自带的图片元素：映射到资产 id。映射不到时**保留槽位但不写 asset**——
@@ -3335,25 +2356,22 @@ def main(argv=None):
             if s.get('media'):
                 aid = media_to_asset.get(s['media'])
                 if not aid:
-                    c = pool.get(alias.get(s['media'], s['media'])) or pool.get(s['media'])
-                    s['role'] = 'asset-candidate'
-                    if c:
-                        s['source_media'] = c['file']
+                    s['role'] = 'icon'
                     s.pop('media', None)
+                    dropped_slots.append((a['name'], s['box']))
                     keep.append(s)
                     continue
                 s['asset'] = aid
-                c = pool.get(alias.get(s['media'], s['media'])) or pool.get(s['media'])
-                if c:
-                    s['source_media'] = c['file']
                 # role 跟着资产走：图标槽写成 logo 会让消费端把它当品牌标识，每页都摆一个
                 s['role'] = next((x['kind'] for x in assets if x['id'] == aid), s['role'])
             keep.append(s)
         a['slots'] = keep
     roles = draft_scale(d, archetypes)
     slot_added = cover_slot_colors(tokens, archetypes, rows, cusage)
-    # 局部图和半透明满屏叠加层必须结合页面语境定性。候选在本阶段按图片槽过滤：
-    # 没有最终槽位的媒体无需让模型判断；有槽位但超出视觉预算的则保留通用 pic 槽。
+    # 进包的资产必须全部上联系表。BRIEF 让 L 层「看联系表确认 logo / 封面归属」，
+    # 表上没有的东西它只会从表里另挑一张顶上去。封面主视觉按定义只出现在封面那一页
+    # （n=1），按出现次数排序时排在最末——实测被 cands[:12] 截掉，模型于是把 bg-cover
+    # 换成了已经在用的内容页背景，封面与内容页字节相同，封面主视觉整个丢失。
     decided_c = sorted([a['src'] for a in assets], key=lambda c: (-c['n'], c['file']))
     other_c = sorted([c for c, _ in rejected], key=lambda c: (-c['n'], c['file']))
     cands, seen_file = [], set()
@@ -3361,28 +2379,16 @@ def main(argv=None):
         if c['file'] not in seen_file:
             seen_file.add(c['file'])
             cands.append(c)
-    review_candidates = []
-    for candidate_index, candidate in enumerate(
-            visual_slot_candidates(cands, archetypes), 1):
-        row = dict(candidate)
-        row['id'] = 'asset-%d' % candidate_index
-        review_candidates.append(row)
-    selected_vision_groups, omitted_vision_groups, sheets = emit_asset_vision_groups(
-        outdir, review_candidates, d['counts']['slides'], ldir)
+    # 表列全部候选，拼版图只拼前几张：两者成本差着数量级。表是文字，60 行也几乎不占
+    # 上下文，却是模型唯一能知道「存在这张图」的地方——名额砍在这里，被误判成未采纳的
+    # 图连翻案的机会都没有。拼版图是要「看」的，60 格就是 4 列×15 行、降采样后每格
+    # 糊成一团，那个上限才有意义。
+    sheet_items = cands[:max(SHEET_CAP, len(decided_c))]
+    sheet = contact_sheet(outdir, sheet_items, os.path.join(ldir, 'contact-sheet.png'))
     lsheet = layout_sheet(outdir, archetypes, os.path.join(ldir, 'layout-sheet.png'))
 
     anchors = draft_anchors(d, tokens, fonts, roles, assets, archetypes)
     gaps, exceptions = [], []
-    if omitted_vision_groups:
-        omitted_pages = sorted({
-            page for group in omitted_vision_groups for page in group['pages'] if page > 0
-        })
-        if omitted_pages:
-            gaps.append('视觉略过：%s页' % '/'.join(map(str, omitted_pages)))
-        else:
-            gaps.append('视觉判断超预算，未覆盖版式候选')
-    if review_candidates and not sheets:
-        gaps.append('视觉拼版不可用，图片候选按内容图保留，未做风格定性。')
     for c, why in rejected:
         if '近全透明' in why:
             gaps.append('母版/版式里的 %s 是%s，不是设计资产，任何情况下不要当背景用。' % (c['file'], why))
@@ -3401,6 +2407,10 @@ def main(argv=None):
         gaps.append('%s%s按名额截断：普查到 %d 个，包内留了 %d 个%s。'
                     % (kind, at, e['total'], e['kept'],
                        '；' + e['advice'] if e['advice'] else ''))
+    if dropped_slots:
+        gaps.append('这些图标槽的源图没有随包分发（超出图标配额或不适合进包）：%s。'
+                    '槽位保留了坐标，渲染时留空或用中性占位，不要自造图形去填。'
+                    % '、'.join('%s %s' % (n, b) for n, b in dropped_slots[:8]))
     # 「没命中映射表」不等于「装不上」：降级目标本身（Noto Sans SC 之类）和 Office 出厂体
     # 都不在 match 列里，但它们本来就可用。真正危险的是**既没命中、又不是已知可用字体**的
     # 那种——design.md 的字体栈里留着一个消费端装不上的商业字体名，且没有任何降级说明。
@@ -3428,7 +2438,7 @@ def main(argv=None):
         exceptions.append('源 deck 第 %s 页是单页孤例，没有归纳成 archetype；需要类似构图时按最接近的页型改。'
                           % '、'.join(map(str, leftover)))
 
-    emit_manifest(d, assets, selected_vision_groups, ldir, archetypes)
+    emit_manifest(d, assets, ldir)
     emit_frontmatter(d, tokens, fonts, roles, anchors, gaps, ldir)
     # 每张背景量一次局部对比度，作为「哪里不能压文字」的客观依据摆进判断单。
     # 只报测到的数，不替人填 avoid——哪块算主体、要不要避让，是看图才能定的。
@@ -3443,17 +2453,16 @@ def main(argv=None):
     for a in archetypes:
         a['flow'] = draft_flow(a, facts.get(a['name']) or {}, (cW, cH))
     emit_layouts(archetypes, ldir, busy_hints, facts, recipes)
-    emit_body(d, tokens, fonts, roles, assets, archetypes, exceptions, cusage, ldir,
-              has_asset_candidates=any(needs_asset_judgment(c) for c in cands))
-    emit_brief(d, (tokens, rest, fonts, roles, assets, rejected, todos, archetypes, cands, sheets,
-                   selected_vision_groups, omitted_vision_groups, leftover, lsheet), ldir)
+    emit_body(d, tokens, fonts, roles, assets, archetypes, exceptions, cusage, ldir)
+    emit_brief(d, (tokens, rest, fonts, roles, assets, rejected, todos, archetypes, cands, sheet,
+                   leftover, lsheet, len(sheet_items)), ldir)
 
     # 这几行落在模型判断「skill 是不是做完了」的那一刻。只报数就会被读成「包已生成」，
     # 于是判断和打包整段被跳过，deck 拿不到任何版式坐标。所以这里报进度与下一条命令。
     print('第 1/3 步完成，判断单草案 -> %s' % ldir)
     print('  待你确认：资产 %d（%s）  版式 %d  色 %d  字体 %d'
           % (len(assets), ', '.join(x['id'] for x in assets), len(archetypes), len(tokens), len(fonts)))
-    print('  第 2 步 读 l-out/BRIEF.md，并行看视觉组拼版与版式图；版式判断只改 layout-controls.yaml')
+    print('  第 2 步 读 l-out/BRIEF.md 与 contact-sheet.png，改掉草案里的 TODO')
     print('  第 3 步 package.py 产出 design.md + layouts.md —— deck 的版式坐标只从这两份读')
     sys.stdout.flush()
     return 0