@litfamily/litopencode 1.0.16 → 1.0.17

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

@@ -28,7 +28,7 @@ const DEFAULT_COLUMN_GAP = 0.25;
 
 /** Layout names v1 shipped with; anything else marks a deck as v2. */
 const V1_LAYOUTS = new Set(["cover", "content", "main", "summary", "closing", "section"]);
-const V2_BLOCK_TYPES = new Set(["columns", "box", "shape", "col", "region", "chart"]);
+const V2_BLOCK_TYPES = new Set(["columns", "box", "shape", "col", "region"]);
 
 /**
  * Build AST blocks for a slide.
@@ -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;
     }
@@ -394,23 +398,6 @@ function buildDirectiveBlocks(seg, layout) {
       }];
     }
 
-    case "chart": {
-      const table = parseTable(value);
-      const kind = String(attrs.type || "bar");
-      if (!table || table.headers.length < 2 || table.rows.length < 2 || !["bar", "line"].includes(kind)) {
-        throw new Error('"::: chart" requires type=bar|line and a pipe table with a category column and at least two data rows.');
-      }
-      const labels = table.rows.map((row) => row[0]);
-      const series = table.headers.slice(1).map((name, index) => ({
-        name,
-        values: table.rows.map((row) => Number(String(row[index + 1]).replace(/,/g, ""))),
-      }));
-      if (series.some((item) => item.values.some((number) => !Number.isFinite(number)))) {
-        throw new Error('"::: chart" data cells must contain finite numbers.');
-      }
-      return [{ type: "chart", chartType: kind, labels, series }];
-    }
-
     case "shape": {
       const kind = positional[0];
       if (!SHAPE_KINDS.has(kind)) {
@@ -449,11 +436,55 @@ function buildDirectiveBlocks(seg, layout) {
       return [block];
     }
 
+    case "chart":
+      return buildChartBlocks(value, attrs, positional);
+
     default:
       return [buildDirectiveBlock(directive, value)];
   }
 }
 
+const CHART_TYPES = new Set(["bar", "column", "line", "area", "pie", "doughnut", "stacked"]);
+
+/**
+ * A native, editable chart. The body is a pipe table: the first column holds the
+ * categories, every further column is one series. It travels as a kpi-table block
+ * with a `chart` field, so any layout that accepts a table accepts a chart, and a
+ * renderer that cannot draw charts still shows the numbers as a table.
+ *
+ *   ::: chart type=column unit="억 원"
+ *   | 분기 | 매출 | 영업이익 |
+ *   |---|---|---|
+ *   | 1Q | 1,120 | 101 |
+ *   > 분기별 매출과 영업이익 (예시 데이터)
+ *   :::
+ */
+function buildChartBlocks(value, attrs, positional) {
+  const table = parseTable(value);
+  if (!table || table.headers.length < 2 || table.rows.length === 0) {
+    throw new Error('"::: chart" needs a pipe table: categories in the first column, one column per series');
+  }
+  const type = String(attrs.type || positional[0] || "column").toLowerCase();
+  if (!CHART_TYPES.has(type)) {
+    throw new Error(`"::: chart" type must be one of ${[...CHART_TYPES].join(", ")}; got "${type}"`);
+  }
+  const captionLine = value.split("\n").map((l) => l.trim()).find((l) => l.startsWith("> "));
+  const caption = captionLine ? captionLine.replace(/^>\s*/, "") : null;
+  const chart = { type };
+  if (attrs.unit != null) chart.unit = String(attrs.unit);
+  if (attrs.title != null) chart.title = String(attrs.title);
+  if (attrs.labels != null) chart.labels = attrs.labels !== false && attrs.labels !== "false";
+  const blocks = [{
+    type: "kpi-table",
+    headers: table.headers,
+    rows: table.rows,
+    chart,
+    ...(caption ? { caption } : {}),
+  }];
+  if (caption) blocks.push({ type: "table-caption", caption, figure: true });
+  return blocks;
+}
+
 /**
  * Build a directive block from name and content.
  */

package/skills/lit-pptx/scripts/lib/spec-validator.js

