@litfamily/lithermes 1.0.7 → 1.0.9

package/assets/lithermes-plugin/skills/lit-pptx/scripts/compile-deck.js

@@ -0,0 +1,447 @@
+#!/usr/bin/env node
+"use strict";
+
+/**
+ * compile-deck.js — Compile a Markdown deck into a versioned slide AST,
+ *                    and optionally render to HTML or PPTX.
+ *
+ * Usage:
+ *   node compile-deck.js input.md --ast out.json
+ *   node compile-deck.js input.md                         (prints JSON to stdout)
+ *   node compile-deck.js input.md --template AZURE-PRO --html out.html
+ *   node compile-deck.js input.md --template AZURE-PRO --pptx out.pptx
+ *   node compile-deck.js input.md --template AZURE-PRO --ast out.json --html out.html --pptx out.pptx
+ *
+ * API:
+ *   const compileDeck = require('./compile-deck');
+ *   const ast = compileDeck(markdownSource);
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+const { load: loadMarkdown } = require("./lib/markdown-loader");
+const { validate: validateContent } = require("./lib/directive-parser");
+const { buildBlocks, buildAst } = require("./lib/slide-ast");
+const { validate: validateAst } = require("./lib/spec-validator");
+
+// Lazy-loaded modules — may not exist yet (built by another agent)
+let templateRegistry = null;
+let layoutResolver = null;
+let renderHtml = null;
+let renderPptx = null;
+
+try {
+  templateRegistry = require("./lib/template-registry");
+} catch (_) { /* template-registry not yet available */ }
+
+try {
+  layoutResolver = require("./lib/layout-resolver");
+} catch (_) { /* layout-resolver not yet available */ }
+
+try {
+  renderHtml = require("./lib/render-adapter-html");
+} catch (_) { /* render-adapter-html not yet available */ }
+
+try {
+  renderPptx = require("./lib/render-adapter-pptx");
+} catch (_) { /* render-adapter-pptx not yet available */ }
+
+/**
+ * Compile a Markdown source string into a slide AST.
+ * @param {string} source — Raw Markdown deck content
+ * @returns {object} — AST conforming to slide-ast-v1.schema.json
+ */
+function compileDeck(source) {
+  // 1. Parse frontmatter and split into slides
+  const { deck, slides } = loadMarkdown(source);
+
+  // 2. Validate content and build AST for each slide
+  const parsedSlides = slides.map((slide) => {
+    // Validate for forbidden constructs (HTML/CSS, nested directives)
+    validateContent(slide.content, slide.index);
+
+    // Build AST blocks
+    const blocks = buildBlocks(slide.layout, slide.content);
+
+    return {
+      index: slide.index,
+      layout: slide.layout,
+      ...(slide.meta && Object.keys(slide.meta).length > 0 ? { meta: slide.meta } : {}),
+      blocks,
+    };
+  });
+
+  // 3. Assemble complete AST
+  const ast = buildAst(deck, parsedSlides);
+
+  // 4. Validate the assembled AST
+  validateAst(ast);
+
+  return ast;
+}
+
+// Bundled faces, by the family a template names. A chart drawn outside this
+// skill needs the file, not the family: matplotlib resolves a Korean family by
+// registering the file and reading its internal name, which is the failure this
+// export exists to prevent.
+const BUNDLED_FONTS = [
+  { match: /Pretendard/i, dir: "pretendard-font/public/static",
+    files: ["PretendardGOV-Regular.otf", "PretendardGOV-Bold.otf"] },
+  { match: /에이투지체/, dir: "fonts/a2z-font",
+    files: ["A2Z-Regular.otf", "A2Z-Bold.otf"] },
+];
+
+/**
+ * Describe a template's visual system for a chart drawn elsewhere.
+ *
+ * A chart belongs to /scientific-visualization, not to this skill, and the
+ * reason charts end up looking foreign in a deck is that the tool drawing them
+ * cannot see the deck's colours, typeface or canvas. This hands those over.
+ *
+ * @param {object} templateObj — loaded template, after any accent or font override
+ * @returns {object}
+ */
+function vizContext(templateObj) {
+  const tpl = (templateObj && templateObj.template) || {};
+  const palette = tpl.palette || {};
+  const dims = tpl.dimensions || {};
+  const family = (tpl.fonts && tpl.fonts.body) || "";
+
+  const bundle = BUNDLED_FONTS.find((f) => f.match.test(family));
+  const files = bundle
+    ? bundle.files
+        .map((name) => path.join(__dirname, "..", bundle.dir, name))
+        .filter((p) => fs.existsSync(p))
+    : [];
+
+  // Series order runs strongest to quietest so a two-line chart reads without a
+  // legend and a four-line one still separates.
+  const series = [palette.primary, palette.azure_soft, palette.primary_deep, palette.ink_muted]
+    .filter(Boolean);
+
+  return {
+    template: templateObj.name,
+    palette: { ...palette, series },
+    fonts: { family, files, bundled: files.length > 0 },
+    canvas: { width: dims.width, height: dims.height, unit: dims.unit || "in" },
+    dpi: 200,
+  };
+}
+
+/**
+ * Resolve an AST against a template and render to the requested formats.
+ * @param {object} ast - Compiled AST
+ * @param {string} templateName - Template name (e.g. AZURE-PRO)
+ * @param {object} outputs - { html: path|null, pptx: path|null }
+ */
+async function resolveAndRender(ast, templateName, outputs, options = {}) {
+  if (!templateRegistry) {
+    throw new Error("template-registry module not available. Cannot resolve template.");
+  }
+  if (!layoutResolver) {
+    throw new Error("layout-resolver module not available. Cannot resolve layouts.");
+  }
+
+  const templateObj = templateRegistry.loadTemplate(templateName);
+
+  // Font override (azure-style templates): swap the whole font system regardless
+  // of which template was chosen. Applied before accent (independent of colour).
+  if (options.font && templateObj.template && templateObj.template.render_style === "azure") {
+    const { applyFont, KEYS } = require("./lib/font-map");
+    if (KEYS.includes(options.font)) {
+      applyFont(templateObj, options.font);
+      console.log(`Font → ${options.font}`);
+    }
+  }
+
+  const resolved = layoutResolver.resolve(ast, templateObj);
+  if (options.sourceDir) resolved.sourceDir = options.sourceDir;
+
+  // Custom accent recolor (azure-style templates only): derive a WCAG-safe
+  // palette from the accent hex, override template tokens + hardcoded decoration
+  // colors, and regenerate the gradient circle PNGs in the new hue.
+  if (options.accent && templateObj.template && templateObj.template.render_style === "azure") {
+    const { derivePalette, defaultToDerivedMap } = require("./lib/derive-palette");
+    const { genGradientAssets } = require("./lib/gen-gradient-assets");
+    const os = require("os");
+    const derived = derivePalette(options.accent);
+    templateObj.template.palette = { ...(templateObj.template.palette || {}), ...derived };
+    templateObj.template.global_typography = {
+      ...(templateObj.template.global_typography || {}),
+      bullet_color: derived.bullet_color,
+      section_accent: derived.section_accent,
+    };
+    const map = defaultToDerivedMap(derived);
+    const remap = (obj, keys) => {
+      for (const k of keys) {
+        if (obj[k]) {
+          const key = "#" + String(obj[k]).replace("#", "").toUpperCase();
+          if (map.has(key)) obj[k] = map.get(key);
+        }
+      }
+    };
+    // font_role colors are hardcoded in capabilities.yaml (eyebrow/kpi use the
+    // default primary etc.) — remap them too, else they leak the old hue.
+    const roles = templateObj.capabilities && templateObj.capabilities.font_roles;
+    if (roles) for (const r of Object.values(roles)) remap(r, ["color", "fill"]);
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "azure-accent-"));
+    await genGradientAssets(derived.gradient, tmpDir);
+    const seen = new Set();
+    for (const slide of resolved.slides || []) {
+      for (const d of slide.decorations || []) {
+        if (seen.has(d)) continue; // decoration objects are shared across slides
+        seen.add(d);
+        remap(d, ["fill", "line", "color"]);
+        if (d.dir === "azure" && d.asset) d.assetPath = path.join(tmpDir, d.asset);
+      }
+    }
+    console.log(`Accent ${options.accent} → primary ${derived.primary} (white-contrast ${derived._ratios.whiteOnPrimary}:1)`);
+  }
+
+  // Blurred gradient-mesh background (azure-style): ambient wash on cover/closing/
+  // content (light) and a deep textured wash on section dividers (dark). Uses the
+  // ACTIVE palette (so it respects --accent). The dark mesh sits ABOVE the base
+  // section fill rect, so qa_deck still resolves the (dark) fill behind white text.
+  if (options.bg === "mesh" && templateObj.template && templateObj.template.render_style === "azure") {
+    const { genMeshBg } = require("./lib/gen-bg");
+    const os = require("os");
+    const dims = templateObj.template.dimensions || {};
+    const pageW = dims.width || 13.333;
+    const pageH = dims.height || 7.5;
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "azure-bg-"));
+    const { light, dark } = await genMeshBg(templateObj.template.palette || {}, tmpDir);
+    for (const slide of resolved.slides || []) {
+      const decs = slide.decorations || (slide.decorations = []);
+      const fullBleed = { type: "image", x: 0, y: 0, w: pageW, h: pageH };
+      if (slide.layout === "section") {
+        const rectIdx = decs.findIndex((d) => d.type === "rect" && (d.w || 0) >= pageW - 0.2);
+        decs.splice(rectIdx >= 0 ? rectIdx + 1 : 0, 0, { ...fullBleed, assetPath: dark });
+      } else {
+        decs.unshift({ ...fullBleed, assetPath: light });
+      }
+    }
+    console.log(`Background: mesh (${(resolved.slides || []).length} slides)`);
+  }
+
+  const tasks = [];
+
+  if (outputs.html) {
+    if (!renderHtml) {
+      throw new Error("render-adapter-html module not available.");
+    }
+    const html = renderHtml.render(resolved, templateObj);
+    tasks.push(
+      fs.promises.writeFile(outputs.html, html, "utf-8").then(() => {
+        console.log(`HTML written to ${outputs.html}`);
+      })
+    );
+  }
+
+  if (outputs.pptx) {
+    if (!renderPptx) {
+      throw new Error("render-adapter-pptx module not available.");
+    }
+    tasks.push(
+      renderPptx.render(resolved, templateObj, outputs.pptx).then(() => {
+        console.log(`PPTX written to ${outputs.pptx}`);
+      })
+    );
+  }
+
+  if (outputs.vizContext) {
+    const ctx = vizContext(templateObj);
+    fs.writeFileSync(outputs.vizContext, JSON.stringify(ctx, null, 2), "utf-8");
+    console.log(`Visualization context written to ${outputs.vizContext}`);
+  }
+
+  await Promise.all(tasks);
+  return resolved;
+}
+
+// CLI entry point
+if (require.main === module) {
+  const args = process.argv.slice(2);
+
+  // Introspection flags — let an agent discover template capabilities before authoring.
+  if (args[0] === "--list-templates") {
+    const reg = require("./lib/template-registry");
+    for (const name of reg.listTemplates()) {
+      let label = "";
+      try {
+        const t = reg.loadTemplate(name);
+        const d = (t.template && t.template.dimensions) || {};
+        label = ` — ${(t.template && t.template.label) || ""} [${d.width}x${d.height}${d.unit ? d.unit[0] : ""}]`;
+      } catch (_) {}
+      console.log(`${name}${label}`);
+    }
+    process.exit(0);
+  }
+  if (args[0] === "--list-layouts" && args[1]) {
+    const reg = require("./lib/template-registry");
+    const t = reg.loadTemplate(args[1]);
+    const layouts = (t.mapping && t.mapping.layouts) || {};
+    const caps = (t.capabilities && t.capabilities.supported_blocks) || {};
+    for (const [layout, def] of Object.entries(layouts)) {
+      const regions = Object.keys((def && def.regions) || {});
+      console.log(`${layout}:`);
+      console.log(`  blocks:  ${(caps[layout] || []).join(", ")}`);
+      console.log(`  regions: ${regions.join(", ")}`);
+    }
+    process.exit(0);
+  }
+
+  if (args.length === 0) {
+    console.error("Usage:");
+    console.error("  node compile-deck.js --list-templates");
+    console.error("  node compile-deck.js --list-layouts <template>");
+    console.error("  node compile-deck.js <input.md> [--ast out.json]");
+    console.error("  node compile-deck.js <input.md> --template <name> --html out.html");
+    console.error("  node compile-deck.js <input.md> --template <name> --pptx out.pptx");
+    console.error("  node compile-deck.js <input.md> --template <name> --ast out.json --html out.html --pptx out.pptx");
+    console.error("  node compile-deck.js <input.md> --template <name> --pptx out.pptx --boilerplate");
+    console.error("  node compile-deck.js <input.md> --template <name> --export-viz-context ctx.json");
+    process.exit(1);
+  }
+
+  const inputPath = args[0];
+  let astPath = null;
+  let templateName = null;
+  let htmlPath = null;
+  let pptxPath = null;
+  let boilerplate = false;
+  let embedFonts = false;
+  let accent = null;
+  let font = null;
+  let bg = null;
+  let vizContextPath = null;
+
+  for (let i = 1; i < args.length; i++) {
+    if (args[i] === "--embed-fonts") { embedFonts = true; continue; }
+    if (args[i] === "--accent" && args[i + 1]) { accent = args[i + 1]; i++; continue; }
+    if (args[i] === "--font" && args[i + 1]) { font = args[i + 1]; i++; continue; }
+    if (args[i] === "--bg" && args[i + 1]) { bg = args[i + 1]; i++; continue; }
+    if (args[i] === "--export-viz-context" && args[i + 1]) { vizContextPath = args[i + 1]; i++; continue; }
+    if (args[i] === "--ast" && args[i + 1]) {
+      astPath = args[i + 1];
+      i++;
+    } else if (args[i] === "--template" && args[i + 1]) {
+      templateName = args[i + 1];
+      i++;
+    } else if (args[i] === "--html" && args[i + 1]) {
+      htmlPath = args[i + 1];
+      i++;
+    } else if (args[i] === "--pptx" && args[i + 1]) {
+      pptxPath = args[i + 1];
+      i++;
+    } else if (args[i] === "--boilerplate") {
+      boilerplate = true;
+    }
+  }
+
+  // If --html or --pptx is requested, --template is required
+  if ((htmlPath || pptxPath || vizContextPath) && !templateName) {
+    console.error("Error: --template is required when using --html, --pptx or --export-viz-context");
+    process.exit(1);
+  }
+
+  // If --boilerplate is used with --pptx, --template is required
+  if (boilerplate && pptxPath && !templateName) {
+    console.error("Error: --template is required when using --boilerplate with --pptx");
+    process.exit(1);
+  }
+
+  const source = fs.readFileSync(inputPath, "utf-8");
+  const sourceDir = path.dirname(path.resolve(inputPath));
+
+  (async () => {
+    try {
+      const ast = compileDeck(source);
+
+      // Accent: CLI flag wins, else frontmatter `accent:`.
+      const effectiveAccent = accent
+        || (ast.deck && ast.deck.accent)
+        || (ast.deck && ast.deck.metadata && ast.deck.metadata.accent)
+        || null;
+      const effectiveFont = font
+        || (ast.deck && ast.deck.font)
+        || (ast.deck && ast.deck.metadata && ast.deck.metadata.font)
+        || null;
+      const effectiveBg = bg
+        || (ast.deck && ast.deck.background)
+        || (ast.deck && ast.deck.metadata && ast.deck.metadata.background)
+        || null;
+
+      // Write AST if requested
+      if (astPath) {
+        const json = JSON.stringify(ast, null, 2);
+        fs.writeFileSync(astPath, json, "utf-8");
+        console.log(`AST written to ${astPath}`);
+      }
+
+      // Resolve and render if template + output formats specified
+      if (templateName && (htmlPath || pptxPath || vizContextPath)) {
+        // When --boilerplate flag is set, use Python boilerplate engine for PPTX
+        if (boilerplate && pptxPath) {
+          // Write AST to a temp file, then invoke Python compile_boilerplate
+          const os = require("os");
+          const tmpAstPath = path.join(os.tmpdir(), `boilerplate-ast-${Date.now()}.json`);
+          fs.writeFileSync(tmpAstPath, JSON.stringify(ast, null, 2), "utf-8");
+
+          const { execFile } = require("child_process");
+          const scriptDir = __dirname;
+          const pyScript = path.join(scriptDir, "compile_boilerplate.py");
+
+          // Render HTML if also requested (use JS renderer)
+          if (htmlPath) {
+            await resolveAndRender(ast, templateName, {
+              html: htmlPath,
+              pptx: null,
+            }, { sourceDir });
+          }
+
+          // Run Python boilerplate engine for PPTX
+          await new Promise((resolve, reject) => {
+            const pyArgs = [pyScript, tmpAstPath, "--output", pptxPath];
+            const scriptRoot = path.resolve(scriptDir, "..");
+            execFile(process.env.LITHERMES_OFFICE_PYTHON || "python3", pyArgs, { cwd: scriptDir }, (error, stdout, stderr) => {
+              // Clean up temp file
+              try { fs.unlinkSync(tmpAstPath); } catch (_) {}
+              if (error) {
+                reject(new Error(`Boilerplate engine failed: ${stderr || error.message}`));
+                return;
+              }
+              if (stdout) process.stdout.write(stdout);
+              if (stderr) process.stderr.write(stderr);
+              resolve();
+            });
+          });
+        } else {
+          // Standard JS-based rendering
+          await resolveAndRender(ast, templateName, {
+            html: htmlPath,
+            pptx: pptxPath,
+            vizContext: vizContextPath,
+          }, { sourceDir, accent: effectiveAccent, font: effectiveFont, bg: effectiveBg });
+        }
+
+        // Optional: embed bundled fonts into the PPTX for a self-contained deck.
+        if (embedFonts && pptxPath) {
+          const { execFileSync } = require("child_process");
+          execFileSync(process.env.LITHERMES_OFFICE_PYTHON || "python3", [path.join(__dirname, "embed_fonts.py"), pptxPath], {
+            stdio: "inherit",
+          });
+        }
+      } else if (!astPath) {
+        // No outputs specified — print AST to stdout
+        console.log(JSON.stringify(ast, null, 2));
+      }
+    } catch (err) {
+      console.error(`Compilation error: ${err.message}`);
+      process.exit(1);
+    }
+  })();
+}
+
+module.exports = compileDeck;
+module.exports.vizContext = vizContext;

