@lark-apaas/coding-steering 0.1.18-dev.ee5404f → 0.1.18-dev.fb5e270

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

@@ -5,7 +5,8 @@
 
 产出 <stage1-outdir>/l-out/：
     BRIEF.md          唯一必读简报：事实 + 草案依据 + 待判断清单
-    contact-sheet.png 候选图拼版（带编号，一次看完所有图）
+    contact-sheet-*.png 候选图分批拼版（带全局编号）
+    asset-context-sheet-*.png 候选图所在整页语境（按页去重）
     manifest.yaml / frontmatter.yaml / layouts.yaml / body.md   四件草案，可直接进 package.py
 
 草案里所有数值都来自 extract.json；凡是需要「像人一样看」才能定的，写成 `TODO:` 行
@@ -29,7 +30,8 @@ OPAQUE_ENOUGH = 128    # 能当背景的最低不透明度：低于半透明就
                        # 那是叠加装饰不是背景
 FILL_MANY = 5          # 「被大量当填充铺开」的次数下限，用于区分卡片底与偶发用色
 BG_CONTENT_CAP = 5     # 内容页背景收几张：再多消费端也挑不过来，超出的写进 TODO 交人取舍
-SHEET_CAP = 12         # 联系表展示上限；进包的资产不受它约束，一张都不截
+SHEET_BATCH = 12       # 每张联系表最多 12 个候选；候选不截断，超出就继续生成下一张
+CONTEXT_BATCH = 8      # 每张整页语境表最多 8 页；同页只渲染一次
 
 HERE = os.path.dirname(os.path.abspath(__file__))
 SKILL_ROOT = os.path.dirname(HERE)
@@ -615,6 +617,54 @@ def probe_image(path):
     return info
 
 
+def needs_asset_judgment(candidate):
+    """局部图和半透明满屏叠加层需要看图定性；不透明满屏图按背景处理。"""
+    effective_alpha = candidate.get('effective_alpha_mean')
+    if ((candidate.get('probe') or {}).get('near_blank')
+            or (effective_alpha is not None and effective_alpha < 13)):
+        return False
+    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 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):
     """把背景图切成网格，报每格的**局部对比度**（该格内亮度极差）。
 
@@ -692,7 +742,8 @@ def copy_logo_candidates(outdir, logo_pool):
     return rows
 
 
-def draft_assets(d, outdir, bg_needed=(), cover_media=None, bg_under=None):
+def draft_assets(d, outdir, bg_needed=(), cover_media=None, bg_under=None,
+                 effective_alpha=None):
     imgs = {i['media']: i for i in d['images']}
     cluster_of = {}
     for c in d.get('media_clusters', []):
@@ -719,6 +770,7 @@ def draft_assets(d, outdir, bg_needed=(), cover_media=None, bg_under=None):
             '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', []),
         })
 
@@ -745,14 +797,18 @@ 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:
-        if c['probe'].get('near_blank'):
-            rejected.append((c, '近全透明（alpha 均值 %.0f/255），PPT 里看不见' % c['probe']['alpha_mean']))
+        effective_am = c.get('effective_alpha_mean')
+        if (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'])))
             continue
         # 铺满 ≠ 能当背景。背景的定义性属性是**遮盖**：它得挡住底下的东西。一张大半透明
         # 的图铺满整页也遮不住任何像素，它在 PPT 里是叠在幻灯片底色上的一层装饰（顶部
         # 光晕之类），底色才是真背景。实测某模板一张 alpha 均值 30/255、72% 完全透明的
         # 顶部光晕被当成满屏背景收进包，消费端每页铺它，顶部就多出一条原稿没有的浓色带。
-        am = c['probe'].get('alpha_mean')
+        am = effective_am if effective_am is not None else c['probe'].get('alpha_mean')
         if c['fullscreen'] and am is not None and am < OPAQUE_ENOUGH:
             rejected.append((c, 'alpha 均值只有 %.0f/255，遮不住底下的东西——'
                              '它是叠在底色上的装饰层，不是背景' % am))
@@ -951,19 +1007,21 @@ def slot_style(s):
     不会写进消费者产物。
     """
     txt = s.get('text') or {}
-    ls = dict((txt.get('lstStyle') or {}).get('lvl1pPr') or {})
+    inherited = dict((txt.get('lstStyle') or {}).get('lvl1pPr') or {})
+    ls = {}
     # 四层逐级兜底，按 OOXML 的就近原则：run rPr → 段落 defRPr → 段落 pPr → lstStyle。
     # 只枚举前几层会整份漏掉——有的导出器把字号全写在 run rPr 上，lstStyle 一个都没有。
     for para in (txt.get('paragraphs') or []):
