@tiwater/office-mcp 0.12.0 → 0.13.0

package/office/index.mjs

@@ -11,6 +11,7 @@ import {
   commandCandidate,
   createToolResult,
   requireString,
+  runCandidateChain,
   runJsonCandidateChain,
   withTempJsonFile,
 } from '../_shared/tool-runtime.mjs';
@@ -35,97 +36,12 @@ const convertCandidates = [
 ];
 
 const pathInput = z.string().trim().min(1);
-const migrationQueryTargetAction = z.enum([
-  'place-content',
-  'keep-template-label',
-  'select-template-option',
-]).describe('Business action: place-content moves the current source content into a target content position; keep-template-label preserves the target label and structure while migrating a uniquely identified current field value; select-template-option marks the target option represented by the current source fact.');
-const targetActions = new Set(migrationQueryTargetAction.options);
-
-const choiceReference = z.string().trim().regex(/^[ST][1-9][0-9]*-[0-9a-f]{8}$/);
-const alternativeReference = z.string().trim().regex(/^S[1-9][0-9]*-[PLO][1-9][0-9]*-[0-9a-f]{8}$/);
-
-const terminalMigrationChoiceInput = z.object({
-  sourceRef: choiceReference,
-  action: z.enum(['exclude-source', 'review-source']),
-}).strict();
-
-const migrationChoiceInput = z.union([
-  z.object({ alternativeRef: alternativeReference }).strict(),
-  terminalMigrationChoiceInput,
-]);
-
-const templateCleanupInput = z.object({
-  targetRef: choiceReference,
-  scope: z.enum(['cell', 'row']),
-}).strict();
-
-const templateMigrationInput = z.object({
-  source: pathInput.describe('Path to the current source DOCX.'),
-  baseline: pathInput.describe('Path to the selected current baseline DOCX.'),
-  output: pathInput.describe('Path to the migrated output DOCX.'),
-  receiptOutput: pathInput.describe('New JSON receipt artifact path. Existing files are never overwritten.'),
-  choices: z.array(migrationChoiceInput).describe('Exactly one business choice for every source ref. Targeted choices use an alternativeRef returned by the query tool. Terminal exclusions and genuine local review use a sourceRef.'),
-  templateCleanup: z.array(templateCleanupInput).optional().describe('Optional baseline-owned placeholders or example rows to clear.'),
-}).strict();
 
 const runtimeIdentity = z.object({
   command: z.string(),
   cwd: z.string(),
 }).strict();
 