package/assets/lithermes-plugin/skills/lit-pptx/scripts/craft_extras.py

@@ -0,0 +1,215 @@
+"""Additive, non-destructive craft checks over the native slide object model."""
+
+from __future__ import annotations
+
+import colorsys
+import re
+from pathlib import Path
+
+from pptx import Presentation
+from pptx.enum.shapes import MSO_SHAPE_TYPE
+from pptx.enum.text import PP_ALIGN
+
+
+RULES = {
+    "accent_saturation": .12, "accent_light_min": .12, "accent_light_max": .93,
+    "hue_family_deg": 20, "full_bleed": .92, "body_min_pt": 10.5,
+    "display_pt": 30, "latin_line_max": 90, "cjk_line_max": 38,
+    "numeric_share": .70, "frame_inset_in": .06, "radius_error_in": .02,
+    "outer_radius_min_in": .04, "group_ratio": 2,
+    "empty_band_high": .35, "empty_band_medium": .25,
+}
+ADVISORY_BY_TEMPLATE = {"AZURE-PRO": {"OF-109"}}
+EMU = 914400
+NUMERIC = re.compile(r"^[\s,$€£¥₩%▲▼+\-±().0-9]+$")
+EMOJI = re.compile("[\U0001f000-\U0001faff\u2600-\u27bf]")
+
+
+def _box(shape):
+    return tuple(float(getattr(shape, key)) / EMU for key in ("left", "top", "width", "height"))
+
+
+def _rgb(shape):
+    try:
+        value = str(shape.fill.fore_color.rgb)
+        return tuple(int(value[i:i + 2], 16) for i in (0, 2, 4))
+    except (AttributeError, TypeError, ValueError):
+        return None
+
+
+def _hsl(rgb):
+    h, l, s = colorsys.rgb_to_hls(*(value / 255 for value in rgb))
+    return h * 360, s, l
+
+
+def _radius(shape):
+    if shape.shape_type != MSO_SHAPE_TYPE.AUTO_SHAPE or not shape.auto_shape_type:
+        return None
+    if "ROUND" not in str(shape.auto_shape_type).upper():
+        return None
+    guides = shape._element.xpath(".//a:avLst/a:gd[@name='adj']")
+    if not guides:
+        return None
+    match = re.search(r"val\s+(\d+)", guides[0].get("fmla", ""))
+    return float(match.group(1)) / 100000 * min(shape.width, shape.height) / EMU if match else None
+
+
+def _title_or_display(shapes):
+    text = [shape for shape in shapes if getattr(shape, "has_text_frame", False) and shape.text.strip()]
+    if len(text) <= 1:
+        return True
+    return any(max((run.font.size.pt for paragraph in shape.text_frame.paragraphs for run in paragraph.runs if run.font.size), default=0) >= RULES["display_pt"] for shape in text) and len(text) <= 2
+
+
+def _numeric(value):
+    value = value.strip()
+    return bool(value and NUMERIC.fullmatch(value) and re.sub(r"[^0-9]", "", value))
+
+
+def _contains(outer, inner):
+    ox, oy, ow, oh = _box(outer)
+    ix, iy, iw, ih = _box(inner)
+    return inner is not outer and ox <= ix and oy <= iy and ix + iw <= ox + ow and iy + ih <= oy + oh
+
+
+def _gap(first, second):
+    ax, ay, aw, ah = _box(first)
+    bx, by, bw, bh = _box(second)
+    return ((max(0, ax - bx - bw, bx - ax - aw)) ** 2 +
+            (max(0, ay - by - bh, by - ay - ah)) ** 2) ** .5
+
+
+def check(path: Path) -> dict:
+    deck = Presentation(str(path))
+    subject = deck.core_properties.subject or ""
+    template_id = subject.split("template:", 1)[1].strip() if "template:" in subject else ""
+    findings = []
+
+    def add(rule, severity, slide_no, shape, value, threshold, *, tier="measured"):
+        advisory = rule in ADVISORY_BY_TEMPLATE.get(template_id, set())
+        findings.append({"rule": rule, "severity": severity, "slide": slide_no,
+                         "shape": getattr(shape, "name", ""), "value": value,
+                         "threshold": threshold, "tier": tier,
+                         **({"advisory_template": template_id} if advisory else {})})
+
+    for slide_no, slide in enumerate(deck.slides, 1):
+        shapes = list(slide.shapes)
+        display = _title_or_display(shapes)
+        page_area = deck.slide_width * deck.slide_height
+        hues = []
+        for shape in shapes:
+            if shape.width * shape.height >= page_area * RULES["full_bleed"]:
+                continue
+            if re.search(r"circle-|template-image|deco", shape.name or "", re.I):
+                continue
+            color = _rgb(shape)
+            if color is None:
+                continue
+            hue, saturation, lightness = _hsl(color)
+            if saturation < RULES["accent_saturation"] or not (RULES["accent_light_min"] <= lightness <= RULES["accent_light_max"]):
+                continue
+            if not any(min(abs(hue - known), 360 - abs(hue - known)) <= RULES["hue_family_deg"] for known in hues):
+                hues.append(hue)
+        high = 4 if display else 3
+        if len(hues) >= high:
+            add("OF-101", "HIGH", slide_no, slide, len(hues), f"<{high} accent families")
+        elif len(hues) == high - 1:
+            add("OF-101", "MEDIUM", slide_no, slide, len(hues), f"<{high - 1} accent families")
+
+        for shape in shapes:
+            xml = shape._element
+            if xml.xpath(".//a:rPr/a:gradFill"):
+                add("OF-106", "HIGH", slide_no, shape, "gradient text", "none")
+            if xml.xpath(".//a:effectLst/a:glow"):
+                add("OF-107", "HIGH", slide_no, shape, "glow", "none")
+            for bullet in xml.xpath(".//a:pPr/a:buChar"):
+                if EMOJI.search(bullet.get("char", "")):
+                    add("OF-108", "HIGH", slide_no, shape, bullet.get("char"), "non-emoji bullet")
+            if getattr(shape, "has_table", False):
+                table = shape.table
+                if len(table.rows) >= 3:
+                    for column in range(len(table.columns)):
+                        cells = [table.cell(row, column) for row in range(1, len(table.rows))]
+                        numeric = [cell for cell in cells if _numeric(cell.text)]
+                        if len(numeric) / len(cells) < RULES["numeric_share"]:
+                            continue
+                        for cell in numeric:
+                            for paragraph in cell.text_frame.paragraphs:
+                                if paragraph.alignment is not None and paragraph.alignment != PP_ALIGN.RIGHT:
+                                    add("OF-103", "HIGH", slide_no, shape, paragraph.alignment, "right-aligned numeric column")
+                                elif paragraph.alignment is None:
+                                    add("OF-103", "MEDIUM", slide_no, shape, "inherited alignment", "verified right alignment", tier="derived")
+            if getattr(shape, "has_text_frame", False) and shape.text.strip():
+                content = shape.text.strip()
+                sizes = [run.font.size.pt for paragraph in shape.text_frame.paragraphs for run in paragraph.runs if run.font.size]
+                size = max(sizes, default=14)
+                if RULES["body_min_pt"] < size < RULES["display_pt"] and shape.width > 0:
+                    cjk = sum("가" <= char <= "힣" for char in content) / len(content) >= .5
+                    glyphs = sum(1 if "가" <= char <= "힣" else .55 for char in content)
+                    capacity = max(1, (shape.width / EMU) * 72 / size)
+                    lines = max(1, round(glyphs / capacity))
+                    ceiling = RULES["cjk_line_max"] if cjk else RULES["latin_line_max"]
+                    if lines >= 2 and len(content) / lines > ceiling:
+                        add("OF-102", "HIGH", slide_no, shape, round(len(content) / lines, 1), ceiling, tier="derived")
+
+        rounded = [(shape, _radius(shape)) for shape in shapes]
+        for outer, outer_radius in rounded:
+            if outer_radius is None or outer_radius <= RULES["outer_radius_min_in"]:
+                continue
+            ox, oy, ow, oh = _box(outer)
+            for inner, inner_radius in rounded:
+                if inner is outer or inner_radius is None:
+                    continue
+                ix, iy, iw, ih = _box(inner)
+                insets = (ix - ox, ox + ow - ix - iw, iy - oy, oy + oh - iy - ih)
+                if min(insets) < 0 or max(insets) - min(insets) > RULES["frame_inset_in"]:
+                    continue
+                expected = max(0, outer_radius - sum(insets) / len(insets))
+                if abs(inner_radius - expected) > RULES["radius_error_in"]:
+                    add("OF-104", "HIGH", slide_no, inner, round(inner_radius, 3), round(expected, 3), tier="derived")
+
+        cards = [shape for shape in shapes if _rgb(shape) is not None and
+                 .05 * page_area <= shape.width * shape.height < RULES["full_bleed"] * page_area]
+        groups = [(card, [child for child in shapes if _contains(card, child) and
+                          (getattr(child, "has_text_frame", False) and child.text.strip() or getattr(child, "has_chart", False))])
+                  for card in cards]
+        groups = [(card, children) for card, children in groups if len(children) >= 2]
+        if len(groups) >= 2:
+            inner_gaps = [min(_gap(a, b) for i, a in enumerate(children) for b in children[i + 1:])
+                          for _, children in groups]
+            outer_gap = min(_gap(a, b) for i, (a, _) in enumerate(groups) for b, _ in groups[i + 1:])
+            within = max(inner_gaps)
+            if within > 0 and outer_gap < RULES["group_ratio"] * within:
+                add("OF-105", "MEDIUM", slide_no, slide, round(outer_gap / within, 2), RULES["group_ratio"], tier="derived")
+        trailing_by_card = []
+        for card, children in groups:
+            if _title_or_display(children):
+                continue
+            _, cy, _, ch = _box(card)
+            last_bottom = max(_box(child)[1] + _box(child)[3] for child in children)
+            trailing = max(0, cy + ch - last_bottom) / max(ch, .01)
+            trailing_by_card.append((card, trailing))
+        for card, trailing in trailing_by_card:
+            _, cy, _, ch = _box(card)
+            row = [value for peer, value in trailing_by_card
+                   if abs(_box(peer)[1] - cy) <= .05 and abs(_box(peer)[3] - ch) <= .05]
+            if len(row) > 1:
+                trailing = min(row)
+            severity = "HIGH" if trailing > RULES["empty_band_high"] else "MEDIUM" if trailing >= RULES["empty_band_medium"] else None
+            if severity:
+                add("OF-109", severity, slide_no, card, round(trailing, 3), RULES["empty_band_high"], tier="derived")
+
+        # The content-area gap check runs only on genuine multi-block content slides.
+        content = [shape for shape in shapes if (getattr(shape, "has_table", False) or getattr(shape, "has_chart", False)
+                   or (getattr(shape, "has_text_frame", False) and len(shape.text.strip()) >= 20))
+                   and shape.top > deck.slide_height * .16 and shape.width * shape.height < page_area * RULES["full_bleed"]]
+        if not display and len(content) >= 2:
+            bottoms = [shape.top + shape.height for shape in content]
+            area_bottom = deck.slide_height * .88
+            trailing = max(0, area_bottom - max(bottoms)) / max(1, deck.slide_height * .70)
+            severity = "HIGH" if trailing > RULES["empty_band_high"] else "MEDIUM" if trailing >= RULES["empty_band_medium"] else None
+            if severity:
+                add("OF-109", severity, slide_no, slide, round(trailing, 3), RULES["empty_band_high"], tier="derived")
+
+    return {"pass": not any(item["severity"] == "HIGH" and not item.get("advisory_template") for item in findings),
+            "template_id": template_id, "findings": findings}