@litfamily/litopencode 1.0.31 → 1.0.33

package/skills/lit-pptx/scripts/lib/slide-grid.js

@@ -0,0 +1,104 @@
+"use strict";
+
+/**
+ * slide-grid.js — where things sit on a slide, the same for every tonality.
+ *
+ * One column grid per canvas and one set of zones per slide kind. A tonality changes how a zone
+ * looks (face, weight, size, colour, rules, fills, ornaments), never where it is: every title,
+ * header, body and footer of a deck lands on the coordinates below whichever pack draws it, so two
+ * tonalities of one source differ in look and never in placement. The density dial sets type and
+ * spacing inside the zones; it no longer moves the margins. Values are points on the 960 x 540
+ * (16:9) or 720 x 540 (4:3) canvas; `emu()` gives the same box in EMU (12,700 per point).
+ *
+ * Content slides
+ *   header  the band over the title: grid marks, the slide index, a kicker label
+ *   title   the title frame of every treatment (top-rule, band, top-plain-large, kicker-numeral,
+ *           side-rail, bottom-anchor); a treatment styles it and never moves it
+ *   aside   right of the title: the kicker numeral
+ *   body    everything the slide says, from the first block to the floor
+ *   footer  the sample-data tag and the source line's foot
+ * Display slides (statement, quote, section, closing statement)
+ *   header  the part number or kicker over the sentence
+ *   title   the sentence, centred in its frame
+ *   support the line under it (the quote's speaker, what the part opens with)
+ *   side    the columns right of the sentence, bled to the page edge (a composition, a rail)
+ * Covers
+ *   header  the meta line (date, team, presenter)
+ *   title   the deck title, standing on the frame's foot
+ *   subtitle the line under the title
+ *   strip   the headline figures or the parts, across the page above the footer
+ *   side    the columns right of the title, bled to the page edge (a field, a picture, a numeral)
+ */
+
+const CANVAS = { "16:9": { W: 960, H: 540 }, "4:3": { W: 720, H: 540 } };
+
+// Side margin, column width and gutter: 12 columns and 11 gutters that sum exactly to the width.
+const COLUMNS = { "16:9": { margin: 24, col: 54, gutter: 24 }, "4:3": { margin: 24, col: 45, gutter: 12 } };
+
+const FOOTER = { cols: [1, 12], y: 498, h: 18 };
+
+const ZONES = {
+  content: {
+    header: { cols: [1, 12], y: 12, h: 18 },
+    title: { cols: [1, 10], y: 36, h: 72 },
+    aside: { cols: [11, 12], y: 36, h: 72 },
+    body: { cols: [1, 12], y: 120, h: 366 },
+    footer: FOOTER,
+  },
+  display: {
+    header: { cols: [1, 9], y: 84, h: 36 },
+    title: { cols: [1, 9], y: 132, h: 216 },
+    support: { cols: [1, 8], y: 372, h: 114 },
+    side: { cols: [10, 12], y: 0, h: 540, bleed: true },
+    footer: FOOTER,
+  },
+  cover: {
+    header: { cols: [1, 8], y: 36, h: 24 },
+    title: { cols: [1, 9], y: 144, h: 168 },
+    subtitle: { cols: [1, 8], y: 324, h: 72 },
+    strip: { cols: [1, 12], y: 414, h: 66 },
+    side: { cols: [10, 12], y: 0, h: 540, bleed: true },
+    footer: FOOTER,
+  },
+};
+
+function columns(canvas) {
+  const c = COLUMNS[canvas];
+  if (!c) throw new Error(`unknown canvas "${canvas}"; canvases: ${Object.keys(COLUMNS).join(", ")}`);
+  return c;
+}
+
+/** Columns a…b (1-based, inclusive) as x and width in points. */
+function span(canvas, a, b) {
+  const c = columns(canvas);
+  const pitch = c.col + c.gutter;
+  return { x: c.margin + pitch * (a - 1), w: pitch * (b - a + 1) - c.gutter };
+}
+
+/**
+ * One zone as a box in points. A bled zone starts half a gutter left of its first column and runs
+ * to the page's right edge, so what fills it meets the edge and keeps the gutter from the text.
+ */
+function zone(canvas, kind, name) {
+  const spec = (ZONES[kind] || {})[name];
+  if (!spec) throw new Error(`no ${name} zone on a ${kind} slide`);
+  const s = span(canvas, spec.cols[0], spec.cols[1]);
+  if (spec.bleed) {
+    const x = s.x - columns(canvas).gutter / 2;
+    return { x, y: spec.y, w: CANVAS[canvas].W - x, h: spec.h, a: spec.cols[0], b: spec.cols[1] };
+  }
+  return { x: s.x, y: spec.y, w: s.w, h: spec.h, a: spec.cols[0], b: spec.cols[1] };
+}
+
+/** Every zone of every slide kind on a canvas, in points. */
+function zones(canvas) {
+  return Object.fromEntries(Object.entries(ZONES).map(([kind, set]) => [kind, Object.fromEntries(Object.keys(set).map((name) => [name, zone(canvas, kind, name)]))]));
+}
+
+/** A box in points as EMU, the unit a .pptx file stores. */
+function emu(box) {
+  const e = (v) => Math.round(v * 12700);
+  return { x: e(box.x), y: e(box.y), w: e(box.w), h: e(box.h) };
+}
+
+module.exports = { CANVAS, COLUMNS, ZONES, span, zone, zones, emu };

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