-const migrationChoiceOutput = z.object({
-  id: z.string(),
-  kind: z.string(),
-  scope: z.string(),
-  text: z.string().nullable(),
-  count: z.number().int(),
-  requiredCardinality: z.string().nullable(),
-  context: z.record(z.string(), z.unknown()).nullable(),
-  allowedActions: z.array(z.string()),
-}).strict();
-
-const migrationPublicChoiceOutput = migrationChoiceOutput.omit({ id: true }).extend({
-  ref: choiceReference,
-}).strict();
-
-const migrationAlternativeOutput = z.object({
-  ref: alternativeReference,
-  action: migrationQueryTargetAction,
-  target: migrationPublicChoiceOutput,
-}).strict();
-
-const migrationCatalog = z.object({
-  schema: z.string(),
-  pass: z.boolean(),
-  sourceSha256: z.string(),
-  baselineSha256: z.string(),
-  sources: z.array(migrationChoiceOutput),
-  targets: z.array(migrationChoiceOutput),
-}).strict().superRefine((catalog, context) => {
-  for (const key of ['sources', 'targets']) {
-    const seen = new Set();
-    for (const [index, choice] of catalog[key].entries()) {
-      if (seen.has(choice.id)) {
-        context.addIssue({ code: 'custom', path: [key, index, 'id'], message: `duplicate ${key} choice id: ${choice.id}` });
-      }
-      seen.add(choice.id);
-    }
-  }
-});
-
-const migrationReceipt = z.object({
-  schema: z.string(),
-  toolVersion: z.string(),
-  status: z.enum(['pass', 'review-required', 'failed']),
-  pass: z.boolean(),
-  reviewRequired: z.boolean(),
-  outputVerified: z.boolean(),
-  output: z.string().nullable(),
-  plan: z.string().nullable(),
-  failures: z.array(z.unknown()),
-}).passthrough();
-
 const inputOnly = z.object({ input: pathInput }).strict();
 const artifactInput = z.object({
   input: pathInput,
@@ -137,39 +53,6 @@ const artifact = z.object({
   bytes: z.number().int().nonnegative(),
 }).strict();
 
-const xlsxAppliedOperation = z.object({
-  type: z.string().min(1),
-  applied: z.boolean(),
-  detail: z.string(),
-  sheet: z.string().nullable().optional(),
-  changedRange: z.string().nullable().optional(),
-  warnings: z.array(z.string()).nullable().optional(),
-}).strict();
-const xlsxEditResult = z.object({
-  input: z.string().min(1),
-  output: z.string().min(1),
-  appliedOperations: z.array(xlsxAppliedOperation),
-}).strict();
-const xlsxApplyReceipt = z.object({
-  schema: z.literal('tiwater.office.xlsx-apply-receipt/v1'),
-  pass: z.boolean(),
-  input: artifact,
-  operations: artifact,
-  output: artifact.nullable(),
-  appliedOperations: z.array(xlsxAppliedOperation),
-}).strict();
-const xlsxApplyOutput = z.object({
-  tool: z.literal('xlsx_apply'),
-  runtime: runtimeIdentity,
-  receipt: artifact,
-  output: artifact.nullable(),
-  summary: z.object({
-    pass: z.boolean(),
-    operationCount: z.number().int().nonnegative(),
-    appliedCount: z.number().int().nonnegative(),
-  }).strict(),
-}).strict();
-
 const pptxTemplateApplyResult = z.object({
   input: z.string().min(1),
   template: z.string().min(1),
@@ -210,23 +93,6 @@ const pptxFormatApplyResult = z.object({
     message: z.string(),
   }).strict()),
 }).strict();
-const pptxTemplateApplyReceipt = z.object({
-  schema: z.literal('tiwater.office.pptx-template-apply-receipt/v1'),
-  pass: z.boolean(),
-  input: artifact,
-  template: artifact,
-  plan: artifact,
-  output: artifact.nullable(),
-  providerResult: pptxTemplateApplyResult,
-}).strict();
-const pptxFormatApplyReceipt = z.object({
-  schema: z.literal('tiwater.office.pptx-format-apply-receipt/v1'),
-  pass: z.boolean(),
-  input: artifact,
-  operations: artifact,
-  output: artifact.nullable(),
-  providerResult: pptxFormatApplyResult,
-}).strict();
 const pptxTemplateApplyOutput = z.object({
   tool: z.literal('pptx_apply_template'),
   runtime: runtimeIdentity,
@@ -287,99 +153,121 @@ const nativeRenderOutput = z.object({
   }).strict(),
 }).strict();
 
-const migrationCatalogOutput = z.object({
-  tool: z.literal('docx_list_migration_choices'),
-  runtime: runtimeIdentity,
-  artifact,
-  summary: z.object({
-    schema: z.string(),
-    pass: z.boolean(),
-    sourceSha256: z.string(),
-    baselineSha256: z.string(),
-    sourceCount: z.number().int().nonnegative(),
-    targetCount: z.number().int().nonnegative(),
-  }).strict(),
+const index = z.number().int().nonnegative();
+const positiveIndex = z.number().int().positive();
+const optionalTextMatch = {
+  matchMode: z.string().optional(),
+  paragraphStyle: z.string().optional(),
+};
+const richTextSegment = z.object({
+  text: z.string(),
+  color: z.string().optional(),
+  underline: z.boolean().optional(),
+  bold: z.boolean().optional(),
+  fontName: z.string().optional(),
 }).strict();
-
-const migrationQueryPage = z.object({
-  offset: z.number().int().nonnegative(),
-  returned: z.number().int().nonnegative(),
-  total: z.number().int().nonnegative(),
-  hasMore: z.boolean(),
+const tableCellInput = z.object({
+  text: z.string().optional(),
+  gridSpan: positiveIndex.optional(),
+  vMerge: z.string().optional(),
+  bold: z.boolean().optional(),
+  header: z.boolean().optional(),
+  shading: z.string().optional(),
+  alignment: z.string().optional(),
+  richText: z.array(richTextSegment).optional(),
 }).strict();
 
-const migrationTargetPage = z.object({
-  schema: z.string(),
-  pass: z.boolean(),
-  sourceChoiceId: z.string().nullable(),
-  branch: z.string(),
-  offset: z.number().int().nonnegative(),
-  limit: z.number().int().positive(),
-  total: z.number().int().nonnegative(),
-  targets: z.array(migrationChoiceOutput),
-}).strict();
-
-const migrationQueryDocuments = {
-  source: pathInput.describe('Path to the current source DOCX used by docx_list_migration_choices.'),
-  baseline: pathInput.describe('Path to the same selected current baseline DOCX used by docx_list_migration_choices.'),
-};
-
-const boundedOffset = z.number().int().nonnegative().optional().describe('Zero-based result offset. Defaults to 0.');
-const boundedLimit = z.number().int().min(1).max(10).optional().describe('Maximum results to return. Defaults to 10 and cannot exceed 10.');
+function editAction(name, operationType, description, changeSchema) {
+  return { name, operationType, description, changeSchema, batch: true };
+}
+
+function documentAction(name, operationType, description) {
+  return { name, operationType, description, batch: false };
+}
+
+const docxEditActions = [
+  editAction('docx_set_anchored_text', 'replaceAnchoredText', 'Set text at current DOCX comment anchors.', z.object({ commentId: pathInput, text: z.string() }).strict()),
+  editAction('docx_set_paragraph_text', 'replaceParagraphText', 'Set current body paragraph text.', z.object({ paragraphIndex: index, text: z.string() }).strict()),
+  editAction('docx_set_paragraph_run_text', 'replaceParagraphRunText', 'Set current body paragraph run text.', z.object({ paragraphIndex: index, runIndex: index, text: z.string() }).strict()),
+  editAction('docx_replace_body_text', 'replaceBodyText', 'Replace uniquely matched current body text.', z.object({ findText: pathInput, text: z.string() }).strict()),
+  editAction('docx_delete_body_paragraph', 'deleteBodyParagraph', 'Delete uniquely matched current body paragraphs.', z.object({ findText: pathInput, ...optionalTextMatch }).strict()),
+  editAction('docx_delete_body_drawing_before_paragraph', 'deleteBodyDrawingBeforeParagraph', 'Delete the drawing immediately before a uniquely matched current paragraph.', z.object({ findText: pathInput, ...optionalTextMatch }).strict()),
+  editAction('docx_delete_body_range', 'deleteBodyRange', 'Delete uniquely bounded current body ranges.', z.object({ findText: pathInput, endFindText: z.string().optional(), matchMode: z.string().optional(), endMatchMode: z.string().optional(), paragraphStyle: z.string().optional(), endParagraphStyle: z.string().optional(), deleteToBodyEnd: z.boolean().optional(), removePrecedingPageBreak: z.boolean().optional() }).strict()),
+  editAction('docx_start_section', 'startSectionBeforeParagraph', 'Start a section before a uniquely matched current paragraph.', z.object({ findText: pathInput, orientation: z.enum(['portrait', 'landscape']) }).strict()),
+  editAction('docx_set_header_paragraph_text', 'replaceHeaderParagraphText', 'Set current header paragraph text.', z.object({ headerIndex: index, paragraphIndex: index, text: z.string() }).strict()),
+  editAction('docx_set_header_run_text', 'replaceHeaderParagraphRunText', 'Set current header run text.', z.object({ headerIndex: index, paragraphIndex: index, runIndex: index, text: z.string() }).strict()),
+  editAction('docx_replace_header_text', 'replaceHeaderText', 'Replace uniquely matched current header text.', z.object({ findText: pathInput, text: z.string() }).strict()),
+  editAction('docx_set_footer_paragraph_text', 'replaceFooterParagraphText', 'Set current footer paragraph text.', z.object({ footerIndex: index, paragraphIndex: index, text: z.string() }).strict()),
+  editAction('docx_set_footer_run_text', 'replaceFooterParagraphRunText', 'Set current footer run text.', z.object({ footerIndex: index, paragraphIndex: index, runIndex: index, text: z.string() }).strict()),
+  editAction('docx_set_table_cell_text', 'replaceTableCellText', 'Set current body table cell text.', z.object({ tableIndex: index, rowIndex: index, cellIndex: index, text: z.string(), alignment: z.string().optional() }).strict()),
+  editAction('docx_set_table_cell_run_text', 'replaceTableCellRunText', 'Set current body table cell run text.', z.object({ tableIndex: index, rowIndex: index, cellIndex: index, paragraphIndex: index, runIndex: index, text: z.string() }).strict()),
+  editAction('docx_set_table_cell_choice_state', 'setTableCellChoiceState', 'Set the selected state represented by current table-cell content.', z.object({ tableIndex: index, rowIndex: index, cellIndex: index, text: z.string() }).strict()),
+  editAction('docx_set_header_table_cell_text', 'replaceHeaderTableCellText', 'Set current header table cell text.', z.object({ headerIndex: index, tableIndex: index, rowIndex: index, cellIndex: index, text: z.string() }).strict()),
+  editAction('docx_set_header_table_cell_run_text', 'replaceHeaderTableCellRunText', 'Set current header table cell run text.', z.object({ headerIndex: index, tableIndex: index, rowIndex: index, cellIndex: index, paragraphIndex: index, runIndex: index, text: z.string() }).strict()),
+  editAction('docx_set_footer_table_cell_text', 'replaceFooterTableCellText', 'Set current footer table cell text.', z.object({ footerIndex: index, tableIndex: index, rowIndex: index, cellIndex: index, text: z.string() }).strict()),
+  editAction('docx_set_footer_table_cell_run_text', 'replaceFooterTableCellRunText', 'Set current footer table cell run text.', z.object({ footerIndex: index, tableIndex: index, rowIndex: index, cellIndex: index, paragraphIndex: index, runIndex: index, text: z.string() }).strict()),
+  editAction('docx_set_table_cell_rich_text', 'replaceTableCellRichText', 'Set current body table cell rich text.', z.object({ tableIndex: index, rowIndex: index, cellIndex: index, richText: z.array(richTextSegment) }).strict()),
+  editAction('docx_insert_table_rows', 'insertTableRows', 'Insert rows into a current body table.', z.object({ tableIndex: index, rowIndex: index, templateRowIndex: index.optional(), rows: z.array(z.array(tableCellInput)) }).strict()),
+  editAction('docx_delete_table_rows', 'deleteTableRows', 'Delete current body table row ranges.', z.object({ tableIndex: index, startRowIndex: index, endRowIndex: index }).strict()),
+  editAction('docx_replace_table_rows', 'replaceTableRows', 'Replace current body table row ranges.', z.object({ tableIndex: index, startRowIndex: index, endRowIndex: index, templateRowIndex: index.optional(), rows: z.array(z.array(tableCellInput)) }).strict()),
+  editAction('docx_insert_table_columns', 'insertTableColumns', 'Insert columns into a current body table.', z.object({ tableIndex: index, columnIndex: index, columnCount: positiveIndex.optional(), templateColumnIndex: index.optional() }).strict()),
+  editAction('docx_set_table_width', 'setTableWidth', 'Set current body table widths.', z.object({ tableIndex: index, width: pathInput, widthType: z.enum(['pct', 'dxa', 'auto', 'nil']) }).strict()),
+  editAction('docx_set_table_cell_alignment', 'setTableCellAlignment', 'Set current body table cell alignment.', z.object({ tableIndex: index, rowIndex: index, cellIndex: index, alignment: pathInput }).strict()),
+  editAction('docx_set_table_cell_no_wrap', 'setTableCellNoWrap', 'Set current body table cell no-wrap state.', z.object({ tableIndex: index, rowIndex: index, cellIndex: index, noWrap: z.boolean() }).strict()),
+  editAction('docx_set_table_cell_font_size', 'setTableCellFontSize', 'Set current body table cell font size.', z.object({ tableIndex: index, rowIndex: index, cellIndex: index, fontSize: pathInput }).strict()),
+  editAction('docx_apply_font_policy', 'applyDocumentFontPolicy', 'Apply an explicit font policy to current document text.', z.object({ fontPolicy: z.object({ schema: pathInput, body: z.record(z.string(), z.string()), table: z.record(z.string(), z.string()) }).strict() }).strict()),
+  editAction('docx_set_table_row_height', 'setTableRowHeight', 'Set current body table row height.', z.object({ tableIndex: index, rowIndex: index, height: pathInput, heightRule: z.string().optional() }).strict()),
+  editAction('docx_set_table_row_cant_split', 'setTableRowCantSplit', 'Set current body table row split behavior.', z.object({ tableIndex: index, rowIndex: index, cantSplit: z.boolean() }).strict()),
+  editAction('docx_set_table_row_keep_next', 'setTableRowKeepNext', 'Set keep-next behavior for current body table rows.', z.object({ tableIndex: index, rowIndex: index, keepNext: z.boolean() }).strict()),
+  editAction('docx_set_body_paragraph_keep_next', 'setBodyParagraphKeepNext', 'Set keep-next behavior for current body paragraphs.', z.object({ paragraphIndex: index, keepNext: z.boolean() }).strict()),
+  editAction('docx_set_body_paragraph_keep_lines', 'setBodyParagraphKeepLines', 'Set keep-lines behavior for current body paragraphs.', z.object({ paragraphIndex: index, keepLines: z.boolean() }).strict()),
+  editAction('docx_set_header_paragraph_font_size', 'setHeaderParagraphFontSize', 'Set current header paragraph font size.', z.object({ headerIndex: index, paragraphIndex: index, fontSize: pathInput }).strict()),
+  documentAction('docx_collapse_trailing_empty_section', 'collapseTrailingEmptySection', 'Collapse a current trailing empty section.'),
+  documentAction('docx_collapse_trailing_empty_paragraphs', 'collapseTrailingEmptyBodyParagraphs', 'Collapse current trailing empty body paragraphs.'),
+  editAction('docx_merge_table_cells', 'mergeTableCells', 'Merge current body table cells.', z.object({ tableIndex: index, rowIndex: index.optional(), startCellIndex: index.optional(), endCellIndex: index.optional(), startRowIndex: index.optional(), endRowIndex: index.optional(), cellIndex: index.optional(), gridColumn: index.optional() }).strict()),
+  editAction('docx_unmerge_table_row_cells', 'unmergeTableRowHorizontalCells', 'Unmerge current horizontal table cells.', z.object({ tableIndex: index, rowIndex: index, cellIndex: index }).strict()),
+  editAction('docx_unmerge_table_column_cells', 'unmergeTableColumnVerticalCells', 'Unmerge current vertical table cell ranges.', z.object({ tableIndex: index, cellIndex: index, startRowIndex: index, endRowIndex: index }).strict()),
+  editAction('docx_delete_comments', 'deleteComments', 'Delete explicit current DOCX comments.', z.object({ commentIds: z.array(pathInput).min(1) }).strict()),
+  documentAction('docx_mark_fields_dirty', 'markFieldsDirty', 'Mark current DOCX fields for native refresh.'),
+  documentAction('docx_sanitize_fields', 'sanitizeFields', 'Remove update prompts and dirty markers from current DOCX fields.'),
+  documentAction('docx_freeze_fields', 'freezeFields', 'Convert current visible DOCX field results to ordinary content.'),
+];
 
-const migrationChoiceQueryInput = z.union([
-  z.object({
-    ...migrationQueryDocuments,
-    view: z.literal('sources'),
-    offset: boundedOffset,
-    limit: boundedLimit,
-  }).strict(),
-  z.object({
-    ...migrationQueryDocuments,
-    view: z.literal('targets'),
-    sourceRef: choiceReference.describe('Short source reference returned by the sources view.'),
-    action: migrationQueryTargetAction.optional().describe('Optional business-action filter. Choose the action from scenario meaning, then use this filter to inspect only compatible targets. Omit it only when comparing the three documented action meanings.'),
-    text: z.string().trim().min(1).optional().describe('Optional literal case-insensitive text to find in target visible text or context.'),
-    offset: boundedOffset,
-    limit: boundedLimit,
-  }).strict(),
-  z.object({
-    ...migrationQueryDocuments,
-    view: z.literal('cleanup'),
-    text: z.string().trim().min(1).optional().describe('Optional literal case-insensitive text to find in cleanup target visible text or context.'),
-    offset: boundedOffset,
-    limit: boundedLimit,
-  }).strict(),
-]);
+const scalar = z.union([z.string(), z.number(), z.boolean(), z.null()]);
+const xlsxEditActions = [
+  editAction('xlsx_set_cell_value', 'setCellValue', 'Set current workbook cell values.', z.object({ sheet: pathInput, cell: pathInput, value: scalar, valueType: z.string().optional(), bold: z.boolean().optional(), shrinkToFit: z.boolean().optional(), wrapText: z.boolean().optional() }).strict()),
+  editAction('xlsx_set_cell_number_format', 'setCellNumberFormat', 'Set current workbook cell number formats.', z.object({ sheet: pathInput, cell: pathInput, numberFormat: pathInput }).strict()),
+  editAction('xlsx_set_rich_text_cell_value', 'setRichTextCellValue', 'Set current workbook rich-text cell values.', z.object({ sheet: pathInput, cell: pathInput, value: z.string(), bold: z.boolean() }).strict()),
+  editAction('xlsx_set_range_values', 'setRangeValues', 'Set rectangular values in a current workbook.', z.object({ sheet: pathInput, startCell: pathInput, values: z.array(z.array(scalar)), valueType: z.string().optional() }).strict()),
+  editAction('xlsx_insert_rows', 'insertRows', 'Insert rows into a current worksheet.', z.object({ sheet: pathInput, startRow: positiveIndex, count: positiveIndex, preserveHorizontalMergedRanges: z.boolean().optional(), expandAdjacentVerticalMergedRanges: z.boolean().optional() }).strict()),
+  editAction('xlsx_copy_row', 'copyRow', 'Copy current worksheet rows.', z.object({ sheet: pathInput, sourceRow: positiveIndex, targetRow: positiveIndex, translateFormulas: z.boolean().optional() }).strict()),
+  editAction('xlsx_expand_section_rows', 'expandSectionRows', 'Expand current worksheet row sections from visible anchors.', z.object({ sheet: pathInput, anchorText: pathInput, exampleRows: positiveIndex, targetRows: positiveIndex, preserveStyle: z.boolean().optional(), preserveFormulas: z.boolean().optional(), preserveMergedRanges: z.boolean().optional() }).strict()),
+  editAction('xlsx_set_print_area', 'setPrintArea', 'Set current worksheet print areas.', z.object({ sheet: pathInput, range: pathInput }).strict()),
+  editAction('xlsx_set_page_setup', 'setPageSetup', 'Set current worksheet page properties.', z.object({ sheet: pathInput, fitToPagesWide: positiveIndex.optional(), fitToPagesTall: positiveIndex.optional(), orientation: z.enum(['portrait', 'landscape']).optional(), paperSize: z.enum(['letter', 'legal', 'a3', 'a4']).optional(), repeatRowsStart: positiveIndex.optional(), repeatRowsEnd: positiveIndex.optional(), repeatColsStart: positiveIndex.optional(), repeatColsEnd: positiveIndex.optional() }).strict()),
+  editAction('xlsx_set_row_page_breaks', 'setRowPageBreaks', 'Set current worksheet row page breaks.', z.object({ sheet: pathInput, breakBeforeRows: z.array(positiveIndex) }).strict()),
+  editAction('xlsx_set_column_width', 'setColumnWidth', 'Set current worksheet column widths.', z.object({ sheet: pathInput, column: pathInput, width: z.number().positive().max(255) }).strict()),
+];
 
-const migrationChoiceQueryOutput = z.object({
-  tool: z.literal('docx_query_migration_choices'),
-  runtime: runtimeIdentity,
-  sourceSha256: z.string(),
-  baselineSha256: z.string(),
-  view: z.enum(['sources', 'targets', 'cleanup']),
-  action: migrationQueryTargetAction.nullable(),
-  source: migrationPublicChoiceOutput.nullable(),
-  items: z.array(z.union([migrationPublicChoiceOutput, migrationAlternativeOutput])),
-  page: migrationQueryPage,
-}).strict();
+function editToolDefinitions(actions) {
+  return actions.map(action => ({
+    name: action.name,
+    description: action.batch ? `${action.description} One call batches only this action kind.` : action.description,
+    inputSchema: z.object({
+      input: pathInput,
+      output: pathInput.describe('New document output path. Existing files are never overwritten.'),
+      receiptOutput: pathInput.describe('New JSON receipt path. Existing files are never overwritten.'),
+      ...(action.batch ? { changes: z.array(action.changeSchema).min(1) } : {}),
+    }).strict(),
+    outputSchema: fixedEditOutput(action.name),
+    annotations: action.batch ? undefined : { idempotentHint: true },
+    handler: args => fixedEdit(action, args),
+  }));
+}
 
-function migrationReceiptOutput(tool) {
+function fixedEditOutput(tool) {
   return z.object({
-    tool: z.literal(tool),
-    runtime: runtimeIdentity,
-    artifact,
-    summary: z.object({
-      schema: z.string(),
-      toolVersion: z.string(),
-      status: z.enum(['pass', 'review-required', 'failed']),
-      pass: z.boolean(),
-      reviewRequired: z.boolean(),
-      outputVerified: z.boolean(),
-      output: z.string().nullable(),
-      plan: z.string().nullable(),
-      failureCount: z.number().int().nonnegative(),
-    }).strict(),
+    tool: z.literal(tool), runtime: runtimeIdentity, receipt: artifact, output: artifact.nullable(),
+    summary: z.object({ pass: z.boolean(), operationCount: z.number().int().nonnegative(), appliedCount: z.number().int().nonnegative() }).strict(),
   }).strict();
 }
 
@@ -396,37 +284,12 @@ const tools = [
     handler: docxInspect,
   },
   {
-    name: 'docx_list_migration_choices',
-    description: 'Write every current source item that still needs a business choice and the selectable current baseline targets to an opaque run-local evidence artifact. Use docx_query_migration_choices with the same source and baseline to inspect bounded alternatives; do not parse the artifact.',
-    inputSchema: z.object({
-      source: pathInput.describe('Path to the current source DOCX.'),
-      baseline: pathInput.describe('Path to the selected current baseline DOCX.'),
-      output: pathInput.describe('New JSON artifact path. Existing files are never overwritten.'),
-    }).strict(),
-    outputSchema: migrationCatalogOutput,
-    handler: docxListMigrationChoices,
-  },
-  {
-    name: 'docx_query_migration_choices',
-    description: 'Query current template-migration alternatives without reading the catalog artifact. place-content moves current content into a target content position; keep-template-label preserves the target label and structure while migrating a uniquely identified current field value; select-template-option marks a target option represented by the current source fact. Choose the action from scenario meaning and filter by it before paging compatible targets. Target results bind the action and target into one alternativeRef; result order helps discovery but never makes the business choice.',
-    inputSchema: migrationChoiceQueryInput,
-    outputSchema: migrationChoiceQueryOutput,
+    name: 'docx_inspect_tables',
+    description: 'Inspect current DOCX tables, cells, merges, paragraphs, runs, and formatting.',
+    inputSchema: artifactInput,
+    outputSchema: artifactOutput('docx_inspect_tables'),
     annotations: { readOnlyHint: true, idempotentHint: true },
-    handler: docxQueryMigrationChoices,
-  },
-  {
-    name: 'docx_migrate_template',
-    description: 'Migrate a current DOCX into the selected baseline from one complete batch of business choices. For targeted choices, submit one alternativeRef returned by docx_query_migration_choices. Exclusion and local review use a sourceRef plus their terminal action. The tool derives all document values, coordinates, plans, and edits.',
-    inputSchema: templateMigrationInput,
-    outputSchema: migrationReceiptOutput('docx_migrate_template'),
-    handler: docxMigrateTemplate,
-  },
-  {
-    name: 'docx_verify_migration',
-    description: 'Independently re-resolve the same business choices and verify a migrated DOCX against the current source and baseline. This does not trust the migration receipt.',
-    inputSchema: templateMigrationInput,
-    outputSchema: migrationReceiptOutput('docx_verify_migration'),
-    handler: docxVerifyMigration,
+    handler: docxInspectTables,
   },
   {
     name: 'docx_compare',
@@ -442,6 +305,39 @@ const tools = [
     outputSchema: artifactOutput('docx_export_json'),
     handler: docxExportJson,
   },
+  {
+    name: 'docx_validate',
+    description: 'Validate a current DOCX package against the published OpenXML contract.',
+    inputSchema: inputOnly,
+    annotations: { readOnlyHint: true, idempotentHint: true },
+    handler: docxValidate,
+  },
+  {
+    name: 'docx_validate_font_policy',
+    description: 'Validate current DOCX text against an explicit font policy.',
+    inputSchema: z.object({ input: pathInput, policy: z.object({ schema: pathInput, body: z.record(z.string(), z.string()), table: z.record(z.string(), z.string()) }).strict() }).strict(),
+    annotations: { readOnlyHint: true, idempotentHint: true },
+    handler: docxValidateFontPolicy,
+  },
+  {
+    name: 'docx_strip_direct_formatting',
+    description: 'Remove direct paragraph and run formatting while preserving styles.',
+    inputSchema: z.object({ input: pathInput, output: pathInput }).strict(),
+    handler: docxStripDirectFormatting,
+  },
+  {
+    name: 'docx_replace_style_ids',
+    description: 'Replace current DOCX style IDs from an explicit style map.',
+    inputSchema: z.object({ input: pathInput, output: pathInput, styleMap: z.record(z.string(), z.string()) }).strict(),
+    handler: docxReplaceStyleIds,
+  },
+  {
+    name: 'docx_fill_template',
+    description: 'Fill current DOCX placeholders from an explicit data object.',
+    inputSchema: z.object({ template: pathInput, output: pathInput, data: z.record(z.string(), z.unknown()) }).strict(),
+    handler: docxFillTemplate,
+  },
+  ...editToolDefinitions(docxEditActions),
   {
     name: 'office_render_pdf',
     description: 'Render a current Office document to PDF with its required native WPS backend and write the complete provider receipt as evidence. The input extension selects Writer, Spreadsheets, or Presentation; fallback rendering is rejected.',
@@ -453,9 +349,15 @@ const tools = [
     outputSchema: nativeRenderOutput,
     handler: officeRenderPdf,
   },
+  {
+    name: 'xlsx_convert_legacy',
+    description: 'Convert a current legacy XLS workbook to XLSX using the published native ET backend.',
+    inputSchema: z.object({ input: pathInput, output: pathInput, receiptOutput: pathInput }).strict(),
+    handler: xlsxConvertLegacy,
+  },
   {
     name: 'xlsx_inspect',
-    description: 'Inspect an XLSX workbook and write one JSON observation containing workbook structure, exported values, formulas, styles, merged ranges, and conversion evidence.',
+    description: 'Inspect a current XLSX workbook or legacy XLS workbook and write one JSON observation containing workbook structure, exported values, formulas, styles, merged ranges, and any published legacy-format conversion evidence.',
     inputSchema: artifactInput,
     outputSchema: artifactOutput('xlsx_inspect'),
     handler: xlsxInspect,
@@ -472,17 +374,12 @@ const tools = [
     handler: xlsxExportJson,
   },
   {
-    name: 'xlsx_apply',
-    description: 'Apply one deterministic XLSX operations artifact to a current workbook. This tool executes published workbook edits; it does not derive values, coordinates, or business decisions.',
-    inputSchema: z.object({
-      input: pathInput.describe('Path to the current XLSX workbook.'),
-      operations: pathInput.describe('Path to the deterministic tiwater.xlsx-edit/v1 operations artifact.'),
-      output: pathInput.describe('New XLSX output path. Existing files are never overwritten.'),
-      receiptOutput: pathInput.describe('New JSON receipt path. Existing files are never overwritten.'),
-    }).strict(),
-    outputSchema: xlsxApplyOutput,
-    handler: xlsxApply,
+    name: 'xlsx_fill_template',
+    description: 'Fill current XLSX placeholders from an explicit data object.',
+    inputSchema: z.object({ template: pathInput, output: pathInput, data: z.record(z.string(), z.unknown()) }).strict(),
+    handler: xlsxFillTemplate,
   },
+  ...editToolDefinitions(xlsxEditActions),
   {
     name: 'xlsx_validate',
     description: 'Validate an XLSX workbook package and return Open XML validation evidence.',
@@ -504,13 +401,20 @@ const tools = [
     outputSchema: artifactOutput('pptx_export_json'),
     handler: pptxExportJson,
   },
+  {
+    name: 'pptx_fill_template',
+    description: 'Fill current PPTX placeholders from an explicit data object.',
+    inputSchema: z.object({ template: pathInput, output: pathInput, data: z.record(z.string(), z.unknown()) }).strict(),
+    handler: pptxFillTemplate,
+  },
   {
     name: 'pptx_apply_template',
     description: 'Apply one deterministic PPTX template-application plan to a current presentation. This tool executes the published plan; it does not select a template or derive business content, slide mappings, geometry, or formatting decisions.',
     inputSchema: z.object({
       input: pathInput.describe('Path to the current source PPTX.'),
       template: pathInput.describe('Path to the selected current template PPTX.'),
-      plan: pathInput.describe('Path to the deterministic template-application plan artifact.'),
+      targetMasterPath: pathInput,
+      slides: z.array(z.object({ slideNumber: positiveIndex, targetLayoutPath: pathInput, contentBounds: z.object({ x: index, y: index, cx: positiveIndex, cy: positiveIndex }).strict().optional(), contentShapeIds: z.array(positiveIndex).min(1).optional(), sourceLayoutShapeIdsToPreserve: z.array(positiveIndex).optional() }).strict()).min(1),
       output: pathInput.describe('New PPTX output path. Existing files are never overwritten.'),
       receiptOutput: pathInput.describe('New JSON receipt path. Existing files are never overwritten.'),
     }).strict(),
@@ -522,20 +426,27 @@ const tools = [
     description: 'Apply one deterministic PPTX formatting plan to a current presentation. This tool executes published formatting operations; it does not derive values, coordinates, or business decisions.',
     inputSchema: z.object({
       input: pathInput.describe('Path to the current PPTX.'),
-      operations: pathInput.describe('Path to the deterministic formatting operations artifact.'),
+      changes: z.array(z.object({ slideNumber: positiveIndex, shapeId: positiveIndex, runIndex: index, fontFamily: z.string().optional(), fontSize: z.number().positive().optional(), color: z.string().optional(), bold: z.boolean().optional(), paragraphAlignment: z.string().optional() }).strict()).min(1),
       output: pathInput.describe('New PPTX output path. Existing files are never overwritten.'),
       receiptOutput: pathInput.describe('New JSON receipt path. Existing files are never overwritten.'),
     }).strict(),
     outputSchema: pptxFormatApplyOutput,
     handler: pptxApplyFormat,
   },
+  {
+    name: 'pptx_validate',
+    description: 'Validate a current PPTX package against the published OpenXML contract.',
+    inputSchema: inputOnly,
+    annotations: { readOnlyHint: true, idempotentHint: true },
+    handler: pptxValidate,
+  },
 ];
 
 function buildServer() {
   const server = new McpServer(
     { name: 'tiwater-office', version: packageMetadata.version },
     {
-      instructions: 'Use the Office tools for technical document observation. For template migration, list the current choices, select only allowed business actions, migrate once, and independently verify the result. Never invent document values, identities, coordinates, plans, or edit operations.',
+      instructions: 'Use these tools only for generic Office observation, conversion, editing, validation, and native rendering. Derive business meaning from the active scenario knowledge and current documents; the provider owns no scenario workflow.',
     },
   );
   for (const tool of tools) {
@@ -563,452 +474,98 @@ async function docxInspect(args) {
   };
 }
 
-async function docxListMigrationChoices(args) {
-  const source = requireString(args.source, 'source');
-  const baseline = requireString(args.baseline, 'baseline');
-  const result = await runJsonCandidateChain(docxCandidates, ['list-template-migration-choices', source, baseline]);
-  const catalog = migrationCatalog.parse(result.json);
-  return {
-    tool: 'docx_list_migration_choices',
-    runtime: commandRuntime(result),
-    artifact: await writeJsonArtifact(requireString(args.output, 'output'), catalog),
-    summary: {
-      schema: catalog.schema,
-      pass: catalog.pass,
-      sourceSha256: catalog.sourceSha256,
-      baselineSha256: catalog.baselineSha256,
-      sourceCount: catalog.sources.length,
-      targetCount: catalog.targets.length,
-    },
-  };
-}
-
-async function docxQueryMigrationChoices(args) {
-  const sourcePath = requireString(args.source, 'source');
-  const baselinePath = requireString(args.baseline, 'baseline');
-  const offset = args.offset ?? 0;
-  const limit = args.limit ?? 10;
-  const catalogResult = await runJsonCandidateChain(docxCandidates, ['list-template-migration-choices', sourcePath, baselinePath]);
-  const catalog = migrationCatalog.parse(catalogResult.json);
-
-  if (args.view === 'sources') {
-    return migrationQueryResult({
-      runtime: commandRuntime(catalogResult),
-      catalog,
-      view: 'sources',
-      action: null,
-      source: null,
-      items: catalog.sources.slice(offset, offset + limit),
-      offset,
-      total: catalog.sources.length,
-    });
-  }
-
-  let source = null;
-  let action = null;
-  if (args.view === 'cleanup') {
-    const targetResult = await loadMigrationTargets({
-      sourcePath,
-      baselinePath,
-      sourceChoiceId: '-',
-      branch: 'baseline-clear',
-      text: args.text,
-    });
-    const orderedTargets = validateAndOrderMigrationTargets(catalog, null, targetResult.targets);
-    return migrationQueryResult({
-      runtime: targetResult.runtime,
-      catalog,
-      view: 'cleanup',
-      action: null,
-      source: null,
-      items: orderedTargets.slice(offset, offset + limit),
-      offset,
-      total: orderedTargets.length,
-    });
-  }
-
-  const requestedSourceId = choiceIdFromRef(catalog, catalog.sources, args.sourceRef, 'S', 'source');
-  source = catalog.sources.find(item => item.id === requestedSourceId) ?? null;
-  if (!source) {
-    throw Object.assign(new Error(`Unknown migration source: ${args.sourceRef}`), { code: -32602 });
-  }
-  action = args.action ?? null;
-  const actions = action
-    ? [action]
-    : [...targetActions].filter(candidate => source.allowedActions.includes(candidate));
-  const pages = await Promise.all(actions.map(async candidate => {
-    if (!source.allowedActions.includes(candidate)) {
-      throw Object.assign(new Error(`Action ${candidate} is not allowed for ${source.id}`), { code: -32602 });
-    }
-    const result = await loadMigrationTargets({
-      sourcePath,
-      baselinePath,
-      sourceChoiceId: source.id,
-      branch: migrationTargetBranch(candidate, source.kind),
-      text: args.text,
-    });
-    return {
-      action: candidate,
-      runtime: result.runtime,
-      targets: validateAndOrderMigrationTargets(catalog, source, result.targets),
-    };
-  }));
-  const catalogOrder = new Map(catalog.targets.map((item, index) => [item.id, index]));
-  const actionOrder = new Map([...targetActions].map((item, index) => [item, index]));
-  const alternatives = pages.flatMap(page => page.targets.map(target => ({ action: page.action, target })))
-    .sort((left, right) => {
-      const relevance = compareRelevance(
-        migrationChoiceRelevance(source, right.target),
-        migrationChoiceRelevance(source, left.target));
-      return relevance
-        || catalogOrder.get(left.target.id) - catalogOrder.get(right.target.id)
-        || actionOrder.get(left.action) - actionOrder.get(right.action);
-    })
-    .map(item => ({
-      ref: migrationAlternativeRef(catalog, source, item.action, item.target),
-      action: item.action,
-      target: publicMigrationChoice(catalog, item.target, 'T'),
-    }));
-  return migrationQueryResult({
-    runtime: pages[0]?.runtime ?? commandRuntime(catalogResult),
-    catalog,
-    view: 'targets',
-    action,
-    source,
-    items: alternatives.slice(offset, offset + limit),
-    offset,
-    total: alternatives.length,
-    alternatives: true,
-  });
-}
-
-function validateAndOrderMigrationTargets(catalog, source, targets) {
-  const catalogTargets = new Map(catalog.targets.map(item => [item.id, item]));
-  for (const target of targets) {
-    const current = catalogTargets.get(target.id);
-    if (!current || !isDeepStrictEqual(current, target)) {
-      throw new Error(`Migration target ${target.id} is not bound to the current catalog`);
-    }
-  }
-  const catalogOrder = new Map(catalog.targets.map((item, index) => [item.id, index]));
-  return source
-    ? [...targets].sort((left, right) => {
-      const relevance = compareRelevance(
-        migrationChoiceRelevance(source, right),
-        migrationChoiceRelevance(source, left));
-      return relevance || catalogOrder.get(left.id) - catalogOrder.get(right.id);
-    })
-    : [...targets].sort((left, right) => catalogOrder.get(left.id) - catalogOrder.get(right.id));
-}
-
-async function loadMigrationTargets({ sourcePath, baselinePath, sourceChoiceId, branch, text }) {
-  const targets = [];
-  let offset = 0;
-  let total = null;
-  let runtime = null;
-  do {
-    const result = await runJsonCandidateChain(docxCandidates, [
-      'find-template-migration-targets',
-      sourcePath,
-      baselinePath,
-      sourceChoiceId,
-      branch,
-      text ?? '-',
-      String(offset),
-      '100',
-    ]);
-    const page = migrationTargetPage.parse(result.json);
-    if (page.sourceChoiceId !== (sourceChoiceId === '-' ? null : sourceChoiceId) || page.branch !== branch) {
-      throw new Error('Migration target page identity does not match the requested current source and action');
-    }
-    if (total !== null && page.total !== total) {
-      throw new Error('Migration target page total changed while reading current alternatives');
-    }
-    if (page.offset !== offset || page.targets.length === 0 && offset < page.total) {
-      throw new Error('Migration target pagination did not advance');
-    }
-    runtime ??= commandRuntime(result);
-    total = page.total;
-    targets.push(...page.targets);
-    offset += page.targets.length;
-  } while (offset < total);
-  return { runtime, targets };
-}
-
-function migrationChoiceRelevance(source, target) {
-  const sourceContext = source.context ?? {};
-  const targetContext = target.context ?? {};
-  const sourceRows = sourceContext.sameRowTexts ?? [];
-  const targetRows = targetContext.sameRowTexts ?? [];
-  const sourceHeaders = sourceContext.tableHeaderTexts ?? [];
-  const targetHeaders = targetContext.tableHeaderTexts ?? [];
-  const mainText = textSimilarity(source.text, target.text);
-  const tableIdentity = Math.max(
-    textSimilarity(sourceContext.columnHeaderText, targetContext.columnHeaderText),
-    maximumPairSimilarity(sourceHeaders, targetHeaders));
-  const neighborhood = Math.max(
-    textSimilarity(sourceContext.previousText, targetContext.previousText),
-    textSimilarity(sourceContext.nextText, targetContext.nextText),
-    maximumPairSimilarity(sourceRows, targetRows),
-    maximumPairSimilarity([source.text], targetRows),
-    maximumPairSimilarity(sourceRows, [target.text]));
-  return source.kind === 'table-cell' && target.kind === 'table-cell'
-    ? [tableIdentity, mainText, neighborhood]
-    : [mainText, neighborhood, tableIdentity];
-}
-
-function compareRelevance(left, right) {
-  for (let index = 0; index < left.length; index += 1) {
-    if (left[index] !== right[index]) return left[index] - right[index];
-  }
-  return 0;
-}
-
-function maximumPairSimilarity(leftValues, rightValues) {
-  let maximum = 0;
-  for (const left of leftValues ?? []) {
-    for (const right of rightValues ?? []) {
-      maximum = Math.max(maximum, textSimilarity(left, right));
-    }
-  }
-  return maximum;
-}
-
-function textSimilarity(leftValue, rightValue) {
-  const left = normalizeSearchText(leftValue);
-  const right = normalizeSearchText(rightValue);
-  if (!left || !right) return 0;
-  if (left === right) return 1;
-  if (Math.min(left.length, right.length) >= 3 && (left.includes(right) || right.includes(left))) {
-    return Math.min(left.length, right.length) / Math.max(left.length, right.length);
-  }
-  const leftPairs = characterPairs(left);
-  const rightPairs = characterPairs(right);
-  if (leftPairs.size === 0 || rightPairs.size === 0) return 0;
-  let shared = 0;
-  for (const pair of leftPairs) if (rightPairs.has(pair)) shared += 1;
-  return 2 * shared / (leftPairs.size + rightPairs.size);
-}
-
-function normalizeSearchText(value) {
-  return typeof value === 'string'
-    ? value.normalize('NFKC').toLowerCase().replace(/[^\p{L}\p{N}]+/gu, '')
-    : '';
+async function docxInspectTables(args) {
+  const result = await runJsonCandidateChain(docxCandidates, ['inspect-tables', requireString(args.input, 'input'), '--json']);
+  return { tool: 'docx_inspect_tables', runtime: commandRuntime(result), artifact: await writeJsonArtifact(requireString(args.output, 'output'), result.json) };
 }
 
-function characterPairs(value) {
-  const characters = [...value];
-  if (characters.length < 2) return new Set(value ? [value] : []);
-  const pairs = new Set();
-  for (let index = 0; index + 1 < characters.length; index += 1) {
-    pairs.add(characters[index] + characters[index + 1]);
-  }
-  return pairs;
-}
-
-function migrationTargetBranch(action, sourceKind) {
-  if (action === 'place-content') return sourceKind === 'media' ? 'copy-media' : 'copy-text';
-  if (action === 'keep-template-content') return 'retain-target';
-  if (action === 'keep-template-label') return 'retain-target-label';
-  if (action === 'select-template-option') return 'choice-selection';
-  throw new Error(`Unsupported migration target action: ${action}`);
-}
-
-function catalogReferenceToken(catalog) {
-  return createHash('sha256')
-    .update(`${catalog.sourceSha256}\n${catalog.baselineSha256}`)
-    .digest('hex')
-    .slice(0, 8);
-}
-
-function choiceRef(catalog, items, id, prefix) {
-  const index = items.findIndex(item => item.id === id);
-  if (index < 0) throw new Error(`Migration choice is not bound to the current catalog: ${id}`);
-  return `${prefix}${index + 1}-${catalogReferenceToken(catalog)}`;
-}
-
-function choiceIdFromRef(catalog, items, ref, prefix, label) {
-  if (!ref.startsWith(prefix)) {
-    throw invalidMigrationInput(`invalid migration ${label} ref: ${ref}`);
-  }
-  const [ordinal, token] = ref.slice(1).split('-');
-  if (token !== catalogReferenceToken(catalog)) {
-    throw invalidMigrationInput(`stale migration ${label} ref: ${ref}`);
-  }
-  const item = items[Number(ordinal) - 1];
-  if (!item) throw invalidMigrationInput(`unknown migration ${label} ref: ${ref}`);
-  return item.id;
+async function docxValidate(args) {
+  const result = await runJsonCandidateChain(docxCandidates, ['validate-openxml', requireString(args.input, 'input')], { allowedExitCodes: [0, 1] });
+  return { tool: 'docx_validate', runtime: commandRuntime(result), result: result.json };
 }
 
-const migrationActionCodes = new Map([
-  ['place-content', 'P'],
-  ['keep-template-label', 'L'],
-  ['select-template-option', 'O'],
-]);
-const migrationActionsByCode = new Map([...migrationActionCodes].map(([action, code]) => [code, action]));
-
-function migrationAlternativeRef(catalog, source, action, target) {
-  const sourceOrdinal = catalog.sources.findIndex(item => item.id === source.id) + 1;
-  const targetOrdinal = catalog.targets.findIndex(item => item.id === target.id) + 1;
-  const code = migrationActionCodes.get(action);
-  if (sourceOrdinal < 1 || targetOrdinal < 1 || !code) {
-    throw new Error('Migration alternative is not bound to the current catalog');
-  }
-  return `S${sourceOrdinal}-${code}${targetOrdinal}-${migrationAlternativeToken(catalog, source, action, target)}`;
-}
-
-function migrationAlternativeToken(catalog, source, action, target) {
-  return createHash('sha256')
-    .update(`${catalog.sourceSha256}\n${catalog.baselineSha256}\n${source.id}\n${action}\n${target.id}`)
-    .digest('hex')
-    .slice(0, 8);
-}
-
-function migrationChoiceFromAlternativeRef(catalog, ref) {
-  const match = /^S([1-9][0-9]*)-([PLO])([1-9][0-9]*)-([0-9a-f]{8})$/.exec(ref);
-  if (!match) throw invalidMigrationInput(`invalid migration alternative ref: ${ref}`);
-  const source = catalog.sources[Number(match[1]) - 1];
-  const target = catalog.targets[Number(match[3]) - 1];
-  const action = migrationActionsByCode.get(match[2]);
-  if (!source || !target || !action) {
-    throw invalidMigrationInput(`unknown migration alternative ref: ${ref}`);
-  }
-  if (match[4] !== migrationAlternativeToken(catalog, source, action, target)) {
-    throw invalidMigrationInput(`stale or invalid migration alternative ref: ${ref}`);
-  }
-  return { sourceChoiceId: source.id, action, targetChoiceId: target.id };
+async function docxValidateFontPolicy(args) {
+  return withTempJsonFile(args.policy, async policyPath => {
+    const result = await runJsonCandidateChain(docxCandidates, ['validate-font-policy', requireString(args.input, 'input'), policyPath], { allowedExitCodes: [0, 1] });
+    return { tool: 'docx_validate_font_policy', runtime: commandRuntime(result), result: result.json };
+  });
 }
 
-function publicMigrationChoice(catalog, choice, prefix) {
-  const { id, ...visible } = choice;
-  const items = prefix === 'S' ? catalog.sources : catalog.targets;
-  return {
-    ...visible,
-    allowedActions: visible.allowedActions.filter(action => action !== 'keep-template-content'),
-    ref: choiceRef(catalog, items, id, prefix),
-  };
+async function docxStripDirectFormatting(args) {
+  return copyTransform('docx_strip_direct_formatting', docxCandidates, ['strip-direct-formatting'], args);
 }
 
-function migrationQueryResult({ runtime, catalog, view, action, source, items, offset, total, alternatives = false }) {
-  return {
-    tool: 'docx_query_migration_choices',
-    runtime,
-    sourceSha256: catalog.sourceSha256,
-    baselineSha256: catalog.baselineSha256,
-    view,
-    action,
-    source: source ? publicMigrationChoice(catalog, source, 'S') : null,
-    items: alternatives
-      ? items
-      : items.map(item => publicMigrationChoice(catalog, item, view === 'sources' ? 'S' : 'T')),
-    page: {
-      offset,
-      returned: items.length,
-      total,
-      hasMore: offset + items.length < total,
-    },
-  };
+async function docxReplaceStyleIds(args) {
+  return withTempJsonFile(args.styleMap, styleMapPath => copyTransform('docx_replace_style_ids', docxCandidates, ['replace-style-ids'], args, [styleMapPath]));
 }
 
-async function docxMigrateTemplate(args) {
-  return runTemplateMigrationCommand('docx_migrate_template', 'migrate-template', args);
+async function docxFillTemplate(args) {
+  return withTempJsonFile(args.data, dataPath => templateFill('docx_fill_template', docxCandidates, args, dataPath));
 }
 
-async function docxVerifyMigration(args) {
-  return runTemplateMigrationCommand('docx_verify_migration', 'verify-template-migration', args);
+async function xlsxFillTemplate(args) {
+  return withTempJsonFile(args.data, dataPath => templateFill('xlsx_fill_template', xlsxCandidates, args, dataPath));
 }
 
-function invalidMigrationInput(message) {
-  return Object.assign(new Error(message), { code: -32602 });
+async function pptxFillTemplate(args) {
+  return withTempJsonFile(args.data, dataPath => templateFill('pptx_fill_template', pptxCandidates, args, dataPath));
 }
 
-function completeMigrationChoices(catalog, choices) {
-  const sources = new Map(catalog.sources.map(source => [source.id, source]));
-  const seen = new Set();
-  const completed = choices.map(rawChoice => {
-    const choice = rawChoice.alternativeRef
-      ? migrationChoiceFromAlternativeRef(catalog, rawChoice.alternativeRef)
-      : {
-          sourceChoiceId: choiceIdFromRef(catalog, catalog.sources, rawChoice.sourceRef, 'S', 'source'),
-          action: rawChoice.action,
-        };
-    const { sourceChoiceId } = choice;
-    const source = sources.get(sourceChoiceId);
-    if (!source) throw invalidMigrationInput(`unknown migration source id: ${sourceChoiceId}`);
-    if (seen.has(sourceChoiceId)) throw invalidMigrationInput(`duplicate migration source id: ${sourceChoiceId}`);
-    seen.add(sourceChoiceId);
-    if (!source.allowedActions.includes(choice.action)) {
-      throw invalidMigrationInput(`migration action ${choice.action} is not allowed for source id: ${sourceChoiceId}`);
-    }
-    return source.requiredCardinality === 'all'
-      ? { ...choice, cardinality: 'all' }
-      : choice;
-  });
-  const missing = [...sources.keys()].filter(sourceChoiceId => !seen.has(sourceChoiceId));
-  if (missing.length > 0) {
-    throw invalidMigrationInput(`migration choices must cover every source id; missing ${missing.length}`);
-  }
-  return completed;
+async function templateFill(tool, candidates, args, dataPath) {
+  const template = path.resolve(requireString(args.template, 'template'));
+  const output = path.resolve(requireString(args.output, 'output'));
+  await requireNewFile(output, 'output');
+  const result = await runJsonCandidateChain(candidates, ['fill-template', template, dataPath, output]);
+  return { tool, runtime: commandRuntime(result), output: await fileArtifact(output), result: result.json };
 }
 
-function completeTemplateCleanup(catalog, cleanup, choices) {
-  const targets = new Map(catalog.targets.map(target => [target.id, target]));
-  const claimedTargets = new Set(choices.flatMap(choice => choice.targetChoiceId ? [choice.targetChoiceId] : []));
-  const seen = new Set();
-  return cleanup.map(rawCleanup => {
-    const targetChoiceId = choiceIdFromRef(catalog, catalog.targets, rawCleanup.targetRef, 'T', 'target');
-    if (!seen.add(targetChoiceId)) throw invalidMigrationInput(`duplicate migration cleanup target id: ${targetChoiceId}`);
-    if (!targets.get(targetChoiceId)?.allowedActions.includes('template-cleanup')) {
-      throw invalidMigrationInput(`migration cleanup is not allowed for target id: ${targetChoiceId}`);
-    }
-    return { targetChoiceId, scope: rawCleanup.scope };
-  }).filter(cleanupChoice => !claimedTargets.has(cleanupChoice.targetChoiceId));
+async function copyTransform(tool, candidates, command, args, suffix = []) {
+  const input = path.resolve(requireString(args.input, 'input'));
+  const output = path.resolve(requireString(args.output, 'output'));
+  await requireNewFile(output, 'output');
+  const result = await runCandidateChain(candidates, [...command, input, output, ...suffix]);
+  return { tool, runtime: commandRuntime(result), output: await fileArtifact(output) };
 }
 
-async function runTemplateMigrationCommand(tool, command, args) {
-  const source = requireString(args.source, 'source');
-  const baseline = requireString(args.baseline, 'baseline');
-  const output = requireString(args.output, 'output');
-  if (!Array.isArray(args.choices)) {
-    throw Object.assign(new Error('choices must be an array'), { code: -32602 });
-  }
-  const catalogResult = await runJsonCandidateChain(docxCandidates, ['list-template-migration-choices', source, baseline]);
-  const catalog = migrationCatalog.parse(catalogResult.json);
-  const choices = completeMigrationChoices(catalog, args.choices);
-  const templateCleanup = Array.isArray(args.templateCleanup)
-    ? completeTemplateCleanup(catalog, args.templateCleanup, choices)
-    : [];
-  const payload = {
-    schema: 'tiwater.docx.template-migration-business-choices/v1',
-    choices,
-    ...(templateCleanup.length > 0 ? { templateCleanup } : {}),
-  };
-  return withTempJsonFile(payload, async choicesPath => {
-    const result = await runJsonCandidateChain(
-      docxCandidates,
-      [command, source, baseline, choicesPath, output],
-      { allowedExitCodes: [0, 1] });
-    if (result.json === null) {
-      const detail = result.stderr.trim() || result.stdout.trim() || 'no diagnostic output';
-      throw new Error(`${result.command} ${command} returned no JSON receipt (exit ${result.code}): ${detail}`);
+async function fixedEdit(action, args) {
+  const input = path.resolve(requireString(args.input, 'input'));
+  const output = path.resolve(requireString(args.output, 'output'));
+  const receiptOutput = path.resolve(requireString(args.receiptOutput, 'receiptOutput'));
+  await requireNewFile(output, 'output');
+  await requireNewFile(receiptOutput, 'receiptOutput');
+  const inputArtifact = await fileArtifact(input);
+  const operations = action.batch
+    ? args.changes.map(change => ({ ...change, type: action.operationType }))
+    : [{ type: action.operationType }];
+  const candidates = action.name.startsWith('docx_') ? docxCandidates : xlsxCandidates;
+  return withTempJsonFile({ operations }, async operationsPath => {
+    try {
+      const result = await runJsonCandidateChain(candidates, ['edit', input, operationsPath, output], { allowedExitCodes: [0, 1] });
+      const appliedOperations = Array.isArray(result.json?.appliedOperations) ? result.json.appliedOperations : [];
+      const pass = appliedOperations.length === operations.length && appliedOperations.every(operation => operation.applied === true);
+      const outputArtifact = pass ? await fileArtifact(output) : null;
+      if (!pass) await rm(output, { force: true });
+      const receipt = {
+        schema: 'tiwater.office.fixed-edit-receipt/v1',
+        tool: action.name,
+        operationType: action.operationType,
+        pass,
+        input: inputArtifact,
+        output: outputArtifact,
+        operationCount: operations.length,
+        appliedOperations,
+      };
+      return {
+        tool: action.name,
+        runtime: commandRuntime(result),
+        receipt: await writeJsonArtifact(receiptOutput, receipt),
+        output: outputArtifact,
+        summary: { pass, operationCount: operations.length, appliedCount: appliedOperations.filter(operation => operation.applied).length },
+      };
+    } catch (error) {
+      await rm(output, { force: true });
+      throw error;
     }
-    const receipt = migrationReceipt.parse(result.json);
-    return {
-      tool,
-      runtime: commandRuntime(result),
-      artifact: await writeJsonArtifact(requireString(args.receiptOutput, 'receiptOutput'), receipt),
-      summary: {
-        schema: receipt.schema,
-        toolVersion: receipt.toolVersion,
-        status: receipt.status,
-        pass: receipt.pass,
-        reviewRequired: receipt.reviewRequired,
-        outputVerified: receipt.outputVerified,
-        output: receipt.output,
-        plan: receipt.plan,
-        failureCount: receipt.failures.length,
-      },
-    };
   });
 }
 
@@ -1080,6 +637,30 @@ async function officeRenderPdf(args) {
   }
 }
 
+async function xlsxConvertLegacy(args) {
+  const input = path.resolve(requireString(args.input, 'input'));
+  const output = path.resolve(requireString(args.output, 'output'));
+  const receiptOutput = path.resolve(requireString(args.receiptOutput, 'receiptOutput'));
+  if (path.extname(input).toLowerCase() !== '.xls' || path.extname(output).toLowerCase() !== '.xlsx') {
+    throw Object.assign(new Error('Legacy conversion requires .xls input and .xlsx output'), { code: -32602 });
+  }
+  await requireNewFile(output, 'output');
+  await requireNewFile(receiptOutput, 'receiptOutput');
+  const inputArtifact = await fileArtifact(input);
+  try {
+    const result = await runJsonCandidateChain(convertCandidates, ['xls-to-xlsx', input, output]);
+    const outputArtifact = await fileArtifact(output);
+    const receipt = {
+      schema: 'tiwater.office.xlsx-legacy-conversion-receipt/v1',
+      backend: 'et', input: inputArtifact, output: outputArtifact, provider: result.json,
+    };
+    return { tool: 'xlsx_convert_legacy', runtime: commandRuntime(result), output: outputArtifact, receipt: await writeJsonArtifact(receiptOutput, receipt) };
+  } catch (error) {
+    await rm(output, { force: true });
+    throw error;
+  }
+}
+
 function nativeRenderBackend(sourceFormat) {
   if (['doc', 'docx', 'odt', 'rtf'].includes(sourceFormat)) return 'wps';
   if (['xls', 'xlsx', 'ods'].includes(sourceFormat)) return 'et';
@@ -1111,56 +692,6 @@ async function xlsxExportJson(args) {
   };
 }
 
-async function xlsxApply(args) {
-  const input = path.resolve(requireString(args.input, 'input'));
-  const operations = path.resolve(requireString(args.operations, 'operations'));
-  const output = path.resolve(requireString(args.output, 'output'));
-  const receiptOutput = path.resolve(requireString(args.receiptOutput, 'receiptOutput'));
-  if (path.extname(input).toLowerCase() !== '.xlsx' || path.extname(output).toLowerCase() !== '.xlsx') {
-    throw Object.assign(new Error('XLSX apply input and output must use the .xlsx extension'), { code: -32602 });
-  }
-  await requireNewFile(output, 'output');
-  await requireNewFile(receiptOutput, 'receiptOutput');
-  const inputArtifact = await fileArtifact(input);
-  const operationsArtifact = await fileArtifact(operations);
-  await mkdir(path.dirname(output), { recursive: true });
-  try {
-    const result = await runJsonCandidateChain(
-      xlsxCandidates,
-      ['edit', input, operations, output],
-      { allowedExitCodes: [0, 1] });
-    const edit = xlsxEditResult.parse(result.json);
-    if (path.resolve(edit.input) !== input || path.resolve(edit.output) !== output) {
-      throw new Error('XLSX edit receipt is not bound to the current input and output');
-    }
-    const pass = edit.appliedOperations.every(operation => operation.applied);
-    const outputArtifact = pass ? await fileArtifact(output) : null;
-    if (!pass) await rm(output, { force: true });
-    const receipt = xlsxApplyReceipt.parse({
-      schema: 'tiwater.office.xlsx-apply-receipt/v1',
-      pass,
-      input: inputArtifact,
-      operations: operationsArtifact,
-      output: outputArtifact,
-      appliedOperations: edit.appliedOperations,
-    });
-    return {
-      tool: 'xlsx_apply',
-      runtime: commandRuntime(result),
-      receipt: await writeJsonArtifact(receiptOutput, receipt),
-      output: outputArtifact,
-      summary: {
-        pass,
-        operationCount: edit.appliedOperations.length,
-        appliedCount: edit.appliedOperations.filter(operation => operation.applied).length,
-      },
-    };
-  } catch (error) {
-    await rm(output, { force: true });
-    throw error;
-  }
-}
-
 async function xlsxValidate(args) {
   const input = requireString(args.input, 'input');
   const result = await runJsonCandidateChain(xlsxCandidates, ['validate', input], { allowedExitCodes: [0, 1] });
@@ -1188,17 +719,16 @@ async function pptxExportJson(args) {
 }
 
 async function pptxApplyTemplate(args) {
-  return pptxApply('pptx_apply_template', args, true);
+  return withTempJsonFile({ targetMasterPath: args.targetMasterPath, slides: args.slides }, planPath => pptxApply('pptx_apply_template', args, true, planPath));
 }
 
 async function pptxApplyFormat(args) {
-  return pptxApply('pptx_apply_format', args, false);
+  return withTempJsonFile({ operations: args.changes }, planPath => pptxApply('pptx_apply_format', args, false, planPath));
 }
 
-async function pptxApply(tool, args, templateMode) {
+async function pptxApply(tool, args, templateMode, plan) {
   const input = path.resolve(requireString(args.input, 'input'));
   const template = templateMode ? path.resolve(requireString(args.template, 'template')) : null;
-  const plan = path.resolve(requireString(templateMode ? args.plan : args.operations, templateMode ? 'plan' : 'operations'));
   const output = path.resolve(requireString(args.output, 'output'));
   const receiptOutput = path.resolve(requireString(args.receiptOutput, 'receiptOutput'));
   for (const [label, candidate] of [['input', input], ['output', output], ...(template ? [['template', template]] : [])]) {
@@ -1230,18 +760,17 @@ async function pptxApply(tool, args, templateMode) {
     const pass = providerResult.issues.length === 0;
     const outputArtifact = pass ? await fileArtifact(output) : null;
     if (!pass) await rm(output, { force: true });
-    const receiptSchema = templateMode ? pptxTemplateApplyReceipt : pptxFormatApplyReceipt;
-    const receipt = receiptSchema.parse({
+    const receipt = {
       schema: templateMode
         ? 'tiwater.office.pptx-template-apply-receipt/v1'
         : 'tiwater.office.pptx-format-apply-receipt/v1',
       pass,
       input: inputArtifact,
       ...(templateMode ? { template: templateArtifact } : {}),
-      ...(templateMode ? { plan: planArtifact } : { operations: planArtifact }),
+      requestSha256: planArtifact.sha256,
       output: outputArtifact,
       providerResult,
-    });
+    };
     return {
       tool,
       runtime: commandRuntime(result),
@@ -1257,6 +786,11 @@ async function pptxApply(tool, args, templateMode) {
   }
 }
 
+async function pptxValidate(args) {
+  const result = await runJsonCandidateChain(pptxCandidates, ['validate', requireString(args.input, 'input')], { allowedExitCodes: [0, 1] });
+  return { tool: 'pptx_validate', runtime: commandRuntime(result), result: result.json };
+}
+
 async function requireArtifactUnchanged(expected, label) {
   const current = await fileArtifact(expected.path);
   if (!isDeepStrictEqual(current, expected)) throw new Error(`${label} changed during provider execution`);