-        srcs = [r.get('rPr') or {} for r in (para.get('runs') or [])]
+        srcs = [r 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)
-        if ls.get('sz_px'):
-            break
+    for k, v in inherited.items():
+        if v is not None:
+            ls.setdefault(k, v)
     if not ls.get('sz_px'):
         # 仍无声明：退到整形状里出现过的最大字号（generic walk），仍是文件里的值
         anysz = shape_sz(s)
@@ -982,9 +1040,16 @@ def slot_style(s):
             css_number(insets.get('lIns', 0) or 0),
         ))
     if ls.get('sz_px'):
-        size = round(ls['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)
         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)
@@ -1020,10 +1085,13 @@ 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'):
-        css.append('line-height: %s' % css_number(line_spacing['mult'] * 1.2))
+        mult = line_spacing['mult'] * 1.2 * (1 - reduction)
+        css.append('line-height: %s' % css_number(mult))
     elif line_spacing.get('px'):
-        css.append('line-height: %spx' % css_number(line_spacing['px']))
+        css.append('line-height: %spx' % css_number(line_spacing['px'] * (1 - reduction)))
     anchor = body.get('anchor')
     if anchor in ('ctr', 'b'):
         css += ['display: flex', 'flex-direction: column',
@@ -1106,7 +1174,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['ph'] or {}).get('type'), 'body')
+            t = PH_TO_TYPE.get((s.get('ph') or {}).get('type'), 'body')
             if t in ('slide-number', 'footer') and not shape_text(s):
                 continue                      # 空 chrome 占位符不是实际元素
             b = s['box']
@@ -1186,6 +1254,7 @@ 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'],
                      'source': 'layout:' + r['part'].split('/')[-1]})
     return arch
 
@@ -1301,13 +1370,122 @@ def inherited_text_shapes(layout_shapes, slide_shapes):
     return out
 
 
-def draft_layouts(d, outdir):
+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 has_small_image_cluster(pages, canvas):
+    """多张独立小图需要保留整页语境，供模型判断 logo 墙或内容图组。"""
+    canvas_w, canvas_h = canvas
+    for page in pages:
+        media = {
+            mark.get('media')
+            for mark in page.get('marks') or []
+            if mark.get('media')
+            and (mark.get('box') or {}).get('w', canvas_w) <= canvas_w * 0.25
+            and (mark.get('box') or {}).get('h', canvas_h) <= canvas_h * 0.25
+        }
+        if len(media) >= 3:
+            return True
+    return False
+
+
+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 attach_leftover_image_marks(archetypes, pages, kept_parts):
+    """把孤例图片槽并入最接近的真实页型，不为图片单独制造伪页型。"""
+    if not archetypes:
+        return
+    for page in pages:
+        if page['part'] in kept_parts or not page.get('marks'):
+            continue
+        page_bg = page.get('rendered_bg') or page.get('bg_media') or page.get('bg_color')
+        target = min(archetypes, key=lambda archetype: (
+            0 if page.get('layout') in (archetype.get('_source_layouts') or ()) else 1,
+            0 if page_bg in (archetype.get('_source_backgrounds') or ()) else 1,
+            abs(len(page.get('texts') or []) - archetype.get('_text_n', 0)),
+            abs(page['no'] - archetype.get('rep', page['no'])),
+        ))
+        seen = {
+            (slot.get('media'), tuple(slot.get('box') or ()))
+            for slot in target.get('slots') or []
+            if slot.get('media')
+        }
+        for mark in page['marks']:
+            box = [round(mark['box'].get(key, 0)) for key in ('x', 'y', 'w', 'h')]
+            key = (mark['media'], tuple(box))
+            if key in seen:
+                continue
+            seen.add(key)
+            target['slots'].append({
+                'role': 'logo',
+                'type': 'pic',
+                'sz': 0,
+                'txt': '',
+                'media': mark['media'],
+                'box': box,
+            })
+
+
+def draft_layouts(d, outdir, effective_alpha=None):
     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)
@@ -1316,6 +1494,7 @@ def draft_layouts(d, outdir):
             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 = {}, {}
     for s in d.get('slides', []):
@@ -1360,10 +1539,25 @@ def draft_layouts(d, outdir):
             })
         texts.sort(key=lambda t: (-t['sz'], t['box'].get('y', 0)))
         visible_shapes = layout_shapes + sh
