@miao-vision/cli 0.1.8 → 0.1.10

package/dist/cli.cjs

@@ -34716,7 +34716,7 @@ var require_stringify = __commonJS({
         props.push(doc.directives.tagString(tag));
       return props.join(" ");
     }
-    function stringify2(item, ctx, onComment, onChompKeep) {
+    function stringify3(item, ctx, onComment, onChompKeep) {
       if (identity.isPair(item))
         return item.toString(ctx, onComment, onChompKeep);
       if (identity.isAlias(item)) {
@@ -34745,7 +34745,7 @@ var require_stringify = __commonJS({
 ${ctx.indent}${str}`;
     }
     exports2.createStringifyContext = createStringifyContext;
-    exports2.stringify = stringify2;
+    exports2.stringify = stringify3;
   }
 });
 
@@ -34755,7 +34755,7 @@ var require_stringifyPair = __commonJS({
     "use strict";
     var identity = require_identity();
     var Scalar = require_Scalar();
-    var stringify2 = require_stringify();
+    var stringify3 = require_stringify();
     var stringifyComment = require_stringifyComment();
     function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
       const { allNullValues, doc, indent, indentStep, options: { commentString, indentSeq, simpleKeys } } = ctx;
@@ -34777,7 +34777,7 @@ var require_stringifyPair = __commonJS({
       });
       let keyCommentDone = false;
       let chompKeep = false;
-      let str = stringify2.stringify(key, ctx, () => keyCommentDone = true, () => chompKeep = true);
+      let str = stringify3.stringify(key, ctx, () => keyCommentDone = true, () => chompKeep = true);
       if (!explicitKey && !ctx.inFlow && str.length > 1024) {
         if (simpleKeys)
           throw new Error("With simple keys, single line scalar must not span more than 1024 characters");
@@ -34829,7 +34829,7 @@ ${indent}:`;
         ctx.indent = ctx.indent.substring(2);
       }
       let valueCommentDone = false;
-      const valueStr = stringify2.stringify(value, ctx, () => valueCommentDone = true, () => chompKeep = true);
+      const valueStr = stringify3.stringify(value, ctx, () => valueCommentDone = true, () => chompKeep = true);
       let ws = " ";
       if (keyComment || vsb || vcb) {
         ws = vsb ? "\n" : "";
@@ -34967,7 +34967,7 @@ var require_addPairToJSMap = __commonJS({
     "use strict";
     var log = require_log();
     var merge2 = require_merge();
-    var stringify2 = require_stringify();
+    var stringify3 = require_stringify();
     var identity = require_identity();
     var toJS = require_toJS();
     function addPairToJSMap(ctx, map2, { key, value }) {
@@ -35003,7 +35003,7 @@ var require_addPairToJSMap = __commonJS({
       if (typeof jsKey !== "object")
         return String(jsKey);
       if (identity.isNode(key) && ctx?.doc) {
-        const strCtx = stringify2.createStringifyContext(ctx.doc, {});
+        const strCtx = stringify3.createStringifyContext(ctx.doc, {});
         strCtx.anchors = /* @__PURE__ */ new Set();
         for (const node of ctx.anchors.keys())
           strCtx.anchors.add(node.anchor);
@@ -35070,12 +35070,12 @@ var require_stringifyCollection = __commonJS({
   "../../node_modules/yaml/dist/stringify/stringifyCollection.js"(exports2) {
     "use strict";
     var identity = require_identity();
-    var stringify2 = require_stringify();
+    var stringify3 = require_stringify();
     var stringifyComment = require_stringifyComment();
     function stringifyCollection(collection, ctx, options) {
       const flow = ctx.inFlow ?? collection.flow;
-      const stringify3 = flow ? stringifyFlowCollection : stringifyBlockCollection;
-      return stringify3(collection, ctx, options);
+      const stringify4 = flow ? stringifyFlowCollection : stringifyBlockCollection;
+      return stringify4(collection, ctx, options);
     }
     function stringifyBlockCollection({ comment, items }, ctx, { blockItemPrefix, flowChars, itemIndent, onChompKeep, onComment }) {
       const { indent, options: { commentString } } = ctx;
@@ -35100,7 +35100,7 @@ var require_stringifyCollection = __commonJS({
           }
         }
         chompKeep = false;
-        let str2 = stringify2.stringify(item, itemCtx, () => comment2 = null, () => chompKeep = true);
+        let str2 = stringify3.stringify(item, itemCtx, () => comment2 = null, () => chompKeep = true);
         if (comment2)
           str2 += stringifyComment.lineComment(str2, itemIndent, commentString(comment2));
         if (chompKeep && comment2)
@@ -35167,7 +35167,7 @@ ${indent}${line}` : "\n";
         }
         if (comment)
           reqNewline = true;
-        let str = stringify2.stringify(item, itemCtx, () => comment = null);
+        let str = stringify3.stringify(item, itemCtx, () => comment = null);
         if (i < items.length - 1)
           str += ",";
         if (comment)
@@ -36521,7 +36521,7 @@ var require_stringifyDocument = __commonJS({
   "../../node_modules/yaml/dist/stringify/stringifyDocument.js"(exports2) {
     "use strict";
     var identity = require_identity();
-    var stringify2 = require_stringify();
+    var stringify3 = require_stringify();
     var stringifyComment = require_stringifyComment();
     function stringifyDocument(doc, options) {
       const lines = [];
@@ -36536,7 +36536,7 @@ var require_stringifyDocument = __commonJS({
       }
       if (hasDirectives)
         lines.push("---");
-      const ctx = stringify2.createStringifyContext(doc, options);
+      const ctx = stringify3.createStringifyContext(doc, options);
       const { commentString } = ctx.options;
       if (doc.commentBefore) {
         if (lines.length !== 1)
@@ -36558,7 +36558,7 @@ var require_stringifyDocument = __commonJS({
           contentComment = doc.contents.comment;
         }
         const onChompKeep = contentComment ? void 0 : () => chompKeep = true;
-        let body = stringify2.stringify(doc.contents, ctx, () => contentComment = null, onChompKeep);
+        let body = stringify3.stringify(doc.contents, ctx, () => contentComment = null, onChompKeep);
         if (contentComment)
           body += stringifyComment.lineComment(body, "", commentString(contentComment));
         if ((body[0] === "|" || body[0] === ">") && lines[lines.length - 1] === "---") {
@@ -36566,7 +36566,7 @@ var require_stringifyDocument = __commonJS({
         } else
           lines.push(body);
       } else {
-        lines.push(stringify2.stringify(doc.contents, ctx));
+        lines.push(stringify3.stringify(doc.contents, ctx));
       }
       if (doc.directives?.docEnd) {
         if (doc.comment) {
@@ -38693,7 +38693,7 @@ var require_cst_scalar = __commonJS({
 var require_cst_stringify = __commonJS({
   "../../node_modules/yaml/dist/parse/cst-stringify.js"(exports2) {
     "use strict";
-    var stringify2 = (cst) => "type" in cst ? stringifyToken(cst) : stringifyItem(cst);
+    var stringify3 = (cst) => "type" in cst ? stringifyToken(cst) : stringifyItem(cst);
     function stringifyToken(token) {
       switch (token.type) {
         case "block-scalar": {
@@ -38746,7 +38746,7 @@ var require_cst_stringify = __commonJS({
         res += stringifyToken(value);
       return res;
     }
-    exports2.stringify = stringify2;
+    exports2.stringify = stringify3;
   }
 });
 
@@ -40459,7 +40459,7 @@ var require_public_api = __commonJS({
       }
       return doc.toJS(Object.assign({ reviver: _reviver }, options));
     }
-    function stringify2(value, replacer, options) {
+    function stringify3(value, replacer, options) {
       let _replacer = null;
       if (typeof replacer === "function" || Array.isArray(replacer)) {
         _replacer = replacer;
@@ -40484,7 +40484,7 @@ var require_public_api = __commonJS({
     exports2.parse = parse4;
     exports2.parseAllDocuments = parseAllDocuments;
     exports2.parseDocument = parseDocument;
-    exports2.stringify = stringify2;
+    exports2.stringify = stringify3;
   }
 });
 
@@ -41204,8 +41204,79 @@ function prepareChartData(rows, chart) {
   for (const transform2 of chart.data?.transform ?? []) {
     current = applyTransform(current, transform2);
   }
+  current = applyEncodingAggregates(current, chart);
   return current;
 }
+function inspectChartTransforms(rows, chart) {
+  let current = [...rows];
+  const transforms = [];
+  let step = 1;
+  for (const transform2 of chart.data?.transform ?? []) {
+    const inputRows = current.length;
+    current = applyTransform(current, transform2);
+    transforms.push({
+      step: step++,
+      type: transform2.type,
+      inputRows,
+      outputRows: current.length,
+      preview: current.slice(0, 3)
+    });
+  }
+  const beforeEncoding = current;
+  current = applyEncodingAggregates(current, chart);
+  if (current !== beforeEncoding) {
+    transforms.push({
+      step,
+      type: "encoding-aggregate",
+      inputRows: beforeEncoding.length,
+      outputRows: current.length,
+      preview: current.slice(0, 3)
+    });
+  }
+  return { rows: current, transforms };
+}
+function applyEncodingAggregates(rows, chart) {
+  const enc = chart.encoding;
+  if (!enc) return rows;
+  if (chart.type === "bigvalue") {
+    const valueEnc = enc.value;
+    if (valueEnc?.field && valueEnc.aggregate) {
+      const result = aggregateMeasure(rows, valueEnc.field, valueEnc.aggregate);
+      return [{ [valueEnc.field]: result }];
+    }
+    return rows;
+  }
+  if (chart.type === "bar" || chart.type === "line" || chart.type === "area") {
+    const xField = enc.x?.field;
+    const yEnc = enc.y;
+    if (xField && yEnc?.field && yEnc.aggregate) {
+      return groupByAndAggregate(rows, xField, yEnc.field, yEnc.aggregate);
+    }
+    return rows;
+  }
+  if (chart.type === "pie") {
+    const labelField = enc.label?.field;
+    const valueEnc = enc.value;
+    if (labelField && valueEnc?.field && valueEnc.aggregate) {
+      return groupByAndAggregate(rows, labelField, valueEnc.field, valueEnc.aggregate);
+    }
+    return rows;
+  }
+  return rows;
+}
+function groupByAndAggregate(rows, groupField, valueField, op) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const key = row[groupField];
+    const group = groups.get(key) ?? [];
+    group.push(row);
+    groups.set(key, group);
+  }
+  return [...groups.entries()].map(([key, groupRows]) => ({
+    [groupField]: key,
+    [valueField]: aggregateMeasure(groupRows, valueField, op)
+  }));
+}
 function applyTransform(rows, transform2) {
   if (transform2.type === "derive-month" && transform2.field && transform2.as) {
     return rows.map((row) => ({
@@ -41292,11 +41363,14 @@ function renderChartSvg(chart, rows, svgTheme, options = {}) {
   if (chart.type === "pie") return renderPieChart(chart, data, theme, options);
   if (chart.type === "table") return renderTable(chart, data, options);
   if (chart.type === "bigvalue") return renderBigValue(chart, data);
+  if (chart.type === "histogram") return renderHistogramChart(chart, data, theme, options);
+  if (chart.type === "scatter") return renderScatterChart(chart, data, theme, options);
+  if (chart.type === "heatmap") return renderHeatmapChart(chart, data, theme, options);
   return renderUnsupported(chart);
 }
 function renderBarChart(chart, rows, theme, options) {
-  const xField = chart.encoding.x?.field ?? "";
-  const yField = chart.encoding.y?.field ?? "";
+  const xField = chart.encoding?.x?.field ?? "";
+  const yField = chart.encoding?.y?.field ?? "";
   const width = numberStyle(chart, "width", 720);
   const height = numberStyle(chart, "height", 420);
   const margin = { top: 24, right: 24, bottom: 48, left: 72 };
@@ -41326,8 +41400,8 @@ function renderBarChart(chart, rows, theme, options) {
   `);
 }
 function renderLineChart(chart, rows, theme, options) {
-  const xField = chart.encoding.x?.field ?? "";
-  const yField = chart.encoding.y?.field ?? "";
+  const xField = chart.encoding?.x?.field ?? "";
+  const yField = chart.encoding?.y?.field ?? "";
   const width = numberStyle(chart, "width", 720);
   const height = numberStyle(chart, "height", 420);
   const margin = { top: 24, right: 24, bottom: 64, left: 72 };
@@ -41359,8 +41433,8 @@ function renderLineChart(chart, rows, theme, options) {
   `);
 }
 function renderPieChart(chart, rows, theme, options) {
-  const labelField = chart.encoding.label?.field ?? "";
-  const valueField = chart.encoding.value?.field ?? "";
+  const labelField = chart.encoding?.label?.field ?? "";
+  const valueField = chart.encoding?.value?.field ?? "";
   const width = numberStyle(chart, "width", 720);
   const height = numberStyle(chart, "height", 420);
   const cx = width / 2 - 80;
@@ -41389,19 +41463,182 @@ function renderPieChart(chart, rows, theme, options) {
   return svgFrame(width, height, theme.background, `${slices}${legend}`);
 }
 function renderTable(chart, rows, options) {
-  const columns = Object.keys(rows[0] ?? {}).slice(0, 8);
+  const columns = Object.keys(rows[0] ?? {});
   const header = columns.map((c) => `<th>${escapeHtml(c)}</th>`).join("");
   const markField = chart.encoding?.label?.field ?? chart.encoding?.x?.field ?? columns[0] ?? "";
   const body = rows.slice(0, 20).map(
-    (row) => `<tr ${markAttrs(options.chartId, markField, row[markField], 0, String(row[markField] ?? "Row"))}>${columns.map((c) => `<td>${escapeHtml(String(row[c] ?? ""))}</td>`).join("")}</tr>`
+    (row, i) => `<tr ${markAttrs(options.chartId, markField, row[markField], i, String(row[markField] ?? "Row"))}>${columns.map((c) => `<td>${escapeHtml(String(row[c] ?? ""))}</td>`).join("")}</tr>`
   ).join("");
   return `<div class="miao-table-wrap"><table class="miao-table"><caption>${escapeHtml(chart.title ?? "Table")}</caption><thead><tr>${header}</tr></thead><tbody>${body}</tbody></table></div>`;
 }
 function renderBigValue(chart, rows) {
-  const valueField = chart.encoding.value?.field ?? "";
+  const valueField = chart.encoding?.value?.field ?? "";
   const value = rows[0]?.[valueField] ?? "";
   return `<div class="miao-bigvalue"><div class="miao-bigvalue-label">${escapeHtml(chart.title ?? valueField)}</div><div class="miao-bigvalue-number">${escapeHtml(String(value))}</div></div>`;
 }
+function renderHistogramChart(chart, rows, theme, options) {
+  const xField = chart.encoding?.x?.field ?? "";
+  const width = numberStyle(chart, "width", 720);
+  const height = numberStyle(chart, "height", 420);
+  const margin = { top: 24, right: 24, bottom: 56, left: 72 };
+  const chartWidth = width - margin.left - margin.right;
+  const chartHeight = height - margin.top - margin.bottom;
+  const values = rows.map((row) => Number(row[xField])).filter(Number.isFinite);
+  if (values.length === 0) return renderUnsupported(chart);
+  const bucketCount = 8;
+  const xMin = Math.min(...values);
+  const xMax = Math.max(...values);
+  const bucketSpan = xMax - xMin || 1;
+  const bucketWidth = bucketSpan / bucketCount;
+  const counts = Array(bucketCount).fill(0);
+  for (const v of values) {
+    counts[Math.min(Math.floor((v - xMin) / bucketWidth), bucketCount - 1)]++;
+  }
+  const yMax = Math.max(...counts, 1);
+  const barGap = 2;
+  const barW = (chartWidth - barGap * (bucketCount - 1)) / bucketCount;
+  const color = theme.palette[0];
+  const x0 = margin.left;
+  const y0 = margin.top + chartHeight;
+  const bars = counts.map((count, i) => {
+    const barH = count / yMax * chartHeight;
+    const x = margin.left + i * (barW + barGap);
+    const y = margin.top + chartHeight - barH;
+    const lo = xMin + i * bucketWidth;
+    const tooltip = `${formatTick(lo)}\u2013${formatTick(lo + bucketWidth)}: ${count}`;
+    return `<rect ${markAttrs(options.chartId, xField, lo, i, tooltip)} x="${x.toFixed(1)}" y="${y.toFixed(1)}" width="${barW.toFixed(1)}" height="${barH.toFixed(1)}" fill="${color}" />`;
+  }).join("");
+  const xTickPositions = [0, 2, 4, 6, 8];
+  const xTicks = xTickPositions.map((i) => {
+    const val = xMin + i * bucketWidth;
+    const x = margin.left + i * (barW + barGap);
+    return `<text x="${x.toFixed(1)}" y="${(y0 + 18).toFixed(1)}" text-anchor="middle" fill="${theme.labelColor}" font-size="10">${escapeHtml(formatTick(val))}</text>`;
+  }).join("");
+  const tickCount = 4;
+  const yTicks = Array.from({ length: tickCount + 1 }, (_, i) => ({
+    count: Math.round(i / tickCount * yMax),
+    y: margin.top + chartHeight - i / tickCount * chartHeight
+  }));
+  const gridLines = yTicks.filter((_, i) => i > 0).map(
+    (t) => `<line x1="${x0}" y1="${t.y.toFixed(1)}" x2="${x0 + chartWidth}" y2="${t.y.toFixed(1)}" stroke="${theme.axisColor}" stroke-opacity="0.4" stroke-dasharray="4 3" />`
+  ).join("");
+  const yTickLabels = yTicks.map(
+    (t) => `<text x="${(x0 - 6).toFixed(1)}" y="${(t.y + 4).toFixed(1)}" text-anchor="end" fill="${theme.labelColor}" font-size="11">${t.count}</text>`
+  ).join("");
+  return svgFrame(width, height, theme.background, `
+    ${gridLines}
+    <line x1="${x0}" y1="${y0}" x2="${(x0 + chartWidth).toFixed(1)}" y2="${y0}" stroke="${theme.axisColor}" />
+    <line x1="${x0}" y1="${margin.top}" x2="${x0}" y2="${y0}" stroke="${theme.axisColor}" />
+    ${yTickLabels}
+    <text x="${(x0 + chartWidth / 2).toFixed(1)}" y="${(y0 + 50).toFixed(1)}" text-anchor="middle" fill="${theme.labelColor}" font-size="12">${escapeHtml(xField)}</text>
+    <text x="14" y="${(margin.top + chartHeight / 2).toFixed(1)}" text-anchor="middle" transform="rotate(-90 14 ${(margin.top + chartHeight / 2).toFixed(1)})" fill="${theme.labelColor}" font-size="12">count</text>
+    ${bars}
+    ${xTicks}
+  `);
+}
+function renderScatterChart(chart, rows, theme, options) {
+  const xField = chart.encoding?.x?.field ?? "";
+  const yField = chart.encoding?.y?.field ?? "";
+  const labelField = chart.encoding?.label?.field ?? "";
+  const width = numberStyle(chart, "width", 720);
+  const height = numberStyle(chart, "height", 420);
+  const margin = { top: 24, right: 24, bottom: 56, left: 72 };
+  const chartWidth = width - margin.left - margin.right;
+  const chartHeight = height - margin.top - margin.bottom;
+  const MAX_POINTS = 400;
+  const sample = rows.length > MAX_POINTS ? rows.filter((_, i) => i % Math.ceil(rows.length / MAX_POINTS) === 0) : rows;
+  const xValues = sample.map((row) => Number(row[xField])).filter(Number.isFinite);
+  const yValues = sample.map((row) => Number(row[yField])).filter(Number.isFinite);
+  if (xValues.length === 0 || yValues.length === 0) return renderUnsupported(chart);
+  const xMin = Math.min(...xValues);
+  const xMax = Math.max(...xValues);
+  const yMin = Math.min(...yValues);
+  const yMax = Math.max(...yValues);
+  const xSpan = xMax - xMin || 1;
+  const ySpan = yMax - yMin || 1;
+  const color = theme.palette[0];
+  const x0 = margin.left;
+  const y0 = margin.top + chartHeight;
+  const dots = sample.map((row, i) => {
+    const xVal = Number(row[xField]);
+    const yVal = Number(row[yField]);
+    if (!Number.isFinite(xVal) || !Number.isFinite(yVal)) return "";
+    const cx = margin.left + (xVal - xMin) / xSpan * chartWidth;
+    const cy = margin.top + chartHeight - (yVal - yMin) / ySpan * chartHeight;
+    const label = labelField ? String(row[labelField] ?? "") : `${formatTick(xVal)}, ${formatTick(yVal)}`;
+    const tooltip = labelField ? `${label}: (${formatTick(xVal)}, ${formatTick(yVal)})` : `(${formatTick(xVal)}, ${formatTick(yVal)})`;
+    return `<circle ${markAttrs(options.chartId, xField, xVal, i, tooltip)} cx="${cx.toFixed(1)}" cy="${cy.toFixed(1)}" r="4" fill="${color}" fill-opacity="0.55" />`;
+  }).join("");
+  const sampledNote = rows.length > MAX_POINTS ? `<text x="${(x0 + chartWidth).toFixed(1)}" y="${margin.top - 6}" text-anchor="end" fill="${theme.labelColor}" font-size="10">sampled ${MAX_POINTS} of ${rows.length} rows</text>` : "";
+  const xTickCount = 5;
+  const xTicks = Array.from({ length: xTickCount }, (_, i) => {
+    const val = xMin + i / (xTickCount - 1) * xSpan;
+    const x = margin.left + i / (xTickCount - 1) * chartWidth;
+    return `<text x="${x.toFixed(1)}" y="${(y0 + 18).toFixed(1)}" text-anchor="middle" fill="${theme.labelColor}" font-size="10">${escapeHtml(formatTick(val))}</text>`;
+  }).join("");
+  return svgFrame(width, height, theme.background, `
+    ${buildAxis(margin, chartWidth, chartHeight, xField, yField, yMin, yMax, theme)}
+    ${dots}
+    ${xTicks}
+    ${sampledNote}
+  `);
+}
+function renderHeatmapChart(chart, rows, theme, options) {
+  const xField = chart.encoding?.x?.field ?? "";
+  const yField = chart.encoding?.y?.field ?? "";
+  const valueField = chart.encoding?.value?.field ?? "";
+  const width = numberStyle(chart, "width", 720);
+  const height = numberStyle(chart, "height", 420);
+  const margin = { top: 24, right: 24, bottom: 64, left: 80 };
+  const chartWidth = width - margin.left - margin.right;
+  const chartHeight = height - margin.top - margin.bottom;
+  const xValues = [...new Set(rows.map((row) => String(row[xField] ?? "")))];
+  const yValues = [...new Set(rows.map((row) => String(row[yField] ?? "")))];
+  if (xValues.length === 0 || yValues.length === 0) return renderUnsupported(chart);
+  const cellMap = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    cellMap.set(`${row[xField]}|${row[yField]}`, Number(row[valueField]) || 0);
+  }
+  const allValues = [...cellMap.values()];
+  const minVal = Math.min(...allValues);
+  const maxVal = Math.max(...allValues, minVal + 1);
+  const span = maxVal - minVal;
+  const cellW = chartWidth / xValues.length;
+  const cellH = chartHeight / yValues.length;
+  const color = theme.palette[0];
+  const x0 = margin.left;
+  const y0 = margin.top + chartHeight;
+  const cells = yValues.flatMap(
+    (yVal, yi) => xValues.map((xVal, xi) => {
+      const val = cellMap.get(`${xVal}|${yVal}`) ?? 0;
+      const opacity = (0.1 + (val - minVal) / span * 0.85).toFixed(2);
+      const x = margin.left + xi * cellW;
+      const y = margin.top + yi * cellH;
+      const tooltip = `${xVal}, ${yVal}: ${formatTick(val)}`;
+      return `<rect ${markAttrs(options.chartId, xField, xVal, xi + yi * xValues.length, tooltip)} x="${x.toFixed(1)}" y="${y.toFixed(1)}" width="${cellW.toFixed(1)}" height="${cellH.toFixed(1)}" fill="${color}" fill-opacity="${opacity}" stroke="${theme.background}" stroke-width="1" />`;
+    })
+  ).join("");
+  const MAX_LABELS = 12;
+  const xStep = Math.max(1, Math.ceil(xValues.length / MAX_LABELS));
+  const xLabels = xValues.filter((_, i) => i % xStep === 0).map((val, i) => {
+    const x = margin.left + (i * xStep + 0.5) * cellW;
+    return `<text x="${x.toFixed(1)}" y="${(y0 + 16).toFixed(1)}" text-anchor="middle" fill="${theme.labelColor}" font-size="10">${escapeHtml(val)}</text>`;
+  }).join("");
+  const yStep = Math.max(1, Math.ceil(yValues.length / MAX_LABELS));
+  const yLabels = yValues.filter((_, i) => i % yStep === 0).map((val, i) => {
+    const y = margin.top + (i * yStep + 0.5) * cellH;
+    return `<text x="${(x0 - 6).toFixed(1)}" y="${(y + 4).toFixed(1)}" text-anchor="end" fill="${theme.labelColor}" font-size="10">${escapeHtml(val)}</text>`;
+  }).join("");
+  return svgFrame(width, height, theme.background, `
+    <line x1="${x0}" y1="${y0}" x2="${(x0 + chartWidth).toFixed(1)}" y2="${y0}" stroke="${theme.axisColor}" />
+    <line x1="${x0}" y1="${margin.top}" x2="${x0}" y2="${y0}" stroke="${theme.axisColor}" />
+    ${cells}
+    ${xLabels}
+    ${yLabels}
+    <text x="${(x0 + chartWidth / 2).toFixed(1)}" y="${(y0 + 52).toFixed(1)}" text-anchor="middle" fill="${theme.labelColor}" font-size="12">${escapeHtml(xField)}</text>
+    <text x="14" y="${(margin.top + chartHeight / 2).toFixed(1)}" text-anchor="middle" transform="rotate(-90 14 ${(margin.top + chartHeight / 2).toFixed(1)})" fill="${theme.labelColor}" font-size="12">${escapeHtml(yField)}</text>
+  `);
+}
 function renderUnsupported(chart) {
   return `<div class="miao-unsupported">Static HTML rendering for ${escapeHtml(chart.type)} is not implemented yet.</div>`;
 }
@@ -41482,7 +41719,19 @@ var defaultTheme = {
     labelColor: "#475569"
   },
   css: `
-    :root { color-scheme: light; font-family: Inter, ui-sans-serif, system-ui, -apple-system, sans-serif; }
+    :root {
+      color-scheme: light;
+      font-family: Inter, ui-sans-serif, system-ui, -apple-system, sans-serif;
+      --mv-paper: #f8fafc;
+      --mv-surface: #ffffff;
+      --mv-border: #e2e8f0;
+      --mv-ink: #0f172a;
+      --mv-muted: #64748b;
+      --mv-soft: #475569;
+      --mv-brand: #2563eb;
+      --mv-serif: Georgia, "Times New Roman", serif;
+      --mv-mono: "SF Mono", "JetBrains Mono", Consolas, monospace;
+    }
     body { margin: 0; background: #f8fafc; color: #0f172a; }
     .miao-viz-report { max-width: 1120px; margin: 0 auto; padding: 40px 24px 56px; }
     header { margin-bottom: 28px; }
@@ -41523,6 +41772,7 @@ var editorialTheme = {
       --mv-ink: #141413;
       --mv-muted: #6b6a64;
       --mv-soft-text: #504e49;
+      --mv-soft: #504e49;
       --mv-brand: #1b365d;
       --mv-mono: "SF Mono", "JetBrains Mono", Consolas, monospace;
       --mv-serif: Charter, Georgia, "Times New Roman", serif;
@@ -41587,6 +41837,7 @@ var darkTheme = {
       --mv-ink: #e2e0d8;
       --mv-muted: #737069;
       --mv-soft-text: #a8a69f;
+      --mv-soft: #a8a69f;
       --mv-brand: #7eb8f7;
       --mv-mono: "SF Mono", "JetBrains Mono", Consolas, monospace;
       --mv-serif: Charter, Georgia, "Times New Roman", serif;
@@ -41644,7 +41895,19 @@ var minimalTheme = {
     labelColor: "#6b7280"
   },
   css: `
-    :root { color-scheme: light; font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", system-ui, sans-serif; }
+    :root {
+      color-scheme: light;
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", system-ui, sans-serif;
+      --mv-paper: #ffffff;
+      --mv-surface: #ffffff;
+      --mv-border: #e5e7eb;
+      --mv-ink: #111111;
+      --mv-muted: #6b7280;
+      --mv-soft: #374151;
+      --mv-brand: #1d4ed8;
+      --mv-serif: Georgia, "Times New Roman", serif;
+      --mv-mono: "SF Mono", "JetBrains Mono", Consolas, monospace;
+    }
     body { margin: 0; background: #fff; color: #111; }
     .miao-viz-report { max-width: 960px; margin: 0 auto; padding: 48px 24px 64px; }
     header { margin-bottom: 32px; }
@@ -42117,12 +42380,38 @@ function escapeScriptJson(value) {
   return JSON.stringify(value).replace(/</g, "\\u003c");
 }
 
+// src/insight-utils.ts
+function normalizeInsight(insight) {
+  if (typeof insight === "string") {
+    return { text: insight, evidence: [], original: insight };
+  }
+  return {
+    text: insight.text,
+    evidence: insight.evidence ?? [],
+    caveat: insight.caveat,
+    severity: insight.severity,
+    original: insight
+  };
+}
+function normalizeInsights(insights) {
+  return (insights ?? []).map(normalizeInsight);
+}
+function mapInsightText(insight, mapText) {
+  if (typeof insight === "string") return mapText(insight);
+  return { ...insight, text: mapText(insight.text) };
+}
+function insightPreview(text) {
+  return `"${text.slice(0, 80)}${text.length > 80 ? "..." : ""}"`;
+}
+
 // src/html-export.ts
 var INSIGHTS_CSS = `
   .report-insights { margin: 0 0 32px; padding: 16px 20px 14px; border-radius: 4px; border: 1px solid rgba(128,128,128,0.18); background: rgba(128,128,128,0.04); }
   .insights-label { font-size: 10px; font-weight: 700; text-transform: uppercase; letter-spacing: 0.1em; opacity: 0.45; margin: 0 0 8px; }
   .insights-list { margin: 0; padding: 0 0 0 18px; }
   .insights-list li { margin: 5px 0; font-size: 13px; line-height: 1.55; opacity: 0.75; }
+  .insight-warning { color: #8a4b00; }
+  .insight-caveat { display: block; margin-top: 2px; font-size: 11px; opacity: 0.58; }
 `;
 function renderStaticHtml(spec, profile, rows, themeOverride, interactiveOptions = {}) {
   const theme = getTheme(themeOverride ?? spec.theme);
@@ -42229,7 +42518,11 @@ function chartIdFor(chart, index) {
   return chart.id ?? `chart-${index + 1}`;
 }
 function renderInsights(insights) {
-  const items = insights.map((s) => `<li>${escapeHtml(s)}</li>`).join("\n      ");
+  const items = normalizeInsights(insights).map((insight) => {
+    const className = insight.severity === "warning" ? ' class="insight-warning"' : "";
+    const caveat = insight.caveat ? `<span class="insight-caveat">${escapeHtml(insight.caveat)}</span>` : "";
+    return `<li${className}>${escapeHtml(insight.text)}${caveat}</li>`;
+  }).join("\n      ");
   return `<section class="report-insights">
     <p class="insights-label">Key Observations</p>
     <ul class="insights-list">
@@ -42239,9 +42532,9 @@ function renderInsights(insights) {
 }
 function buildCaption(chart) {
   const parts = [];
-  if (chart.encoding.x?.field) parts.push(`x: ${chart.encoding.x.field}`);
-  if (chart.encoding.y?.field) parts.push(`y: ${chart.encoding.y.field}`);
-  if (chart.encoding.value?.field) parts.push(`value: ${chart.encoding.value.field}`);
+  if (chart.encoding?.x?.field) parts.push(`x: ${chart.encoding.x.field}`);
+  if (chart.encoding?.y?.field) parts.push(`y: ${chart.encoding.y.field}`);
+  if (chart.encoding?.value?.field) parts.push(`value: ${chart.encoding.value.field}`);
   const transforms = chart.data?.transform ?? [];
   const agg = transforms.find((t) => t.type === "aggregate");
   if (agg?.groupBy?.length) parts.push(`grouped by ${agg.groupBy.join(", ")}`);
@@ -56806,6 +57099,15 @@ var chartInteractionSchema = external_exports.object({
   tooltip: external_exports.boolean().optional(),
   select: external_exports.enum(["filter", "detail"]).optional()
 });
+var insightSchema = external_exports.union([
+  external_exports.string(),
+  external_exports.object({
+    text: external_exports.string().min(1),
+    evidence: external_exports.array(external_exports.string().min(1)).optional(),
+    caveat: external_exports.string().optional(),
+    severity: external_exports.enum(["info", "warning"]).optional()
+  })
+]);
 var chartSpecSchema = external_exports.object({
   id: external_exports.string().min(1).optional(),
   type: external_exports.enum(MVP_CHART_TYPES),
@@ -56833,7 +57135,7 @@ var reportSpecSchema = external_exports.object({
   interactions: external_exports.object({
     globalFilters: external_exports.array(globalFilterSchema).optional()
   }).optional(),
-  insights: external_exports.array(external_exports.string()).optional(),
+  insights: external_exports.array(insightSchema).optional(),
   charts: external_exports.array(chartSpecSchema).min(1)
 });
 var singleOrReportSpecSchema = external_exports.union([
@@ -56889,12 +57191,23 @@ function resolveEvidencePath(evidence, id, path) {
   }
   return { found: false, value: void 0 };
 }
+function resolveDirectives(text, evidence) {
+  return text.replace(new RegExp(EVIDENCE_RE.source, "g"), (_, id, path) => {
+    const { found, value } = resolveEvidencePath(evidence, id, path);
+    return found ? String(value) : `[?${id}.${path}]`;
+  });
+}
 
 // src/chart-catalog.ts
 var CHART_CATALOG = [
   {
     id: "bar",
     displayName: "Bar Chart",
+    compactFor: "rank,compare",
+    requires: "dim(2-30)+measure",
+    transformRecipe: "agg>sort(desc)>limit(10)",
+    avoid: "dim>30,time>=3",
+    insightPattern: "top {dimension} by {measure}",
     requiredEncodings: ["x", "y"],
     allowedTransforms: ["aggregate", "sort", "limit", "derive-month"],
     bestFor: ["ranking by category", "comparison across dimensions", "top-N with limit"],
@@ -56917,6 +57230,25 @@ var CHART_CATALOG = [
           return null;
         }
       },
+      {
+        code: "BAR_NO_AGGREGATE",
+        severity: "warning",
+        expression: "encoding.y.aggregate not set and no aggregate transform",
+        message: "bar will plot one bar per raw row \u2014 unsorted and unaggregated. Add encoding.y.aggregate or data.transform aggregate + sort + limit.",
+        validate: (chart) => {
+          const hasAggTransform = (chart.data?.transform ?? []).some((t) => t.type === "aggregate");
+          const hasEncodingAgg = !!chart.encoding?.y?.aggregate;
+          if (!hasAggTransform && !hasEncodingAgg) {
+            return {
+              code: "BAR_NO_AGGREGATE",
+              severity: "warning",
+              message: `bar${chart.id ? ` '${chart.id}'` : ""}: no aggregation \u2014 will plot one bar per raw row (unsorted, unaggregated). Add encoding.y.aggregate (sum/avg/count) or data.transform: aggregate + sort + limit.`,
+              chartId: chart.id
+            };
+          }
+          return null;
+        }
+      },
       {
         code: "TOO_MANY_CATEGORIES",
         severity: "warning",
@@ -56943,6 +57275,11 @@ var CHART_CATALOG = [
   {
     id: "line",
     displayName: "Line Chart",
+    compactFor: "trend",
+    requires: "time(>=3)+measure",
+    transformRecipe: "agg(time)>sort(asc)",
+    avoid: "time<3,nominal_x",
+    insightPattern: "{measure} over {time}",
     requiredEncodings: ["x", "y"],
     allowedTransforms: ["aggregate", "sort", "derive-month"],
     bestFor: ["time series trends", "continuous data over ordered axis"],
@@ -56992,6 +57329,10 @@ var CHART_CATALOG = [
   {
     id: "area",
     displayName: "Area Chart",
+    compactFor: "trend,magnitude",
+    requires: "time(>=3)+measure",
+    transformRecipe: "agg(time)>sort(asc)",
+    avoid: "time<3,negative_values,nominal_x",
     requiredEncodings: ["x", "y"],
     allowedTransforms: ["aggregate", "sort", "derive-month"],
     bestFor: ["cumulative trends", "filled time series with visual mass"],
@@ -57041,11 +57382,35 @@ var CHART_CATALOG = [
   {
     id: "pie",
     displayName: "Pie Chart",
+    compactFor: "share,composition",
+    requires: "dim(2-7)+measure",
+    transformRecipe: "agg>sort(desc)>limit(7)",
+    avoid: "dim>7,non_whole_values",
+    insightPattern: "{dimension} share of {measure}",
     requiredEncodings: ["label", "value"],
     allowedTransforms: ["aggregate", "sort", "limit"],
     bestFor: ["part-to-whole proportions", "share distribution with \u22647 categories"],
     antiPatterns: ["more than 7 slices (use bar)", "values that do not sum to a meaningful whole"],
     rules: [
+      {
+        code: "PIE_NO_AGGREGATE",
+        severity: "warning",
+        expression: "encoding.value.aggregate not set and no aggregate transform",
+        message: "pie will show one slice per raw row. Add encoding.value.aggregate or data.transform aggregate + sort + limit.",
+        validate: (chart) => {
+          const hasAggTransform = (chart.data?.transform ?? []).some((t) => t.type === "aggregate");
+          const hasEncodingAgg = !!chart.encoding?.value?.aggregate;
+          if (!hasAggTransform && !hasEncodingAgg) {
+            return {
+              code: "PIE_NO_AGGREGATE",
+              severity: "warning",
+              message: `pie${chart.id ? ` '${chart.id}'` : ""}: no aggregation \u2014 will show one slice per raw row (too many slices, wrong values). Add encoding.value.aggregate (sum/avg/count) or data.transform: aggregate + sort + limit.`,
+              chartId: chart.id
+            };
+          }
+          return null;
+        }
+      },
       {
         code: "TOO_MANY_SLICES",
         severity: "warning",
@@ -57072,6 +57437,10 @@ var CHART_CATALOG = [
   {
     id: "scatter",
     displayName: "Scatter Chart",
+    compactFor: "relationship,correlation",
+    requires: "measure+measure",
+    transformRecipe: "raw_or_limit",
+    avoid: "single_measure,categorical_axis",
     requiredEncodings: ["x", "y"],
     allowedTransforms: ["sort", "limit"],
     bestFor: ["correlation between two measures", "distribution of two quantitative variables"],
@@ -57081,6 +57450,11 @@ var CHART_CATALOG = [
   {
     id: "histogram",
     displayName: "Histogram",
+    compactFor: "distribution",
+    requires: "measure+rows(>=20)",
+    transformRecipe: "bin(numeric)>count",
+    avoid: "rows<20,categorical_field",
+    insightPattern: "{measure} distribution",
     requiredEncodings: ["x"],
     allowedTransforms: ["derive-month"],
     bestFor: ["distribution of a single numeric field", "frequency across value bins"],
@@ -57091,6 +57465,11 @@ var CHART_CATALOG = [
   {
     id: "heatmap",
     displayName: "Heatmap",
+    compactFor: "matrix,density",
+    requires: "dim+dim+measure",
+    transformRecipe: "agg(dim,dim)>encode(value)",
+    avoid: "single_dimension,sparse_matrix",
+    insightPattern: "{measure} by {x_dimension} and {y_dimension}",
     requiredEncodings: ["x", "y", "value"],
     allowedTransforms: ["aggregate"],
     bestFor: ["matrix of two dimensions vs one measure", "calendar-style density maps"],
@@ -57100,6 +57479,10 @@ var CHART_CATALOG = [
   {
     id: "table",
     displayName: "Data Table",
+    compactFor: "detail,high-cardinality,export",
+    requires: "any_fields",
+    transformRecipe: "sort_or_limit_optional",
+    avoid: "too_many_columns_without_selection",
     requiredEncodings: [],
     allowedTransforms: ["aggregate", "sort", "limit", "derive-month"],
     bestFor: ["high-cardinality dimension detail", "multi-measure comparison", "data export"],
@@ -57109,17 +57492,60 @@ var CHART_CATALOG = [
   {
     id: "bigvalue",
     displayName: "Big Value (KPI Card)",
+    compactFor: "kpi,summary",
+    requires: "measure",
+    transformRecipe: "agg(measure)>single_value",
+    avoid: "raw_row_value,too_many_cards",
+    insightPattern: "total {measure}",
     requiredEncodings: ["value"],
     allowedTransforms: ["aggregate"],
     bestFor: ["single top-level KPI", "summary metric with optional delta"],
     antiPatterns: ["more than 4 bigvalue cards per report (use kpigrid)", "showing a dimension value without a measure"],
-    rules: []
+    rules: [
+      {
+        code: "BIGVALUE_NO_REDUCTION",
+        severity: "warning",
+        expression: "no aggregate transform and encoding.value.aggregate not set",
+        message: "bigvalue will show rows[0] raw value. Add encoding.value.aggregate or data.transform aggregate + limit: 1.",
+        validate: (chart) => {
+          const hasAggTransform = (chart.data?.transform ?? []).some((t) => t.type === "aggregate");
+          const hasEncodingAgg = !!chart.encoding?.value?.aggregate;
+          if (!hasAggTransform && !hasEncodingAgg) {
+            const field = chart.encoding?.value?.field ?? "value";
+            return {
+              code: "BIGVALUE_NO_REDUCTION",
+              severity: "warning",
+              message: `bigvalue${chart.id ? ` '${chart.id}'` : ""}: no aggregation \u2014 will display rows[0].${field} (a raw row value, almost always wrong). Add encoding.value.aggregate (max/sum/avg/min/count) or data.transform: aggregate + limit: 1.`,
+              chartId: chart.id
+            };
+          }
+          return null;
+        }
+      }
+    ]
   }
 ];
 function getCatalogItem(chartType) {
   return CHART_CATALOG.find((c) => c.id === chartType);
 }
 
+// src/spec-utils.ts
+function findChartIndex(spec, chartId) {
+  if (!chartId) return spec.charts.length === 1 ? 0 : -1;
+  const byId = spec.charts.findIndex((c) => c.id === chartId);
+  if (byId >= 0) return byId;
+  return spec.charts.findIndex((c) => c.type === chartId);
+}
+function findLastChartIndexById(spec, id) {
+  for (let i = spec.charts.length - 1; i >= 0; i--) {
+    if (spec.charts[i].id === id) return i;
+  }
+  return -1;
+}
+function countChartsByType(spec, type) {
+  return spec.charts.filter((c) => c.type === type).length;
+}
+
 // src/spec-validator.ts
 var FORBIDDEN_WORDS = [
   { pattern: /\b(trend|趋势)\b/i, word: "trend/\u8D8B\u52BF" },
@@ -57174,6 +57600,8 @@ function validateReportSpec(spec, profile, formats = ["html"], context) {
         });
       }
     }
+    const finalSchemaResult = validateEncodingFieldsInFinalSchema(chart);
+    if (isAgentError(finalSchemaResult)) return finalSchemaResult;
   }
   return ok(parsed.data);
 }
@@ -57195,7 +57623,7 @@ function collectValidationWarnings(spec, profile, context) {
       `Report has ${spec.charts.length} charts (>6). Consider splitting into multiple sections or removing low-value charts.`
     );
   }
-  const bigvalueCount = spec.charts.filter((c) => c.type === "bigvalue").length;
+  const bigvalueCount = countChartsByType(spec, "bigvalue");
   if (bigvalueCount > 4) {
     warnings.push(
       `Report has ${bigvalueCount} bigvalue cards (>4). Use kpigrid for 5+ KPI cards to avoid visual clutter.`
@@ -57235,8 +57663,20 @@ function collectValidationWarnings(spec, profile, context) {
   return warnings;
 }
 function validateEvidencePaths(spec, context) {
+  const availableIds = context.evidence.map((e) => e.id);
+  for (const insight of normalizeInsights(spec.insights)) {
+    for (const evidenceId of insight.evidence) {
+      if (!availableIds.includes(evidenceId)) {
+        return agentError(
+          "INSIGHT_EVIDENCE_NOT_FOUND",
+          `insight.evidence id '${evidenceId}' not found in context.evidence. Available ids: ${availableIds.join(", ") || "(none)"}`,
+          { evidenceId, availableIds }
+        );
+      }
+    }
+  }
   const texts = [
-    ...spec.insights ?? [],
+    ...normalizeInsights(spec.insights).map((insight) => insight.text),
     ...spec.charts.map((c) => c.title).filter((t) => Boolean(t))
   ];
   for (const text of texts) {
@@ -57255,22 +57695,29 @@ function validateEvidencePaths(spec, context) {
 }
 function collectVerifyWarnings(spec, context) {
   const warnings = [];
-  const insights = spec.insights ?? [];
-  for (const text of insights) {
+  const insights = normalizeInsights(spec.insights);
+  for (const insight of insights) {
     for (const { pattern, word } of FORBIDDEN_WORDS) {
-      if (pattern.test(text)) {
+      if (pattern.test(insight.text)) {
         warnings.push(
-          `insight contains forbidden word '${word}': "${text.slice(0, 80)}${text.length > 80 ? "..." : ""}" \u2014 use only when backed by statistical evidence in context.evidence[]`
+          `insight contains forbidden word '${word}': ${insightPreview(insight.text)} \u2014 use only when backed by statistical evidence in context.evidence[]`
         );
       }
     }
+    if (typeof insight.original !== "string" && /\d/.test(insight.text) && insight.evidence.length === 0) {
+      warnings.push(
+        `insight contains numeric claim without structured evidence: ${insightPreview(insight.text)}`
+      );
+    }
   }
   if (context?.sampleWarnings.length) {
     const CAVEAT_PATTERNS = [
       /仅供参考|样本量|有限数据|based on.*rows?|N-row sample|limited data|small sample/i,
       /环比变化|period.over.period/i
     ];
-    const hasCaveat = insights.some((text) => CAVEAT_PATTERNS.some((p) => p.test(text)));
+    const hasCaveat = insights.some(
+      (insight) => Boolean(insight.caveat) || CAVEAT_PATTERNS.some((p) => p.test(insight.text))
+    );
     if (insights.length > 0 && !hasCaveat) {
       const codes = context.sampleWarnings.map((w) => w.code).join(", ");
       warnings.push(
@@ -57280,6 +57727,24 @@ function collectVerifyWarnings(spec, context) {
   }
   return warnings;
 }
+function strictVerifyError(warnings) {
+  if (warnings.length === 0) return ok(void 0);
+  const issues = warnings.map(warningToVerifyIssue);
+  return agentError(
+    "STRICT_VERIFY_FAILED",
+    `Strict verify failed with ${warnings.length} warning(s).`,
+    { warnings, issues }
+  );
+}
+function warningToVerifyIssue(message) {
+  if (message.includes("forbidden word")) {
+    return { code: "INSIGHT_FORBIDDEN_WORD_STRICT", message };
+  }
+  if (message.includes("numeric claim without structured evidence")) {
+    return { code: "INSIGHT_NUMERIC_CLAIM_WITHOUT_EVIDENCE_STRICT", message };
+  }
+  return { code: "INSIGHT_MISSING_CAVEAT_STRICT", message };
+}
 function validateChartType(chart) {
   if (!MVP_CHART_TYPES.includes(chart.type)) {
     return agentError("UNSUPPORTED_CHART_TYPE", `Chart type '${chart.type}' is not supported in the MVP.`, {
@@ -57365,6 +57830,38 @@ function validateTransforms(chart) {
   }
   return ok(chart);
 }
+function simulateFinalSchema(chart) {
+  let schema = null;
+  for (const transform2 of chart.data?.transform ?? []) {
+    if (transform2.type === "aggregate") {
+      const next = /* @__PURE__ */ new Set();
+      for (const field of transform2.groupBy ?? []) next.add(field);
+      for (const measure of transform2.measures ?? []) next.add(measure.as);
+      schema = next;
+    } else if (transform2.type === "derive-month" && transform2.as && schema !== null) {
+      schema.add(transform2.as);
+    }
+  }
+  return schema;
+}
+function validateEncodingFieldsInFinalSchema(chart) {
+  const finalSchema = simulateFinalSchema(chart);
+  if (!finalSchema) return ok(chart);
+  const chartLabel = chart.id ? `chart '${chart.id}'` : `${chart.type} chart`;
+  const available = [...finalSchema].join(", ") || "(none)";
+  for (const [channel, encoding] of Object.entries(chart.encoding ?? {})) {
+    const field = encoding?.field;
+    if (!field) continue;
+    if (!finalSchema.has(field)) {
+      return agentError(
+        "ENCODING_FIELD_NOT_IN_FINAL_ROWS",
+        `${chartLabel}: encoding.${channel}.field '${field}' does not exist in rows after transforms. Available fields after transforms: ${available}`,
+        { chartId: chart.id, channel, field, availableAfterTransforms: [...finalSchema] }
+      );
+    }
+  }
+  return ok(chart);
+}
 function collectSourceFields(chart, derivedFields) {
   const fields = /* @__PURE__ */ new Set();
   for (const encoding of Object.values(chart.encoding ?? {})) {
@@ -57428,6 +57925,18 @@ var blockedBlockEntrySchema = external_exports.object({
   id: external_exports.string().min(1),
   reason: external_exports.string().min(1)
 });
+var catalogTemplateEntrySchema = external_exports.object({
+  id: external_exports.string().min(1),
+  score: external_exports.number().min(0).max(1),
+  bestFor: external_exports.array(external_exports.string()),
+  requires: external_exports.array(external_exports.enum(["measure", "dimension", "time"])),
+  blocks: external_exports.array(external_exports.string()),
+  density: external_exports.enum(["compact", "medium", "full"])
+});
+var blockedTemplateEntrySchema = external_exports.object({
+  id: external_exports.string().min(1),
+  reason: external_exports.string().min(1)
+});
 var analyzeCatalogSchema = external_exports.object({
   charts: external_exports.array(external_exports.string().min(1)),
   blockedCharts: external_exports.array(external_exports.object({
@@ -57439,7 +57948,9 @@ var analyzeCatalogSchema = external_exports.object({
     note: external_exports.string().optional()
   })),
   blocks: external_exports.array(catalogBlockEntrySchema).optional(),
-  blockedBlocks: external_exports.array(blockedBlockEntrySchema).optional()
+  blockedBlocks: external_exports.array(blockedBlockEntrySchema).optional(),
+  templates: external_exports.array(catalogTemplateEntrySchema).optional(),
+  blockedTemplates: external_exports.array(blockedTemplateEntrySchema).optional()
 });
 var metricCandidateSchema = external_exports.object({
   id: external_exports.string().min(1),
@@ -57450,15 +57961,35 @@ var metricCandidateSchema = external_exports.object({
   confidence: external_exports.enum(["high", "medium"]),
   caveat: external_exports.string().optional()
 });
+var analyzeAssumptionSchema = external_exports.object({
+  key: external_exports.enum(["primary_measure", "primary_dimension", "time_field"]),
+  value: external_exports.string(),
+  confidence: external_exports.number().min(0).max(1),
+  alternatives: external_exports.array(external_exports.string()).optional(),
+  reason: external_exports.string().optional()
+});
+var legacyAssumptionSchema = external_exports.string().transform((value) => ({
+  key: value.includes("dimension") ? "primary_dimension" : value.includes("time") ? "time_field" : "primary_measure",
+  value,
+  confidence: 0.5,
+  reason: "legacy string assumption"
+}));
 var analyzeIntentSchema = external_exports.object({
   raw: external_exports.string().min(1),
   coverage: external_exports.enum(["full", "partial"]),
-  assumptions: external_exports.array(external_exports.string())
+  assumptions: external_exports.array(external_exports.union([analyzeAssumptionSchema, legacyAssumptionSchema]))
 });
 var analyzeSampleWarningSchema = external_exports.object({
   code: external_exports.string().min(1),
   message: external_exports.string().min(1)
 });
+var clarificationQuestionSchema = external_exports.object({
+  id: external_exports.string().min(1),
+  question: external_exports.string().min(1),
+  options: external_exports.array(external_exports.string()),
+  blocking: external_exports.boolean(),
+  appliesTo: external_exports.enum(["measure", "dimension", "time", "template"])
+});
 var analyzeContextSchema = external_exports.object({
   intent: analyzeIntentSchema,
   fields: external_exports.array(analyzeFieldSchema),
@@ -57466,13 +57997,199 @@ var analyzeContextSchema = external_exports.object({
   catalog: analyzeCatalogSchema,
   sampleWarnings: external_exports.array(analyzeSampleWarningSchema),
   promptRules: external_exports.array(external_exports.string()),
-  metricCandidates: external_exports.array(metricCandidateSchema).optional()
-});
+  metricCandidates: external_exports.array(metricCandidateSchema).optional(),
+  clarificationQuestions: external_exports.array(clarificationQuestionSchema).optional()
+});
+var compactAnalyzeContextSchema = external_exports.object({
+  format: external_exports.literal("compact-v1"),
+  intent: external_exports.object({
+    raw: external_exports.string(),
+    coverage: external_exports.enum(["full", "partial"])
+  }),
+  assumptions: external_exports.array(external_exports.tuple([
+    external_exports.enum(["primary_measure", "primary_dimension", "time_field"]),
+    external_exports.string(),
+    external_exports.number(),
+    external_exports.array(external_exports.string()).nullable().optional()
+  ])),
+  fields: external_exports.array(external_exports.tuple([
+    external_exports.string(),
+    external_exports.enum(["measure", "dimension", "time", "id", "status", "score", "unknown"]),
+    external_exports.enum(["number", "string", "date", "boolean", "unknown"]),
+    external_exports.number().nullable().optional(),
+    external_exports.number().nullable().optional()
+  ])),
+  evidence: external_exports.array(external_exports.tuple([external_exports.string(), external_exports.union([
+    external_exports.record(external_exports.string(), external_exports.unknown()),
+    external_exports.array(external_exports.record(external_exports.string(), external_exports.unknown()))
+  ])])),
+  metricCandidates: external_exports.array(external_exports.tuple([
+    external_exports.string(),
+    external_exports.enum(["unit_average", "rate", "share", "period_change", "difference"]),
+    external_exports.string(),
+    external_exports.number().nullable().optional()
+  ])),
+  catalog: external_exports.object({
+    charts: external_exports.array(external_exports.string()),
+    blockedCharts: external_exports.array(external_exports.tuple([external_exports.string(), external_exports.string()])),
+    blocks: external_exports.array(external_exports.tuple([external_exports.string(), external_exports.number(), external_exports.enum(["compact", "medium", "full"]), external_exports.array(external_exports.string())])).optional(),
+    blockedBlocks: external_exports.array(external_exports.tuple([external_exports.string(), external_exports.string()])).optional(),
+    templates: external_exports.array(external_exports.tuple([external_exports.string(), external_exports.number(), external_exports.enum(["compact", "medium", "full"]), external_exports.array(external_exports.string())])).optional(),
+    blockedTemplates: external_exports.array(external_exports.tuple([external_exports.string(), external_exports.string()])).optional()
+  }),
+  warnings: external_exports.array(external_exports.tuple([external_exports.string(), external_exports.string()])),
+  clarificationQuestions: external_exports.array(external_exports.tuple([
+    external_exports.string(),
+    external_exports.string(),
+    external_exports.array(external_exports.string()),
+    external_exports.boolean(),
+    external_exports.enum(["measure", "dimension", "time", "template"])
+  ]))
+});
+function toCompactAnalyzeContext(ctx) {
+  return {
+    format: "compact-v1",
+    intent: { raw: ctx.intent.raw, coverage: ctx.intent.coverage },
+    assumptions: ctx.intent.assumptions.map((a) => [a.key, a.value, a.confidence, a.alternatives]),
+    fields: ctx.fields.map((f) => [f.name, f.role, f.type, f.distinctCount, f.timePeriods]),
+    evidence: ctx.evidence.map((e) => [e.id, e.values ?? e.rows ?? {}]),
+    metricCandidates: (ctx.metricCandidates ?? []).map((m) => [m.id, m.type, m.formula, m.value]),
+    catalog: {
+      charts: ctx.catalog.charts,
+      blockedCharts: ctx.catalog.blockedCharts.map((c) => [c.type, c.reason]),
+      blocks: ctx.catalog.blocks?.map((b) => [b.id, b.score, b.density, b.charts]),
+      blockedBlocks: ctx.catalog.blockedBlocks?.map((b) => [b.id, b.reason]),
+      templates: ctx.catalog.templates?.map((t) => [t.id, t.score, t.density, t.blocks]),
+      blockedTemplates: ctx.catalog.blockedTemplates?.map((t) => [t.id, t.reason])
+    },
+    warnings: ctx.sampleWarnings.map((w) => [w.code, w.message]),
+    clarificationQuestions: (ctx.clarificationQuestions ?? []).map((q) => [
+      q.id,
+      q.question,
+      q.options,
+      q.blocking,
+      q.appliesTo
+    ])
+  };
+}
+function fromCompactAnalyzeContext(ctx) {
+  return {
+    intent: {
+      raw: ctx.intent.raw,
+      coverage: ctx.intent.coverage,
+      assumptions: ctx.assumptions.map(([key, value, confidence, alternatives]) => ({
+        key,
+        value,
+        confidence,
+        alternatives: alternatives ?? void 0
+      }))
+    },
+    fields: ctx.fields.map(([name, role, type, distinctCount, timePeriods]) => ({
+      name,
+      role,
+      type,
+      ...distinctCount !== void 0 && distinctCount !== null ? { distinctCount } : {},
+      ...timePeriods !== void 0 && timePeriods !== null ? { timePeriods } : {}
+    })),
+    evidence: ctx.evidence.map(([id, value]) => ({
+      id,
+      query: `compact evidence: ${id}`,
+      ...Array.isArray(value) ? { rows: value } : { values: value }
+    })),
+    catalog: {
+      charts: ctx.catalog.charts,
+      blockedCharts: ctx.catalog.blockedCharts.map(([type, reason]) => ({ type, reason })),
+      recommendedPlan: [],
+      blocks: ctx.catalog.blocks?.map(([id, score, density, charts]) => ({
+        id,
+        score,
+        description: "",
+        bestFor: [],
+        density,
+        examplePrompt: "",
+        charts,
+        variables: {},
+        qualityChecks: []
+      })),
+      blockedBlocks: ctx.catalog.blockedBlocks?.map(([id, reason]) => ({ id, reason })),
+      templates: ctx.catalog.templates?.map(([id, score, density, blocks]) => ({
+        id,
+        score,
+        bestFor: [],
+        requires: [],
+        blocks,
+        density
+      })),
+      blockedTemplates: ctx.catalog.blockedTemplates?.map(([id, reason]) => ({ id, reason }))
+    },
+    sampleWarnings: ctx.warnings.map(([code, message]) => ({ code, message })),
+    promptRules: [],
+    metricCandidates: ctx.metricCandidates.map(([id, type, formula, value]) => ({
+      id,
+      type,
+      label: id,
+      formula,
+      ...value !== void 0 && value !== null ? { value } : {},
+      confidence: "medium"
+    })),
+    clarificationQuestions: ctx.clarificationQuestions.map(([id, question, options, blocking, appliesTo]) => ({
+      id,
+      question,
+      options,
+      blocking,
+      appliesTo
+    }))
+  };
+}
+function parseAnalyzeContext(value) {
+  const unwrapped = value.ok === true ? value.value : value;
+  const full = analyzeContextSchema.safeParse(unwrapped);
+  if (full.success) return full.data;
+  const compact = compactAnalyzeContextSchema.safeParse(unwrapped);
+  if (compact.success) return fromCompactAnalyzeContext(compact.data);
+  return null;
+}
 
 // src/deck-layouts.ts
 function withSize(chart, width, height) {
   return { ...chart, style: { ...chart.style, width, height } };
 }
+function formatMetricValue(num, fmt) {
+  const hasCurrency = fmt.includes("$");
+  const hasPercent = fmt.includes("%");
+  const hasThousands = fmt.includes(",");
+  const hasSiPrefix = fmt.includes("s");
+  const precisionMatch = fmt.match(/\.(\d+)/);
+  let precision = precisionMatch ? parseInt(precisionMatch[1], 10) : void 0;
+  let value = num;
+  let suffix = "";
+  if (hasPercent) {
+    value = num < 2 ? num * 100 : num;
+    suffix = "%";
+    if (precision === void 0) precision = 1;
+  }
+  if (hasSiPrefix) {
+    const abs = Math.abs(value);
+    if (abs >= 1e9) {
+      value /= 1e9;
+      suffix = "B" + suffix;
+    } else if (abs >= 1e6) {
+      value /= 1e6;
+      suffix = "M" + suffix;
+    } else if (abs >= 1e3) {
+      value /= 1e3;
+      suffix = "K" + suffix;
+    }
+    if (precision === void 0) precision = 0;
+  }
+  if (precision === void 0 && hasThousands) precision = 0;
+  const fixed = precision !== void 0 ? value.toFixed(precision) : Math.round(value).toString();
+  const [intPart, decPart] = fixed.split(".");
+  const formattedInt = hasThousands ? intPart.replace(/\B(?=(\d{3})+(?!\d))/g, ",") : intPart;
+  const formatted = decPart !== void 0 ? `${formattedInt}.${decPart}` : formattedInt;
+  const prefix = hasCurrency ? "$" : "";
+  return prefix + formatted + suffix;
+}
 function resolveMetricValue(metric, rows) {
   let raw = metric.value;
   if (raw === void 0 && metric.data?.transform?.length) {
@@ -57482,10 +58199,7 @@ function resolveMetricValue(metric, rows) {
   }
   const num = Number(raw);
   if (!Number.isFinite(num)) return String(raw ?? "\u2014");
-  const fmt = metric.format ?? "";
-  if (fmt.includes("$")) return "$" + Math.round(num).toLocaleString();
-  if (fmt.includes("%")) return (num < 2 ? (num * 100).toFixed(1) : num.toFixed(1)) + "%";
-  return Math.round(num).toLocaleString();
+  return formatMetricValue(num, metric.format ?? "");
 }
 function renderEyebrow(text) {
   return `<div class="slide-eyebrow">${escapeHtml(text)}</div>`;
@@ -57511,21 +58225,22 @@ function pageFooter(index, _total, mark) {
     <div class="slide-page-num">${String(index + 1).padStart(2, "0")}</div>`;
 }
 var COVER_DECO = `<svg viewBox="0 0 320 320" xmlns="http://www.w3.org/2000/svg" style="width:260px;opacity:0.9">
-  <circle cx="160" cy="160" r="140" fill="none" stroke="#e5e3d8" stroke-width="1"/>
-  <circle cx="160" cy="160" r="100" fill="none" stroke="#e5e3d8" stroke-width="1"/>
-  <circle cx="160" cy="160" r="60" fill="#eef2f7" stroke="#1b365d" stroke-width="1.2"/>
-  <path d="M160 20 A140 140 0 0 1 300 160" fill="none" stroke="#1b365d" stroke-width="2.2" stroke-linecap="round"/>
-  <path d="M300 160 A140 140 0 0 1 160 300" fill="none" stroke="#6b6a64" stroke-width="1" stroke-linecap="round"/>
-  <path d="M160 300 A140 140 0 0 1 20 160" fill="none" stroke="#6b6a64" stroke-width="1" stroke-linecap="round"/>
-  <path d="M20 160 A140 140 0 0 1 160 20" fill="none" stroke="#6b6a64" stroke-width="1" stroke-linecap="round"/>
+  <circle cx="160" cy="160" r="140" fill="none" stroke="var(--mv-border, #e5e3d8)" stroke-width="1"/>
+  <circle cx="160" cy="160" r="100" fill="none" stroke="var(--mv-border, #e5e3d8)" stroke-width="1"/>
+  <circle cx="160" cy="160" r="60" fill="var(--mv-surface, #eef2f7)" stroke="var(--mv-brand, #1b365d)" stroke-width="1.2"/>
+  <path d="M160 20 A140 140 0 0 1 300 160" fill="none" stroke="var(--mv-brand, #1b365d)" stroke-width="2.2" stroke-linecap="round"/>
+  <path d="M300 160 A140 140 0 0 1 160 300" fill="none" stroke="var(--mv-muted, #6b6a64)" stroke-width="1" stroke-linecap="round"/>
+  <path d="M160 300 A140 140 0 0 1 20 160" fill="none" stroke="var(--mv-muted, #6b6a64)" stroke-width="1" stroke-linecap="round"/>
+  <path d="M20 160 A140 140 0 0 1 160 20" fill="none" stroke="var(--mv-muted, #6b6a64)" stroke-width="1" stroke-linecap="round"/>
 </svg>`;
-function renderCoverSlide(slide, _rows, _svg, index, total) {
+function renderCoverSlide(slide, _rows, _svg, index, total, deckDescription) {
+  const subtitle = slide.claim ?? deckDescription;
   return `<div class="slide">
   <div class="slide-cover">
     <div class="slide-cover-left">
       <div class="slide-mark">miao-vision</div>
       <h1>${escapeHtml(slide.title ?? "Presentation")}</h1>
-      ${slide.claim ? `<div class="sub">${escapeHtml(slide.claim)}</div>` : ""}
+      ${subtitle ? `<div class="sub">${escapeHtml(subtitle)}</div>` : ""}
       <div class="line"></div>
       <div class="meta">${escapeHtml(slide.eyebrow ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10))}</div>
     </div>
@@ -57611,18 +58326,6 @@ function renderEndingSlide(slide, _rows, _svg, index, total) {
 
 // src/deck-renderer.ts
 var SLIDE_CSS = `
-  :root {
-    --mv-paper:   #f5f4ed;
-    --mv-surface: #faf9f5;
-    --mv-brand:   #1b365d;
-    --mv-ink:     #141413;
-    --mv-muted:   #6b6a64;
-    --mv-soft:    #504e49;
-    --mv-border:  #e5e3d8;
-    --mv-serif:   Charter, Georgia, "Times New Roman", serif;
-    --mv-mono:    "SF Mono", "JetBrains Mono", Consolas, monospace;
-    --slide-scale: 1;
-  }
   *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
   body { font-family: var(--mv-serif); -webkit-font-smoothing: antialiased; }
 
@@ -57714,7 +58417,7 @@ var SLIDE_CSS = `
     .slide:last-child { break-after: auto; page-break-after: auto; }
     .slide-nav { display: none !important; }
   }
-  @page { size: A4 landscape; margin: 0; background: #f5f4ed; }
+  @page { size: A4 landscape; margin: 0; background: var(--mv-paper, #f5f4ed); }
 `;
 var SLIDE_JS = `
 (function() {
@@ -57766,10 +58469,14 @@ var SLIDE_JS = `
   goTo(0);
 })();
 `;
-function renderSlide(slide, rows, svgTheme, index, total) {
+function extractRootVars(css) {
+  const match = css.match(/:root\s*\{([\s\S]*?)\}/);
+  return match ? `:root {${match[1]}}` : "";
+}
+function renderSlide(slide, rows, svgTheme, index, total, deckDescription) {
   switch (slide.layout) {
     case "cover":
-      return renderCoverSlide(slide, rows, svgTheme, index, total);
+      return renderCoverSlide(slide, rows, svgTheme, index, total, deckDescription);
     case "title-only":
       return renderTitleOnlySlide(slide, rows, svgTheme, index, total);
     case "text-points":
@@ -57788,16 +58495,19 @@ function renderSlide(slide, rows, svgTheme, index, total) {
 }
 function renderDeckHtml(spec, rows, themeOverride) {
   const theme = getTheme(themeOverride ?? spec.theme ?? "editorial");
+  const themeRootVars = extractRootVars(theme.css);
   const title = spec.title ?? "Presentation";
   const total = spec.slides.length;
-  const slidesHtml = spec.slides.map((slide, i) => renderSlide(slide, rows, theme.svg, i, total)).join("\n");
+  const slidesHtml = spec.slides.map((slide, i) => renderSlide(slide, rows, theme.svg, i, total, spec.description)).join("\n");
   return `<!doctype html>
 <html lang="en">
 <head>
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
+  ${spec.description ? `<meta name="description" content="${escapeHtml(spec.description)}" />` : ""}
   <title>${escapeHtml(title)}</title>
   <style>${SLIDE_CSS}</style>
+  ${themeRootVars ? `<style id="miao-deck-theme">${themeRootVars}</style>` : ""}
 </head>
 <body class="present-mode">
   <div class="slide-viewport">
@@ -57919,6 +58629,14 @@ function validateDeckSpecSemantics(spec) {
         hint: hintForIssue(path, "at most 4 metrics")
       });
     }
+    if (slide.charts && slide.charts.length > 1) {
+      const path = `slides[${index}].charts`;
+      errors.push({
+        path,
+        message: `${path}: A slide can include at most 1 chart.`,
+        hint: hintForIssue(path, "at most 1 chart")
+      });
+    }
     if (slide.layout === "table-full" && slide.charts?.[0] && slide.charts[0].type !== "table") {
       const path = `slides[${index}].charts[0].type`;
       errors.push({
@@ -57961,13 +58679,13 @@ function validateChartFields(chart, sourceFields, path) {
     return deckFieldError(path, chart.type, `Chart type '${chart.type}' is not supported.`);
   }
   for (const encoding of REQUIRED_ENCODINGS[chart.type] ?? []) {
-    if (!chart.encoding[encoding]?.field) {
+    if (!chart.encoding?.[encoding]?.field) {
       return deckFieldError(`${path}.encoding.${encoding}`, encoding, `Chart type '${chart.type}' requires encoding '${encoding}'.`);
     }
   }
   const available = applyTransforms(chart.data?.transform ?? [], sourceFields, path);
   if (isAgentError(available)) return available;
-  for (const [encoding, spec] of Object.entries(chart.encoding)) {
+  for (const [encoding, spec] of Object.entries(chart.encoding ?? {})) {
     if (spec?.field && !available.value.has(spec.field)) {
       return deckFieldError(`${path}.encoding.${encoding}.field`, spec.field, `Field '${spec.field}' is not available for this chart encoding.`);
     }
@@ -58031,6 +58749,7 @@ function hintForIssue(path, message) {
   if (message.includes("requires at least one chart")) return `Add a chart under ${path}.`;
   if (message.includes("requires at least one metric")) return `Add one to four metrics under ${path}.`;
   if (message.includes("at most 4 metrics")) return `Reduce ${path} to four metrics or split them across multiple slides.`;
+  if (message.includes("at most 1 chart")) return `Reduce ${path} to a single chart or spread multiple charts across separate slides.`;
   if (message.includes("only accepts a table chart")) return `Change ${path} to 'table' or use a chart-focused layout.`;
   return `Check ${path} in the DeckSpec.`;
 }
@@ -58064,7 +58783,7 @@ var infographicSpecSchema = external_exports.object({
     inputFile: external_exports.string().default(""),
     generatedAt: external_exports.string().default(() => (/* @__PURE__ */ new Date()).toISOString()),
     wordCount: external_exports.number().int().min(0).default(0)
-  }).default({})
+  }).default(() => ({ inputFile: "", generatedAt: (/* @__PURE__ */ new Date()).toISOString(), wordCount: 0 }))
 });
 function loadInfographicSpec(file2) {
   let raw;
@@ -58768,6 +59487,178 @@ function toCatalogBlockEntry(resolver, decision, ctx) {
   };
 }
 
+// src/report-template-registry.ts
+var YAML = __toESM(require_dist(), 1);
+function scoreForRequirements(ctx, requires) {
+  for (const role of requires) {
+    if (role === "measure" && !ctx.fields.some((f) => f.role === "measure" || f.role === "score")) {
+      return { ok: false, score: 0, reason: "missing required measure" };
+    }
+    if (role === "dimension" && !ctx.fields.some((f) => f.role === "dimension" || f.role === "status")) {
+      return { ok: false, score: 0, reason: "missing required dimension" };
+    }
+    if (role === "time") {
+      const time3 = ctx.fields.find((f) => f.role === "time");
+      if (!time3) return { ok: false, score: 0, reason: "missing required time" };
+      const periods = time3.timePeriods ?? 0;
+      if (periods < 3) return { ok: false, score: 0, reason: `timePeriods=${periods} < 3` };
+    }
+  }
+  return { ok: true, score: Math.min(0.65 + requires.length * 0.1 + (ctx.evidence.length > 0 ? 0.05 : 0), 1) };
+}
+function compileBlocks(blockIds, ctx) {
+  const charts = [];
+  for (const id of blockIds) {
+    const block = getBlockById(id);
+    if (!block) continue;
+    const decision = block.canUse(ctx);
+    if (!decision.ok) continue;
+    const variables = block.defaultVariables(ctx);
+    charts.push(...block.compile(variables, ctx).charts);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return {
+    title: "Miao Vision Report",
+    insights: [],
+    charts: charts.map((chart) => {
+      if (!chart.id || !seen.has(chart.id)) {
+        if (chart.id) seen.add(chart.id);
+        return chart;
+      }
+      const next = { ...chart, id: `${chart.id}_${seen.size + 1}` };
+      seen.add(next.id);
+      return next;
+    })
+  };
+}
+var TEMPLATE_REGISTRY = [
+  {
+    id: "snapshot-overview",
+    bestFor: ["static comparison", "category ranking", "no time axis"],
+    requires: ["measure", "dimension"],
+    blocks: ["kpi-summary", "snapshot-ranking"],
+    density: "compact",
+    qualityNotes: ["Use for static comparisons without requiring a trend.", "Add sample caveats when sampleWarnings are present."],
+    canUse: (ctx) => scoreForRequirements(ctx, ["measure", "dimension"]),
+    instantiate: (ctx) => compileBlocks(["kpi-summary", "snapshot-ranking"], ctx)
+  },
+  {
+    id: "trend-ranking-overview",
+    bestFor: ["executive trend with category ranking", "monthly review"],
+    requires: ["measure", "dimension", "time"],
+    blocks: ["trend-ranking"],
+    density: "full",
+    qualityNotes: ["Requires at least 3 time periods.", "Combines KPI, trend, and ranking views."],
+    canUse: (ctx) => scoreForRequirements(ctx, ["measure", "dimension", "time"]),
+    instantiate: (ctx) => compileBlocks(["trend-ranking"], ctx)
+  },
+  {
+    id: "full-detail-report",
+    bestFor: ["comprehensive business review", "trend plus ranking plus table"],
+    requires: ["measure", "dimension", "time"],
+    blocks: ["full-detail-report"],
+    density: "full",
+    qualityNotes: ["Use for comprehensive reviews where detail table is acceptable.", "Keep total chart count within report limits."],
+    canUse: (ctx) => scoreForRequirements(ctx, ["measure", "dimension", "time"]),
+    instantiate: (ctx) => compileBlocks(["full-detail-report"], ctx)
+  },
+  {
+    id: "composition-review",
+    bestFor: ["share analysis", "part-to-whole breakdown", "composition report"],
+    requires: ["measure", "dimension"],
+    blocks: ["kpi-summary", "comparison-breakdown"],
+    density: "medium",
+    qualityNotes: ["Use for share or composition analysis.", "Avoid when the primary dimension has too many categories for pie."],
+    canUse: (ctx) => scoreForRequirements(ctx, ["measure", "dimension"]),
+    instantiate: (ctx) => compileBlocks(["kpi-summary", "comparison-breakdown"], ctx)
+  }
+];
+function getTemplateById(id) {
+  return TEMPLATE_REGISTRY.find((template) => template.id === id);
+}
+function templateInfo(template) {
+  return {
+    id: template.id,
+    bestFor: template.bestFor,
+    requires: template.requires,
+    blocks: template.blocks,
+    density: template.density,
+    qualityNotes: template.qualityNotes
+  };
+}
+function toCatalogTemplateEntry(resolver, decision) {
+  return {
+    id: resolver.id,
+    score: decision.score,
+    bestFor: resolver.bestFor,
+    requires: resolver.requires,
+    blocks: resolver.blocks,
+    density: resolver.density
+  };
+}
+function templateSpecToYaml(spec) {
+  return YAML.stringify(spec);
+}
+function buildTemplateCatalog(ctx) {
+  const templates = [];
+  const blockedTemplates = [];
+  for (const template of TEMPLATE_REGISTRY) {
+    const decision = template.canUse(ctx);
+    if (decision.ok && decision.score >= 0.5) {
+      templates.push(toCatalogTemplateEntry(template, decision));
+    } else {
+      blockedTemplates.push({ id: template.id, reason: decision.reason ?? `score=${decision.score.toFixed(2)} < 0.5` });
+    }
+  }
+  templates.sort((a, b) => b.score - a.score);
+  return { templates, blockedTemplates };
+}
+
+// src/analyze-clarifications.ts
+function buildClarificationQuestions(fields, intent = "") {
+  const questions = [];
+  const measures = fields.filter((f) => f.role === "measure" || f.role === "score");
+  const dimensions = fields.filter((f) => f.role === "dimension" || f.role === "status");
+  const times = fields.filter((f) => f.role === "time");
+  const precisionMode = /precise|accurate|decision|executive|老板|决策|精准/i.test(intent);
+  if (measures.length === 0) {
+    questions.push({
+      id: "primary_measure",
+      question: "Which field should be treated as the primary measure?",
+      options: fields.map((f) => f.name),
+      blocking: true,
+      appliesTo: "measure"
+    });
+  } else if (measures.length > 1) {
+    questions.push({
+      id: "primary_measure",
+      question: `This dataset has multiple measures. Analyze ${measures.map((f) => f.name).join(", ")}?`,
+      options: measures.map((f) => f.name),
+      blocking: precisionMode,
+      appliesTo: "measure"
+    });
+  }
+  if (dimensions.length > 1) {
+    questions.push({
+      id: "primary_dimension",
+      question: `Which dimension should drive the main comparison: ${dimensions.map((f) => f.name).join(", ")}?`,
+      options: dimensions.map((f) => f.name),
+      blocking: false,
+      appliesTo: "dimension"
+    });
+  }
+  if (times.length > 1) {
+    questions.push({
+      id: "time_field",
+      question: `Which time field should drive trend views: ${times.map((f) => f.name).join(", ")}?`,
+      options: times.map((f) => f.name),
+      blocking: false,
+      appliesTo: "time"
+    });
+  }
+  return questions;
+}
+
 // src/analyzer.ts
 function analyzeDataset(dataset, options = {}) {
   const profile = profileDataset(dataset);
@@ -58782,7 +59673,8 @@ function analyzeDataset(dataset, options = {}) {
   const catalog = buildCatalog(fields, sampleWarnings, profile.rows, evidence);
   const promptRules = buildPromptRules(catalog.charts, sampleWarnings);
   const metricCandidates = buildMetricCandidates(fields, evidence);
-  return { intent, fields, evidence, catalog, sampleWarnings, promptRules, metricCandidates };
+  const clarificationQuestions = buildClarificationQuestions(fields, options.intent ?? "");
+  return { intent, fields, evidence, catalog, sampleWarnings, promptRules, metricCandidates, clarificationQuestions };
 }
 function buildAnalyzeFields(columns) {
   return columns.map((col) => {
@@ -58816,7 +59708,6 @@ function refineRole(col) {
   if (col.type === "string") {
     const name = col.name.toLowerCase();
     if (/\b(status|state|phase|stage|flag|type|category|tier)\b/.test(name) && col.distinctCount <= 10) return "status";
-    if (col.role === "id") return "id";
     return "dimension";
   }
   return "unknown";
@@ -58838,27 +59729,50 @@ function parseIntent(raw, fields, correctAssumption) {
   const times = fields.filter((f) => f.role === "time");
   let primaryMeasure = measures[0]?.name;
   let primaryDimension = dimensions[0]?.name;
+  let timeField = times[0]?.name;
   if (correctAssumption) {
-    const m = correctAssumption.match(/^primary_measure=(\w+)$/);
-    const d = correctAssumption.match(/^primary_dimension=(\w+)$/);
+    const m = correctAssumption.match(/^primary_measure=([\w-]+)$/);
+    const d = correctAssumption.match(/^primary_dimension=([\w-]+)$/);
+    const t = correctAssumption.match(/^time_field=([\w-]+)$/);
     if (m) primaryMeasure = m[1];
     if (d) primaryDimension = d[1];
+    if (t) timeField = t[1];
   }
   const assumptions = [];
   if (primaryMeasure) {
-    const verify = measures.length > 1 ? ` (verify: ${measures.map((f) => f.name).join(", ")} \u2014 choose with --correct-assumption primary_measure=<name>)` : "";
-    assumptions.push(`primary measure is "${primaryMeasure}"${verify}`);
+    assumptions.push({
+      key: "primary_measure",
+      value: primaryMeasure,
+      confidence: measures.length > 1 ? 0.62 : 0.9,
+      alternatives: measures.filter((f) => f.name !== primaryMeasure).map((f) => f.name),
+      reason: measures.length > 1 ? "multiple numeric measures detected" : "single clear numeric measure"
+    });
   }
   if (primaryDimension) {
-    assumptions.push(`primary dimension is "${primaryDimension}"`);
+    assumptions.push({
+      key: "primary_dimension",
+      value: primaryDimension,
+      confidence: dimensions.length > 1 ? 0.72 : 0.9,
+      alternatives: dimensions.filter((f) => f.name !== primaryDimension).map((f) => f.name),
+      reason: dimensions.length > 1 ? "multiple dimensions detected" : "single clear dimension"
+    });
   }
   if (times.length > 0) {
-    const t = times[0];
-    const verify = times.length > 1 ? ` (verify: ${times.map((f) => f.name).join(", ")})` : "";
-    assumptions.push(`time field is "${t.name}"${verify}`);
+    assumptions.push({
+      key: "time_field",
+      value: timeField ?? times[0].name,
+      confidence: times.length > 1 ? 0.7 : 0.9,
+      alternatives: times.filter((f) => f.name !== timeField).map((f) => f.name),
+      reason: times.length > 1 ? "multiple time fields detected" : "single clear time field"
+    });
   }
   if (measures.length === 0) {
-    assumptions.push("no numeric measure detected \u2014 use --correct-assumption primary_measure=<col>");
+    assumptions.push({
+      key: "primary_measure",
+      value: "",
+      confidence: 0,
+      reason: "no numeric measure detected"
+    });
   }
   const rawLower = raw.toLowerCase();
   const wantsTrend = /trend|over time|by month|by year/.test(rawLower);
@@ -58877,7 +59791,7 @@ function runStandardQueries(dataset, fields, sampleWarnings) {
   if (measures.length > 0) {
     const measureExpr = measures.slice(0, 4).map((m) => `sum(${m.name}) as total_${m.name}`).concat(["count(*) as row_count"]).join(", ");
     const result = queryDataset(dataset.rows, { measure: measureExpr });
-    if (result && "rows" in result && result.rows.length > 0) {
+    if (!isAgentError(result) && result.rows.length > 0) {
       evidence.push({
         id: "total",
         query: `Total aggregates: ${measureExpr}`,
@@ -58892,7 +59806,7 @@ function runStandardQueries(dataset, fields, sampleWarnings) {
       measure: measureExpr,
       orderby: `total_${primaryMeasure.name} desc`
     });
-    if (result && "rows" in result && result.rows.length > 0) {
+    if (!isAgentError(result) && result.rows.length > 0) {
       const totalVal = result.rows.reduce((s, r) => s + Number(r[`total_${primaryMeasure.name}`] ?? 0), 0);
       const rows = result.rows.map((r) => {
         const val = Number(r[`total_${primaryMeasure.name}`] ?? 0);
@@ -58913,7 +59827,7 @@ function runStandardQueries(dataset, fields, sampleWarnings) {
       measure: measureExpr,
       orderby: `${primaryTime.name} asc`
     });
-    if (result && "rows" in result && result.rows.length > 0) {
+    if (!isAgentError(result) && result.rows.length > 0) {
       evidence.push({
         id: "by_time",
         query: `${primaryMeasure.name} by ${primaryTime.name} (ascending)`,
@@ -58937,7 +59851,7 @@ function runExtraQuery(dataset, extraQuery, existingCount) {
     orderby: parts.orderby,
     limit: parts.limit ? Number(parts.limit) : void 0
   });
-  if (!result || !("rows" in result)) return null;
+  if (isAgentError(result)) return null;
   return {
     id: `extra_${existingCount + 1}`,
     query: `Custom query: ${extraQuery}`,
@@ -59027,7 +59941,8 @@ function buildCatalog(fields, warnings, rowCount, evidence) {
     }
   }
   blocks.sort((a, b) => b.score - a.score);
-  return { charts, blockedCharts, recommendedPlan, blocks, blockedBlocks };
+  const templateCatalog = buildTemplateCatalog(matchCtx);
+  return { charts, blockedCharts, recommendedPlan, blocks, blockedBlocks, ...templateCatalog };
 }
 function buildRecommendedPlan(charts, fields) {
   const plan = [];
@@ -59127,7 +60042,7 @@ function generatePatchHints(error51, spec, catalogCharts) {
   switch (error51.code) {
     case "UNSUPPORTED_TRANSFORM": {
       const chartId = detail?.["chartId"];
-      const chartIndex = spec.charts.findIndex((c) => (c.id ?? c.type) === chartId);
+      const chartIndex = findChartIndex(spec, chartId);
       if (chartIndex < 0) return void 0;
       const transforms = spec.charts[chartIndex].data?.transform ?? [];
       const tIdx = transforms.findIndex((t) => t.type === "filter");
@@ -59136,7 +60051,7 @@ function generatePatchHints(error51, spec, catalogCharts) {
     }
     case "BLOCKED_CHART_STRICT": {
       const chartType = detail?.["chartType"];
-      const chartIdx = spec.charts.findIndex((c) => c.type === chartType);
+      const chartIdx = findChartIndex(spec, chartType);
       if (chartIdx < 0 || !catalogCharts?.length) return void 0;
       const suggestion = catalogCharts[0];
       return [{ op: "replace", path: `/charts/${chartIdx}/type`, value: suggestion }];
@@ -59144,20 +60059,14 @@ function generatePatchHints(error51, spec, catalogCharts) {
     case "DUPLICATE_CHART_ID": {
       const dupId = detail?.["chartId"];
       if (!dupId) return void 0;
-      let lastIdx = -1;
-      for (let i = spec.charts.length - 1; i >= 0; i--) {
-        if (spec.charts[i].id === dupId) {
-          lastIdx = i;
-          break;
-        }
-      }
+      const lastIdx = findLastChartIndexById(spec, dupId);
       if (lastIdx < 0) return void 0;
       return [{ op: "replace", path: `/charts/${lastIdx}/id`, value: `${dupId}_2` }];
     }
     case "MISSING_ENCODING": {
       const chartType = detail?.["chartType"];
       const required2 = detail?.["requiredEncodings"];
-      const chartIdx = spec.charts.findIndex((c) => c.type === chartType);
+      const chartIdx = findChartIndex(spec, chartType);
       if (chartIdx < 0 || !required2?.length) return void 0;
       const existing = Object.keys(spec.charts[chartIdx].encoding ?? {});
       const missing = required2.filter((enc) => !existing.includes(enc));
@@ -59203,12 +60112,6 @@ function collectWarningPatches(spec) {
   }
   return patches;
 }
-function findChartIndex(spec, chartId) {
-  if (!chartId) return spec.charts.length === 1 ? 0 : -1;
-  const byId = spec.charts.findIndex((c) => c.id === chartId);
-  if (byId >= 0) return byId;
-  return spec.charts.findIndex((c) => c.type === chartId);
-}
 
 // src/cli-help.ts
 var COMMAND_HELP = {
@@ -59220,8 +60123,10 @@ Outputs context.json: intent, fields, evidence, catalog (blockedCharts), sampleW
 Options:
   --intent <text>               Natural language description of the report goal
   --output <file>               Write context.json to this path (default: stdout)
+  --compact                     Output compact context for agent consumption
+  --verbose                     Keep full context output explicitly for debugging
   --extra-query <expr>          Custom query: "groupby=col;measure=sum(x) as y;filter=col>=val"
-  --correct-assumption <expr>   Override an assumption: "primary_measure=orders"
+  --correct-assumption <expr>   Override an assumption: "primary_measure=orders", "primary_dimension=region", or "time_field=date"
   --sheet <name>                Sheet name (Excel only)
   --limit <n>                   Max rows to read
 `,
@@ -59246,13 +60151,28 @@ Options:
   --profile <file>    Path to profile JSON (output of "profile")
   --context <file>    Path to context.json (output of "analyze") for catalog compliance and
                       $evidence path checks
-  --strict            Treat blockedChart violations as hard errors (requires --context)
+  --strict            With --verify, treat verify warnings as hard errors; also hard-fails blockedChart violations
   --verify            Also check for forbidden words and missing sampleWarning caveats
   --patch-hints       Attach machine-readable JSON Patch hints to fixable errors
 `,
   catalog: `Usage: miao-viz catalog
 
 List all available chart types and their required fields.
+`,
+  block: `Usage: miao-viz block instantiate <block-id> --context <context.json> [--output <file>]
+
+Instantiate a report block using full or compact analyze context.
+`,
+  template: `Usage:
+  miao-viz template list
+  miao-viz template inspect <template-id>
+  miao-viz template instantiate <template-id> --context <context.json> [--output <file>]
+
+List, inspect, or instantiate report templates using full or compact analyze context.
+`,
+  inspect: `Usage: miao-viz inspect --input <file> --spec <file> --context <context.json> --output <file>
+
+Inspect chart transform pipelines and evidence usage for debugging.
 `,
   render: `Usage: miao-viz render --input <file> --spec <file> --output <file> [options]
 
@@ -59264,6 +60184,7 @@ Options:
   --output <file>   Output file path
   --format <fmt>    Output format: html, svg (default: html)
   --theme <name>    Theme: default, editorial, dark, minimal
+  --context <file>  Path to context.json (output of "analyze") \u2014 resolves $evidence: directives in insights[]
   --interactive     Force interactive runtime for HTML output
   --no-interactive  Force static HTML output
   --sheet <name>    Sheet name (Excel only)
@@ -59323,6 +60244,9 @@ Commands:
   query     Run an aggregation query to get real computed values
   validate  Validate a vizspec against a data profile
   catalog   List all available chart types
+  block     Instantiate report blocks from analyze context
+  template  List, inspect, or instantiate report templates
+  inspect   Inspect chart transforms and evidence usage
   render    Render a vizspec to HTML or SVG
   deck      Render a deck spec to HTML slides
   article   Convert a local article to an infographic artifact
@@ -59332,12 +60256,12 @@ Run "miao-viz <command> --help" for command-specific options.
 }
 
 // src/cli-block.ts
-var YAML2 = __toESM(require_dist(), 1);
+var YAML3 = __toESM(require_dist(), 1);
 
 // src/cli-utils.ts
 var import_node_fs3 = require("node:fs");
 var import_node_path3 = require("node:path");
-var YAML = __toESM(require_dist(), 1);
+var YAML2 = __toESM(require_dist(), 1);
 var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "h",
   "help",
@@ -59348,7 +60272,9 @@ var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "strict",
   "patch-hints",
   "verify",
-  "for-llm"
+  "for-llm",
+  "compact",
+  "verbose"
 ]);
 function parseArgs(argv) {
   const [command, ...rest] = argv;
@@ -59410,7 +60336,7 @@ function printJson(value) {
 function readSpec(file2) {
   const text = (0, import_node_fs3.readFileSync)(file2, "utf8");
   if (file2.endsWith(".json")) return JSON.parse(text);
-  return YAML.parse(text);
+  return YAML2.parse(text);
 }
 function readJson(file2) {
   return JSON.parse((0, import_node_fs3.readFileSync)(file2, "utf8"));
@@ -59443,6 +60369,11 @@ function runCatalog(args) {
     const catalog = {
       charts: CHART_CATALOG.map((c) => ({
         id: c.id,
+        compactFor: c.compactFor,
+        requires: c.requires,
+        transformRecipe: c.transformRecipe,
+        avoid: c.avoid,
+        insightPattern: c.insightPattern,
         requiredEncodings: c.requiredEncodings,
         allowedTransforms: c.allowedTransforms,
         rules: c.rules.map((r) => r.expression),
@@ -59474,11 +60405,11 @@ function runBlock(args) {
   if (isAgentError(contextPath)) return fail(contextPath);
   const raw = readJson(contextPath);
   const unwrapped = raw.ok === true ? raw.value : raw;
-  const parsed = analyzeContextSchema.safeParse(unwrapped);
-  if (!parsed.success) {
-    return fail(agentError("INVALID_CONTEXT", `context.json format is invalid: ${parsed.error.issues.map((i) => i.message).join("; ")}`, { contextPath }));
+  const parsed = parseAnalyzeContext(unwrapped);
+  if (!parsed) {
+    return fail(agentError("INVALID_CONTEXT", "context.json format is invalid.", { contextPath }));
   }
-  const ctx = parsed.data;
+  const ctx = parsed;
   const resolver = getBlockById(blockId);
   if (!resolver) {
     return fail(agentError("UNKNOWN_BLOCK_ID", `Block id '${blockId}' not found. Available: ${BLOCK_REGISTRY.map((b) => b.id).join(", ")}`, { blockId, availableIds: BLOCK_REGISTRY.map((b) => b.id) }));
@@ -59505,7 +60436,7 @@ function runBlock(args) {
 }
 function buildBlockDraft(resolver, variables, score, compiled) {
   const varSummary = Object.entries(variables).map(([k, v]) => `${k}=${v}`).join(", ");
-  const yamlBody = YAML2.stringify({ charts: compiled.charts, insights: compiled.insights ?? [] });
+  const yamlBody = YAML3.stringify({ charts: compiled.charts, insights: compiled.insights ?? [] });
   const checks = resolver.qualityChecks.map((c) => `# [ ] ${c}`).join("\n");
   return [
     `# Generated by: miao-viz block instantiate ${resolver.id}`,
@@ -59519,6 +60450,140 @@ function buildBlockDraft(resolver, variables, score, compiled) {
   ].join("\n");
 }
 
+// src/cli-template.ts
+function runTemplate(args) {
+  const subcommand = args.positional[0];
+  if (subcommand === "list") {
+    return {
+      ok: true,
+      value: TEMPLATE_REGISTRY.map(templateInfo)
+    };
+  }
+  if (subcommand === "inspect") {
+    const templateId = args.positional[1];
+    if (!templateId) return fail(agentError("MISSING_INPUT", "Usage: miao-viz template inspect <template-id>"));
+    const template = getTemplateById(templateId);
+    if (!template) return fail(agentError("UNKNOWN_TEMPLATE_ID", `Template id '${templateId}' not found.`, { availableIds: TEMPLATE_REGISTRY.map((t) => t.id) }));
+    return { ok: true, value: templateInfo(template) };
+  }
+  if (subcommand === "instantiate") {
+    return runTemplateInstantiate(args);
+  }
+  return fail(agentError("UNKNOWN_SUBCOMMAND", `Unknown template subcommand '${subcommand ?? "(none)"}'. Supported: list, inspect, instantiate`, { subcommand }));
+}
+function runTemplateInstantiate(args) {
+  const templateId = args.positional[1];
+  if (!templateId) {
+    return fail(agentError("MISSING_INPUT", "Usage: miao-viz template instantiate <template-id> --context <context.json> [--output <file>]"));
+  }
+  const contextPath = requiredFlag(args, "context");
+  if (isAgentError(contextPath)) return fail(contextPath);
+  const ctx = parseAnalyzeContext(readJson(contextPath));
+  if (!ctx) return fail(agentError("INVALID_CONTEXT", "context.json format is invalid.", { contextPath }));
+  const template = getTemplateById(templateId);
+  if (!template) {
+    return fail(agentError("UNKNOWN_TEMPLATE_ID", `Template id '${templateId}' not found.`, { templateId, availableIds: TEMPLATE_REGISTRY.map((t) => t.id) }));
+  }
+  const matchCtx = {
+    fields: ctx.fields,
+    evidence: ctx.evidence,
+    catalog: ctx.catalog,
+    sampleWarnings: ctx.sampleWarnings
+  };
+  const decision = template.canUse(matchCtx);
+  if (!decision.ok) {
+    return fail(agentError("TEMPLATE_NOT_APPLICABLE", `Template '${templateId}' cannot be used: ${decision.reason}`, { templateId, reason: decision.reason }));
+  }
+  const spec = template.instantiate(matchCtx);
+  const yaml = [
+    `# Generated by: miao-viz template instantiate ${template.id}`,
+    `# Template: ${template.id} (score: ${decision.score.toFixed(2)})`,
+    "# IMPORTANT: Review chart order and fill structured insights[] before validate",
+    "",
+    templateSpecToYaml(spec)
+  ].join("\n");
+  const outputPath = stringFlag(args, "output");
+  if (outputPath) {
+    writeOutput(outputPath, yaml);
+    return { ok: true, value: { output: outputPath, templateId, score: decision.score } };
+  }
+  return { ok: true, value: { yaml, templateId, score: decision.score } };
+}
+
+// src/cli-inspect.ts
+function runInspect(args) {
+  const input = requiredFlag(args, "input");
+  const specPath = requiredFlag(args, "spec");
+  const contextPath = requiredFlag(args, "context");
+  const output = requiredFlag(args, "output");
+  if (isAgentError(input)) return fail(input);
+  if (isAgentError(specPath)) return fail(specPath);
+  if (isAgentError(contextPath)) return fail(contextPath);
+  if (isAgentError(output)) return fail(output);
+  const dataset = loadDataset(input);
+  if (isAgentError(dataset)) return fail(dataset);
+  const spec = normalizeSpec(readSpec(specPath));
+  if (isAgentError(spec)) return fail(spec);
+  const context = parseAnalyzeContext(readJson(contextPath));
+  if (!context) return fail(agentError("INVALID_CONTEXT", "context.json format is invalid.", { contextPath }));
+  const profile = profileDataset(dataset.value);
+  const charts = spec.charts.map((chart, index) => {
+    const inspected = inspectChartTransforms(dataset.value.rows, chart);
+    return {
+      id: chart.id ?? `chart-${index + 1}`,
+      type: chart.type,
+      transforms: inspected.transforms,
+      encoding: Object.fromEntries(Object.entries(chart.encoding ?? {}).map(([channel, enc]) => {
+        const field = enc?.field;
+        const profileField = field ? profile.columns.find((c) => c.name === field) : void 0;
+        const finalMatch = field ? inspected.rows.some((row) => Object.prototype.hasOwnProperty.call(row, field)) : false;
+        const sourceFieldMatch = Boolean(profileField);
+        return [channel, {
+          field,
+          specType: enc?.type,
+          resolvedType: profileField?.type ?? (finalMatch ? inferFinalFieldType(inspected.rows, field) : void 0),
+          sourceFieldMatch,
+          finalRowsMatch: finalMatch,
+          match: sourceFieldMatch || finalMatch
+        }];
+      }))
+    };
+  });
+  function inferFinalFieldType(rows, field) {
+    if (!field) return void 0;
+    const values = rows.map((row) => row[field]).filter((value) => value !== null && value !== void 0);
+    if (values.length === 0) return void 0;
+    if (values.every((value) => typeof value === "number")) return "number";
+    if (values.every((value) => typeof value === "boolean")) return "boolean";
+    if (values.every((value) => value instanceof Date)) return "date";
+    return "string";
+  }
+  const referenced = /* @__PURE__ */ new Set();
+  for (const insight of normalizeInsights(spec.insights)) {
+    for (const id of insight.evidence) referenced.add(id);
+    for (const ref of parseEvidenceRefs(insight.text)) referenced.add(ref.id);
+  }
+  for (const chart of spec.charts) {
+    if (!chart.title) continue;
+    for (const ref of parseEvidenceRefs(chart.title)) referenced.add(ref.id);
+  }
+  const defined = context.evidence.map((e) => e.id);
+  const result = {
+    ok: true,
+    value: {
+      charts,
+      evidence: {
+        defined,
+        referenced: [...referenced],
+        unreferenced: defined.filter((id) => !referenced.has(id))
+      }
+    }
+  };
+  writeOutput(output, `${JSON.stringify(result.value, null, 2)}
+`);
+  return result;
+}
+
 // src/cli.ts
 async function main() {
   const args = parseArgs(process.argv.slice(2));
@@ -59547,6 +60612,14 @@ async function main() {
       printJson(runBlock(args));
       return;
     }
+    if (args.command === "template") {
+      printJson(runTemplate(args));
+      return;
+    }
+    if (args.command === "inspect") {
+      printJson(runInspect(args));
+      return;
+    }
     if (args.command === "render") {
       printJson(runRender(args));
       return;
@@ -59568,7 +60641,7 @@ async function main() {
       return;
     }
     printJson(agentError("UNKNOWN_COMMAND", `Unknown command: ${args.command ?? "(none)"}`, {
-      commands: ["profile", "validate", "catalog", "block", "render", "deck", "article", "query", "analyze"]
+      commands: ["profile", "validate", "catalog", "block", "template", "inspect", "render", "deck", "article", "query", "analyze"]
     }));
     process.exitCode = 1;
   } catch (error51) {
@@ -59613,15 +60686,15 @@ function runValidate(args) {
   if (contextPath) {
     const raw = readJson(contextPath);
     const unwrapped = raw.ok === true ? raw.value : raw;
-    const parsed = analyzeContextSchema.safeParse(unwrapped);
-    if (!parsed.success) {
+    const parsed = parseAnalyzeContext(unwrapped);
+    if (!parsed) {
       return fail(agentError(
         "INVALID_CONTEXT",
-        `context.json format is invalid: ${parsed.error.issues.map((i) => i.message).join("; ")}`,
+        "context.json format is invalid.",
         { contextPath }
       ));
     }
-    context = parsed.data;
+    context = parsed;
   }
   const warnings = collectValidationWarnings(result.value, profile, context);
   if (args.flags["strict"] === true && context) {
@@ -59653,6 +60726,10 @@ function runValidate(args) {
   if (args.flags["verify"] === true) {
     const verifyWarnings = collectVerifyWarnings(result.value, context);
     warnings.push(...verifyWarnings);
+    if (args.flags["strict"] === true) {
+      const strictResult = strictVerifyError(verifyWarnings);
+      if (isAgentError(strictResult)) return fail(strictResult);
+    }
   }
   if (args.flags["patch-hints"] === true) {
     const warningPatches = collectWarningPatches(result.value);
@@ -59682,6 +60759,17 @@ function runRender(args) {
   if (isAgentError(normalized)) return fail(normalized);
   const validation = validateReportSpec(normalized, profile, formats);
   if (isAgentError(validation)) return fail(validation);
+  const contextPath = stringFlag(args, "context");
+  if (contextPath && validation.value.insights && validation.value.insights.length > 0) {
+    const raw = readJson(contextPath);
+    const unwrapped = raw.ok === true ? raw.value : raw;
+    const parsed = parseAnalyzeContext(unwrapped);
+    if (parsed) {
+      validation.value.insights = validation.value.insights.map(
+        (insight) => mapInsightText(insight, (text) => resolveDirectives(text, parsed.evidence))
+      );
+    }
+  }
   const themeFlag = stringFlag(args, "theme");
   const interactive = args.flags["interactive"] === true ? true : args.flags["no-interactive"] === true ? false : void 0;
   const written = [];
@@ -59762,7 +60850,8 @@ async function runAnalyze(args) {
     extraQuery: stringFlag(args, "extra-query"),
     correctAssumption: stringFlag(args, "correct-assumption")
   });
-  const result = { ok: true, value: context };
+  const value = args.flags["compact"] === true ? toCompactAnalyzeContext(context) : context;
+  const result = { ok: true, value };
   const outputPath = stringFlag(args, "output");
   if (outputPath) {
     writeOutput(outputPath, `${JSON.stringify(result, null, 2)}