@@ -428,19 +428,29 @@ const FACES = {
   "A2Z Medium": { font: "에이투지체 5 Medium", bold: false },
   "A2Z Bold": { font: "에이투지체 7 Bold", bold: false },
   "A2Z Black": { font: "에이투지체 9 Black", bold: false },
+  // A Latin-only face: Hangul and other East Asian text in its runs is set in Pretendard.
+  "JetBrains Mono Regular": { font: "JetBrains Mono", bold: false, ea: "Pretendard" },
+  "JetBrains Mono Bold": { font: "JetBrains Mono", bold: true, ea: "Pretendard" },
 };
-const DECORATIONS = ["accent-rule", "hairline-rule", "header-band", "rail-fill", "colour-field", "caption-band", "column-hairlines", "box-outline", "mark-underline", "numeral"];
+const DECORATIONS = ["accent-rule", "hairline-rule", "header-band", "rail-fill", "colour-field", "caption-band", "column-hairlines", "box-outline", "mark-underline", "numeral", "grid-marks"];
 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"],
+  cover: ["plain", "drench", "plate", "rail", "band", "figures", "rules", "numeral", "geometry"],
+  statement: ["open", "drench", "rules", "plate", "offset", "geometry"],
   number: ["field", "tint", "outline"],
   closing: ["band", "box", "rules"],
 };
+// Allowances a pack may claim from the gate, each a bounded value (see craft_extras.py). The accent
+// limits only widen: four hue families pass every slide by default, so a pack may allow five or six.
+const QA_ALLOWANCES = {
+  "accent-families": (v) => Number.isInteger(v) && v >= 5 && v <= 6,
+  "display-accent-families": (v) => Number.isInteger(v) && v >= 5 && v <= 6,
+  "offset-shadow": (v) => typeof v === "boolean",
+};
 // 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],