-        pics = [s for s in visible_shapes if s.get('kind') == 'pic' and s.get('w_pct', 0) < 95]
+        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)
         # 小图元素（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') and s.get('w_pct', 0) < 30]
+                 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)
         pages.append({'part': part, 'no': slide_no(part), 'bg_media': bg_media,
                       'rendered_bg': rendered_bg,
                       'bg_color': bg_of_slide.get(part), 'texts': texts, 'pic_n': len(pics),
@@ -1398,7 +1592,13 @@ def draft_layouts(d, outdir):
             break
         if g not in kept:
             kept.append(g)
+    # logo 墙必须保留整页结构，模型才能结合文本与多图关系判断。其他带图孤例不提升
+    # 成完整页型，稍后把图片槽并入最接近的真实页型。
+    for group in ranked:
+        if group not in kept and has_small_image_cluster(group[1], (cW, cH)):
+            kept.append(group)
     leftover = sorted(p['no'] for g in ranked if g not in kept for p in g[1])
+    kept_pages = {page['part'] for _, group_pages in kept for page in group_pages}
 
     archetypes = []
     for gi, ((bg_raw, _band), ps) in enumerate(kept, 1):
@@ -1421,10 +1621,7 @@ def draft_layouts(d, outdir):
         rest.sort(key=lambda t: (t['box'].get('y', 0), t['box'].get('x', 0)))
         ordered = ([title] if title else []) + rest
         slots = []
-        note_truncation('文字槽', 6, len(ordered),
-                        '需要更多同类槽时，按已有同类槽的间距等距延续，不要另起一套网格'
-                        '——包里的坐标是模板量出来的，自创网格等于放弃这套版式', name)
-        for i, t in enumerate(ordered[:6]):
+        for i, t in enumerate(ordered):
             b = t['box']
             if t.get('needs_role'):
                 role = typ = 'body'
@@ -1453,18 +1650,20 @@ def draft_layouts(d, outdir):
                     '_placeholder': t.get('placeholder'),
                 })
             slots.append(row)
-        # 代表页上的小图元素按位置去重后落 slots（同一 logo 在不同页型位置不同）
+        # 同组页面上的图片元素按素材+位置去重后落候选 slots。内容图去掉具体资产引用，
+        # 保留通用图片槽；装饰图绑定资产，避免非代表页上的装饰没有进入 layouts。
         seen_mark = set()
-        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))]})
+        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))]})
         taken = {tuple(s['box']) for s in slots}
         decor = []
         seen_decor = set()
@@ -1478,8 +1677,21 @@ def draft_layouts(d, outdir):
                            '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({
+                               p.get('rendered_bg') or p.get('bg_media') or p.get('bg_color')
+                               for p in ps
+                               if p.get('rendered_bg') or p.get('bg_media') or p.get('bg_color')
+                           }),
+                           '_text_n': len(rep['texts']),
                            'confidence': 'high' if len(ps) >= 3 else
                                          ('medium' if len(ps) == 2 else 'low')})
+    # 普通孤例的图片候选仍需 layouts 槽位闭环，但不值得把整页文本升级成正式页型：
+    # 那会为每个孤例增加名称、角色、文本角色和布局模式判断。优先按同源版式承载，
+    # 再按背景、文本密度和相邻页匹配到最接近的真实页型。
+    attach_leftover_image_marks(archetypes, pages, kept_pages)
     return archetypes, pages, leftover
 
 
@@ -1491,13 +1703,19 @@ 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')
-    if r.returncode or not os.path.isdir(png_dir):
+    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):
         return None
     try:
         from PIL import Image, ImageDraw
@@ -1513,7 +1731,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' % ('layout' if use_layout else 'slide', no))
+        f = os.path.join(png_dir, '%s-%s.png' % (kind, no))
         if os.path.exists(f):
             im = Image.open(f).convert('RGB')
             im.thumbnail((cw, ch))
@@ -1530,7 +1748,7 @@ def layout_sheet(outdir, archetypes, path):
     return path
 
 
-def contact_sheet(outdir, cands, path):
+def contact_sheet(outdir, cands, path, start_index=1):
     try:
         from PIL import Image, ImageDraw
     except Exception:
@@ -1560,19 +1778,95 @@ def contact_sheet(outdir, cands, path):
             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'