@@ -25,8 +25,8 @@ const PLACEMENT_BLOCKS = new Set(["box", "shape", "columns"]);
 
 const LAYOUT_BLOCKS = {
   cover: new Set(["title"]),
-  content: new Set(["title", "key-message", "body", "image", "notes", "kpi-table", "chart", "figure-caption", "table-caption"]),
-  main: new Set(["title", "key-message", "body", "main-box", "kpi-table", "chart", "image", "figure-caption", "table-caption"]),
+  content: new Set(["title", "key-message", "body", "image", "notes", "kpi-table", "figure-caption", "table-caption"]),
+  main: new Set(["title", "key-message", "body", "main-box", "kpi-table", "image", "figure-caption", "table-caption"]),
   summary: new Set(["title", "key-message", "summary-group", "image", "kpi-table", "figure-caption", "table-caption"]),
   closing: new Set(["title"]),
   section: new Set(["title", "notes"]),

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

@@ -12,6 +12,21 @@ const path = require("path");
 
 const ENROLLED_DIR = path.resolve(__dirname, "../../templates/enrolled");
 
+/**
+ * Where templates are looked up, first match wins: every directory in
+ * LIT_PPTX_TEMPLATE_DIRS (path-delimiter separated), then .lit-pptx/templates
+ * under the working directory (learn_template.py writes there by default),
+ * then the templates bundled with the skill. The installed skill directory is
+ * read-only, so a learned template never has to be written into it.
+ */
+function templateDirs() {
+  const extra = (process.env.LIT_PPTX_TEMPLATE_DIRS || "")
+    .split(path.delimiter)
+    .filter(Boolean)
+    .map((dir) => path.resolve(dir));
+  return [...extra, path.resolve(process.cwd(), ".lit-pptx", "templates"), ENROLLED_DIR];
+}
+
 /**
  * Minimal YAML parser for the project's template files.
  * Handles nested mappings, lists, quoted strings, and numeric values.
@@ -276,10 +291,27 @@ function parseSequence(lines, startLine, minIndent) {
   return { value: result, nextLine: i };
 }
 
+/**
+ * Drop a trailing YAML comment (whitespace, then `#`) from a scalar. A quoted
+ * value ends at its closing quote, so a `#` inside the quotes stays. Without
+ * this, `char_spacing: -0.5   # note` parsed as a string and every run of the
+ * template was written with spc="NaN".
+ */
+function stripInlineComment(raw) {
+  const quote = raw[0];
+  if (quote === '"' || quote === "'") {
+    const close = raw.indexOf(quote, 1);
+    if (close > 0 && /^\s+#/.test(raw.slice(close + 1))) return raw.slice(0, close + 1);
+    return raw;
+  }
+  return raw.replace(/\s+#.*$/, "");
+}
+
 /**
  * Parse a scalar YAML value (string, number, boolean, null).
  */
 function parseScalar(raw) {
+  raw = stripInlineComment(raw);
   if (raw === "null" || raw === "~") return null;
   if (raw === "true") return true;
   if (raw === "false") return false;
@@ -312,23 +344,30 @@ function parseScalar(raw) {
  * @returns {string[]}
  */
 function listTemplates() {
-  if (!fs.existsSync(ENROLLED_DIR)) return [];
-  return fs
-    .readdirSync(ENROLLED_DIR)
-    .filter((name) =>
-      fs.statSync(path.join(ENROLLED_DIR, name)).isDirectory()
-    );
+  const names = new Set();
+  for (const dir of templateDirs()) {
+    if (!fs.existsSync(dir)) continue;
+    for (const name of fs.readdirSync(dir)) {
+      if (fs.statSync(path.join(dir, name)).isDirectory()) names.add(name);
+    }
+  }
+  return [...names].sort();
 }
 
 /**
  * Load an enrolled template by name.
- * @param {string} name — Template directory name (e.g. "AZURE-PRO")
+ * @param {string} name — Template directory name (e.g. "MY-BRAND")
  * @returns {{ name: string, version: string, template: object, mapping: object, capabilities: object }}
  */
 function loadTemplate(name) {
-  const dir = path.join(ENROLLED_DIR, name);
-  if (!fs.existsSync(dir)) {
-    throw new Error(`Unknown template: "${name}" not found in enrolled templates`);
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(String(name))) {
+    throw new Error(`Invalid template name: "${name}"`);
+  }
+  const dir = templateDirs()
+    .map((base) => path.join(base, name))
+    .find((candidate) => fs.existsSync(path.join(candidate, "template.yaml")));
+  if (!dir) {
+    throw new Error(`Unknown template: "${name}" not found in ${templateDirs().join(", ")}`);
   }
 
   const readFile = (basename) => {
@@ -349,7 +388,292 @@ function loadTemplate(name) {
     template,
     mapping,
     capabilities,
+    pack: legacyPack(template.name || name, template),
+  };
+}
+
+// ── 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-pretendard-only", "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 };
+module.exports = { loadTemplate, listTemplates, loadPack, listTonalities, loadTonality, hasCapability, validatePack, legacyPack, LEGACY_TOKENS };

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

@@ -1,12 +1,18 @@
 #!/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  — 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)
 
 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
@@ -29,6 +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
 
 ROOT = Path(__file__).resolve().parents[1]
 VALIDATE = ROOT / "scripts" / "validate_pptx.py"
@@ -94,10 +101,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
@@ -112,7 +131,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]:
@@ -123,10 +142,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():
@@ -444,7 +464,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)
@@ -593,6 +617,12 @@ 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)
+        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))]
         for shape_no, shape in enumerate(slide.shapes, 1):
             box = _bbox_in(shape)
             if box is None:
@@ -607,13 +637,14 @@ def check_composition(path: Path) -> dict[str, Any]:
             chart_count += has_chart
             if (has_table or has_chart or shape.shape_type == MSO_SHAPE_TYPE.PICTURE or
                     (getattr(shape, "has_text_frame", False) and shape.text_frame.text.strip())):
-                if y0 >= 1.7 and y0 < 6.7:
-                    content.append((max(0.7, x0), max(1.7, y0), min(width - 0.7, x1), min(6.7, y1)))
+                if top <= y0 < floor:
+                    content.append((max(0.7, x0), max(top, y0), min(width - 0.7, x1), min(floor, y1)))
             if (not _shape_text(shape) and not has_table and not has_chart and
                     shape.shape_type == MSO_SHAPE_TYPE.AUTO_SHAPE and
                     (x1 - x0) * (y1 - y0) > 0.3 and
-                    _shape_fill_rgb(shape) is None):
-                # A large empty outlined rectangle is usually a leftover box.
+                    _shape_fill_rgb(shape) is None and
+                    not any(x0 <= a + 0.03 and y0 <= b + 0.03 and c <= x1 + 0.03 and d <= y1 + 0.03 for a, b, c, d in held)):
+                # A large empty outlined rectangle is usually a leftover box; one around text is its frame.
                 try:
                     line_rgb = _hex_to_rgb(shape.line.color.rgb)
                 except (TypeError, AttributeError):
@@ -622,7 +653,7 @@ def check_composition(path: Path) -> dict[str, Any]:
                     issues.append({"slide": slide_no, "shape": shape_no, "kind": "empty_outline",
                                    "hint": "Remove the unused outlined box or put its intended content inside it."})
         if 1 < slide_no < len(prs.slides):
-            area = (width - 1.4) * 5.0
+            area = (width - 1.4) * (floor - top)
             occupied = sum(max(0, x1 - x0) * max(0, y1 - y0) for x0, y0, x1, y1 in content)
             ratio = round(min(1, occupied / area), 3)
             fill_ratios.append({"slide": slide_no, "ratio": ratio})
@@ -692,7 +723,7 @@ 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]:
     validate_report = run_validate(pptx)
     inv_summary = summarize_inventory(load_inventory_issues(pptx))
     contrast = check_contrast(pptx)
@@ -701,6 +732,9 @@ def qa(pptx: Path) -> dict[str, Any]:
     objective = check_objective_quality(pptx)
     composition = check_composition(pptx)
     craft = analyse_craft(pptx)
+    if sibling is not None:
+        craft["findings"] += compare_skeletons(pptx, sibling)
+        craft["pass"] = not any(item["severity"] == "HIGH" for item in craft["findings"])
 
     reasons: list[str] = []
     if not validate_report.get("pass", False):
@@ -763,8 +797,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