mixdog 0.9.154 → 0.9.155

package/src/runtime/office/capabilities.mjs

@@ -54,19 +54,19 @@ const CATALOG = {
       fields: ['toc', 'page', 'numPages', 'pageBreak', 'sectionBreak'],
       links: ['address', 'subAddress', 'display', 'bookmark'],
       provenance: ['source.document', 'source.target', 'source.label'],
-      design: ['profile', 'intent', 'audience', 'tone', 'density', 'palette', 'typography', 'signature', 'content.packageId', 'content.audience', 'content.objective', 'content.decision', 'content.period', 'content.facts', 'content.claims', 'review'],
+      design: ['profile', 'purpose', 'expressionMode', 'intent', 'audience', 'tone', 'density', 'palette', 'typography', 'signature', 'content.packageId', 'content.audience', 'content.objective', 'content.decision', 'content.period', 'content.facts', 'content.claims', 'review'],
     },
   },
   xlsx: {
     paths: ['/sheet[NAME]', '/sheet[NAME]/cell[A1]', '/sheet[NAME]/range[A1:C10]'],
     operations: {
-      common: ['replace_text', 'set_cell', 'set_formula', 'set_range', 'append_row', 'clear_cell'],
-      office: ['compose_sheet', 'add_sheet', 'copy_sheet', 'delete_sheet', 'rename_sheet', 'set_style', 'add_note', 'delete_note', 'add_image', 'add_table', 'add_chart', 'add_conditional_format', 'delete_conditional_formats', 'add_validation', 'freeze_panes', 'add_pivot_table', 'autofit_range', 'set_page_setup', 'set_sheet_view', 'set_sheet_visibility', 'insert_rows', 'delete_rows', 'insert_columns', 'delete_columns', 'merge_cells', 'unmerge_cells', 'set_autofilter', 'set_hyperlink', 'define_name', 'delete_name', 'protect_sheet', 'unprotect_sheet', 'add_provenance'],
+      common: ['replace_text', 'set_cell', 'set_formula', 'set_range', 'append_row', 'clear_cell', 'compose_sheet', 'add_sheet', 'delete_sheet', 'rename_sheet', 'set_style', 'merge_cells', 'unmerge_cells', 'freeze_panes', 'autofit_range', 'set_page_setup', 'set_sheet_view'],
+      office: ['copy_sheet', 'add_note', 'delete_note', 'add_image', 'add_table', 'add_chart', 'add_conditional_format', 'delete_conditional_formats', 'add_validation', 'add_pivot_table', 'set_sheet_visibility', 'insert_rows', 'delete_rows', 'insert_columns', 'delete_columns', 'set_autofilter', 'set_hyperlink', 'define_name', 'delete_name', 'protect_sheet', 'unprotect_sheet', 'add_provenance'],
       portable: [],
     },
     properties: {
       cellStyle: ['fontName', 'fontSize', 'bold', 'italic', 'color', 'fillColor', 'numberFormat', 'horizontalAlignment', 'verticalAlignment', 'wrapText'],
-      chart: ['chartType', 'left', 'top', 'width', 'height', 'title'],
+      chart: ['chartType', 'left', 'top', 'width', 'height', 'title', 'seriesColors', 'showValues', 'showLegend', 'zeroBaseline', 'valueNumberFormat', 'dataLabelPosition', 'dataLabelColor'],
       table: ['name', 'style'],
       pivot: ['source', 'destination', 'name', 'rows', 'columns', 'values'],
       note: ['text', 'author'],
@@ -77,14 +77,14 @@ const CATALOG = {
       pageSetup: ['printArea', 'orientation', 'fitToPagesWide', 'fitToPagesTall', 'centerHorizontally', 'topMargin', 'bottomMargin', 'leftMargin', 'rightMargin'],
       sheetView: ['showGridlines', 'zoom'],
       provenance: ['source.document', 'source.target', 'source.label'],
-      design: ['profile', 'intent', 'audience', 'tone', 'density', 'palette', 'typography', 'signature', 'content.packageId', 'content.audience', 'content.objective', 'content.decision', 'content.period', 'content.facts', 'content.claims', 'review'],
+      design: ['profile', 'purpose', 'expressionMode', 'intent', 'audience', 'tone', 'density', 'palette', 'typography', 'signature', 'content.packageId', 'content.audience', 'content.objective', 'content.decision', 'content.period', 'content.facts', 'content.claims', 'review'],
     },
   },
   pptx: {
     paths: ['/slide[N]', '/slide[N]/shape[N]'],
     operations: {
-      common: ['replace_text', 'fill_template', 'set_text', 'add_textbox', 'delete_shape'],
-      office: ['compose_slide', 'add_slide', 'delete_slide', 'move_slide', 'duplicate_slide', 'import_slides', 'keep_slides', 'set_notes', 'set_footer', 'set_slide_number', 'add_comment', 'delete_comment', 'add_image', 'replace_image', 'crop_image', 'add_media', 'set_shape', 'group_shapes', 'ungroup_shape', 'set_slide_background', 'set_layout', 'apply_theme', 'set_transition', 'add_animation', 'add_chart', 'fit_text', 'add_shape', 'add_table', 'set_table_data', 'set_chart_data', 'set_chart_series', 'set_chart_axis', 'set_chart_data_labels', 'set_chart_trendline', 'set_chart_error_bars', 'set_hyperlink', 'z_order', 'align_shapes', 'distribute_shapes', 'add_provenance'],
+      common: ['replace_text', 'fill_template', 'set_text', 'add_textbox', 'delete_shape', 'compose_slide', 'add_slide', 'delete_slide', 'move_slide', 'set_notes', 'add_image', 'add_shape', 'add_table', 'set_shape', 'set_slide_background', 'import_slides', 'replace_image', 'set_table_data'],
+      office: ['duplicate_slide', 'keep_slides', 'set_footer', 'set_slide_number', 'add_comment', 'delete_comment', 'crop_image', 'add_media', 'group_shapes', 'ungroup_shape', 'set_layout', 'apply_theme', 'set_transition', 'add_animation', 'add_chart', 'fit_text', 'set_chart_data', 'set_chart_series', 'set_chart_axis', 'set_chart_data_labels', 'set_chart_trendline', 'set_chart_error_bars', 'set_hyperlink', 'z_order', 'align_shapes', 'distribute_shapes', 'add_provenance'],
       portable: [],
     },
     properties: {
@@ -100,7 +100,7 @@ const CATALOG = {
       media: ['kind', 'link', 'embed', 'poster'],
       comment: ['author', 'initials', 'left', 'top'],
       provenance: ['source.document', 'source.target', 'source.label'],
-      design: ['profile', 'intent', 'audience', 'tone', 'density', 'palette', 'typography', 'signature', 'content.packageId', 'content.audience', 'content.objective', 'content.decision', 'content.period', 'content.facts', 'content.claims', 'template', 'deck.backgroundMode', 'deck.dominantColorRole', 'deck.motif', 'deck.spacingScale', 'deck.sectionSlides', 'deck.roles', 'deck.requireSlidePlan', 'deck.templateMode', 'review', 'reviewed', 'reviewToken', 'critique'],
+      design: ['profile', 'purpose', 'expressionMode', 'intent', 'audience', 'tone', 'density', 'palette', 'typography', 'signature', 'content.packageId', 'content.audience', 'content.objective', 'content.decision', 'content.period', 'content.facts', 'content.claims', 'template', 'deck.backgroundMode', 'deck.dominantColorRole', 'deck.motif', 'deck.spacingScale', 'deck.sectionSlides', 'deck.roles', 'deck.requireSlidePlan', 'deck.templateMode', 'review', 'reviewed', 'reviewToken', 'critique'],
     },
   },
   pdf: {
@@ -143,9 +143,9 @@ const COMMON_SIGNATURES = {
 
 const FORMAT_SIGNATURES = {
   docx: {
-    compose_document: signature(['title'], ['claimId', 'subtitle', 'summary', 'meta', 'sections', 'footer', 'orientation', 'pageNumbers'], {
+    compose_document: signature(['title'], ['claimId', 'purpose', 'expressionMode', 'variant', 'subtitle', 'summary', 'meta', 'sections', 'footer', 'orientation', 'pageNumbers'], {
       propertySets: ['design'],
-      notes: 'Semantic create-time composition. Content is mapped to native Word title, heading, paragraph, list, table, section, and footer operations.',
+      notes: 'Purpose-aware native Word composition; variant is optional because content topology selects the default.',
     }),
     append_text: signature(['text'], ['style', 'properties'], {
       propertySets: ['paragraph', 'font', 'paragraphFormat'],
@@ -179,7 +179,7 @@ const FORMAT_SIGNATURES = {
     set_page: signature(['properties'], ['section'], { propertySets: ['page'] }),
     fit_table: signature(['table']),
     insert_toc: signature([], ['paragraph', 'lowerHeadingLevel', 'upperHeadingLevel']),
-    add_page_numbers: signature([], ['section', 'kind', 'prefix', 'separator', 'includeTotal']),
+    add_page_numbers: signature([], ['section', 'kind', 'prefix', 'separator', 'includeTotal', 'alignment']),
     insert_break: signature([], ['paragraph', 'kind']),
     set_list: signature(['paragraph', 'kind'], ['level']),
     add_hyperlink: signature([], ['find', 'paragraph', 'address', 'subAddress', 'display'], {
@@ -190,9 +190,9 @@ const FORMAT_SIGNATURES = {
     add_provenance: signature(['paragraph', 'source'], [], { propertySets: ['provenance'] }),
   },
   xlsx: {
-    compose_sheet: signature(['rows'], ['claimId', 'sheet', 'kind', 'title', 'subtitle', 'source', 'headers', 'metrics', 'insights', 'columnFormats', 'tableName', 'tableStyle', 'chart'], {
+    compose_sheet: signature(['rows'], ['claimId', 'purpose', 'expressionMode', 'variant', 'sheet', 'kind', 'title', 'subtitle', 'source', 'headers', 'metrics', 'insights', 'columnFormats', 'tableName', 'tableStyle', 'chart'], {
       propertySets: ['design'],
-      notes: 'Semantic Excel composition with title hierarchy, native table styling, frozen headers, chart placement, and autofit.',
+      notes: 'Purpose-aware native Excel composition with content-selected dashboard, trend, comparison, scorecard, or analysis layout.',
     }),
     set_cell: signature(['cell', 'value'], ['sheet']),
     set_formula: signature(['cell', 'formula'], ['sheet']),
@@ -211,7 +211,7 @@ const FORMAT_SIGNATURES = {
     delete_note: signature(['cell'], ['sheet']),
     add_image: signature(['path'], ['sheet', 'left', 'top', 'width', 'height']),
     add_table: signature(['range'], ['sheet', 'name', 'style'], { propertySets: ['table'] }),
-    add_chart: signature(['range'], ['sheet', 'chartType', 'title', 'left', 'top', 'width', 'height'], {
+    add_chart: signature(['range'], ['sheet', 'chartType', 'title', 'left', 'top', 'width', 'height', 'seriesColors', 'showValues', 'showLegend', 'zeroBaseline', 'valueNumberFormat', 'dataLabelPosition', 'dataLabelColor'], {
       propertySets: ['chart'],
       notes: 'The first source column supplies categories; remaining columns become series.',
     }),
@@ -223,7 +223,7 @@ const FORMAT_SIGNATURES = {
     autofit_range: signature(['range'], ['sheet', 'rows'], {
       notes: 'Accepts cell, whole-column, or whole-row ranges such as A1:D5, A:D, or 2:8.',
     }),
-    set_page_setup: signature([], ['sheet', 'printArea', 'orientation', 'fitToPagesWide', 'fitToPagesTall', 'centerHorizontally', 'topMargin', 'bottomMargin', 'leftMargin', 'rightMargin'], {
+    set_page_setup: signature([], ['sheet', 'printArea', 'orientation', 'fitToPagesWide', 'fitToPagesTall', 'centerHorizontally', 'centerVertically', 'topMargin', 'bottomMargin', 'leftMargin', 'rightMargin'], {
       propertySets: ['pageSetup'],
     }),
     set_sheet_view: signature([], ['sheet', 'showGridlines', 'zoom'], {
@@ -247,9 +247,9 @@ const FORMAT_SIGNATURES = {
     add_provenance: signature(['cell', 'source'], ['sheet'], { propertySets: ['provenance'] }),
   },
   pptx: {
-    compose_slide: signature(['kind'], ['claimId', 'title', 'subtitle', 'takeaway', 'eyebrow', 'body', 'bullets', 'metrics', 'columns', 'steps', 'chart', 'table', 'image', 'imagePath', 'visualText', 'visualLabel', 'meta', 'notes', 'source', 'background', 'backgroundRole', 'slideRole', 'plan', 'create', 'slide', 'layoutId', 'variant', 'titleSize'], {
+    compose_slide: signature(['kind'], ['claimId', 'purpose', 'expressionMode', 'title', 'subtitle', 'takeaway', 'eyebrow', 'body', 'bullets', 'metrics', 'columns', 'steps', 'chart', 'table', 'image', 'imagePath', 'visualText', 'visualLabel', 'meta', 'notes', 'source', 'background', 'backgroundRole', 'slideRole', 'plan', 'create', 'slide', 'layoutId', 'variant', 'titleSize'], {
       propertySets: ['design'],
-      notes: 'Template-first semantic slide. Use a declarative title as the takeaway, subject-specific evidence, and source notes for material numbers. Approved sample slides preserve native masters/layouts; deck.templateMode:"strict" rejects scratch fallback. Kinds: cover, statement, content, split, comparison, metrics, process, chart, table, closing.',
+      notes: 'Template-first semantic slide; generic content is reclassified from its evidence, while explicit layoutId or variant stays pinned.',
     }),
     set_text: signature(['slide', 'shape', 'text']),
     add_textbox: signature(['slide', 'text'], ['paragraphs', 'left', 'top', 'width', 'height', 'fontName', 'fontSize', 'color', 'properties'], { propertySets: ['shape', 'authoring'] }),

package/src/runtime/office/composition-system.mjs

@@ -0,0 +1,451 @@
+import { createHash } from 'node:crypto';
+
+const PURPOSES = new Set(['monitor', 'decide', 'compare', 'explain', 'inspect']);
+const EXPRESSION_MODES = new Set(['conservative', 'strong-fit', 'divergent']);
+
+const FORMAT_CANDIDATES = Object.freeze({
+  docx: Object.freeze([
+    Object.freeze({
+      id: 'decision-brief',
+      family: 'decision',
+      purposes: ['decide'],
+      modes: ['conservative', 'strong-fit'],
+      evidence: ['claims', 'facts'],
+      densities: ['balanced', 'dense'],
+      novelty: 0,
+    }),
+    Object.freeze({
+      id: 'evidence-brief',
+      family: 'evidence',
+      purposes: ['decide', 'compare', 'inspect'],
+      modes: ['strong-fit', 'divergent'],
+      evidence: ['table', 'facts'],
+      densities: ['balanced', 'dense'],
+      novelty: 1,
+    }),
+    Object.freeze({
+      id: 'editorial-report',
+      family: 'narrative',
+      purposes: ['explain'],
+      modes: ['strong-fit', 'divergent'],
+      evidence: ['narrative', 'claims'],
+      densities: ['light', 'balanced'],
+      novelty: 1,
+    }),
+    Object.freeze({
+      id: 'compact-memo',
+      family: 'memo',
+      purposes: ['decide', 'inspect'],
+      modes: ['conservative'],
+      evidence: ['narrative'],
+      densities: ['balanced', 'dense'],
+      novelty: 0,
+    }),
+  ]),
+  xlsx: Object.freeze([
+    Object.freeze({
+      id: 'monitor-dashboard',
+      family: 'monitor',
+      purposes: ['monitor'],
+      modes: ['conservative', 'strong-fit'],
+      evidence: ['metrics', 'table'],
+      densities: ['balanced', 'dense'],
+      novelty: 0,
+    }),
+    Object.freeze({
+      id: 'trend-dashboard',
+      family: 'trend',
+      purposes: ['monitor', 'explain'],
+      modes: ['strong-fit', 'divergent'],
+      evidence: ['chart', 'table'],
+      densities: ['balanced'],
+      novelty: 1,
+    }),
+    Object.freeze({
+      id: 'comparison-board',
+      family: 'comparison',
+      purposes: ['compare', 'decide'],
+      modes: ['strong-fit', 'divergent'],
+      evidence: ['chart', 'metrics'],
+      densities: ['balanced', 'dense'],
+      novelty: 1,
+    }),
+    Object.freeze({
+      id: 'analysis-sheet',
+      family: 'analysis',
+      purposes: ['inspect', 'explain'],
+      modes: ['conservative', 'strong-fit'],
+      evidence: ['table', 'facts'],
+      densities: ['dense'],
+      novelty: 0,
+    }),
+    Object.freeze({
+      id: 'narrative-scorecard',
+      family: 'scorecard',
+      purposes: ['monitor', 'decide'],
+      modes: ['divergent'],
+      evidence: ['metrics', 'claims'],
+      densities: ['light', 'balanced'],
+      novelty: 2,
+    }),
+  ]),
+});
+
+const PPTX_VARIANTS = Object.freeze({
+  cover: Object.freeze([
+    Object.freeze({ variant: 'editorial-left', family: 'editorial', modes: ['conservative', 'strong-fit'], novelty: 0 }),
+    Object.freeze({ variant: 'minimal-focus', family: 'minimal', modes: ['strong-fit', 'divergent'], novelty: 1 }),
+  ]),
+  statement: Object.freeze([
+    Object.freeze({ variant: 'metric-statement', family: 'evidence', purposes: ['decide', 'monitor'], evidence: ['metrics'], novelty: 0 }),
+    Object.freeze({ variant: 'typographic-statement', family: 'typography', purposes: ['decide', 'explain'], evidence: ['narrative'], novelty: 1 }),
+  ]),
+  metrics: Object.freeze([
+    Object.freeze({ variant: 'asymmetric-metrics', family: 'evidence', purposes: ['decide', 'monitor'], modes: ['conservative', 'strong-fit'], novelty: 0 }),
+    Object.freeze({ variant: 'metric-band', family: 'rhythm', purposes: ['monitor', 'explain'], modes: ['strong-fit', 'divergent'], novelty: 1 }),
+  ]),
+  comparison: Object.freeze([
+    Object.freeze({ variant: 'contrast-panels', family: 'comparison', modes: ['conservative', 'strong-fit'], novelty: 0 }),
+    Object.freeze({ variant: 'aligned-evidence', family: 'evidence', modes: ['strong-fit', 'divergent'], novelty: 1 }),
+  ]),
+  process: Object.freeze([
+    Object.freeze({ variant: 'horizontal-flow', family: 'process', modes: ['conservative', 'strong-fit'], novelty: 0 }),
+    Object.freeze({ variant: 'staggered-flow', family: 'rhythm', modes: ['strong-fit', 'divergent'], novelty: 1 }),
+  ]),
+  chart: Object.freeze([
+    Object.freeze({ variant: 'commentary-chart', family: 'evidence', purposes: ['decide', 'explain'], evidence: ['narrative'], novelty: 0 }),
+    Object.freeze({ variant: 'chart-led', family: 'data', purposes: ['monitor', 'compare'], evidence: ['chart'], modes: ['strong-fit', 'divergent'], novelty: 1 }),
+  ]),
+  table: Object.freeze([
+    Object.freeze({ variant: 'table-led', family: 'evidence', modes: ['conservative', 'strong-fit'], novelty: 0 }),
+    Object.freeze({ variant: 'table-callout', family: 'comparison', modes: ['strong-fit', 'divergent'], novelty: 1 }),
+  ]),
+  split: Object.freeze([
+    Object.freeze({ variant: 'visual-right', family: 'split', modes: ['conservative', 'strong-fit'], novelty: 0 }),
+    Object.freeze({ variant: 'visual-left', family: 'editorial', modes: ['strong-fit', 'divergent'], novelty: 1 }),
+  ]),
+  content: Object.freeze([
+    Object.freeze({ variant: 'evidence-right', family: 'evidence', purposes: ['decide', 'inspect'], evidence: ['visual'], novelty: 0 }),
+    Object.freeze({ variant: 'editorial-wide', family: 'typography', purposes: ['explain'], evidence: ['narrative'], modes: ['strong-fit', 'divergent'], novelty: 1 }),
+  ]),
+  closing: Object.freeze([
+    Object.freeze({ variant: 'decision-left', family: 'decision', modes: ['conservative', 'strong-fit'], novelty: 0 }),
+    Object.freeze({ variant: 'decision-focus', family: 'minimal', modes: ['strong-fit', 'divergent'], novelty: 1 }),
+  ]),
+});
+
+function plainObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function stableValue(value) {
+  if (Array.isArray(value)) return value.map(stableValue);
+  if (!plainObject(value)) return value;
+  return Object.fromEntries(Object.keys(value).sort().map((key) => [key, stableValue(value[key])]));
+}
+
+function sha256(value) {
+  return createHash('sha256').update(JSON.stringify(stableValue(value))).digest('hex');
+}
+
+function bucket(value, boundaries = [0, 1, 3, 8]) {
+  const count = Math.max(0, Number(value) || 0);
+  if (count <= boundaries[0]) return '0';
+  if (count <= boundaries[1]) return '1';
+  if (count <= boundaries[2]) return 'few';
+  if (count <= boundaries[3]) return 'several';
+  return 'many';
+}
+
+function rowsOf(value) {
+  if (Array.isArray(value)) return value;
+  return Array.isArray(value?.values) ? value.values : [];
+}
+
+function textCount(value) {
+  if (Array.isArray(value)) return value.filter((entry) => String(entry ?? '').trim()).length;
+  return value == null || value === '' ? 0 : 1;
+}
+
+function normalizePurpose(value, fallback) {
+  const normalized = String(value || '').trim().toLowerCase();
+  return PURPOSES.has(normalized) ? normalized : fallback;
+}
+
+function normalizeExpressionMode(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  return EXPRESSION_MODES.has(normalized) ? normalized : 'strong-fit';
+}
+
+function defaultPurpose(format, input) {
+  if (format === 'xlsx') return 'monitor';
+  if (format === 'csv' || format === 'tsv') return 'inspect';
+  if (input?.content?.decision) return 'decide';
+  return 'explain';
+}
+
+function normalizedRecentCompositions(value) {
+  if (!Array.isArray(value)) return [];
+  return value
+    .filter(plainObject)
+    .slice(0, 24)
+    .map((entry) => ({
+      fingerprint: String(entry.fingerprint || ''),
+      format: String(entry.format || ''),
+      profile: String(entry.profile || ''),
+      purpose: String(entry.purpose || ''),
+      expressionMode: String(entry.expressionMode || ''),
+      compositionIds: Array.isArray(entry.compositionIds)
+        ? entry.compositionIds.map((id) => String(id || '')).filter(Boolean).slice(0, 64)
+        : [],
+      createdAt: String(entry.createdAt || ''),
+    }));
+}
+
+export function resolveOfficeCompositionContext(format, input = {}, {
+  recentCompositions = [],
+} = {}) {
+  const normalizedFormat = String(format || '').toLowerCase();
+  const composition = plainObject(input.composition) ? input.composition : {};
+  const fallbackPurpose = defaultPurpose(normalizedFormat, input);
+  return {
+    purpose: normalizePurpose(input.purpose || composition.purpose, fallbackPurpose),
+    expressionMode: normalizeExpressionMode(input.expressionMode || composition.expressionMode),
+    recentCompositions: normalizedRecentCompositions(recentCompositions),
+  };
+}
+
+export function officeContentTopology(format, operation = {}, design = {}) {
+  const sections = Array.isArray(operation.sections) ? operation.sections : [];
+  const tableRows = Math.max(
+    rowsOf(operation.table).length,
+    ...sections.map((section) => rowsOf(section?.table).length),
+  );
+  const metrics = Array.isArray(operation.metrics) ? operation.metrics.length : 0;
+  const columns = Array.isArray(operation.columns) ? operation.columns.length : 0;
+  const steps = Array.isArray(operation.steps) ? operation.steps.length : 0;
+  const rows = Array.isArray(operation.rows) ? operation.rows.length : 0;
+  const chartSeries = Array.isArray(operation.chart?.series) ? operation.chart.series.length : 0;
+  const paragraphs = textCount(operation.body)
+    + textCount(operation.bullets)
+    + sections.reduce((total, section) => (
+      total + textCount(section?.paragraphs || section?.body) + textCount(section?.bullets)
+    ), 0);
+  const facts = Array.isArray(design.content?.facts) ? design.content.facts.length : 0;
+  const claims = Array.isArray(design.content?.claims) ? design.content.claims.length : 0;
+  const evidence = [];
+  if (metrics) evidence.push('metrics');
+  if (tableRows || rows) evidence.push('table');
+  if (operation.chart || chartSeries) evidence.push('chart');
+  if (operation.image || operation.imagePath) evidence.push('image');
+  if (operation.visualText) evidence.push('visual');
+  if (columns) evidence.push('comparison');
+  if (steps) evidence.push('process');
+  if (paragraphs) evidence.push('narrative');
+  if (facts) evidence.push('facts');
+  if (claims) evidence.push('claims');
+  const weight = metrics * 2 + columns * 2 + steps + Math.ceil((rows + tableRows) / 4) + paragraphs + claims;
+  const density = weight >= 14 ? 'dense' : weight <= 4 ? 'light' : 'balanced';
+  const signature = [
+    String(format || '').toLowerCase(),
+    `m:${bucket(metrics)}`,
+    `c:${bucket(columns)}`,
+    `s:${bucket(steps)}`,
+    `r:${bucket(rows + tableRows, [0, 3, 10, 24])}`,
+    `p:${bucket(paragraphs)}`,
+    `e:${evidence.sort().join(',')}`,
+  ].join('|');
+  return {
+    metrics,
+    columns,
+    steps,
+    rows,
+    tableRows,
+    chartSeries,
+    paragraphs,
+    sections: sections.length,
+    facts,
+    claims,
+    evidence,
+    density,
+    signature,
+  };
+}
+
+function recentPenalty(context, candidateId) {
+  return context.recentCompositions.slice(0, 8).reduce((total, entry, index) => (
+    entry.compositionIds.includes(candidateId)
+      ? total + Math.max(1, 4 - Math.floor(index / 2))
+      : total
+  ), 0);
+}
+
+function stableTie(seed, id) {
+  return Number.parseInt(sha256(`${seed}\0${id}`).slice(0, 8), 16) / 0xFFFFFFFF;
+}
+
+function selectCandidate(candidates, {
+  context,
+  topology,
+  density,
+  seed,
+  usage,
+  explicitVariant = '',
+}) {
+  const evidence = new Set(topology.evidence);
+  const ranked = candidates.map((candidate) => {
+    const candidateId = String(candidate.id || candidate.variant || '');
+    let score = 0;
+    if (candidate.purposes?.includes(context.purpose)) score += 18;
+    else if (candidate.purposes?.length) score -= 6;
+    if (candidate.modes?.includes(context.expressionMode)) score += 5;
+    if (candidate.densities?.includes(density || topology.density)) score += 3;
+    score += (candidate.evidence || []).filter((entry) => evidence.has(entry)).length * 3;
+    if (context.expressionMode === 'divergent') score += Number(candidate.novelty || 0) * 3;
+    if (context.expressionMode === 'conservative') score -= Number(candidate.novelty || 0) * 2;
+    if (explicitVariant && (candidate.variant === explicitVariant || candidate.id === explicitVariant)) score += 100;
+    const historyPenalty = recentPenalty(context, candidateId);
+    score -= historyPenalty;
+    score -= (usage.get(candidateId) || 0) * 7;
+    score += stableTie(seed, candidateId);
+    return { candidate, candidateId, score, historyPenalty };
+  });
+  ranked.sort((left, right) => right.score - left.score || left.candidateId.localeCompare(right.candidateId));
+  return ranked[0];
+}
+
+function resolvedPptxKind(operation, topology) {
+  const requested = String(operation.kind || 'content').toLowerCase();
+  if (requested !== 'content' || operation.layoutId) return requested;
+  if (operation.chart) return 'chart';
+  if (operation.table) return 'table';
+  if (topology.metrics >= 2) return 'metrics';
+  if (topology.columns >= 2) return 'comparison';
+  if (topology.steps >= 2) return 'process';
+  if (operation.image || operation.imagePath) return 'split';
+  return 'content';
+}
+
+export function planOfficeComposition(format, operation = {}, design = {}, {
+  usage = new Map(),
+} = {}) {
+  const normalizedFormat = String(format || '').toLowerCase();
+  const topology = officeContentTopology(normalizedFormat, operation, design);
+  const context = {
+    purpose: normalizePurpose(operation.purpose, design.purpose || 'explain'),
+    expressionMode: normalizeExpressionMode(operation.expressionMode || design.expressionMode),
+    recentCompositions: normalizedRecentCompositions(design.recentCompositions),
+  };
+  const seed = design.content?.fingerprint
+    || [design.intent, design.audience, design.signature, operation.title, topology.signature].join('|');
+  if (normalizedFormat === 'pptx') {
+    const kind = resolvedPptxKind(operation, topology);
+    const explicitVariant = String(operation.variant || '').trim().toLowerCase();
+    const variants = PPTX_VARIANTS[kind] || PPTX_VARIANTS.content;
+    const candidates = explicitVariant && !variants.some((entry) => entry.variant === explicitVariant)
+      ? [...variants, { variant: explicitVariant, family: kind, novelty: 0 }]
+      : variants;
+    const selected = selectCandidate(candidates.map((entry) => ({
+      ...entry,
+      id: `${kind}:${entry.variant}`,
+      purposes: entry.purposes || [context.purpose],
+    })), {
+      context,
+      topology,
+      density: design.density,
+      seed,
+      usage,
+      explicitVariant,
+    });
+    const result = {
+      id: selected.candidateId,
+      family: selected.candidate.family,
+      kind,
+      variant: selected.candidate.variant,
+      purpose: context.purpose,
+      expressionMode: context.expressionMode,
+      topology,
+      historyPenalty: selected.historyPenalty,
+      source: explicitVariant ? 'explicit' : 'content-planner',
+    };
+    usage.set(result.id, (usage.get(result.id) || 0) + 1);
+    return result;
+  }
+  const candidates = FORMAT_CANDIDATES[normalizedFormat] || [{
+    id: `${normalizedFormat || 'office'}-default`,
+    family: 'default',
+    purposes: [context.purpose],
+    modes: [context.expressionMode],
+    novelty: 0,
+  }];
+  const selected = selectCandidate(candidates, {
+    context,
+    topology,
+    density: design.density,
+    seed,
+    usage,
+    explicitVariant: String(operation.variant || '').trim().toLowerCase(),
+  });
+  const result = {
+    id: selected.candidateId,
+    family: selected.candidate.family,
+    purpose: context.purpose,
+    expressionMode: context.expressionMode,
+    topology,
+    historyPenalty: selected.historyPenalty,
+    source: operation.variant ? 'explicit' : 'content-planner',
+  };
+  usage.set(result.id, (usage.get(result.id) || 0) + 1);
+  return result;
+}
+
+export function summarizeOfficeCompositions(format, compositions = []) {
+  const normalized = (Array.isArray(compositions) ? compositions : [])
+    .map((entry) => entry?.composition || entry)
+    .filter((entry) => plainObject(entry) && entry.id)
+    .map((entry) => ({
+      id: String(entry.id),
+      family: String(entry.family || ''),
+      kind: String(entry.kind || ''),
+      purpose: String(entry.purpose || ''),
+      topology: String(entry.topology?.signature || ''),
+    }));
+  if (!normalized.length) {
+    return {
+      format: String(format || '').toLowerCase(),
+      fingerprint: '',
+      compositionIds: [],
+      count: 0,
+    };
+  }
+  return {
+    format: String(format || '').toLowerCase(),
+    fingerprint: sha256({ format: String(format || '').toLowerCase(), sequence: normalized }),
+    compositionIds: normalized.map((entry) => entry.id),
+    count: normalized.length,
+  };
+}
+
+export function reviewOfficeCompositionSequence({
+  format,
+  compositions = [],
+  recentCompositions = [],
+  allowRepetition = false,
+} = {}) {
+  const plans = (Array.isArray(compositions) ? compositions : [])
+    .map((entry) => entry?.composition || entry)
+    .filter((entry) => plainObject(entry) && entry.id);
+  const summary = summarizeOfficeCompositions(format, plans);
+  if (allowRepetition || !plans.length) return { summary, repeated: null, recentMatch: null };
+  const eligible = plans.filter((entry) => !['cover', 'closing'].includes(String(entry.kind || '')));
+  const counts = new Map();
+  for (const entry of eligible) counts.set(entry.id, (counts.get(entry.id) || 0) + 1);
+  const [repeatedId = '', repeatedCount = 0] = [...counts.entries()]
+    .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))[0] || [];
+  const repeated = eligible.length >= 4 && repeatedCount / eligible.length >= 0.75
+    ? { id: repeatedId, count: repeatedCount, total: eligible.length }
+    : null;
+  const recentMatch = normalizedRecentCompositions(recentCompositions)
+    .find((entry) => entry.fingerprint && entry.fingerprint === summary.fingerprint) || null;
+  return { summary, repeated, recentMatch };
+}