-                % (idx + 1, c['file'], c['probe'].get('w') or 0, c['probe'].get('h') or 0, c['n']),
+                % (c.get('_candidate_index', start_index + idx), 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_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 emit_manifest(d, assets, ldir):
+def emit_manifest(d, assets, review_candidates, ldir):
     L = ['version: alpha',
          'name: TODO-style-name        # 英文 kebab，体现气质，不要用文件名',
          'name_zh: TODO中文名',
@@ -1593,6 +1887,19 @@ def emit_manifest(d, assets, ldir):
                 L.append('    on-bg: %s' % (a.get('on_bg') or 'light'))
             if a['use_full']:
                 L.append('    use_full: true')
+    if review_candidates:
+        L += [
+            'asset_decisions:',
+            '  # 每个局部图或半透明满屏叠加层都要结合候选图与整页语境定性。',
+            '  # package.py 只把 texture|logo|icon|slogan 合并进 assets；content 不进包。',
+        ]
+        for index, c in enumerate(review_candidates, 1):
+            if not needs_asset_judgment(c):
+                continue
+            L.append('  - source_media: %s' % c['file'])
+            L.append('    decision: TODO-kind-%d   # content|texture|logo|icon|slogan；'
+                     '候选 #%d，所在页 %s'
+                     % (index, index, ','.join(map(str, c['slides'][:6])) or 'layout'))
     write(os.path.join(ldir, 'manifest.yaml'), '\n'.join(L) + '\n')
 
 
@@ -1663,9 +1970,13 @@ def draft_flow(a, facts, canvas):
     cW, cH = canvas
     # 装饰件也算进来：很多模板的版式层只有几个占位符，真正撑起版面的是卡片容器
     # （在 decor 里）。只看 slots 会把一页的主体结构整个漏掉。
-    items = [s for s in a['slots'] if s.get('box')]
-    items += [{'role': 'container', 'type': 'decor', 'box': dcr['box'], 'css': dcr.get('css')}
-              for dcr in (a.get('decor') or [])]
+    slots = [s for s in a['slots'] if s.get('box')]
+    fixed_roles = {'logo', 'slide-number', 'page-number', 'header', 'footer'}
+    fixed = [s for s in slots if s.get('role') in fixed_roles]
+    content_slots = [s for s in slots if s.get('role') not in fixed_roles]
+    containers = [{'role': 'container', 'type': 'decor', 'box': dcr['box'],
+                   'css': dcr.get('css')} for dcr in (a.get('decor') or [])]
+    items = group_flow_cards(content_slots, containers)
     if len(items) < 2:
         return None
     items.sort(key=lambda s: (s['box'][1], s['box'][0]))
@@ -1676,7 +1987,7 @@ def draft_flow(a, facts, canvas):
         return None
     # 区带边界 = 间距分布里的最大空档。同一区带内部的间距（网格行距之类）总是明显
     # 小于区带之间的间距，用本页自己的分布切，不设固定阈值。
-    cut = _gap_cut(pos, min(pos), max(pos)) if len(pos) > 1 else max(pos) + 1
+    cut = _gap_cut(pos, min(pos), max(pos)) if len(pos) > 1 else pos[0]
     regions, cur = [], [items[0]]
     for i, g in enumerate(gaps):
         if g >= cut:
@@ -1685,6 +1996,11 @@ 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:
@@ -1707,8 +2023,17 @@ 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]))
-            out.append({'kind': 'grid', 'cols': cols, 'gap': [max(col_gap, 0), max(row_gap, 0)],
-                        'items': rows[0]})
+            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)
         elif len(rows) == len(reg):
             # 每行一个元素 = 真的竖着排
             inner = 0
@@ -1719,14 +2044,91 @@ def draft_flow(a, facts, canvas):
             # 每行元素数不一致（比如左列两张、右列一张跨两行）。硬说成 stack 会让消费端
             # 以为它们是竖排的，比不给还糟。如实说这块推不出规整结构，按坐标摆。
             out.append({'kind': 'free', 'items': reg})
+    if fixed:
+        out.append({'kind': 'free', 'items': fixed})
     if len(out) < 2:
         return None
-    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)],
+    return {'top': items[0]['box'][1], 'margin': page_margin,
             'gap': round(cut), 'regions': out}
 
 
