@litfamily/litclaude 1.0.19 → 1.0.21

package/plugins/litclaude/skills/lit-pptx/scripts/lib/slide-ast.js

@@ -139,12 +139,16 @@ function buildBlocks(layout, content) {
       continue;
     }
 
-    // Check for standalone image
-    const img = parseImage(remaining);
-    if (img && !remaining.split("\n").some((l) => l.trim() && !l.trim().startsWith("!["))) {
-      blocks.push({ type: "image", src: img.src, caption: img.alt || "" });
-      if (img.alt) {
-        blocks.push({ type: "figure-caption", caption: img.alt });
+    // Check for standalone images: a run of image lines keeps every image, each with its caption.
+    const imageLines = remaining.split("\n").filter((l) => l.trim());
+    if (imageLines.length && imageLines.every((l) => l.trim().startsWith("![")) && imageLines.some((l) => parseImage(l))) {
+      for (const line of imageLines) {
+        const img = parseImage(line);
+        if (!img) continue;
+        blocks.push({ type: "image", src: img.src, caption: img.alt || "" });
+        if (img.alt) {
+          blocks.push({ type: "figure-caption", caption: img.alt });
+        }
       }
       continue;
     }

package/plugins/litclaude/skills/lit-pptx/scripts/lib/template-registry.js

@@ -388,7 +388,292 @@ function loadTemplate(name) {
     template,
     mapping,
     capabilities,
+    pack: legacyPack(template.name || name, template),
   };
 }
 
-module.exports = { loadTemplate, listTemplates };
+// ── Tonality packs ──────────────────────────────────────────────────────────
+
+const grid = require("./grid-resolver");
+
+const TONALITY_DIR = path.resolve(__dirname, "../../templates/tonalities");
+
+/** Pack lookup, first match wins, in the same order as templates. */
+function tonalityDirs() {
+  const extra = (process.env.LIT_PPTX_TONALITY_DIRS || "")
+    .split(path.delimiter)
+    .filter(Boolean)
+    .map((dir) => path.resolve(dir));
+  return [...extra, path.resolve(process.cwd(), ".lit-pptx", "tonalities"), TONALITY_DIR];
+}
+
+function listTonalities() {
+  const names = new Set();
+  for (const dir of tonalityDirs()) {
+    if (!fs.existsSync(dir)) continue;
+    for (const name of fs.readdirSync(dir)) {
+      if (fs.existsSync(path.join(dir, name, "pack.yaml"))) names.add(name);
+    }
+  }
+  return [...names].sort();
+}
+
+const PALETTE_ROLES = ["ground", "surface", "ink", "ink-muted", "line", "accent", "accent-deep", "accent-tint", "field", "on-field", "positive", "negative"];
+const FACE_KEYS = ["display", "title", "body", "label", "numeral"];
+const FACES = {
+  "Pretendard Regular": { font: "Pretendard", bold: false },
+  "Pretendard Bold": { font: "Pretendard", bold: true },
+  "A2Z Light": { font: "에이투지체 3 Light", bold: false },
+  "A2Z Regular": { font: "에이투지체 4 Regular", bold: false },
+  "A2Z Medium": { font: "에이투지체 5 Medium", bold: false },
+  "A2Z Bold": { font: "에이투지체 7 Bold", bold: false },
+  "A2Z Black": { font: "에이투지체 9 Black", bold: false },
+};
+const DECORATIONS = ["accent-rule", "hairline-rule", "header-band", "rail-fill", "colour-field", "caption-band", "column-hairlines", "box-outline", "mark-underline", "numeral"];
+const SLIDE_ROLES = ["content", "data", "data-takeaway", "sequence", "image", "statement", "reference", "definition"];
+const FILL_POLICIES = ["distribute", "step-up", "anchor-visual", "change-family"];
+// How a pack carries its display slides: the device on a type-led cover, around a statement,
+// behind a big number and under a closing's next step (`display.index` adds the part index to
+// section slides).
+const DISPLAY_DEVICES = {
+  cover: ["plain", "drench", "plate", "rail", "band", "figures", "rules", "numeral"],
+  statement: ["open", "drench", "rules", "plate", "offset"],
+  number: ["field", "tint", "outline"],
+  closing: ["band", "box", "rules"],
+};
+// Contrast pairs every pack must meet (text pairs 4.5:1, large marks 3:1).
+const CONTRAST_PAIRS = [["ink", "ground", 4.5], ["ink", "surface", 4.5], ["ink-muted", "ground", 4.5], ["ink-muted", "surface", 4.5],
+  ["accent", "ground", 3.0], ["accent-deep", "accent-tint", 4.5], ["ink", "accent-tint", 4.5], ["on-field", "field", 4.5],
+  ["positive", "ground", 4.5], ["negative", "ground", 4.5]];
+
+function luminance(hexColour) {
+  const v = String(hexColour).replace("#", "");
+  const [r, g, b] = [0, 2, 4].map((i) => parseInt(v.slice(i, i + 2), 16) / 255)
+    .map((c) => (c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4));
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+
+function contrast(a, b) {
+  const [hi, lo] = [luminance(a), luminance(b)].sort((x, y) => y - x);
+  return (hi + 0.05) / (lo + 0.05);
+}
+
+/** Check a parsed pack against the pack schema; throws one message naming every problem. */
+function validatePack(pack, file) {
+  const problems = [];
+  const need = (cond, msg) => { if (!cond) problems.push(msg); };
+  const isList = (v) => Array.isArray(v);
+  const hex = (v) => typeof v === "string" && /^#[0-9A-Fa-f]{6}$/u.test(v);
+  need(typeof pack.id === "string" && /^[a-z][a-z0-9-]{2,23}$/u.test(pack.id), "id must be 3-24 lowercase letters, digits or hyphens");
+  need(typeof pack.name === "string" && pack.name.length >= 1 && pack.name.length <= 24, "name must be 1-24 characters");
+  need(typeof pack.version === "string" && /^\d+\.\d+\.\d+$/u.test(pack.version), "version must be semver");
+  need(typeof pack.intent === "string" && pack.intent.length > 0, "intent is missing");
+  need(isList(pack.canvas) && pack.canvas.length > 0 && pack.canvas.every((c) => grid.CANVAS[c]), "canvas must list 16:9 and/or 4:3");
+  // `faces` is the deck's default and is Pretendard only; `faces-a2z` applies when the source asks.
+  for (const key of ["faces", "faces-a2z"]) {
+    if (key === "faces-a2z" && pack[key] == null) continue;
+    const faces = pack[key] || {};
+    for (const role of FACE_KEYS) {
+      need(FACES[faces[role]] && (key === "faces-a2z" || /^Pretendard /u.test(faces[role])), `${key}.${role} must name a bundled face${key === "faces-a2z" ? "" : " (Pretendard Regular or Bold)"}`);
+    }
+    const distinct = new Set(FACE_KEYS.map((r) => faces[r]));
+    need(distinct.size <= 3, `${key} uses ${distinct.size} faces; at most 3`);
+    need(new Set([...distinct].map((f) => String(f).split(" ")[0])).size <= 2, `${key} mixes more than two families`);
+  }
+  const palette = pack.palette || {};
+  for (const role of PALETTE_ROLES) need(hex(palette[role]), `palette.${role} is missing or not #RRGGBB`);
+  need(isList(palette.series) && palette.series.length >= 2 && palette.series.length <= 4 && palette.series.every(hex),
+    "palette.series must list 2-4 #RRGGBB colours");
+  if (PALETTE_ROLES.every((r) => hex(palette[r]))) {
+    for (const [a, b, min] of CONTRAST_PAIRS) {
+      const got = contrast(palette[a], palette[b]);
+      need(got >= min, `${a} on ${b} is ${got.toFixed(2)}:1, below ${min}:1`);
+    }
+    need(Math.abs(luminance(palette.line) - luminance(palette.ground)) >= 0.08, "line is not visible on ground (luminance difference below 0.08)");
+    if (isList(palette.series) && palette.series.every(hex)) {
+      need(palette.series[0].toUpperCase() === palette.accent.toUpperCase(), "palette.series must start with the accent");
+      for (const s of palette.series) need(contrast(s, palette.ground) >= 3, `series colour ${s} is below 3:1 on ground`);
+    }
+  }
+  need(["presented", "reading"].includes(pack.ramp), "ramp must be presented or reading");
+  need(typeof pack.hero === "boolean", "hero must be true or false");
+  need(Number.isInteger(pack.density) && pack.density >= 1 && pack.density <= 10, "density must be an integer 1-10");
+  need(Number.isInteger(pack.variance) && pack.variance >= 4 && pack.variance <= 10, "variance must be an integer 4-10");
+  need(pack.radius === 0 || pack.radius === 6, "radius must be 0 or 6");
+  need(["border", "fill", "fill+border"].includes(pack.edge), "edge must be border, fill or fill+border");
+  const treatments = isList(pack.treatments) ? pack.treatments : [];
+  need(treatments.length >= 3 && treatments.length <= 5, "treatments must list 3-5 title treatments");
+  for (const t of treatments) need(grid.TREATMENTS.includes(t), `unknown treatment "${t}" (known: ${grid.TREATMENTS.join(", ")})`);
+  const roles = pack["role-defaults"] || {};
+  for (const role of SLIDE_ROLES) need(treatments.includes(roles[role]), `role-defaults.${role} must be one of the pack's treatments`);
+  // A family's own title in this pack, ahead of its role default: the structure the pack draws it with.
+  const structure = pack.structure || {};
+  need(typeof structure === "object" && !Array.isArray(structure), "structure must be a map of family to treatment");
+  for (const [f, t] of Object.entries(structure)) {
+    need(Boolean(grid.FAMILIES[f]), `structure names an unknown family "${f}"`);
+    need(treatments.includes(t) && grid.FAMILIES[f] && grid.FAMILIES[f].allow.includes(t), `structure.${f} must be a treatment of the pack that the family allows`);
+  }
+  for (const d of pack.decoration || []) need(DECORATIONS.includes(d), `unknown decoration "${d}"`);
+  need(pack.rail == null || ["surface", "field"].includes(pack.rail), "rail must be surface or field");
+  const display = pack.display || {};
+  need(typeof display === "object" && !Array.isArray(display), "display must be a map");
+  for (const [key, devices] of Object.entries(DISPLAY_DEVICES)) {
+    need(display[key] == null || devices.includes(display[key]), `display.${key} must be one of ${devices.join(", ")}`);
+  }
+  need(display.index == null || typeof display.index === "boolean", "display.index must be true or false");
+  for (const key of Object.keys(display)) need(key === "index" || DISPLAY_DEVICES[key], `unknown display key "${key}"`);
+  const families = pack["layout-families"] || [];
+  need(families.length >= 6, "layout-families must list at least 6 families");
+  for (const f of families) {
+    need(Boolean(grid.FAMILIES[f]), `unknown layout family "${f}"`);
+    if (grid.FAMILIES[f]) need(grid.FAMILIES[f].allow.some((t) => treatments.includes(t)), `the ${f} family allows none of the pack's treatments`);
+  }
+  for (const [key, kind, min] of [["covers", "cover", 3], ["sections", "section", 2], ["closings", "closing", 2]]) {
+    const list = pack[key] || [];
+    need(list.length >= min, `${key} must list at least ${min} variants`);
+    for (const v of list) need(grid.VARIANTS[kind].includes(v), `unknown ${kind} variant "${v}"`);
+  }
+  for (const key of ["table", "chart", "image"]) need(pack[key] && typeof pack[key] === "object", `${key} settings are missing`);
+  const order = pack["fill-order"] || [];
+  need(order.length === FILL_POLICIES.length && FILL_POLICIES.every((p) => order.includes(p)), `fill-order must order ${FILL_POLICIES.join(", ")}`);
+  if (problems.length) throw new Error(`Tonality pack ${file}: ${problems.join("; ")}`);
+  return pack;
+}
+
+/** Load and check one tonality pack by id. */
+function loadPack(name) {
+  // Pack ids are lowercase; a display name such as "Ledger" names the same pack.
+  const id = String(name).toLowerCase();
+  const known = listTonalities();
+  const dir = tonalityDirs()
+    .map((base) => path.join(base, String(id)))
+    .find((candidate) => /^[a-z][a-z0-9-]*$/u.test(String(id)) && fs.existsSync(path.join(candidate, "pack.yaml")));
+  if (!dir) {
+    throw new Error(`Unknown tonality "${name}". Tonalities: ${known.join(", ") || "(none)"}; legacy templates: ${listTemplates().join(", ")}`);
+  }
+  const file = path.join(dir, "pack.yaml");
+  const pack = validatePack(parseYaml(fs.readFileSync(file, "utf-8")), file);
+  if (pack.id !== path.basename(dir)) throw new Error(`Tonality pack ${file}: id "${pack.id}" must match its folder name`);
+  return pack;
+}
+
+// Today's hand-tuned geometry, now a token set. A legacy template draws with these values unless
+// its template.yaml overrides one under `pack: tokens:`; a tonality pack derives its own from the dials.
+const LEGACY_TOKENS = {
+  card: { pad: 0.30, chip: 0.52, minH: 1.6, gap: 0.28, radius: 0.16 },
+  kpi: { minCardWidth: 1.9, blockHeight: 1.75, gap: 0.26 },
+  bullet: { size: 16, x: 0.59, w: 8.8, h: 0.38, ySpacing: 0.42, lineSpacing: 1.25 },
+  secHeader: { size: 18, x: 0.39, w: 9.0, h: 0.5 },
+  summary: { headerW: 4.3, bulletW: 4.8, bulletSize: 14, bulletH: 0.34, ySpacing: 0.38, lineSpacing: 1.05 },
+  toc: { size: 18, x: 0.39, w: 7.5, h: 0.55, yStart: 0.957, ySpacing: 0.65 },
+  notice: { x: 0.45, h: 0.3, bottom: 0.14, size: 10.5 },
+};
+// Rich card, KPI and table rendering plus the accent, font and background switches, for a copy of
+// an older template that still says `render_style: azure` instead of listing its capabilities.
+const RICH_LEGACY_CAPABILITIES = ["rich-blocks", "recolor", "font-swap", "mesh-background"];
+
+function mergeTokens(base, extra) {
+  const out = {};
+  for (const [group, values] of Object.entries(base)) out[group] = { ...values, ...((extra && extra[group]) || {}) };
+  return out;
+}
+
+/**
+ * A legacy template read as a pack: one title treatment, its own palette mapped onto the pack
+ * roles, its capabilities, and today's geometry as tokens. It renders through the legacy path, so
+ * a deck that names the template keeps its look.
+ */
+function legacyPack(name, template) {
+  const pal = template.palette || {};
+  const own = template.pack || {};
+  const capabilities = Array.isArray(own.capabilities)
+    ? own.capabilities
+    : template.render_style === "azure" ? RICH_LEGACY_CAPABILITIES : [];
+  const accent = pal.primary || `#${String((template.global_typography || {}).bullet_color || "3C3836").replace("#", "")}`;
+  const palette = {
+    ground: pal.ground || pal.paper || "#FFFFFF",
+    surface: pal.tint || pal.paper_warm || pal.header_fill || "#F6F6F6",
+    ink: pal.ink || "#000000",
+    "ink-muted": pal.ink_muted || pal.muted || pal.ink || "#555555",
+    line: pal.line || "#CCCCCC",
+    accent,
+    "accent-deep": pal.primary_deep || pal.ink || accent,
+    "accent-tint": pal.tint || pal.paper_warm || "#F6F6F6",
+    field: pal.primary_deep || pal.ink || accent,
+    "on-field": "#FFFFFF",
+  };
+  const report = CONTRAST_PAIRS
+    .filter(([a, b]) => palette[a] && palette[b])
+    .map(([a, b, min]) => ({ pair: `${a} on ${b}`, ratio: +contrast(palette[a], palette[b]).toFixed(2), min }))
+    .filter((r) => r.ratio < r.min);
+  return {
+    id: name,
+    name,
+    legacy: true,
+    treatments: ["top-rule"],
+    capabilities,
+    palette,
+    tokens: mergeTokens(LEGACY_TOKENS, own.tokens),
+    contrast: report,
+  };
+}
+
+function hasCapability(templateObj, capability) {
+  return Boolean(templateObj && templateObj.pack && (templateObj.pack.capabilities || []).includes(capability));
+}
+
+/**
+ * Load a tonality pack as the template object the resolver and renderer read. The dials come from
+ * the deck (frontmatter or flags) or the pack defaults; the renderer never sees the pack's name.
+ */
+function loadTonality(id, options = {}) {
+  const pack = loadPack(id);
+  const density = grid.clampDial(options.density != null ? options.density : pack.density, pack.density);
+  const variance = grid.clampDial(options.variance != null ? options.variance : pack.variance, pack.variance);
+  const canvas = options.canvas || pack.canvas[0];
+  if (!pack.canvas.includes(canvas)) {
+    throw new Error(`Tonality "${pack.id}" supports ${pack.canvas.join(", ")}, not canvas ${canvas}`);
+  }
+  const tok = grid.densityTokens(density, pack.ramp);
+  const g = grid.makeGrid(canvas, tok.grid);
+  // Pretendard by default; the A2Z map only when the source asks for it (`faces: a2z`).
+  const wantsA2z = String(options.faces || "").toLowerCase() === "a2z" && pack["faces-a2z"];
+  const faceMap = wantsA2z ? pack["faces-a2z"] : pack.faces;
+  const faces = Object.fromEntries(FACE_KEYS.map((role) => [role, FACES[faceMap[role]]]));
+  const P = pack.palette;
+  const template = {
+    name: pack.name,
+    label: `${pack.name} tonality`,
+    version: pack.version,
+    fonts: { title: faces.title.font, body: faces.body.font, light: faces.body.font },
+    dimensions: { width: g.W / 72, height: g.H / 72, unit: "inches", format: canvas },
+    palette: {
+      ink: P.ink, ink_muted: P["ink-muted"], primary: P.accent, primary_deep: P["accent-deep"],
+      azure: P.series[1] || P.accent, azure_soft: P["accent-tint"], tint: P.surface, line: P.line, ground: P.ground, paper: P.ground,
+    },
+    global_typography: { char_spacing: 0, bullet_color: P.accent.replace("#", ""), section_accent: P.accent.replace("#", "") },
+  };
+  const pt = (v) => v / 72;
+  return {
+    name: pack.id,
+    version: pack.version,
+    template,
+    mapping: { layouts: {} },
+    capabilities: { font_roles: {} },
+    pack: {
+      ...pack,
+      legacy: false,
+      capabilities: [],
+      faces,
+      dials: { density, variance, varianceMax: grid.varianceMax(variance, pack.treatments.length), canvas },
+      tok,
+      grid: g,
+      tokens: mergeTokens(LEGACY_TOKENS, {
+        card: { pad: pt(tok.pad), chip: 0, minH: 0, gap: pt(g.gutter), radius: pt(pack.radius) },
+        kpi: { minCardWidth: pt(g.span(1, 2).w), blockHeight: pt(tok.pad * 2 + tok.sizes.display * 1.15 + 6 + tok.sizes.label * 1.3), gap: pt(g.gutter) },
+      }),
+    },
+  };
+}
+
+module.exports = { loadTemplate, listTemplates, loadPack, listTonalities, loadTonality, hasCapability, validatePack, legacyPack, LEGACY_TOKENS };

package/plugins/litclaude/skills/lit-pptx/scripts/qa_deck.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """Honest, renderer-agnostic QA gate for generated PPTX decks.
 
-Brand-neutral: works for any enrolled template. Combines three checks and
+Brand-neutral: works for any enrolled template. Combines these checks and
 exits non-zero if ANY real defect is found:
 
   1. Layout issues  — layout_inventory.py (frame overflow / slide overflow / off-slide)
@@ -12,6 +12,13 @@ exits non-zero if ANY real defect is found:
   5. Deck craft     — deck_craft.py (sparse slides, table-only decks, shapes off
                       the canvas, stray empty boxes, [placeholder] blanks, long
                       foreign-language source lines on a Korean deck)
+  6. Craft floor    — craft_extras.py (OF-101..OF-109 per slide; OF-110..OF-113
+                      over the deck: title-treatment count, composition variety,
+                      empty bottom band, one frame per title treatment; OF-114
+                      titles and the cover subtitle as labels, not sentences;
+                      OF-115 no empty region; OF-117 no light figure card on a
+                      dark ground; OF-116 with --sibling: another tonality of
+                      the same source draws another skeleton)
 
 No LibreOffice / rendering engine required: everything is read from the OOXML
 via python-pptx. (A renderer is only ever needed for the *visual* pass, which
@@ -107,10 +114,22 @@ def _bbox(shape):
         return None
 
 
-def _resolve_bg(shape, idx, filled):
+def _slide_ground(slide) -> tuple[int, int, int]:
+    """The slide's own solid background, white when it has none (or inherits one)."""
+    try:
+        fill = slide.background.fill
+        if fill.type == 1:  # solid
+            return _hex_to_rgb(fill.fore_color.rgb) or (255, 255, 255)
+    except (AttributeError, TypeError, ValueError):
+        pass
+    return (255, 255, 255)
+
+
+def _resolve_bg(shape, idx, filled, ground=(255, 255, 255)):
     """Effective background for a text shape: its own fill, else the topmost
     filled shape drawn *behind* it (lower z-order) that contains its centre,
-    else white. Prevents false positives like white text over a charcoal band."""
+    else the slide background. Prevents false positives like white text over a
+    charcoal band, or light text on a dark slide."""
     own = _shape_fill_rgb(shape)
     if own is not None:
         return own
@@ -125,7 +144,7 @@ def _resolve_bg(shape, idx, filled):
                 best = f_rgb  # later (higher idx) wins -> topmost behind text
         if best is not None:
             return best
-    return (255, 255, 255)
+    return ground
 
 
 def check_contrast(path: Path) -> dict[str, Any]:
@@ -136,10 +155,11 @@ def check_contrast(path: Path) -> dict[str, Any]:
     for s_idx, slide in enumerate(prs.slides, start=1):
         shapes = list(slide.shapes)
         filled = [(i, rgb, _bbox(sh)) for i, sh in enumerate(shapes) if (rgb := _shape_fill_rgb(sh)) is not None]
+        ground = _slide_ground(slide)
         for idx, shape in enumerate(shapes):
             if not getattr(shape, "has_text_frame", False):
                 continue
-            bg = _resolve_bg(shape, idx, filled)
+            bg = _resolve_bg(shape, idx, filled, ground)
             for para in shape.text_frame.paragraphs:
                 for run in para.runs:
                     if not run.text.strip():
@@ -457,7 +477,11 @@ def check_evidence_binding(path: Path) -> dict[str, Any]:
             checked += 1
             figure_box = _bbox_in(shape)
             nearby: list[str] = []
-            if figure_box is not None:
+            page_area = (prs.slide_width / 914400.0) * (prs.slide_height / 914400.0)
+            if figure_box is not None and _is_full_bleed(figure_box, page_area):
+                # A full-bleed picture carries its caption on the panel laid over it.
+                nearby = [text for other in shapes if other is not shape and (text := _shape_text(other))]
+            elif figure_box is not None:
                 figure_width = figure_box[2] - figure_box[0]
                 for other in shapes:
                     text = _shape_text(other)
@@ -664,14 +688,17 @@ def run_validate(pptx: Path) -> dict[str, Any]:
 
 
 # ── gate ───────────────────────────────────────────────────────────────────
-def qa(pptx: Path) -> dict[str, Any]:
+def qa(pptx: Path, sibling: Path | None = None) -> dict[str, Any]:
     from ooxml_integrity import check_package
     from deck_craft import analyse as analyse_craft
-    from craft_extras import analyse as analyse_extras
+    from craft_extras import analyse as analyse_extras, compare_skeletons
 
     integrity = check_package(pptx)
     craft = analyse_craft(pptx)
     extras = analyse_extras(pptx)
+    # Another tonality of the same source, when given: the two must not draw one skeleton (OF-116).
+    if sibling is not None:
+        extras["findings"] += compare_skeletons(pptx, sibling)
     validate_report = run_validate(pptx)
     inv_summary = summarize_inventory(load_inventory_issues(pptx))
     contrast = check_contrast(pptx)
@@ -695,7 +722,8 @@ def qa(pptx: Path) -> dict[str, Any]:
             extras_high.setdefault(finding["check"], []).append(finding)
     for check, found in extras_high.items():
         slides = sorted({f["slide"] for f in found if f["slide"] is not None})
-        reasons.append(f"craft {check} on slide(s) {', '.join(map(str, slides))} — {found[0]['hint']}")
+        where = f" on slide(s) {', '.join(map(str, slides))}" if slides else f" ({found[0]['detail']})"
+        reasons.append(f"craft {check}{where} — {found[0]['hint']}")
     if not validate_report.get("pass", False):
         reasons.append("anti-slop: " + ", ".join(
             k for k, v in validate_report.get("checks", {}).items() if isinstance(v, dict) and not v.get("pass", True)
@@ -756,8 +784,9 @@ def qa(pptx: Path) -> dict[str, Any]:
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(description="Honest renderer-agnostic QA gate for PPTX decks.")
     parser.add_argument("pptx", type=Path)
+    parser.add_argument("--sibling", type=Path, help="the same source compiled under another tonality (OF-116)")
     args = parser.parse_args(argv)
-    report = qa(args.pptx.resolve())
+    report = qa(args.pptx.resolve(), args.sibling.resolve() if args.sibling else None)
     print(json.dumps(report, ensure_ascii=False, indent=2))
     return 0 if report["pass"] else 1
 

package/plugins/litclaude/skills/lit-pptx/scripts/validate_pptx.py

@@ -61,15 +61,24 @@ def _load_terms() -> tuple[list[str], list[str], bool, bool]:
     )
 
 
-def _build_regex(terms: list[str], case_insensitive: bool, whole_word: bool) -> re.Pattern[str] | None:
+def _build_regex(terms: list[str], case_insensitive: bool, whole_word: bool, single_words: bool = False) -> re.Pattern[str] | None:
     if not terms:
         return None
-    escaped = [re.escape(term) for term in terms]
+    # An acronym (RAM, FTO) is a word in capitals: matched as that word, so "diagram" or "program"
+    # does not contain it. With single_words a term that is one Latin word (todo, tbd) is matched as
+    # that word or its plural (TODOs), so "Mastodon" or "photodocument" does not contain it. Every
+    # other term keeps the file's case and word settings.
+    acronyms = [term for term in terms if re.fullmatch(r"[A-Z]{2,5}", term)]
+    escaped = [rf"(?<![A-Za-z]){re.escape(term)}s?(?![A-Za-z])" if single_words and re.fullmatch(r"[A-Za-z]+", term) else re.escape(term)
+               for term in terms if term not in acronyms]
     pattern = "|".join(escaped)
-    if whole_word:
+    if whole_word and pattern:
         pattern = rf"(?:(?<=\W)|^)(?:{pattern})(?:(?=\W)|$)"
-    flags = re.IGNORECASE if case_insensitive else 0
-    return re.compile(pattern, flags)
+    if case_insensitive and pattern:
+        pattern = f"(?i:{pattern})"
+    if acronyms:
+        pattern = "|".join(filter(None, [pattern, rf"(?<![A-Za-z])(?:{'|'.join(map(re.escape, acronyms))})(?![A-Za-z])"]))
+    return re.compile(pattern)
 
 
 def _shape_text(shape) -> str:
@@ -112,6 +121,10 @@ def _slide_has_title(slide, slide_height: int | None) -> bool:
     title_shape = getattr(slide.shapes, "title", None)
     if title_shape is not None and _shape_text(title_shape):
         return True
+    # A tonality deck names its title frame by treatment (title@side-rail, title@bottom-anchor, ...),
+    # wherever the treatment puts it on the slide.
+    if any(str(getattr(shape, "name", "")).startswith("title@") and _shape_text(shape) for shape in slide.shapes):
+        return True
     for shape in slide.shapes:
         if not getattr(shape, "is_placeholder", False):
             continue
@@ -137,7 +150,7 @@ def _slide_has_title(slide, slide_height: int | None) -> bool:
 def lint(path: str | Path) -> dict[str, Any]:
     prs = Presentation(str(path))
     hard_terms, soft_terms, case_insensitive, whole_word = _load_terms()
-    hard_re = _build_regex(hard_terms, case_insensitive, whole_word)
+    hard_re = _build_regex(hard_terms, case_insensitive, whole_word, single_words=True)
     soft_re = _build_regex(soft_terms, case_insensitive, whole_word)
 
     missing_titles: list[int] = []
@@ -175,7 +188,9 @@ def lint(path: str | Path) -> dict[str, Any]:
                 default_font_hits.append(f"slide {slide_idx}: {font_name}")
 
     last_slide_text = "\n".join(_shape_text(shape) for shape in prs.slides[-1].shapes if getattr(shape, "has_text_frame", False)).lower() if prs.slides else ""
-    has_source_note = "source:" in last_slide_text or "출처" in last_slide_text
+    # A closing references page is the deck's source note in its long form.
+    has_source_note = "source:" in last_slide_text or "출처" in last_slide_text or bool(
+        re.search(r"^\s*(references|참고\s*문헌)\s*$", last_slide_text, re.MULTILINE))
 
     failures = {
         "missing_titles": bool(missing_titles),

package/plugins/litclaude/skills/lit-pptx/templates/enrolled/AZURE-A2Z/layout-mapping.yaml

@@ -1,5 +1,5 @@
 # Layout Mapping — AZURE-PRO (16:9, 13.333 x 7.5 in). Positions in inches.
-# render_style: azure → body→cards, kpi-table→KPI cards, cover title **emphasis**.
+# rich-blocks capability (template.yaml pack:) → body→cards, kpi-table→KPI cards, cover title **emphasis**.
 
 layouts:
   cover:

package/plugins/litclaude/skills/lit-pptx/templates/enrolled/AZURE-A2Z/template.yaml

@@ -1,7 +1,6 @@
 name: AZURE-A2Z
 version: "1.0.0"
 label: "Azure Professional (에이투지체 / A2Z)"
-render_style: azure
 description: "Flagship SOTA blue-and-white deck — 16:9 widescreen, Pretendard, geometric gradient accents, rounded tint cards, numbered chips, KPI cards. Pro-designer aesthetic."
 
 fonts:
@@ -35,3 +34,7 @@ global_typography:
   bullet_char: "•"
   bullet_color: "1D4ED8"
   section_accent: "1D4ED8"
+
+# Read as a legacy pack: what this template can draw beyond plain text regions.
+pack:
+  capabilities: [rich-blocks, recolor, font-swap, mesh-background]

package/plugins/litclaude/skills/lit-pptx/templates/enrolled/AZURE-PRO/layout-mapping.yaml

@@ -1,5 +1,5 @@
 # Layout Mapping — AZURE-PRO (16:9, 13.333 x 7.5 in). Positions in inches.
-# render_style: azure → body→cards, kpi-table→KPI cards, cover title **emphasis**.
+# rich-blocks capability (template.yaml pack:) → body→cards, kpi-table→KPI cards, cover title **emphasis**.
 
 layouts:
   cover:

package/plugins/litclaude/skills/lit-pptx/templates/enrolled/AZURE-PRO/template.yaml

@@ -1,7 +1,6 @@
 name: AZURE-PRO
 version: "1.0.0"
 label: "Azure Professional"
-render_style: azure
 description: "Flagship SOTA blue-and-white deck — 16:9 widescreen, Pretendard, geometric gradient accents, rounded tint cards, numbered chips, KPI cards. Pro-designer aesthetic."
 
 fonts:
@@ -35,3 +34,7 @@ global_typography:
   bullet_char: "•"
   bullet_color: "1D4ED8"
   section_accent: "1D4ED8"
+
+# Read as a legacy pack: what this template can draw beyond plain text regions.
+pack:
+  capabilities: [rich-blocks, recolor, font-swap, mesh-background]

package/plugins/litclaude/skills/lit-pptx/templates/tonalities/atlas/pack.yaml

@@ -0,0 +1,92 @@
+# Atlas: a picture book with captions. Images bleed, titles sit on dark panels over photographs
+# or under large images, text stays short and calm, and the photographs bring the colour. Wrong
+# when there are few real images: a look built around pictures turns into empty boxes without them.
+id: atlas
+name: Atlas
+version: "1.0.0"
+intent: "Image-led decks: products, portfolios, places, field work."
+canvas: ["16:9", "4:3"]
+
+# Pretendard by default; the A2Z map below applies only when the source asks (faces: a2z).
+faces:
+  display: Pretendard Regular
+  title: Pretendard Bold
+  body: Pretendard Regular
+  label: Pretendard Regular
+  numeral: Pretendard Regular
+faces-a2z:
+  display: A2Z Light
+  title: Pretendard Bold
+  body: Pretendard Regular
+  label: Pretendard Regular
+  numeral: A2Z Light
+
+palette:
+  ground: "#FFFFFF"
+  surface: "#F3F4F5"
+  ink: "#1A1D21"
+  ink-muted: "#555B63"
+  line: "#D6D9DD"
+  accent: "#2B4C7E"
+  accent-deep: "#1B2F4E"
+  accent-tint: "#E6ECF4"
+  field: "#1A1D21"
+  on-field: "#FFFFFF"
+  positive: "#1E7A3F"
+  negative: "#B3261E"
+  series: ["#2B4C7E", "#555B63", "#8A6A2E", "#3E7A5A"]
+
+ramp: reading
+hero: false
+type-voice:
+  title-tracking: 0
+  display-tracking: -1
+
+density: 10
+variance: 7
+radius: 0
+edge: fill
+
+treatments: [overlay, bottom-anchor, side-rail, top-plain-large, statement]
+role-defaults:
+  content: side-rail
+  data: top-plain-large
+  data-takeaway: bottom-anchor
+  sequence: top-plain-large
+  image: overlay
+  statement: statement
+  reference: side-rail
+  definition: side-rail
+
+decoration: [caption-band, hairline-rule, colour-field]
+layout-families: [image-full, image-split, photo-grid, figure-pair, asymmetric-feature, kpi-row, comparison, timeline, text-column, statement]
+# Display slides: the device a type-led cover, a statement, a big number and a closing's next step
+# are drawn with (see references/layout-families.md, "Display slides").
+display:
+  cover: plate
+  statement: drench
+  number: tint
+  closing: band
+covers: [cover-full-image, cover-split-image, cover-typographic]
+sections: [section-image, section-field]
+closings: [closing-contact-split, closing-ask]
+
+table:
+  header: none
+  header-ink: ink
+  rules: rows
+  banding: none
+  totals: bold
+chart:
+  gridlines: hairline
+  labels: direct
+  highlight: accent-on-muted
+image:
+  frame: none
+
+fill-order: [anchor-visual, change-family, distribute, step-up]
+avoid:
+  - text placed straight on photographs
+  - images in card frames
+  - more than three images in one row
+  - grey placeholder boxes in a delivered deck