@@ -473,9 +483,12 @@ function validatePack(pack, file) {
   for (const key of ["faces", "faces-a2z"]) {
     if (key === "faces-a2z" && pack[key] == null) continue;
     const faces = pack[key] || {};
+    // A Latin-only face may set the display roles; body text always stays in a Korean face.
     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 own = key === "faces-a2z" || /^Pretendard /u.test(faces[role]) || (role !== "body" && FACES[faces[role]] && FACES[faces[role]].ea);
+      need(FACES[faces[role]] && own, `${key}.${role} must name a bundled face${key === "faces-a2z" ? "" : role === "body" ? " (Pretendard Regular or Bold)" : " (Pretendard Regular or Bold, or JetBrains Mono Regular or Bold)"}`);
     }
+    need(!(FACES[faces.body] && FACES[faces.body].ea), `${key}.body must be a face that sets Hangul`);
     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`);
@@ -497,10 +510,32 @@ function validatePack(pack, file) {
   }
   need(["presented", "reading"].includes(pack.ramp), "ramp must be presented or reading");
   need(typeof pack.hero === "boolean", "hero must be true or false");
+  // A report pack reads at its density step; a bold pack (a pitch, a launch, a campaign) may set presented type.
+  // Any pack may take the hero step on its cover and statements. Either way the words stay in the slide grid's
+  // zones: the register and the hero step change size, never place.
+  const register = pack.register == null ? "report" : pack.register;
+  need(["report", "bold"].includes(register), "register must be report or bold");
+  need(register === "bold" || pack.ramp === "reading", "presented type needs register: bold; a report pack keeps ramp: reading");
   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");
+  // A heavier border and a hard offset shadow (zero blur) under surfaces; the shadow needs the border.
+  const weight = pack["edge-weight"];
+  need(weight == null || (typeof weight === "number" && weight >= 0.5 && weight <= 4), "edge-weight must be 0.5-4 pt");
+  const shadow = pack.shadow;
+  if (shadow != null) {
+    need(typeof shadow === "object" && typeof shadow.offset === "number" && shadow.offset >= 3 && shadow.offset <= 10, "shadow.offset must be 3-10 pt");
+    need(shadow && PALETTE_ROLES.includes(shadow.colour), "shadow.colour must name a palette role");
+    need(pack.edge !== "fill", "a shadow needs a bordered edge (border or fill+border)");
+  }
+  need(pack["edge-colour"] == null || PALETTE_ROLES.includes(pack["edge-colour"]), "edge-colour must name a palette role");
+  // What the gate allows this pack beyond the default craft floor (read by craft_extras.py).
+  const qa = pack.qa || {};
+  need(typeof qa === "object" && !Array.isArray(qa), "qa must be a map");
+  for (const k of Object.keys(qa)) need(QA_ALLOWANCES[k], `unknown qa allowance "${k}" (known: ${Object.keys(QA_ALLOWANCES).join(", ")})`);
+  for (const [k, ok] of Object.entries(QA_ALLOWANCES)) if (qa[k] != null) need(ok(qa[k]), `qa.${k} is out of range`);
+  need(!qa["offset-shadow"] || shadow != null, "qa.offset-shadow needs a shadow");
   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(", ")})`);
@@ -514,6 +549,10 @@ function validatePack(pack, file) {
     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}"`);
+  // Grid marks sit in the top margin on the ground: a band or a filled rail there would cover them.
+  if ((pack.decoration || []).includes("grid-marks")) {
+    need(!treatments.includes("band") && !(pack.decoration || []).includes("rail-fill"), "grid-marks needs the top margin on the ground (no band treatment, no rail-fill)");
+  }
   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");
@@ -634,12 +673,22 @@ function loadTonality(id, options = {}) {
   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);
+  // Only a bold register sets presented type; a report pack reads at its density step.
+  const tok = grid.densityTokens(density, pack.register === "bold" ? pack.ramp : "reading");
+  const g = grid.makeGrid(canvas);
   // 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]]]));