+def box_contains(outer, inner):
+    return (outer[0] <= inner[0] and outer[1] <= inner[1]
+            and outer[0] + outer[2] >= inner[0] + inner[2]
+            and outer[1] + outer[3] >= inner[1] + inner[3])
+
+
+def boxes_overlap(a, b):
+    return (min(a[0] + a[2], b[0] + b[2]) > max(a[0], b[0])
+            and min(a[1] + a[3], b[1] + b[3]) > max(a[1], b[1]))
+
+
+def overlap_ratio(outer, inner):
+    width = min(outer[0] + outer[2], inner[0] + inner[2]) - max(outer[0], inner[0])
+    height = min(outer[1] + outer[3], inner[1] + inner[3]) - max(outer[1], inner[1])
+    if width <= 0 or height <= 0 or inner[2] <= 0 or inner[3] <= 0:
+        return 0
+    return width * height / (inner[2] * inner[3])
+
+
+def group_flow_cards(slots, containers):
+    """把并列卡片容器及其文字组成一层 group，避免拍平成多列元素。"""
+    candidates = []
+    for container in containers:
+        children = [slot for slot in slots if box_contains(container['box'], slot['box'])]
+        if len(children) >= 2:
+            candidates.append((container, children))
+    selected = []
+    for container, children in sorted(
+            candidates, key=lambda pair: pair[0]['box'][2] * pair[0]['box'][3]):
+        if not any(boxes_overlap(container['box'], other['box']) for other, _ in selected):
+            selected.append((container, children))
+    if len(selected) < 2:
+        return slots + containers
+
+    grouped_slots = {id(slot) for _, children in selected for slot in children}
+    nested_by_container = {}
+    for container, _ in selected:
+        nested_by_container[id(container)] = [
+            other for other in containers
+            if other is not container and overlap_ratio(container['box'], other['box']) >= 0.9
+        ]
+    grouped_containers = {
+        id(container)
+        for container, _ in selected
+        for container in [container] + nested_by_container[id(container)]
+    }
+    out = [slot for slot in slots if id(slot) not in grouped_slots]
+    out += [container for container in containers if id(container) not in grouped_containers]
+    for container, children in selected:
+        children = children + nested_by_container[id(container)]
+        children = sorted(children, key=lambda slot: (slot['box'][1], slot['box'][0]))
+        gaps = [children[i + 1]['box'][1]
+                - (children[i]['box'][1] + children[i]['box'][3])
+                for i in range(len(children) - 1)]
+        outer = container['box']
+        insets = [
+            min(child['box'][1] - outer[1] for child in children),
+            min(outer[0] + outer[2] - child['box'][0] - child['box'][2] for child in children),
+            min(outer[1] + outer[3] - child['box'][1] - child['box'][3] for child in children),
+            min(child['box'][0] - outer[0] for child in children),
+        ]
+        padding = max(0, round(min(insets)))
+        css = container.get('css') or ''
+        if padding:
+            css = '; '.join(part for part in (
+                css.rstrip('; '), 'box-sizing: border-box', 'padding: %dpx' % padding) if part)
+        out.append({
+            'role': 'group',
+            'type': 'group',
+            'box': outer,
+            'css': css,
+            'gap': max(0, round(min(gaps))) if gaps else 0,
+            'items': children,
+        })
+    return out
+
+
 def structure_facts(archetypes, d, shapes):
     """每个页型的**结构事实**：栅格、垂直间距序列、容器样式配方、样张里的实际字数。
 
@@ -1798,7 +2200,7 @@ def structure_facts(archetypes, d, shapes):
 def emit_layouts(archetypes, ldir, busy_hints=None, facts=None, recipes=None):
     prefilled = sum(1 for a in archetypes if a.get('zh'))
     L = ['# 判断单草案 —— package.py 读它产出 layouts.md，deck 的版式坐标从 layouts.md 读。',
-         '# 只改 names / roles / text_roles / bg_rules 四段（都是扁平键值，'
+         '# 只改 names / roles / text_roles / layout_modes / bg_rules 五段（都是扁平键值，'
          '改完 package.py 自动并回各页型）。',
          '# 下面 layouts 段是普查数值，一个字都不要动——改它容易连带删掉 slots/confidence。']
     if prefilled:
@@ -1849,6 +2251,11 @@ def emit_layouts(archetypes, ldir, busy_hints=None, facts=None, recipes=None):
                             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('layout_modes:   # 取值 flow|slots；内容会变的内容页优先 flow，固定构图页用 slots')
+        for a in flow_archetypes:
+            L.append('  %s: TODO布局模式   # 依据见 layouts 段该页型上方的结构事实' % a['name'])
     # 禁放区是**背景图**的属性，不是页型的属性——按背景资产分组，页型再多也不涨
     bgs = []
     for a in archetypes:
@@ -1915,8 +2322,6 @@ def emit_layouts(archetypes, ldir, busy_hints=None, facts=None, recipes=None):
             L.append('    background: %s' % a['bg'])
         fl = a.get('flow')
         if fl:
-            L.append('    # ↓ flow 与 slots 二选一：内容长度会变的页用 flow（区带依次排、'
-                     '高度由内容定、下面的自动被推下去），构图固定的页用 slots。删掉不要的那个。')
             L.append('    flow:')
             L.append('      top: %d' % fl['top'])
             L.append('      margin: [%d, %d]' % tuple(fl['margin']))
@@ -1927,6 +2332,10 @@ 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:
@@ -1934,6 +2343,31 @@ def emit_layouts(archetypes, ldir, busy_hints=None, facts=None, recipes=None):
                     L.append('          gap: %d' % r['gap'])
                 L.append('          items:')
                 for s in r['items']:
+                    if s.get('type') == 'group':
+                        L.append('            - role: group')
+                        L.append('              gap: %d' % s['gap'])
+                        if s.get('css'):
+                            L.append('              css: "%s"'
+                                     % str(s['css']).replace('"', "'"))
+                        L.append('              items:')
+                        for child in s['items']:
+                            role_id = text_role_ids.get(id(child))
+                            if role_id:
+                                L.append('                # text-role: %s' % role_id)
+                            if child.get('type') == 'decor':
+                                L.append('                - {role: container, css: "%s"}'
+                                         % str(child.get('css') or '').replace('"', "'"))
+                                continue
+                            extra = ''
+                            if child.get('css') is not 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']
+                            L.append('                - {role: %s, type: %s%s}'
+                                     % (child['role'], child['type'], extra))
+                        continue
                     role_id = text_role_ids.get(id(s))
                     if role_id:
                         L.append('            # text-role: %s' % role_id)
@@ -1949,6 +2383,8 @@ 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']
                     L.append('            - {role: %s, type: %s%s}' % (s['role'], s['type'], extra))
         L.append('    slots:')
         for s in a['slots']:
@@ -1958,6 +2394,8 @@ 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}'
@@ -1971,7 +2409,8 @@ def emit_layouts(archetypes, ldir, busy_hints=None, facts=None, recipes=None):
     write(os.path.join(ldir, 'layouts.yaml'), '\n'.join(L) + '\n')
 
 
-def emit_body(d, tokens, fonts, roles, assets, archetypes, exceptions, cusage, ldir):
+def emit_body(d, tokens, fonts, roles, assets, archetypes, exceptions, cusage, ldir,
+              has_asset_candidates=False):
     """design.md 正文。
 
     每条规则只出现一次——同一条散在 Fast Path / Usage / Background Safety /
@@ -1980,7 +2419,6 @@ 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`'
 
@@ -2001,14 +2439,18 @@ def emit_body(d, tokens, fonts, roles, assets, archetypes, exceptions, cusage, l
           % 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` '
-          '按该页型 `slots` 里的坐标绝对定位。每个 `role: container` 的项是容器，把它的 '
-          '`css` 逐项原样写进 style，内容放进去；其中没有 `border-radius` 就按 `0`，'
-          '不得自行补圆角。',
+          '按 item 自带的 `box` 绝对定位。区带自带 `margin: [左, 右]` 时用它的、'
+          '覆盖整块的 `margin`（模板里居中的卡片组和贴左的标题横向范围本就不同）；'
+          '没带就用整块的 `margin`。`grid` 在自己这份左右边距里再 `repeat(cols, 1fr)`。'
+          '`grid` 里的 `role: group` 是一张卡片：'
+          'group 的 `css` 用于外层容器，内部 `items` 按顺序纵向排布并使用 group 的 `gap`。'
+          '每个 `role: container` 的项是容器，把它的 `css` 逐项原样写进 style，内容放进去；'
+          '其中没有 `border-radius` 就按 `0`，不得自行补圆角。',
           '4. **按 slot 落元素（页型给的是 slots 时）** —— 每个 slot 渲染成一个绝对定位元素：`box` 是 '
           '`[x, y, w, h]`（%dx%d 画布上的绝对像素），机械展开成 `left/top/width/height`；'
           'slot 的 `css` 是模板排版属性已转译好的声明串，原样写进 style，不要另选字号、'
@@ -2027,7 +2469,7 @@ def emit_body(d, tokens, fonts, roles, assets, archetypes, exceptions, cusage, l
           '7. **保持标题结构** —— 有合适页型可参考时，沿用该页型已有的标题层级与局部 '
           '`css`；只渲染该页型已有的文字槽，背景中已经可见的固定标题不再创建文本，'
           '页型没有 `subtitle` 槽就不新增副标题。没有合适参考时，按本包整体视觉组织标题。']