+  // The deck may add decoration kinds to the pack's own list and turn the hero step off (`hero: false`,
+  // the calm opt-out); both arrive as front-matter strings.
+  const extra = String(options.decoration || "").split(",").map((d) => d.trim()).filter(Boolean);
+  for (const d of extra) if (!DECORATIONS.includes(d)) throw new Error(`decoration "${d}" is not a known kind (${DECORATIONS.join(", ")})`);
+  const decoration = [...new Set([...(pack.decoration || []), ...extra])];
+  if (decoration.includes("grid-marks") && (pack.treatments.includes("band") || decoration.includes("rail-fill"))) {
+    throw new Error(`grid-marks needs the top margin on the ground (no band treatment, no rail-fill); tonality "${pack.id}" has one`);
+  }
+  const hero = String(options.hero).toLowerCase() === "false" || options.hero === false ? false : pack.hero;
   const P = pack.palette;
   const template = {
     name: pack.name,
@@ -662,6 +711,8 @@ function loadTonality(id, options = {}) {
     capabilities: { font_roles: {} },
     pack: {
       ...pack,
+      decoration,
+      hero,
       legacy: false,
       capabilities: [],
       faces,

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

@@ -7,12 +7,12 @@ exits non-zero if ANY real defect is found:
   1. Layout issues  — inventory.py --issues-only (overflow / overlap / off-slide)
   2. Anti-slop      — validate_pptx.py (forbidden/placeholder terms, default fonts)
   3. WCAG contrast  — text colour vs its fill (body < 4.5:1, large < 3:1)
-  4. Craft floor    — craft_extras.py (OF-101..OF-109 per slide) and deck_output.py
-                      (OF-110..OF-117 over the deck: title-treatment count, composition
-                      variety, empty body band, one frame per treatment, label titles,
-                      no empty region, no light figure card on a dark ground; with
-                      --sibling, OF-116: another tonality of the same source must draw
-                      a different skeleton)
+  4. Craft floor    — craft_extras.py (OF-101..OF-109 per slide, OF-120 hard shadows) and
+                      deck_output.py (OF-110..OF-119 over the deck: title-treatment count,
+                      composition variety, empty body band, one shared title frame, label
+                      titles, no empty region, no light figure card on a dark ground; with
+                      --sibling, OF-116: another tonality of the same source sets titles and
+                      body in the same places)
 
 No LibreOffice / rendering engine required: everything is read from the OOXML
 via python-pptx. (A renderer is only ever needed for *visual* preview, which is
@@ -35,7 +35,7 @@ from pptx.dml.color import RGBColor
 from pptx.enum.shapes import MSO_SHAPE_TYPE
 from pptx.opc.constants import RELATIONSHIP_TYPE as RT
 from craft_extras import analyse as analyse_craft
-from deck_output import compare_skeletons
+from deck_output import compare_placement
 
 ROOT = Path(__file__).resolve().parents[1]
 VALIDATE = ROOT / "scripts" / "validate_pptx.py"
@@ -617,9 +617,8 @@ def check_composition(path: Path) -> dict[str, Any]:
     for slide_no, slide in enumerate(prs.slides, 1):
         content = []
         table_count = chart_count = 0
-        # The content area runs under a top title; a bottom title closes it from below, so it starts at the top margin.
-        title = next((shape for shape in slide.shapes if shape.name == "title@bottom-anchor" and shape.top is not None), None)
-        top, floor = (0.45, title.top / 914400) if title is not None else (1.7, 6.7)
+        # Every treatment styles the one title zone, so the content area is the shared body zone under it.
+        top, floor = 120 / 72 - 0.03, 6.7
         held = [box for shape in slide.shapes if (box := _bbox_in(shape)) is not None and (
             getattr(shape, "has_table", False) or getattr(shape, "has_chart", False)
             or shape.shape_type == MSO_SHAPE_TYPE.PICTURE or _shape_text(shape))]
@@ -733,7 +732,7 @@ def qa(pptx: Path, sibling: Path | None = None) -> dict[str, Any]:
     composition = check_composition(pptx)
     craft = analyse_craft(pptx)
     if sibling is not None:
-        craft["findings"] += compare_skeletons(pptx, sibling)
+        craft["findings"] += compare_placement(pptx, sibling)
         craft["pass"] = not any(item["severity"] == "HIGH" for item in craft["findings"])
 
     reasons: list[str] = []

package/skills/lit-pptx/scripts/render_pages.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""render_pages.py - render a .pptx to a PDF and PNG pages so a person (or the model) can look at them.
+
+LibreOffice (soffice) converts the deck to PDF in a private profile directory, so parallel runs
+never share a lock. LibreOffice ignores the font parts a deck embeds, so the plain font files in
+`ppt/fonts/*.fntdata` (what embed_fonts.py writes) are copied into that profile's font folder
+first: the pages then show the faces PowerPoint shows, JetBrains Mono and Pretendard included,
+even where the fonts are not installed. `pdftoppm` (poppler) rasterises the PDF when it is on
+PATH; without it the PDF is the result. Without soffice nothing can be rendered: the script
+prints SKIP with the reason and exits 0, and the caller must say the visual pass did not happen.
+
+Usage:
+    python3 scripts/render_pages.py <deck.pptx> --out-dir DIR [--pages N] [--dpi 110] [--json]
+
+Writes DIR/<stem>.pdf and DIR/page-01.png ... Exit 1 on a failed conversion.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+import subprocess
+import sys
+import tempfile
+import zipfile
+from pathlib import Path
+
+
+def profile_fonts(source: Path, profile: Path) -> list[Path]:
+    """Copy the plain font files a .pptx embeds (ppt/fonts/*.fntdata) into the profile's font folder."""
+    placed = []
+    try:
+        with zipfile.ZipFile(source) as package:
+            for name in package.namelist():
+                if not (name.startswith("ppt/fonts/") and name.endswith(".fntdata")):
+                    continue
+                data = package.read(name)
+                # Only a TrueType or OpenType file; an obfuscated or EOT part is left to the renderer.
+                kind = ".otf" if data[:4] == b"OTTO" else ".ttf" if data[:4] in (b"\x00\x01\x00\x00", b"true") else None
+                if not kind:
+                    continue
+                target = profile / "user" / "fonts" / (Path(name).stem + kind)
+                target.parent.mkdir(parents=True, exist_ok=True)
+                target.write_bytes(data)
+                placed.append(target)
+    except zipfile.BadZipFile:
+        return []
+    return placed
+
+
+def to_pdf(source: Path, out_dir: Path) -> tuple[Path | None, str]:
+    soffice = shutil.which("soffice") or shutil.which("libreoffice")
+    if not soffice:
+        return None, "LibreOffice (soffice) is not on PATH"
+    with tempfile.TemporaryDirectory(prefix="litopencode-soffice-") as profile:
+        profile_fonts(source, Path(profile))
+        result = subprocess.run(
+            [soffice, f"-env:UserInstallation={Path(profile).as_uri()}", "--headless", "--convert-to", "pdf",
+             "--outdir", str(out_dir), str(source)],
+            capture_output=True, text=True, timeout=300,
+        )
+    pdf = out_dir / f"{source.stem}.pdf"
+    if result.returncode != 0 or not pdf.exists():
+        raise RuntimeError(f"soffice conversion failed: {(result.stderr or result.stdout).strip()[-400:]}")
+    return pdf, "converted with soffice"
+
+
+def rasterise(pdf: Path, out_dir: Path, pages: int, dpi: int) -> list[Path]:
+    pdftoppm = shutil.which("pdftoppm")
+    if not pdftoppm:
+        return []
+    subprocess.run([pdftoppm, "-png", "-r", str(dpi), "-l", str(pages), str(pdf), str(out_dir / "page")],
+                   capture_output=True, text=True, timeout=300, check=True)
+    written = []
+    for png in sorted(out_dir.glob("page-*.png")):
+        # pdftoppm pads the page number to the page count's width; page-01.png is the stable name.
+        number = int(png.stem.split("-")[1])
+        target = out_dir / f"page-{number:02d}.png"
+        if png != target:
+            png.replace(target)
+        written.append(target)
+    return written
+
+
+def main(argv: list[str]) -> int:
+    parser = argparse.ArgumentParser(description="Render a deck to PDF and PNG pages.")
+    parser.add_argument("input", type=Path)
+    parser.add_argument("--out-dir", type=Path, required=True)
+    parser.add_argument("--pages", type=int, default=12)
+    parser.add_argument("--dpi", type=int, default=110)
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args(argv)
+
+    source = args.input.expanduser().resolve()
+    out_dir = args.out_dir.expanduser().resolve()
+    out_dir.mkdir(parents=True, exist_ok=True)
+    try:
+        pdf, how = to_pdf(source, out_dir)
+        pngs = rasterise(pdf, out_dir, args.pages, args.dpi) if pdf else []
+    except (RuntimeError, subprocess.SubprocessError) as error:
+        report = {"status": "fail", "input": str(source), "detail": str(error), "pages": []}
+        print(json.dumps(report, ensure_ascii=False) if args.json else f"FAIL  {error}")
+        return 1
+    status = "rendered" if pdf else "skipped"
+    detail = how if pngs or not pdf else f"{how}; pdftoppm is not on PATH, so only the PDF was written"
+    report = {"status": status, "input": str(source), "detail": detail, "pdf": str(pdf) if pdf else None, "pages": [str(p) for p in pngs]}
+    if args.json:
+        print(json.dumps(report, ensure_ascii=False, indent=2))
+    elif pdf:
+        print(f"PASS  rendered {len(pngs)} page(s) -> {out_dir}" if pngs else f"PASS  {detail}")
+    else:
+        print(f"SKIP  {how}; visual pages were not rendered")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

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

@@ -37,7 +37,7 @@ palette:
   series: ["#2B4C7E", "#555B63", "#8A6A2E", "#3E7A5A"]
 
 ramp: reading
-hero: false
+hero: true
 type-voice:
   title-tracking: 0
   display-tracking: -1

package/skills/lit-pptx/templates/tonalities/bauhaus/pack.yaml

@@ -0,0 +1,98 @@
+# Bauhaus: primary colours and elementary geometry, kept to the display slides. The cover and the
+# statements carry a composition of a square, a circle, a bar and a triangle; content slides stay
+# quiet, on an off-white ground with black type and one red accent. Wrong for data-heavy business
+# reviews, finance, public-sector reports and sombre topics.
+id: bauhaus
+name: Bauhaus
+version: "1.0.0"
+intent: "Design, architecture and culture lectures: primary colours and geometry on the display slides."
+canvas: ["16:9", "4:3"]
+
+# Pretendard by default; the A2Z map below applies only when the source asks (faces: a2z).
+faces:
+  display: Pretendard Bold
+  title: Pretendard Bold
+  body: Pretendard Regular
+  label: Pretendard Bold
+  numeral: Pretendard Bold
+faces-a2z:
+  display: A2Z Black
+  title: A2Z Black
+  body: Pretendard Regular
+  label: Pretendard Bold
+  numeral: A2Z Black
+
+palette:
+  ground: "#F4F1EA"
+  surface: "#E8E3D6"
+  ink: "#141414"
+  ink-muted: "#4A4740"
+  line: "#141414"
+  accent: "#C8261C"
+  accent-deep: "#7A140E"
+  # The yellow of the geometry: the square on a display slide, the notice and a highlighted table row.
+  accent-tint: "#F2C230"
+  field: "#1F3C99"
+  on-field: "#FFFFFF"
+  positive: "#1E6B3A"
+  # The accent is red, so a loss keeps the ink colour and carries its ▼ sign instead.
+  negative: "#141414"
+  # Red, blue, black, then an ochre: the geometry's yellow darkened so a bar holds 3:1 on the ground.
+  series: ["#C8261C", "#1F3C99", "#141414", "#9E7700"]
+
+ramp: reading
+hero: true
+type-voice:
+  title-tracking: -1
+  display-tracking: -2
+
+density: 10
+variance: 7
+radius: 0
+edge: fill
+
+treatments: [top-rule, side-rail, kicker-numeral, statement, bottom-anchor]
+role-defaults:
+  content: top-rule
+  data: top-rule
+  data-takeaway: side-rail
+  sequence: kicker-numeral
+  image: bottom-anchor
+  statement: statement
+  reference: top-rule
+  definition: side-rail
+
+decoration: [accent-rule, numeral, colour-field]
+layout-families: [asymmetric-feature, big-number, image-split, text-two-column, comparison, process, step-diagram, timeline, chart-insight, table-insight, kpi-row, quote, statement, agenda]
+# 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"). Geometry lives here only.
+display:
+  cover: geometry
+  statement: geometry
+  number: field
+  closing: rules
+covers: [cover-typographic, cover-split-field, cover-numeral]
+sections: [section-field, section-numeral]
+closings: [closing-ask, closing-summary-list, closing-statement]
+
+table:
+  header: none
+  header-ink: ink
+  rules: header-rule
+  banding: none
+  totals: bold
+chart:
+  gridlines: none
+  labels: direct
+  highlight: accent-on-muted
+image:
+  frame: none
+
+fill-order: [change-family, step-up, anchor-visual, distribute]
+# The composition on a display slide sets red, blue and yellow beside one another; content slides keep one accent.
+avoid:
+  - geometry on content slides (it belongs to the cover and the statements)
+  - a circle, square or triangle used as a bullet or an icon
+  - more than one accent colour on a content slide
+  - yellow text on the off-white ground
+  - this look for grief, safety or financial-loss topics

package/skills/lit-pptx/templates/tonalities/chalk/pack.yaml

@@ -37,7 +37,7 @@ palette:
   series: ["#9A3412", "#1F3B33", "#4E5A66", "#2E6A8E"]
 
 ramp: reading
-hero: false
+hero: true
 type-voice:
   title-tracking: -1
   display-tracking: -1

package/skills/lit-pptx/templates/tonalities/computational-brutalism/pack.yaml

@@ -0,0 +1,99 @@
+# Computational Brutalism: retro-futurist computing with its structure left in view. A monospaced
+# Latin face for titles, labels and figures, the twelve-column grid marked in the top margin, ruled
+# tables, a black terminal field with phosphor text and one electric-blue signal. Wrong for boards,
+# finance or public-sector reports and for long Korean reading: the mono face tires over paragraphs.
+id: computational-brutalism
+name: Computational Brutalism
+version: "1.0.0"
+intent: "Engineering reviews and developer launches: the grid, the numbers and the system shown."
+canvas: ["16:9", "4:3"]
+
+# JetBrains Mono sets the Latin of titles, labels and figures; Hangul in those runs is set in
+# Pretendard. Body text stays Pretendard. There is no A2Z map: the mono face is the look.
+faces:
+  display: JetBrains Mono Bold
+  title: JetBrains Mono Bold
+  body: Pretendard Regular
+  label: JetBrains Mono Regular
+  numeral: JetBrains Mono Bold
+
+palette:
+  ground: "#EEEDE7"
+  surface: "#E2E1D9"
+  ink: "#111111"
+  ink-muted: "#4D4C47"
+  line: "#9A988F"
+  accent: "#1F43E0"
+  accent-deep: "#14267A"
+  accent-tint: "#D9DEF2"
+  # The terminal: a black field with phosphor-green text.
+  field: "#111111"
+  on-field: "#8CF5A6"
+  positive: "#1C6B35"
+  negative: "#B3261E"
+  series: ["#1F43E0", "#111111", "#7A786F"]
+
+ramp: reading
+hero: true
+type-voice:
+  title-tracking: 0
+  display-tracking: -1
+
+density: 10
+variance: 7
+radius: 0
+edge: border
+edge-weight: 1
+edge-colour: ink
+
+treatments: [top-rule, top-plain-large, side-rail, bottom-anchor, statement]
+role-defaults:
+  content: top-rule
+  data: top-rule
+  data-takeaway: bottom-anchor
+  sequence: top-rule
+  image: bottom-anchor
+  statement: statement
+  reference: top-rule
+  definition: side-rail
+# A family's own title in this pack: a chart under a ruled title, a table read up to its title, a
+# comparison set as a spec sheet beside its rail, a sequence under a large mono headline.
+structure:
+  chart-insight: top-rule
+  table-insight: bottom-anchor
+  comparison: side-rail
+  step-diagram: top-plain-large
+# The grid and its numbers are the decoration; nothing is filled for ornament.
+decoration: [hairline-rule, column-hairlines, box-outline, grid-marks, numeral]
+layout-families: [dashboard-grid, kpi-row, chart-insight, full-chart, table-insight, ledger-table, method, step-diagram, matrix-2x2, comparison, text-two-column, references-appendix, quote, 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: drench
+  statement: drench
+  number: outline
+  closing: box
+covers: [cover-typographic, cover-index, cover-figures]
+sections: [section-numeral, section-rule]
+closings: [closing-decision-box, closing-ask, closing-summary-list]
+
+table:
+  header: none
+  header-ink: ink
+  rules: grid
+  banding: none
+  totals: bold
+  protagonist: accent-tint
+chart:
+  gridlines: hairline
+  labels: direct
+  highlight: accent-on-muted
+image:
+  frame: hairline
+
+fill-order: [change-family, distribute, anchor-visual, step-up]
+avoid:
+  - mono body paragraphs (body text stays Pretendard)
+  - the accent as decoration (it marks the protagonist number or series)
+  - rounded corners, shadows, gradients
+  - a green other than the phosphor text on the terminal field

package/skills/lit-pptx/templates/tonalities/gazette/pack.yaml

@@ -38,7 +38,7 @@ palette:
   series: ["#A61B1B", "#233A4F", "#4A5568", "#7A6A2A"]
 
 ramp: reading
-hero: false
+hero: true
 type-voice:
   title-tracking: -1
   display-tracking: -1

package/skills/lit-pptx/templates/tonalities/ledger/pack.yaml

@@ -38,7 +38,7 @@ palette:
   series: ["#0E6B5A", "#4B5866", "#9A6A12", "#2F5F8A"]
 
 ramp: reading
-hero: false
+hero: true
 type-voice:
   title-tracking: -1
   display-tracking: -1