-    if assets:
+    if assets or has_asset_candidates:
         L += ['', '资产文件（背景由页型的 `background` 字段指定，'
               '图片资产的位置由该页型 `slots` 里带 `asset` 的槽给出）：', '',
               '{{ASSET_TABLE}}', '',
@@ -2061,21 +2503,14 @@ 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` 字段指定，整幅铺满。')
-    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.append('{{LOGO_RULES}}')
     L += ['- 坐标、字号、色值、资产位置以 %s 为准；本文件的 Colors / Typography 是可用值的清单。'
           % sidecar,
-          '- 强调色族以 Colors 和 %s 的 slot CSS 为准，不得自行新增第二强调色。'
-          % sidecar,
-          '- 允许新增中性色、低彩度辅助色或局部语义色来表达正负、风险、警告、状态、图表序列，'
-          '但必须保持辅助层级；只要新色通过高饱和、高对比、大面积或跨页重复获得主视觉权重，'
+          '- 强调色族以 Colors 和 %s 的 slot CSS 为主；必要时可以使用 Colors 之外的颜色，'
+          '但不能形成与模板主色竞争的第二强调色。' % sidecar,
+          '- 新增颜色应与模板整体的色相、明度和饱和度关系协调。允许新增中性色、低彩度辅助色'
+          '或局部语义色表达正负、风险、警告、状态、图表序列，但保持辅助层级；'
+          '只要新色通过高饱和、高对比、大面积或跨页重复获得主视觉权重，'
           '或被用于标题、关键数字、图表主序列、卡片底色或渐变，就属于新的强调色，改用模板'
           '强调色族的深浅、透明度，或改用线型、纹理、标签区分。',
           '- 交付前逐页检查：色板、字体、版式、背景、资产和本段规则均来自本风格包；'
@@ -2092,8 +2527,8 @@ 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, sheet,
-     leftover, lsheet, sheet_n) = ctx
+    (tokens, rest, fonts, roles, assets, rejected, todos, archetypes, cands, sheets,
+     context_sheets, leftover, lsheet) = ctx
     canvas = d['canvas']['px']
     L = ['# 抽取简报（第 1/3 步产物；改完草案跑 package.py 出包）', '',
          '源：`%s`  画布 %dx%d  %d 页 / %d 版式  主题 %s  form=%s'
@@ -2129,9 +2564,14 @@ def emit_brief(d, ctx, ldir):
                     '（%s）' % hint if hint else ''))
     for t in todos:
         L.append('- ' + t)
-    L += ['', '## 联系表（一次看完所有候选图）', '',
-          '`l-out/contact-sheet.png`  —— 图格编号对应下表前几行；看完再决定 logo / 封面归属。' if sheet
-          else '（Pillow 不可用，未生成联系表；逐张看 `media-out/`）', '',
+    L += ['', '## 资产判断（同一轮并行看完）', '',
+          ('候选图：%s。图格编号对应下表；每张都要定性。'
+           % '、'.join('`l-out/%s`' % os.path.basename(path) for path in sheets))
+          if sheets else '（Pillow 不可用，未生成联系表；逐张看 `media-out/`）',
+          ('整页语境：%s。按页去重，用来判断局部图是内容、装饰，还是 logo 墙中的第三方 logo。'
+           % '、'.join('`l-out/%s`' % os.path.basename(path) for path in context_sheets))
+          if context_sheets else '（没有可用的实例页整页语境；按候选图和版式图判断。）',
+          '',
           '| # | 文件 | 尺寸 | 出现 | 满屏 | 页 | 草案判定 |', '|---|---|---|---|---|---|---|']
     decided = {a['src']['file']: a['id'] for a in assets}
     why = {c['file']: r for c, r in rejected}
@@ -2140,10 +2580,6 @@ def emit_brief(d, ctx, ldir):
             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('拼版图只含前 %d 张（第 %d 行之后的没有图格）。要看后面某张，'
-                 '按文件名直接看 `media-out/`。' % (sheet_n, sheet_n))
     L += ['', '## 颜色（草案 token 已写进 frontmatter.yaml）', '',
           '| token | hex | 出现 |', '|---|---|---|']
     for name, r in tokens:
@@ -2175,7 +2611,7 @@ def emit_brief(d, ctx, ldir):
         for s in a['slots']:
             L.append('  - %s %spx 「%s」' % (s['role'], round(s['sz']), s['txt']))
     L += ['', '## 下一步', '',
-          '1. 看 `contact-sheet.png` 和 `layout-sheet.png`；'
+          '1. 并行看全部 `contact-sheet-*.png`、`asset-context-sheet-*.png` 和 `layout-sheet.png`；'
           '2. 用一次批量编辑/patch 改掉四份草案里的 TODO；3. 跑 `package.py`。']
     write(os.path.join(ldir, 'BRIEF.md'), '\n'.join(L) + '\n')
 
@@ -2194,7 +2630,8 @@ def main(argv=None):
     cusage = color_usage(all_shapes, d)
     tokens, rest, rows = draft_colors(d, cusage)
     fonts = draft_fonts(d)
-    archetypes, pages, leftover = draft_layouts(d, outdir)
+    effective_alpha = fullscreen_effective_alpha(d, outdir, all_shapes)
+    archetypes, pages, leftover = draft_layouts(d, outdir, effective_alpha)
     # 封面底图：form=3 的页型键就是角色名（cover/section/...），直接按名字取。
     # form=2 按样张聚类，键是 layout-1..N，永远匹配不上 'cover'——实测 vo-lite 因此
     # 一张 role: cover 都没有，封面主视觉被标成 bg-content-1，消费端拿不到封面资产，
@@ -2207,7 +2644,8 @@ def main(argv=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)
+    assets, rejected, todos, alias, pool = draft_assets(
+        d, outdir, bg_needed, cover_media, bg_under, effective_alpha)
     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:
@@ -2237,7 +2675,6 @@ def main(argv=None):
             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**——
@@ -2248,22 +2685,25 @@ def main(argv=None):
             if s.get('media'):
                 aid = media_to_asset.get(s['media'])
                 if not aid:
-                    s['role'] = 'icon'
+                    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.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)
-    # 进包的资产必须全部上联系表。BRIEF 让 L 层「看联系表确认 logo / 封面归属」，
-    # 表上没有的东西它只会从表里另挑一张顶上去。封面主视觉按定义只出现在封面那一页
-    # （n=1），按出现次数排序时排在最末——实测被 cands[:12] 截掉，模型于是把 bg-cover
-    # 换成了已经在用的内容页背景，封面与内容页字节相同，封面主视觉整个丢失。
+    # 全部候选都必须上联系表：装饰图与内容图不能靠尺寸/频次可靠区分，logo 墙更必须结合
+    # 整页语境看。按批次出多张图而不是截断，模型可并行看完，不增加串行判断轮次。
     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()
@@ -2271,12 +2711,15 @@ def main(argv=None):
         if c['file'] not in seen_file:
             seen_file.add(c['file'])
             cands.append(c)
-    # 表列全部候选，拼版图只拼前几张：两者成本差着数量级。表是文字，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'))
+    decided_files = {c['file'] for c in decided_c}
+    visual_candidates = []
+    for candidate_index, candidate in enumerate(cands, 1):
+        if needs_asset_judgment(candidate) or candidate['file'] in decided_files:
+            row = dict(candidate)
+            row['_candidate_index'] = candidate_index
+            visual_candidates.append(row)
+    sheets = contact_sheets(outdir, visual_candidates, ldir)
+    context_sheets = asset_context_sheets(outdir, cands, ldir)
     lsheet = layout_sheet(outdir, archetypes, os.path.join(ldir, 'layout-sheet.png'))
 
     anchors = draft_anchors(d, tokens, fonts, roles, assets, archetypes)
@@ -2299,10 +2742,6 @@ 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 的字体栈里留着一个消费端装不上的商业字体名，且没有任何降级说明。
@@ -2330,7 +2769,7 @@ def main(argv=None):
         exceptions.append('源 deck 第 %s 页是单页孤例，没有归纳成 archetype；需要类似构图时按最接近的页型改。'
                           % '、'.join(map(str, leftover)))
 
-    emit_manifest(d, assets, ldir)
+    emit_manifest(d, assets, cands, ldir)
     emit_frontmatter(d, tokens, fonts, roles, anchors, gaps, ldir)
     # 每张背景量一次局部对比度，作为「哪里不能压文字」的客观依据摆进判断单。
     # 只报测到的数，不替人填 avoid——哪块算主体、要不要避让，是看图才能定的。
@@ -2345,16 +2784,17 @@ 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)
-    emit_brief(d, (tokens, rest, fonts, roles, assets, rejected, todos, archetypes, cands, sheet,
-                   leftover, lsheet, len(sheet_items)), ldir)
+    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,
+                   context_sheets, leftover, lsheet), 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 与 contact-sheet.png，改掉草案里的 TODO')
+    print('  第 2 步 读 l-out/BRIEF.md，并行看联系表与整页语境图，改掉草案里的 TODO')
     print('  第 3 步 package.py 产出 design.md + layouts.md —— deck 的版式坐标只从这两份读')
     sys.stdout.flush()
     return 0