@superdoc/sdk 2.5.0 → 2.7.0

package/dist/agent/actions.js

@@ -2,7 +2,7 @@ import { SuperDocCliError } from '../runtime/errors.js';
 import { runSuperdocListTransformWorkflow } from '../action-primitives/tools/list-transform.js';
 import { runSuperdocStructureInsertWorkflow } from '../action-primitives/tools/structure-insert.js';
 import { runSuperdocTextTransformWorkflow } from '../action-primitives/tools/text-transform.js';
-import { buildDocumentSnapshot, resolveSnapshotSelector, } from './doc-snapshot.js';
+import { buildDocumentSnapshot, matchRunsForBlock, resolveSnapshotSelector, } from './doc-snapshot.js';
 const ACTION_NAMES = [
     'insert_paragraphs',
     'insert_heading',
@@ -54,14 +54,14 @@ const ACTION_NAMES = [
  * case; the compiler enforces all but the group, which a unit test covers.
  */
 export const ACTION_HINTS = {
-    insert_paragraphs: 'texts[] (or text for a single paragraph), placement?, headingLevel? (first item as heading 1-6), changeMode?',
+    insert_paragraphs: "texts[] (or text for a single paragraph), placement?, headingLevel? (first item as heading 1-6), changeMode? — THE way to ADD a new paragraph/clause; never replace_text/rewrite_block an existing paragraph to append content. Each texts entry is a plain string OR a STYLED object {runs:[{text,marks}], marks?} (marks: bold/italic/underline/strikethrough/fontFamily/fontSize(points)/color(hex)/highlight). MATCH THE SECTION'S PATTERN: when siblings share intra-paragraph formatting (e.g. lettered clauses with a bold '(m)' lead-in), inspect a narrow block window with includeBlockRuns:true, read the sibling runs, and reproduce the pattern with runs on the new text IN THIS CALL — e.g. runs:[{text:'(n)',marks:{bold:true}},{text:' rest of the clause…'}]. Do not add plain and format_text afterward",
     insert_heading: 'text, level, placement?, changeMode?',
-    replace_text: 'edits[{find,replace}], optional selector to scope replacements to one inspected block, caseSensitive?, changeMode?',
+    replace_text: 'edits[{find,replace}], optional selector to scope replacements to one inspected block, caseSensitive?, changeMode? — for EDITING existing wording only; the replaced span is rewritten as PLAIN text (intra-span bold/italic is dropped), so keep find/replace spans MINIMAL (the words that change, not the whole paragraph) and NEVER use it to append a new sentence/clause/paragraph (use insert_paragraphs)',
     delete_text: "finds[], optional selector to scope deletions to ONE inspected block (required to delete stray whitespace — an unscoped whitespace find matches document-wide), caseSensitive?, changeMode? — deletes TEXT ONLY, leaving the block (and a list item's bullet/number) in place. To remove a whole list item, paragraph or heading use delete_blocks",
     delete_blocks: 'selectors[] (each resolving to ONE inspected block: list item, paragraph or heading), changeMode? — THE way to DELETE a whole LIST ITEM, paragraph or heading, bullet/number included. Use for "remove the first item under Article II" / "delete that clause". delete_text only strikes the text and leaves an empty numbered item behind. Deletes several blocks in ONE call; use delete_table for a whole table and delete_text to clear a table cell (a cell must keep a paragraph)',
     append_list: 'items[], kind?: ordered|bullet, headingText?, headingLevel?, placement? {at:"after"|"before",selector} builds the list at that block instead of document end',
-    create_table: 'rows, columns, cellTexts?, placement?, changeMode? — changeMode:"tracked" makes the table insertion itself a tracked change',
-    rewrite_block: 'selector, text, changeMode?',
+    create_table: 'rows, columns, cellTexts? (2D: rows of cells; each cell is a plain string OR a STYLED object {runs:[{text,marks}], marks?} to format the cell — marks: bold/italic/underline/strikethrough/fontFamily/fontSize(points)/color(hex)/highlight), placement?, changeMode? — style cells HERE, do not format_text afterward; changeMode:"tracked" makes the table insertion itself a tracked change',
+    rewrite_block: "selector, text, changeMode? — REPLACES the whole block text; the block's intra-paragraph run pattern is preserved best-effort over the unchanged prefix/suffix. For appending a NEW paragraph/clause use insert_paragraphs, and for small wording edits prefer replace_text with a minimal find span",
     fill_placeholders: 'values[] and/or fields[{label?,value}], changeMode?',
     move_range: 'fromText (text in the FIRST block of the range to move), toText? (text in the LAST block — omit to auto-extend across the whole VISUAL SECTION: from fromText up to the next heading-like/ALL-CAPS/bold title), then exactly ONE destination: afterText OR beforeText (text in the block to land after/before). Direct-only today: changeMode:"tracked" fails with no mutation because block-range deletion cannot be tracked. Moves plain paragraph/heading text only; a range containing a table, list, or image is refused with nothing changed. THE way to MOVE a contiguous block range or a visual "section" identified BY TEXT (works on styled-paragraph sections like PREAMBLE / SCHEDULE A that are NOT Word heading nodes). afterText on a heading-like block lands the range after that block\'s WHOLE section.',
     comment_paragraphs: 'commentText, scope?: all|body, excludeBlockQuotes?',
@@ -76,8 +76,8 @@ export const ACTION_HINTS = {
     apply_style: 'selector (block to restyle), then ONE of: styleId (e.g. "Heading2"), headingLevel (1-6), or likeText (text inside another block whose style AND effective look to copy) — THE way to restyle an EXISTING block ("make Summary match the Parties heading"). Never delete-and-recreate a block to change its style',
     apply_letter_spacing: 'selector, letterSpacing, changeMode?',
     insert_toc: 'title?, placement?, changeMode?',
-    insert_table_row: 'tableOrdinal?, rowIndex?, position?: before|after|above|below, cellTexts?, changeMode?, dryRun?',
-    insert_table_column: 'tableOrdinal?, columnIndex?, position?, headerText?, changeMode?',
+    insert_table_row: "tableOrdinal?, rowIndex?, position?: before|after|above|below, cellTexts? (one per column; each a plain string OR a STYLED {runs, marks?} cell to reproduce the table's cell formatting), changeMode?, dryRun? — to match existing cell styling, inspect the table with includeTableCellRuns:true first, then style each new cell HERE. PLACEMENT: when the user does not say WHERE the row goes, append it after the LAST existing row (rowIndex = last row's index, position: below); never pick a middle position on your own",
+    insert_table_column: 'tableOrdinal?, columnIndex?, position?: left|right, headerText? OR cellTexts? (one per row; each a plain string OR a STYLED {runs, marks?} cell), changeMode? — style the new column cells HERE, not with format_text',
     delete_table_row: 'tableOrdinal?, rowIndex, changeMode?',
     delete_table_column: 'tableOrdinal?, columnIndex, changeMode?',
     split_table: 'tableOrdinal?, rowIndex, separatorText?, changeMode?',
@@ -86,7 +86,11 @@ export const ACTION_HINTS = {
     undo_changes: 'untilMarker? rendered marker to restore e.g. "2.1.", steps? 1-25 — deterministic revert that steps document history back until the marker reappears',
     redo_changes: 'steps? 1-25 (default 1) — the inverse of undo_changes: steps history FORWARD to re-apply edits a prior undo removed. THE recovery when an undo overshot. Only works right after an undo, before any new edit.',
     attach_numbering: 'anchorText|nodeId, likeMarker e.g. "10.", changeMode? — make an existing block a numbered clause at the same scheme/level as the sibling rendering likeMarker; changeMode:"tracked" records the former unnumbered state as a w:pPrChange',
-    add_list_items: "anchorText (text inside the item to add relative to) + entries[{text, level?}] — level is RELATIVE to the anchor: 0 = same level as the anchor, positive nests deeper, NEGATIVE promotes toward the top (anchor on a sub-item like \"12(e)\" with level:-1 → a new TOP-LEVEL item 13). The item lands after the anchor's whole sub-tree at that level, and the receipt reports the marker it landed on. New items also inherit the anchor item's font/size/bold/colour automatically (receipt.formattingMatched) — do NOT re-format after adding unless asked. To control level ALWAYS use anchorText (listOrdinal/items[] just append at the list's trailing level and cannot set level). THE way to ADD items (incl. nested sub-items or a new top-level item) into an EXISTING list, reusing its numbering + markers — NOT append_list (which starts a brand-new list)",
+    add_list_items: 'THE way to ADD items into an EXISTING list (reusing its numbering + markers) — NOT append_list (which starts a brand-new list). Locate the list with anchorText (text inside an existing item) or listOrdinal (from inspect). Each item in entries/items is EITHER a plain string / {text, level?}, OR a STYLED object {runs, marks?, level?}. ' +
+        'STYLING IN THIS ONE CALL — if any part of the new item needs inline formatting (bold/italic/underline/color/font/size on some or all of it), you MUST express it with `runs` and/or `marks` HERE. Do NOT add the item plain and then call format_text/format_paragraph on it afterward — that is the wrong tool for a just-added item and risks matching stray text elsewhere. ' +
+        '`runs` = ordered segments [{text, marks?}] whose texts concatenate to the item text; put the pattern on each segment (marks: bold/italic/underline/strikethrough/fontFamily/fontSize(points)/color(hex e.g. #1a1a1a)/highlight). `marks` on the item = a whole-item default (e.g. Arial 16pt) applied under the per-run marks. Example — pattern \'first word bold, rest italic\': runs:[{text:"Term:",marks:{bold:true}},{text:" the rest",marks:{italic:true}}]. ' +
+        "MATCHING THE LIST'S FORMATTING IS THE DEFAULT EXPECTATION, and it means per-run inline formatting — NOT numbering (numbering is always reused automatically). superdoc_inspect returns each list item's `runs` (its inline segments with marks) by default: READ the sibling items' runs, infer the rule (which segment is bold/italic/etc., the font/size), and REPRODUCE that run structure with `runs` on the new item's OWN words IN THIS CALL. If the siblings are uniformly styled, a plain add already inherits their font/size/colour, so no marks are needed; but if any sibling has intra-item formatting, you MUST supply `runs`. " +
+        'level is RELATIVE to the anchor (0 = same level, positive nests deeper, NEGATIVE promotes toward the top e.g. anchor "12(e)" + level:-1 → new top-level item 13); only anchorText can set explicit level (listOrdinal appends at the trailing level). PLACEMENT: anchorText inserts the new item RIGHT AFTER the item containing that text — this is how you position within a list. One Word list often spans SEVERAL visual groups (the same numbering id continues past e.g. "Label: value" entries into unrelated paragraphs), so when the new item belongs to a visible GROUP of similar siblings, anchor the LAST item OF THAT GROUP — tail-append (listOrdinal, or anchoring the list\'s final item) can land it in the wrong region. Only when there is no such group and the user gives no placement signal append at the END of the list. The receipt\'s note/addedItems echo the rendered marker AND the immediate neighbor items — verify placement from the receipt; do NOT re-inspect wide block windows after a successful add. receipt.formattingMatched reports what was applied.',
     format_paragraph: 'selector (block to align), alignment: left|center|right|justify, changeMode? — THE way to set paragraph alignment; changeMode:"tracked" records the former alignment as a w:pPrChange so accept/reject toggles it (never apply alignment untracked when tracking is on)',
     move_text: 'text (exact clause/phrase to relocate), afterText? (relocate to immediately after this text), changeMode? — THE way to MOVE a text span. Direct by default (physically relocates; REQUIRES afterText). changeMode:"tracked" records it as a redline (tracked delete of the source + tracked insert at the destination; accept keeps the move, reject restores the order) and may omit afterText (lands right after the struck source).',
     style_table: 'tableOrdinal? (1-based, default 1), accentColor? (header fill hex, default dark navy) — THE way to make a table look professional: filled accent header row with white bold text, bold first-column labels, banded rows, clean borders. Use after create_table or on any existing table.',
@@ -184,7 +188,7 @@ export const ACTION_ARGS = {
     move_range: ['fromText', 'toText', 'afterText', 'beforeText', 'changeMode'],
     insert_toc: ['title', 'placement', 'changeMode'],
     insert_table_row: ['tableOrdinal', 'rowIndex', 'position', 'cellTexts', 'changeMode', 'dryRun'],
-    insert_table_column: ['tableOrdinal', 'columnIndex', 'position', 'headerText', 'changeMode'],
+    insert_table_column: ['tableOrdinal', 'columnIndex', 'position', 'headerText', 'cellTexts', 'changeMode'],
     delete_table_row: ['tableOrdinal', 'rowIndex', 'changeMode'],
     delete_table_column: ['tableOrdinal', 'columnIndex', 'changeMode'],
     split_table: ['tableOrdinal', 'rowIndex', 'separatorText', 'changeMode'],
@@ -224,6 +228,30 @@ export function isActionName(value) {
 function isRecord(value) {
     return value != null && typeof value === 'object' && !Array.isArray(value);
 }
+/** The message to put in a receipt when something best-effort did not happen. */
+function reasonOf(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+/**
+ * Run a best-effort polish step: never throw, and report WHY it did nothing.
+ *
+ * Contextual formatting must not fail an edit that already landed — but a
+ * silently swallowed failure leaves the caller believing the look was matched.
+ * Returns the reason, so the receipt can carry it.
+ */
+async function bestEffort(step) {
+    try {
+        await step();
+        return null;
+    }
+    catch (err) {
+        return reasonOf(err);
+    }
+}
+/** A NO_OP means "already in the requested state" — the goal, not a failure. */
+function isNoOp(err) {
+    return err?.code === 'NO_OP';
+}
 function asRecord(value) {
     return isRecord(value) ? value : null;
 }
@@ -482,7 +510,7 @@ function revisionVerification(preRevision, postRevision, expectChanged) {
     };
 }
 function failedReceipt(intent, err, preSnapshot) {
-    const message = err instanceof Error ? err.message : String(err);
+    const message = reasonOf(err);
     return {
         status: 'failed',
         intent,
@@ -554,15 +582,19 @@ function flattenCellTexts(cellTexts) {
     for (let rowIndex = 0; rowIndex < cellTexts.length; rowIndex += 1) {
         const row = cellTexts[rowIndex] ?? [];
         for (let columnIndex = 0; columnIndex < row.length; columnIndex += 1) {
-            flattened.push({
-                rowIndex,
-                columnIndex,
-                text: row[columnIndex] ?? '',
-            });
+            flattened.push(cellTextFromSpec(row[columnIndex], rowIndex, columnIndex));
         }
     }
     return flattened;
 }
+/** Normalize a cell input (string or object) into a positioned TableCellText. */
+function cellTextFromSpec(cell, rowIndex, columnIndex) {
+    if (typeof cell === 'string' || cell == null) {
+        return { rowIndex, columnIndex, text: cell ?? '' };
+    }
+    const spec = normalizeItemSpec(cell) ?? {};
+    return { rowIndex, columnIndex, text: itemSpecText(spec), runs: spec.runs, marks: spec.marks };
+}
 function findExtractedCellBlock(blocks, rowIndex, columnIndex) {
     return (blocks.find((block) => block.tableContext?.rowIndex === rowIndex && block.tableContext?.columnIndex === columnIndex) ??
         blocks.find((block) => {
@@ -782,7 +814,14 @@ async function executeCommentCreate(doc, snapshot, commentText, blockId) {
         target,
     });
 }
-async function applyTableCellTexts(doc, tableNodeId, tableOrdinal, cellTexts, changeMode) {
+async function applyTableCellTexts(doc, tableNodeId, tableOrdinal, cellTexts, changeMode, 
+/**
+ * Force the cell fill to run as a direct edit even under `changeMode:'tracked'`.
+ * Set only by the column-insert caller, whose new cells land in pre-existing
+ * rows that carry no tracked-insertion marker for the adapter to absorb them
+ * into. See the tracked-mode note below.
+ */
+forceDirectFill = false) {
     const nonEmptyCells = cellTexts.filter((cell) => cell.text.trim().length > 0);
     if (nonEmptyCells.length === 0)
         return [];
@@ -817,36 +856,170 @@ async function applyTableCellTexts(doc, tableNodeId, tableOrdinal, cellTexts, ch
             },
         ];
     });
-    const steps = [];
+    // Prefer tables.setCellText: it emits a `table.cell.setText` STRUCTURAL delta
+    // that survives collaboration. The legacy `text.rewrite` path is a generic
+    // block rewrite the v2 collab backend silently drops for freshly-inserted
+    // cells (rows/columns land empty), so it is only a fallback for non-collab or
+    // older hosts without the op.
+    //
+    // Tracked mode: the adapter accepts a tracked cell fill only where the target
+    // cell's row carries a same-author `<w:trPr><w:ins/>` marker, which already
+    // owns the accept/reject fate of everything inside it. A tracked row insert
+    // and a tracked new table both produce such rows, so their fills go through
+    // tracked and the transport now lets them reach the adapter
+    // (supportsConditionalTrackedMode, SD-4035).
+    //
+    // A tracked COLUMN insert is the exception: its new cells are added to
+    // PRE-EXISTING rows, which carry no marker, so the adapter fails closed with
+    // CAPABILITY_UNAVAILABLE and the column would land empty. Those fills stay
+    // direct — the table-level insertion still owns the redline.
+    const cellFillChangeMode = forceDirectFill && changeMode === 'tracked' ? undefined : changeMode;
+    const setCellFn = maybeMethod(doc, ['tables', 'setCellText']);
+    const legacySteps = [];
+    const resolved = [];
     for (const cell of nonEmptyCells) {
         const block = findExtractedCellBlock(blocks, cell.rowIndex, cell.columnIndex);
         if (!block?.nodeId) {
             throw new SuperDocCliError('Unable to locate a paragraph block for the requested table cell.', {
                 code: 'INVALID_ARGUMENT',
-                details: {
-                    tableNodeId,
-                    rowIndex: cell.rowIndex,
-                    columnIndex: cell.columnIndex,
-                },
+                details: { tableNodeId, rowIndex: cell.rowIndex, columnIndex: cell.columnIndex },
             });
         }
-        steps.push({
-            id: `set-table-cell-${cell.rowIndex}-${cell.columnIndex}`,
-            op: 'text.rewrite',
-            where: {
-                by: 'block',
-                nodeType: block.type ?? 'paragraph',
-                nodeId: block.nodeId,
-            },
-            args: {
-                replacement: { text: cell.text },
-            },
+        resolved.push({ ...cell, nodeId: block.nodeId });
+        if (setCellFn) {
+            await setCellFn({
+                target: { kind: 'block', nodeType: 'table', nodeId: tableNodeId },
+                rowIndex: cell.rowIndex,
+                columnIndex: cell.columnIndex,
+                text: cell.text,
+                ...(cellFillChangeMode ? { changeMode: cellFillChangeMode } : {}),
+            });
+        }
+        else {
+            legacySteps.push({
+                id: `set-table-cell-${cell.rowIndex}-${cell.columnIndex}`,
+                op: 'text.rewrite',
+                where: { by: 'block', nodeType: block.type ?? 'paragraph', nodeId: block.nodeId },
+                args: { replacement: { text: cell.text } },
+            });
+        }
+    }
+    if (legacySteps.length > 0)
+        await executeMutations(doc, legacySteps, cellFillChangeMode);
+    return resolved;
+}
+/**
+ * Sample a block's leading inline look through `query.match`, which is the only
+ * read that reports run styling (`blocks.list` omits it and `getNodeById`
+ * carries no run props). Returns null when nothing is worth copying.
+ */
+async function inlineLookFromBlockText(doc, text, blockId) {
+    const queryFn = maybeMethod(doc, ['query', 'match']);
+    if (!queryFn || !text.trim())
+        return null;
+    const result = asRecord(await queryFn({ select: { type: 'text', pattern: text } }));
+    const items = Array.isArray(result?.items) ? result.items : [];
+    for (const item of items) {
+        const blocks = Array.isArray(asRecord(item)?.blocks) ? asRecord(item).blocks : [];
+        for (const block of blocks) {
+            const rec = asRecord(block);
+            if (asString(rec?.blockId) !== blockId)
+                continue;
+            const runs = Array.isArray(rec?.runs) ? rec.runs : [];
+            if (runs.length === 0)
+                continue;
+            // Same reader the list path uses, so a table cell inherits COLOUR too —
+            // a white-on-blue header cell that keeps its shading but loses its white
+            // text reads as an empty cell.
+            const inline = inlineFromMatchStyle(matchRunStyle(runs[0]));
+            return Object.keys(inline).length > 0 ? inline : null;
+        }
+    }
+    return null;
+}
+/**
+ * Make freshly filled cells look like the cells they were inserted next to.
+ *
+ * Cell text written into a NEW row or column lands with no run properties at
+ * all (under collaboration for rows; always for columns, whose cells live in
+ * pre-existing rows), so the new cells render at the default face while their
+ * neighbours are 10pt bold — the table equivalent of the list-item base layer.
+ * Only cells the agent did not style explicitly are touched; explicit
+ * runs/marks always win.
+ *
+ * `reference` names the cell each new cell should copy: the same column in the
+ * displaced ROW for a row insert, the same row in the adjacent COLUMN for a
+ * column insert. Returning null skips that cell.
+ *
+ * Best-effort: never throws. Reports how many cells were matched AND why any
+ * were not — one cell that fails must neither abort the others nor pass for
+ * "matched the neighbours" in the receipt.
+ */
+async function matchTableCellsToNeighbour(doc, tableOrdinal, cells, reference) {
+    const candidates = cells.filter((c) => !(c.runs && c.runs.length > 0) && c.marks == null);
+    if (candidates.length === 0)
+        return { matched: 0 };
+    const extractFn = maybeMethod(doc, ['extract']);
+    const formatFn = maybeMethod(doc, ['format', 'apply']);
+    if (!extractFn || !formatFn)
+        return { matched: 0 };
+    let blocks = [];
+    const readFailure = await bestEffort(async () => {
+        const extracted = asRecord(await extractFn({}));
+        blocks = Array.isArray(extracted?.blocks) ? extracted.blocks : [];
+    });
+    if (readFailure)
+        return { matched: 0, skipped: readFailure };
+    let matched = 0;
+    const failures = [];
+    for (const cell of candidates) {
+        const failure = await bestEffort(async () => {
+            const ref = reference(cell);
+            if (!ref || ref.rowIndex < 0 || ref.columnIndex < 0)
+                return;
+            const neighbour = blocks
+                .map((b) => asRecord(b))
+                .find((b) => {
+                const ctx = asRecord(b?.tableContext);
+                return (asNumber(ctx?.tableOrdinal, -1) === tableOrdinal - 1 &&
+                    asNumber(ctx?.rowIndex, -1) === ref.rowIndex &&
+                    asNumber(ctx?.columnIndex, -1) === ref.columnIndex);
+            });
+            const neighbourId = asString(neighbour?.nodeId);
+            const neighbourText = asString(neighbour?.text, '');
+            if (!neighbourId || !neighbourText)
+                return;
+            const inline = await inlineLookFromBlockText(doc, neighbourText, neighbourId);
+            if (!inline)
+                return;
+            try {
+                await formatFn({ blockId: cell.nodeId, start: 0, end: Math.max(cell.text.length, 1), inline });
+                matched += 1;
+            }
+            catch (err) {
+                if (!isNoOp(err))
+                    throw err;
+            }
         });
+        if (failure)
+            failures.push(`cell ${cell.rowIndex},${cell.columnIndex}: ${failure}`);
     }
-    if (steps.length === 0)
-        return [];
-    await executeMutations(doc, steps, changeMode);
-    return nonEmptyCells;
+    return { matched, ...(failures.length > 0 ? { skipped: failures.join('; ') } : {}) };
+}
+/**
+ * Apply per-run / whole-cell styling to table cells that requested it, after
+ * their text has been written. Reuses the list-item styling pass (format.apply
+ * per run range on each cell's paragraph nodeId). Best-effort; returns the
+ * number of cells styled.
+ */
+async function styleTableCells(doc, cells, changeMode) {
+    const styled = cells.filter((c) => (c.runs && c.runs.length > 0) || c.marks != null);
+    if (styled.length === 0)
+        return 0;
+    const nodeIds = styled.map((c) => c.nodeId);
+    const specs = styled.map((c) => ({ text: c.text, runs: c.runs, marks: c.marks }));
+    await applyItemStyling(doc, nodeIds, specs, changeMode);
+    return styled.length;
 }
 async function runInsertParagraphs(doc, args) {
     const pre = await buildDocumentSnapshot(doc, { includeDomains: ['blocks'] });
@@ -882,6 +1055,8 @@ async function runInsertParagraphs(doc, args) {
                 ? { kind: 'after', target: { kind: 'block', nodeType: last.nodeType, nodeId: last.nodeId } }
                 : { kind: 'documentEnd' };
         };
+        const styledNodeIds = [];
+        const styledSpecs = [];
         for (let i = 0; i < texts.length; i += 1) {
             const text = texts[i];
             const isFirst = i === 0;
@@ -892,6 +1067,16 @@ async function runInsertParagraphs(doc, args) {
                 operationId: isFirst && headingFirst ? 'doc.create.heading' : 'doc.create.paragraph',
                 result,
             });
+            // Remember the created block for the post-insert styling pass when this
+            // paragraph carries a runs/marks spec.
+            const spec = args.textSpecs?.[i];
+            if (spec && ((spec.runs && spec.runs.length > 0) || spec.marks != null)) {
+                const created = createdBlockTarget(result);
+                if (created?.nodeId) {
+                    styledNodeIds.push(created.nodeId);
+                    styledSpecs.push({ ...spec, text });
+                }
+            }
             currentPlacement = await advanceAfter(result);
             // New-document drafts get a blank paragraph after each item for spacing;
             // inserts into an existing document do not (would scatter blank lines).
@@ -901,6 +1086,14 @@ async function runInsertParagraphs(doc, args) {
                 currentPlacement = await advanceAfter(spacer);
             }
         }
+        if (styledNodeIds.length > 0) {
+            const styling = await applyItemStyling(doc, styledNodeIds, styledSpecs, args.changeMode);
+            executedOperations.push({
+                operationId: 'doc.format.apply',
+                result: styling,
+                rationale: `Styled ${styledNodeIds.length} inserted paragraph(s)`,
+            });
+        }
         const postIdentity = await readDocumentIdentity(doc);
         const verification = [revisionVerification(pre.revision, postIdentity.revision, true)];
         return {
@@ -953,6 +1146,11 @@ async function runReplaceText(doc, args) {
         const selectedTargets = [];
         let skippedEdits = [];
         let steps;
+        // Blocks whose text this call rewrites, with their pre-mutation run layout:
+        // the engine replace lane renders the replaced range as uniform runs, so a
+        // whole-paragraph find/replace flattens intra-paragraph formatting (bold
+        // lead-ins). Restore it positionally after the mutation.
+        const preserveTargets = [];
         if (args.selector) {
             const target = selectorToBlockTarget(args.selector, pre);
             if (!target) {
@@ -990,6 +1188,13 @@ async function runReplaceText(doc, args) {
                 },
             ];
             selectedTargets.push({ selector: args.selector, matched: [target.nodeId] });
+            preserveTargets.push({
+                nodeId: target.nodeId,
+                nodeType: target.nodeType ?? 'paragraph',
+                oldText: target.text,
+                newText: rewrittenText,
+                runs: await captureBlockRuns(doc, target.nodeId, target.text),
+            });
         }
         else {
             const matchingEdits = args.edits.length === 1
@@ -1012,26 +1217,104 @@ async function runReplaceText(doc, args) {
                     ],
                 };
             }
-            steps = matchingEdits.map((edit, index) => ({
-                id: `replace-${index + 1}`,
-                op: 'text.rewrite',
-                where: {
-                    by: 'select',
-                    select: {
-                        type: 'text',
-                        pattern: edit.find,
-                        mode: 'contains',
-                        caseSensitive,
+            // Rewrite affected BODY blocks with block-targeted rewrites. The select
+            // (matched-range) rewrite lane flattens the WHOLE paragraph's runs in
+            // collaborative sessions and leaves format.apply inert on the block
+            // afterwards, so per-block rewrites + the preserve pass below are the
+            // only path that keeps intra-paragraph formatting alive. Bounded; edits
+            // that touch no scanned body block (e.g. header/footer text) fall back
+            // to a select-rewrite step.
+            // Tracked mode keeps the matched-range lane. A block rewrite asks the
+            // engine to delete and re-insert the WHOLE paragraph, so a reviewer sees
+            // the entire block struck and re-added instead of the words that changed,
+            // and each block contributes its own replacement/deletion pair. The
+            // per-block lane exists to keep intra-paragraph formatting alive, which
+            // is a direct-mode concern; under tracked mode the revision itself is the
+            // reviewable unit and must stay scoped to the edit.
+            const scanBlocks = args.changeMode === 'tracked'
+                ? []
+                : pre.blocks.length > 0
+                    ? pre.blocks
+                    : (await buildDocumentSnapshot(doc, { includeDomains: ['blocks'] })).blocks;
+            // An edit counts as covered only when EVERY block holding it got a
+            // rewrite target. The per-block lane is bounded (run capture costs a read
+            // each), so a find present in more blocks than the cap must fall through
+            // to the select lane below, which carries `require: 'all'`. Marking such
+            // an edit covered after its first match would replace only the first
+            // PRESERVE_TARGET_CAP blocks and still report success.
+            const blocksHoldingEdit = matchingEdits.map((edit) => scanBlocks.filter((block) => block.nodeId && block.text && textIncludes(block.text, edit.find, caseSensitive))
+                .length);
+            const blocksCoveredForEdit = Array.from({ length: matchingEdits.length }, () => 0);
+            for (const block of scanBlocks) {
+                if (preserveTargets.length >= PRESERVE_TARGET_CAP)
+                    break;
+                if (!block.nodeId || !block.text)
+                    continue;
+                let newText = block.text;
+                const touched = [];
+                matchingEdits.forEach((edit, editIndex) => {
+                    if (textIncludes(newText, edit.find, caseSensitive)) {
+                        newText = replaceAllText(newText, edit.find, edit.replace, caseSensitive);
+                        touched.push(editIndex);
+                    }
+                });
+                if (newText === block.text)
+                    continue;
+                preserveTargets.push({
+                    nodeId: block.nodeId,
+                    nodeType: block.nodeType ?? 'paragraph',
+                    oldText: block.text,
+                    newText,
+                    runs: await captureBlockRuns(doc, block.nodeId, block.text),
+                });
+                for (const editIndex of touched)
+                    blocksCoveredForEdit[editIndex] += 1;
+            }
+            const coveredEdits = new Set(matchingEdits
+                .map((_edit, editIndex) => editIndex)
+                .filter((editIndex) => blocksHoldingEdit[editIndex] > 0 && blocksCoveredForEdit[editIndex] >= blocksHoldingEdit[editIndex]));
+            steps = [
+                ...preserveTargets.map((entry, index) => ({
+                    id: `replace-block-${index + 1}`,
+                    op: 'text.rewrite',
+                    where: { by: 'block', nodeType: entry.nodeType, nodeId: entry.nodeId },
+                    args: {
+                        replacement: { text: entry.newText },
+                        style: preserveRewriteStyle(),
                     },
-                    require: 'all',
-                },
-                args: {
-                    replacement: { text: edit.replace },
-                    style: preserveRewriteStyle(),
-                },
-            }));
+                })),
+                // Edits that touched no scanned body block (header/footer text, or a
+                // doc larger than the scan window) keep the original select-rewrite.
+                ...matchingEdits
+                    .map((edit, editIndex) => ({ edit, editIndex }))
+                    .filter(({ editIndex }) => !coveredEdits.has(editIndex))
+                    .map(({ edit, editIndex }) => ({
+                    id: `replace-${editIndex + 1}`,
+                    op: 'text.rewrite',
+                    where: {
+                        by: 'select',
+                        select: {
+                            type: 'text',
+                            pattern: edit.find,
+                            mode: 'contains',
+                            caseSensitive,
+                        },
+                        require: 'all',
+                    },
+                    args: {
+                        replacement: { text: edit.replace },
+                        style: preserveRewriteStyle(),
+                    },
+                })),
+            ];
         }
         const result = await executeMutations(doc, steps, args.changeMode);
+        const preserved = [];
+        for (const entry of preserveTargets) {
+            const restored = await preserveRunPatternAfterRewrite(doc, entry.nodeId, entry.oldText, entry.runs, entry.newText);
+            if (restored)
+                preserved.push({ nodeId: entry.nodeId, ...restored });
+        }
         if (args.selector && selectedTargets[0]) {
             const post = await buildDocumentSnapshot(doc, { includeDomains: selectorDomains ?? ['blocks'] });
             const blockId = selectedTargets[0].matched[0];
@@ -1060,7 +1343,10 @@ async function runReplaceText(doc, args) {
                 preSnapshot: { revision: pre.revision, counts: pre.counts },
                 postSnapshot: { revision: post.revision, counts: post.counts },
                 selectedTargets,
-                executedOperations: [{ operationId: 'doc.mutations.apply', result }],
+                executedOperations: [
+                    { operationId: 'doc.mutations.apply', result },
+                    ...(preserved.length > 0 ? [{ operationId: 'doc.format.apply', result: { preserved } }] : []),
+                ],
                 verification,
             };
         }
@@ -1084,6 +1370,7 @@ async function runReplaceText(doc, args) {
                     ...(skippedEditRationale ? { rationale: skippedEditRationale } : {}),
                     result,
                 },
+                ...(preserved.length > 0 ? [{ operationId: 'doc.format.apply', result: { preserved } }] : []),
             ],
             verification,
         };
@@ -1334,7 +1621,7 @@ async function runDeleteBlocks(doc, args) {
             catch (err) {
                 errors.push({
                     code: 'ACTION_FAILED',
-                    message: `blocks.delete failed for ${target.nodeType} ${target.nodeId}: ${err instanceof Error ? err.message : String(err)}`,
+                    message: `blocks.delete failed for ${target.nodeType} ${target.nodeId}: ${reasonOf(err)}`,
                     recovery: { kind: 'reinspect' },
                 });
             }
@@ -1383,18 +1670,33 @@ async function runAppendList(doc, args) {
         if (args.items.length === 0) {
             return failedReceipt('append_list', new Error('items must be non-empty'), pre);
         }
+        // The published schema accepts styled objects here, so normalize them
+        // rather than handing the text-only workflow an object it rejects with
+        // INVALID_ARGUMENT. Text goes in; marks come back as a post-insert pass.
+        const specs = args.items.map((item) => (typeof item === 'string' ? { text: item } : item));
+        const anyStyled = specs.some((spec) => spec.marks != null || (spec.runs && spec.runs.length > 0));
         const workflowResult = await runSuperdocListTransformWorkflow({
             documentHandle: doc,
             args: {
                 action: 'append_new_list',
-                items: [...args.items],
+                items: specs.map((spec) => itemSpecText(spec)),
                 kind: args.kind ?? 'ordered',
                 headingText: args.headingText,
                 headingLevel: args.headingLevel,
                 changeMode: args.changeMode,
             },
         });
-        return receiptFromWorkflowResult(doc, 'append_list', pre, workflowResult);
+        const receipt = await receiptFromWorkflowResult(doc, 'append_list', pre, workflowResult);
+        if (anyStyled) {
+            const insertedNodeIds = Array.isArray(workflowResult.output?.execution?.insertedNodeIds)
+                ? workflowResult.output.execution.insertedNodeIds
+                : [];
+            if (insertedNodeIds.length > 0) {
+                const formattingMatched = await applyItemStyling(doc, insertedNodeIds, specs, args.changeMode);
+                return { ...receipt, formattingMatched };
+            }
+        }
+        return receipt;
     }
     catch (err) {
         return failedReceipt('append_list', err, pre);
@@ -1423,7 +1725,19 @@ async function runInsertListItems(doc, args) {
                 changeMode: args.changeMode,
             },
         });
-        return receiptFromWorkflowResult(doc, 'add_list_items', pre, workflowResult);
+        const receipt = await receiptFromWorkflowResult(doc, 'add_list_items', pre, workflowResult);
+        // The list workflow is text-only; apply any requested per-run / whole-item
+        // styling as a post-pass on the freshly inserted items (aligned by index).
+        if (args.styled && args.styled.length > 0) {
+            const insertedNodeIds = Array.isArray(workflowResult.output?.execution?.insertedNodeIds)
+                ? workflowResult.output.execution.insertedNodeIds
+                : [];
+            if (insertedNodeIds.length > 0) {
+                const formattingMatched = await applyItemStyling(doc, insertedNodeIds, args.styled, args.changeMode);
+                return { ...receipt, formattingMatched };
+            }
+        }
+        return receipt;
     }
     catch (err) {
         return failedReceipt('add_list_items', err, pre);
@@ -1433,14 +1747,35 @@ async function runAddListItems(doc, args, opts) {
     const pre = await buildDocumentSnapshot(doc, { includeDomains: ['blocks'] });
     try {
         const needle = args.anchorText?.trim();
-        if (!needle)
-            return failedReceipt('add_list_items', new Error('anchorText is required'), pre);
+        const anchorNodeId = args.anchorNodeId?.trim();
+        if (!needle && !anchorNodeId) {
+            return failedReceipt('add_list_items', new Error('anchorText or anchorNodeId is required'), pre);
+        }
         if (!args.entries || args.entries.length === 0) {
             return failedReceipt('add_list_items', new Error('entries must be non-empty'), pre);
         }
         const rows = await listBlockRows(doc);
-        // The list to extend: a numbered/bulleted item whose text matches anchorText.
-        const anchor = rows.find((r) => blockNumbering(r) && (r.textPreview ?? '').toLowerCase().includes(needle.toLowerCase()));
+        // `blocks.list` rows carry only a TRUNCATED textPreview (~78 chars), while
+        // the agent quotes anchorText out of the FULL block text that inspect
+        // reports. Matching the preview alone misses any anchor past the truncation
+        // point — and a missed anchor is not a visible failure: the caller falls
+        // through to the text-only path, which silently discards every run mark the
+        // agent asked for. Match full snapshot text first, preview second.
+        const needleLower = (needle ?? '').toLowerCase();
+        const fullTextById = new Map();
+        for (const block of pre.blocks ?? []) {
+            if (block.nodeId && typeof block.text === 'string')
+                fullTextById.set(block.nodeId, block.text);
+        }
+        const rowMatchesNeedle = (r) => {
+            const rowText = fullTextById.get(r.nodeId ?? '') ?? r.textPreview ?? '';
+            return rowText.toLowerCase().includes(needleLower);
+        };
+        // The list to extend: prefer a direct nodeId anchor (from a resolved
+        // listOrdinal), else a numbered/bulleted item whose text matches anchorText.
+        const anchor = anchorNodeId
+            ? rows.find((r) => r.nodeId === anchorNodeId && blockNumbering(r))
+            : rows.find((r) => blockNumbering(r) && rowMatchesNeedle(r));
         if (!anchor || !anchor.nodeId) {
             // The caller can retry via the ghost/ordinal path (imported list-looking
             // paragraphs carry no numbering, so no NUMBERED anchor matches here).
@@ -1484,6 +1819,27 @@ async function runAddListItems(doc, args, opts) {
                 // else: non-numbered paragraph (a continuation) — skip and keep scanning
             }
         }
+        // A new item SHALLOWER than its anchor cannot sit inside a nested run of
+        // sub-items without cutting that run in two: anchored on the middle of a
+        // sub-list, a promoted top-level item lands between two sub-items and
+        // orphans the ones after it. Carry it past every deeper item first, so it
+        // arrives at the end of the group it now belongs to. (The agent quotes
+        // whichever sibling text it noticed; "after this sub-item" and "a top-level
+        // item here" are contradictory instructions, and outline level wins.)
+        const firstEntryLevel = args.entries[0]?.level;
+        const firstRelative = typeof firstEntryLevel === 'number' ? Math.floor(firstEntryLevel) : 0;
+        if (firstRelative < 0) {
+            const firstTargetLevel = Math.max(0, anchorLevel + firstRelative);
+            const startIdx = rows.findIndex((r) => r.nodeId === subtreeEnd.nodeId);
+            for (let i = startIdx + 1; i >= 1 && i < rows.length; i += 1) {
+                const level = levelOfRow(rows[i]);
+                if (level == null)
+                    continue; // non-numbered continuation paragraph
+                if (level <= firstTargetLevel)
+                    break;
+                subtreeEnd = rows[i];
+            }
+        }
         const attachFn = maybeMethod(doc, ['lists', 'attach']);
         if (!attachFn) {
             throw new SuperDocCliError('doc.lists.attach is not available on the document handle.', {
@@ -1501,7 +1857,10 @@ async function runAddListItems(doc, args, opts) {
         };
         const createdItems = [];
         for (const entry of args.entries) {
-            const text = typeof entry?.text === 'string' ? entry.text : '';
+            // Styled items carry ordered `runs`; a plain item is a single run. The
+            // paragraph is created with the concatenated text, then styled per-run.
+            const runs = entry?.runs && entry.runs.length > 0 ? entry.runs : [{ text: entry?.text ?? '' }];
+            const text = itemSpecText(entry);
             // `level` is RELATIVE to the anchor and MAY BE NEGATIVE: positive nests
             // deeper, 0 = same level as the anchor, negative promotes toward the top
             // (e.g. anchor on a sub-item, level:-1 → a top-level sibling). The final
@@ -1527,11 +1886,112 @@ async function runAddListItems(doc, args, opts) {
                 result: compactOpResult(attachResult),
                 rationale: `level ${targetLevel}`,
             });
-            createdItems.push({ nodeId: target.nodeId, targetLevel, text });
+            createdItems.push({ nodeId: target.nodeId, targetLevel, text, runs, itemMarks: entry?.marks });
             // After attach the block is a listItem (same nodeId) — the next placement
             // must address it as such or the create resolver rejects the anchor.
             placement = { kind: 'after', target: { kind: 'block', nodeType: 'listItem', nodeId: target.nodeId } };
         }
+        // A new item is created next to the ANCHOR, so it inherits the anchor's
+        // direct indentation — correct at the same level, wrong at any other one.
+        // `lists.attach` sets the numbering level (`w:ilvl`) but leaves that direct
+        // `w:ind` alone, so a level-changing add renders with a sub-item's indent
+        // under a top-level number: e.g. an item promoted to level 0 kept
+        // left=1800 while its "1./2./3." siblings sit at 1080. Copy the indentation
+        // from an EXISTING sibling at the item's own level. Best-effort: an
+        // unmatched indent is cosmetic and must not fail an item that landed.
+        const createdIds = new Set(createdItems.map((ci) => ci.nodeId));
+        const anchorKind = blockNumbering(anchor)?.kind ?? null;
+        // Search OUTWARD from the anchor, nearest first, and only accept items
+        // of the anchor's own numbering kind: a document holds several lists,
+        // and the first level-0 item in document order usually belongs to a
+        // different one (here: a bullet list far above the ordered list being
+        // extended), whose indentation is unrelated.
+        const findSiblingAt = (level) => {
+            const usable = (r) => !!r?.nodeId &&
+                !createdIds.has(r.nodeId) &&
+                levelOfRow(r) === level &&
+                (blockNumbering(r)?.kind ?? null) === anchorKind;
+            for (let delta = 1; delta <= rows.length; delta += 1) {
+                const before = anchorIdx >= 0 ? rows[anchorIdx - delta] : undefined;
+                if (usable(before))
+                    return before;
+                const after = anchorIdx >= 0 ? rows[anchorIdx + delta] : undefined;
+                if (usable(after))
+                    return after;
+            }
+            return undefined;
+        };
+        /** The existing item a new one should look like: same level, nearest first. */
+        const lookSourceFor = (targetLevel) => targetLevel === anchorLevel ? anchor : findSiblingAt(targetLevel);
+        // Most Word documents keep a list's look in a paragraph STYLE, not in direct
+        // properties: "MB Agr 2", "Quick 1.", even Heading3 carry the numbering, the
+        // indentation and the face. A created paragraph does not get the sibling's
+        // style — it gets the anchor's `next` style (Heading3 → BodyText), a default
+        // (ListParagraph, whose contextualSpacing changes the spacing), or the
+        // anchor's own style when the new item belongs to a DIFFERENT level (keeping
+        // "MB Agr 3" on an item whose numbering now says level 2). Reconcile it with
+        // the sibling at the item's own level.
+        //
+        // setStyleRef, not setStyle: setStyle clears direct run formatting, which
+        // would wipe the sampled run look applied below.
+        const styledItems = [];
+        const styleSkipped = await bestEffort(async () => {
+            const setStyleRefFn = maybeMethod(doc, ['styles', 'paragraph', 'setStyleRef']);
+            const clearStyleFn = maybeMethod(doc, ['styles', 'paragraph', 'clearStyle']);
+            if (!setStyleRefFn && !clearStyleFn)
+                return;
+            let current = null;
+            for (const ci of createdItems) {
+                const source = lookSourceFor(ci.targetLevel);
+                if (!source)
+                    continue;
+                const wanted = source.styleId ?? null;
+                current ??= await listBlockRows(doc);
+                const created = current.find((r) => r.nodeId === ci.nodeId);
+                if ((created?.styleId ?? null) === wanted)
+                    continue;
+                const target = { kind: 'block', nodeType: created?.nodeType ?? 'listItem', nodeId: ci.nodeId };
+                if (wanted && setStyleRefFn)
+                    await setStyleRefFn({ target, styleId: wanted });
+                else if (!wanted && clearStyleFn)
+                    await clearStyleFn({ target });
+                else
+                    continue;
+                styledItems.push({ nodeId: ci.nodeId, styleId: wanted });
+            }
+        });
+        const indentedItems = [];
+        const indentSkipped = await bestEffort(async () => {
+            const setIndentFn = maybeMethod(doc, ['format', 'paragraph', 'setIndentation']);
+            const getNodeFn = maybeMethod(doc, ['getNodeById']);
+            if (!setIndentFn || !getNodeFn)
+                return;
+            for (const ci of createdItems) {
+                const sibling = lookSourceFor(ci.targetLevel);
+                if (!sibling?.nodeId)
+                    continue;
+                const node = (await getNodeFn({ id: sibling.nodeId }));
+                const indent = paragraphIndentOf(node);
+                if (!indent)
+                    continue;
+                // COMPARE rather than assume: a same-level item usually inherits the
+                // anchor's indentation on creation, but not always — one real document
+                // produced items with no `w:ind` at all beside siblings indented 851.
+                const created = paragraphIndentOf(await getNodeFn({ id: ci.nodeId }));
+                if (created && ['left', 'right', 'firstLine', 'hanging'].every((k) => created[k] === indent[k])) {
+                    continue;
+                }
+                await setIndentFn({
+                    target: { kind: 'block', nodeType: 'listItem', nodeId: ci.nodeId },
+                    // The read side reports indentation in POINTS while setIndentation
+                    // takes TWIPS — passing the sampled numbers through unconverted
+                    // indents by a twentieth of the intended amount, which reads as
+                    // "the copy silently did nothing".
+                    ...indent,
+                });
+                indentedItems.push({ nodeId: ci.nodeId, from: sibling.nodeId });
+            }
+        });
         // Report WHERE each item actually landed (rendered marker + outline level),
         // so the caller can trust the result instead of re-deriving it and undoing
         // correct work when the level looked ambiguous.
@@ -1540,63 +2000,220 @@ async function runAddListItems(doc, args, opts) {
         try {
             afterRows = await listBlockRows(doc);
             landed = createdItems.map((ci) => {
-                const row = afterRows.find((r) => r.nodeId === ci.nodeId);
+                const idx = afterRows.findIndex((r) => r.nodeId === ci.nodeId);
+                const row = idx >= 0 ? afterRows[idx] : undefined;
                 const num = row ? blockNumbering(row) : null;
                 const p = num?.path;
-                return { marker: num?.marker ?? null, level: Array.isArray(p) ? Math.max(0, p.length - 1) : ci.targetLevel };
+                const snippet = (r) => (r?.textPreview ? r.textPreview.slice(0, 60) : null);
+                return {
+                    marker: num?.marker ?? null,
+                    level: Array.isArray(p) ? Math.max(0, p.length - 1) : ci.targetLevel,
+                    // Only a read-back that FOUND the created node counts as verified;
+                    // otherwise the level is the requested one, not an observed one.
+                    verified: idx >= 0,
+                    // Immediate neighboring BLOCKS (may be continuation paragraphs, or —
+                    // for multi-entry adds — the other new items) so the caller can
+                    // verify PLACEMENT from the receipt instead of re-inspecting a wide
+                    // block window.
+                    previousBlock: idx > 0 ? snippet(afterRows[idx - 1]) : null,
+                    nextBlock: idx >= 0 && idx + 1 < afterRows.length ? snippet(afterRows[idx + 1]) : null,
+                };
             });
         }
         catch {
             // best-effort read-back; the mutation already applied
         }
-        // Match the anchor item's inline look (font/size/bold/colour) onto each new
-        // item, so a list extended from styled items keeps that styling — the same
-        // neighbour-formatting polish insert_paragraphs/insert_heading receive, except
-        // the anchor IS the explicit reference here. Best-effort: a format.apply
-        // failure must NEVER fail an otherwise-landed add, so the items still exist.
-        let formattingMatched = { skipped: 'anchor had no inline look' };
+        // Format each new item in four layers, later layers overriding earlier on
+        // overlapping keys (successive format.apply calls):
+        //   1. BASE  — the sampled look of the existing item at the same level, over
+        //      the whole item, so an item added with no explicit styling still
+        //      matches its siblings' font/size/colour (fixes the plain-insert
+        //      mismatch where the new item fell back to style defaults instead of
+        //      the list's direct run formatting).
+        //   2. LEAD  — the siblings' "bold label: plain sentence" convention over
+        //      the new item's own label span, when the item requested no styling of
+        //      its own. Without it a plain add reads as the odd one out even though
+        //      every other property matches: the agent is only told the item TEXT of
+        //      its siblings, never that they open with a bold lead-in.
+        //   3. ITEM  — whole-item `marks` the agent supplied (e.g. Arial 16pt on the
+        //      entire item).
+        //   4. RUN   — per-segment `marks` over each run's char range, so the agent
+        //      can replicate an intra-item pattern (e.g. second word italic).
+        // Best-effort: a format.apply failure must NEVER fail an otherwise-landed
+        // add, so the items still exist.
+        let formattingMatched = { skipped: 'no formatting applied' };
+        let leadInMatched = 0;
+        // What the base layer actually asked for, sampled look included — a receipt
+        // reading `base: {}` hides the run sample the row read cannot see.
+        let reportedBase = null;
         try {
-            const inline = inlineLookFromRow(anchor);
+            // The BASE layer must come from the row the item will sit beside, not
+            // from the anchor: a promoted or demoted item crosses levels, and the
+            // anchor's font/size/colour/emphasis is then the wrong level's look.
+            // `lookSourceFor(targetLevel)` already picks the destination sibling for
+            // style and indent, so the look follows the same source. Falls back to
+            // the anchor only when the destination level has no sibling to sample.
+            const anchorBase = inlineLookFromRow(anchor);
             const formatFn = maybeMethod(doc, ['format', 'apply']);
-            if (Object.keys(inline).length > 0 && formatFn) {
+            if (formatFn) {
+                const applied = [];
+                let redundantLayers = 0;
+                const applyRange = async (blockId, start, end, inline) => {
+                    if (Object.keys(inline).length === 0 || end <= start)
+                        return;
+                    // Styling runs DIRECT even in tracked mode: these ranges only ever
+                    // target items created in THIS call, whose tracked insertion already
+                    // owns their accept/reject fate. Tracked format.apply DOES land the
+                    // styling, but stacks an rPrChange revision on top of the insertion,
+                    // so the reviewer sees a redundant "formatting changed" card.
+                    const params = { blockId, start, end, inline };
+                    try {
+                        await formatFn(params);
+                        applied.push({ range: [start, end], inline });
+                    }
+                    catch (err) {
+                        // The layers deliberately overlap, so a later layer often requests
+                        // formatting a new item ALREADY has (it inherits the anchor's look
+                        // on creation) — format.apply rejects that with NO_OP. A redundant
+                        // layer means "nothing left to do here", never "stop styling": each
+                        // layer must be isolated, or one NO_OP cancels every layer after it
+                        // and the agent's explicit per-run marks silently vanish.
+                        if (!isNoOp(err))
+                            throw err;
+                        redundantLayers += 1;
+                    }
+                };
                 for (const ci of createdItems) {
-                    const row = afterRows.find((r) => r.nodeId === ci.nodeId);
-                    const len = (row?.textPreview ?? ci.text ?? '').length;
-                    const params = {
-                        blockId: ci.nodeId,
-                        start: 0,
-                        end: Math.max(len, 1),
-                        inline,
-                    };
-                    // Mirror scoped delete_text/format_text: changeMode is a MutationOption
-                    // passed inside the format.apply params, only when tracking is on.
-                    if (args.changeMode === 'tracked')
-                        params.changeMode = args.changeMode;
-                    await formatFn(params);
+                    const len = Math.max(ci.text.length, 1);
+                    // An item the agent styled itself is left alone by layers 1–2: its
+                    // marks describe the whole intent, and sampling would fight them.
+                    const unstyled = ci.itemMarks == null && !ci.runs.some((r) => r.marks);
+                    const source = unstyled ? lookSourceFor(ci.targetLevel) : undefined;
+                    const sourceText = source?.nodeId ? fullTextById.get(source.nodeId) : undefined;
+                    const pattern = source?.nodeId && sourceText ? await listItemRunPattern(doc, sourceText, source.nodeId) : null;
+                    // 1. sampled base over the whole item (row fields first, run-level
+                    //    sample second: the row read omits run styling entirely).
+                    const destinationBase = source ? inlineLookFromRow(source) : anchorBase;
+                    const merged = { ...destinationBase, ...pattern?.body };
+                    reportedBase = reportedBase ?? merged;
+                    await applyRange(ci.nodeId, 0, len, merged);
+                    // 2. the siblings' label look over this item's own label span
+                    if (pattern?.lead) {
+                        const span = leadInSpanOf(ci.text, pattern.lead.shape);
+                        if (span) {
+                            await applyRange(ci.nodeId, span.start, span.end, pattern.lead.look);
+                            leadInMatched += 1;
+                        }
+                    }
+                    // 3. whole-item marks
+                    await applyRange(ci.nodeId, 0, len, marksToInline(ci.itemMarks));
+                    // 4. per-run marks over each run's char range, each relative to the
+                    //    baseline layers 1–3 established, so an unmarked run reads plain
+                    //    instead of keeping emphasis it inherited.
+                    const runBaseline = { ...merged, ...marksToInline(ci.itemMarks) };
+                    // Only an EXPLICIT pattern clears inherited marks. A plain item is
+                    // stored as one synthesized, unmarked run — clearing there would undo
+                    // the very look layer 1 just sampled from the sibling.
+                    const explicitRunPattern = ci.runs.length > 1 || ci.runs.some((r) => r.marks != null);
+                    let offset = 0;
+                    for (const run of ci.runs) {
+                        const runLen = run.text.length;
+                        const runInline = explicitRunPattern
+                            ? runInlineAgainstBaseline(run.marks, runBaseline)
+                            : marksToInline(run.marks);
+                        if (Object.keys(runInline).length > 0)
+                            await applyRange(ci.nodeId, offset, offset + runLen, runInline);
+                        offset += runLen;
+                    }
                 }
-                formattingMatched = inline;
+                formattingMatched =
+                    applied.length > 0
+                        ? {
+                            base: reportedBase ?? {},
+                            layers: applied.length,
+                            ...(leadInMatched > 0 ? { leadInMatched } : {}),
+                            ...(redundantLayers > 0 ? { alreadyMatched: redundantLayers } : {}),
+                        }
+                        : { skipped: 'no formatting applied' };
             }
         }
         catch (err) {
-            formattingMatched = { skipped: err instanceof Error ? err.message : String(err) };
-        }
+            formattingMatched = { skipped: reasonOf(err) };
+        }
+        // Word paints the LIST NUMBER from the paragraph mark's run properties
+        // (w:pPr/w:rPr), not from the item's text runs — so an item whose text is
+        // styled correctly still shows a default-black "4." next to bold blue
+        // "1./2./3." siblings. Mirror the item's leading run onto the mark, which
+        // is the relationship those siblings already encode. Best-effort and never
+        // fatal: the item and its text styling have already landed.
+        let markStyledItems = 0;
+        const markerSkipped = await bestEffort(async () => {
+            const setMarkFn = maybeMethod(doc, ['format', 'paragraph', 'setMarkRunProps']);
+            const getNodeFn = maybeMethod(doc, ['getNodeById']);
+            if (!setMarkFn)
+                return;
+            for (const ci of createdItems) {
+                // Explicit marks describe the intent — the whole-item ones AND the
+                // leading run's, merged in that order, so a marker never loses the
+                // item's colour just because the first run also asked for bold.
+                //
+                // With no marks at all, COPY the sibling's own paragraph mark instead of
+                // deriving one from the text runs: a marker must not gain bold its
+                // siblings' markers don't have (bullet lists routinely carry a bare mark
+                // next to bold-lead-in text), and must gain it where they do. A
+                // same-level add already inherits the anchor's mark on creation; this
+                // covers the level-CHANGING add, whose inherited mark came from the
+                // wrong level. Reads nothing today: `getNodeById` reports
+                // indent/alignment/spacing but not `markRunProps`, so an unstyled
+                // promotion keeps the plain marker until that read lands.
+                let markProps = markRunPropsFromMarks({ ...ci.itemMarks, ...ci.runs[0]?.marks });
+                if (!markProps && getNodeFn) {
+                    const source = lookSourceFor(ci.targetLevel);
+                    if (source?.nodeId)
+                        markProps = paragraphMarkRunPropsOf(await getNodeFn({ id: source.nodeId }));
+                }
+                if (!markProps)
+                    continue;
+                await setMarkFn({
+                    target: { kind: 'block', nodeType: 'paragraph', nodeId: ci.nodeId },
+                    markRunProps: markProps,
+                });
+                markStyledItems += 1;
+            }
+        });
         const postIdentity = await readDocumentIdentity(doc);
         const verification = [revisionVerification(pre.revision, postIdentity.revision, true)];
         return {
             status: verification.every((v) => v.passed) ? 'ok' : 'failed',
             intent: `add_list_items: ${args.entries.length} into list @ ${anchor.nodeId}`,
+            ...(styledItems.length ? { styleMatched: styledItems.map((i) => i.styleId ?? '(none)') } : {}),
+            ...(styleSkipped ? { styleSkipped } : {}),
+            ...(indentedItems.length ? { indentMatchedFrom: indentedItems.map((i) => i.from) } : {}),
+            ...(indentSkipped ? { indentSkipped } : {}),
+            ...(markStyledItems > 0 ? { markerStyled: markStyledItems } : {}),
+            ...(markerSkipped ? { markerSkipped } : {}),
             ...(landed.length
                 ? {
                     note: `landed at ${landed
-                        .map((l) => (l.marker ? `${l.marker} (level ${l.level})` : `level ${l.level}`))
-                        .join(', ')}`,
+                        .map((l) => {
+                        const pos = l.marker ? `${l.marker} (level ${l.level})` : `level ${l.level}`;
+                        const between = l.previousBlock || l.nextBlock
+                            ? ` between ${JSON.stringify(l.previousBlock ?? '(list start)')} and ${JSON.stringify(l.nextBlock ?? '(list end)')}`
+                            : '';
+                        return pos + between;
+                    })
+                        .join(', ')}${landed.every((l) => l.verified)
+                        ? ' — placement is verified; re-inspect only if this looks wrong'
+                        : ' — read-back incomplete; verify with a NARROW inspect window around the anchor'}`,
                     addedItems: landed,
                 }
                 : {}),
             formattingMatched,
             preSnapshot: { revision: pre.revision, counts: pre.counts },
             postSnapshot: postIdentity,
-            selectedTargets: [{ selector: { kind: 'textSearch', terms: [needle] }, matched: [anchor.nodeId] }],
+            selectedTargets: [
+                { selector: { kind: 'textSearch', terms: [needle ?? anchor.textPreview ?? ''] }, matched: [anchor.nodeId] },
+            ],
             executedOperations: executed,
             verification,
         };
@@ -1681,6 +2298,13 @@ async function runCreateTable(doc, args) {
                     rationale: `Populated ${appliedCells.length} table cells.`,
                 });
             }
+            const styledCount = await styleTableCells(doc, appliedCells, args.changeMode);
+            if (styledCount > 0) {
+                executedOperations.push({
+                    operationId: 'doc.format.apply',
+                    rationale: `Styled ${styledCount} table cell(s).`,
+                });
+            }
         }
         const post = await buildDocumentSnapshot(doc);
         const verification = evaluateChecks(pre, post, [
@@ -1852,7 +2476,7 @@ async function runResolveComments(doc, args) {
                 result = await patchFn({ commentId: c.id, status: newStatus });
             }
             catch (e) {
-                const msg = e instanceof Error ? e.message : String(e);
+                const msg = reasonOf(e);
                 if (/unknown field|commentId/i.test(msg)) {
                     result = await patchFn({ id: c.id, status: newStatus });
                 }
@@ -1964,6 +2588,11 @@ async function runRewriteBlock(doc, args) {
             return failedReceipt('rewrite_block', new Error('selector did not resolve to a body block'), pre);
         }
         const normalizedText = normalizeTitleLikeRewriteText(target.text, args.text);
+        // The engine rewrites the whole block as ONE uniform run — losing an
+        // intra-paragraph pattern (bold "(n)" lead-in), or smearing the first
+        // run's marks across the entire text. Capture the current run layout so
+        // it can be re-applied over the unchanged prefix/suffix afterward.
+        const preRuns = await captureBlockRuns(doc, target.nodeId, target.text);
         const steps = [
             {
                 id: 'rewrite-block-1',
@@ -1976,6 +2605,7 @@ async function runRewriteBlock(doc, args) {
             },
         ];
         const result = await executeMutations(doc, steps, args.changeMode);
+        const preservation = await preserveRunPatternAfterRewrite(doc, target.nodeId, target.text, preRuns, normalizedText);
         const post = await buildDocumentSnapshot(doc);
         const rewrittenBlock = findSnapshotTextByNodeId(post, target.nodeId);
         const verification = [
@@ -1993,7 +2623,10 @@ async function runRewriteBlock(doc, args) {
             preSnapshot: { revision: pre.revision, counts: pre.counts },
             postSnapshot: { revision: post.revision, counts: post.counts },
             selectedTargets: [{ selector: args.selector, matched: [target.nodeId] }],
-            executedOperations: [{ operationId: 'doc.mutations.apply', result }],
+            executedOperations: [
+                { operationId: 'doc.mutations.apply', result },
+                ...(preservation ? [{ operationId: 'doc.format.apply', result: preservation }] : []),
+            ],
             verification,
             errors: changed && rewritten
                 ? undefined
@@ -2011,6 +2644,238 @@ async function runRewriteBlock(doc, args) {
         return failedReceipt('rewrite_block', err, pre);
     }
 }
+const RUN_BOOL_MARKS = ['bold', 'italic', 'underline', 'strike'];
+/**
+ * The format.apply inline bag reproducing a SnapshotRun's marks. Boolean marks
+ * listed in `normalize` are always emitted (true OR explicit false) so ranges
+ * that were plain actively CLEAR a mark the engine smeared across the block.
+ */
+function inlineFromSnapshotRun(run, normalize) {
+    const inline = {};
+    for (const key of RUN_BOOL_MARKS) {
+        if (run[key])
+            inline[key] = true;
+        else if (normalize.has(key))
+            inline[key] = false;
+    }
+    if (run.fontFamily)
+        inline.fontFamily = run.fontFamily;
+    if (run.fontSize)
+        inline.fontSize = run.fontSize;
+    if (run.color)
+        inline.color = run.color;
+    return inline;
+}
+/**
+ * format.apply that tolerates the engine's "produced no change" rejection —
+ * for these restore/pattern passes a no-op range (marks already in the
+ * requested state) is success, and throwing would abandon the REMAINING
+ * ranges of the pass.
+ */
+async function applyInlineQuiet(formatFn, params) {
+    try {
+        await formatFn(params);
+        return true;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err?.message ?? err);
+        if (/produced no change/i.test(message))
+            return false;
+        throw err;
+    }
+}
+/** Best-effort read of a block's current run layout (null when unavailable). */
+async function captureBlockRuns(doc, nodeId, text) {
+    const queryFn = maybeMethod(doc, ['query', 'match']);
+    const trimmed = text.trim();
+    if (!queryFn || !trimmed || text.includes('\n'))
+        return null;
+    try {
+        const runs = await matchRunsForBlock(queryFn, trimmed, nodeId);
+        return runs.length > 0 ? runs : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Re-apply a block's pre-rewrite run pattern after a whole-block text.rewrite.
+ * The engine renders the rewritten block as a single uniform run, which both
+ * drops intra-paragraph formatting AND can smear the first run's marks over
+ * everything. Marks are restored positionally over the parts of the text the
+ * rewrite did NOT change (the common prefix and suffix of old vs new text),
+ * and the changed middle takes the marks of the run it continues from —
+ * Word's "typing continues formatting" rule. Best-effort: never fails the
+ * rewrite.
+ */
+/**
+ * Span-aware run-pattern restore for scoped replaces. The generic
+ * preserveRunPatternAfterRewrite diffs prefix/suffix and treats everything
+ * between the FIRST and LAST change as one modified middle — with two
+ * separated replacements that flattens independently-styled runs between
+ * them. Here the exact spans are known, so every untouched interval keeps its
+ * original run formatting at the offset-mapped position, and each replacement
+ * inherits the marks of the run it starts in.
+ * `spans` are FULL-TEXT coordinates, ascending, non-overlapping.
+ */
+async function preserveScopedRunPattern(doc, nodeId, oldText, oldRuns, spans) {
+    if (!oldRuns || oldRuns.length === 0 || spans.length === 0)
+        return null;
+    if (!oldRuns.some((run) => Object.keys(inlineFromSnapshotRun(run, new Set())).length > 0))
+        return null;
+    const formatFn = maybeMethod(doc, ['format', 'apply']);
+    if (!formatFn)
+        return null;
+    const normalize = new Set(RUN_BOOL_MARKS.filter((key) => oldRuns.some((run) => run[key])));
+    // Run offsets (captureBlockRuns) are relative to the TRIMMED text; spans are
+    // full-text. Convert spans to trimmed coordinates and clamp.
+    const oldTrimStart = oldText.length - oldText.trimStart().length;
+    const oldTrimLen = oldText.trim().length;
+    const trimSpans = spans
+        .map((s) => ({
+        start: Math.max(0, s.start - oldTrimStart),
+        end: Math.min(oldTrimLen, s.end - oldTrimStart),
+        replaceLen: (s.replace ?? '').length,
+    }))
+        .filter((s) => s.end > s.start || s.replaceLen > 0);
+    if (trimSpans.length === 0)
+        return null;
+    const newText = spans.reduceRight((text, span) => text.slice(0, span.start) + span.replace + text.slice(span.end), oldText);
+    const newTrimStart = newText.length - newText.trimStart().length;
+    // Cumulative old→new offset shift for positions AT OR AFTER a given old offset.
+    const deltaBefore = (oldPos) => {
+        let d = 0;
+        for (const s of trimSpans) {
+            if (s.end <= oldPos)
+                d += s.replaceLen - (s.end - s.start);
+            else
+                break;
+        }
+        return d;
+    };
+    let applied = 0;
+    const applyRange = async (start, end, inline) => {
+        if (end <= start || Object.keys(inline).length === 0)
+            return;
+        // Always direct, even under tracked mode. This pass RESTORES the marks the
+        // rewrite flattened; it is not new authorial formatting, and the text
+        // revision already owns the span's accept/reject fate. Applying it tracked
+        // adds a second reviewable change per rewrite (SD-4309's conformance matrix
+        // counts one per action), and rejecting that change alone would strand the
+        // text in the flattened look the rewrite produced.
+        const changed = await applyInlineQuiet(formatFn, {
+            blockId: nodeId,
+            start: newTrimStart + start,
+            end: newTrimStart + end,
+            inline,
+        });
+        if (changed)
+            applied += 1;
+    };
+    try {
+        // Untouched intervals between/around the spans, in old trimmed coords.
+        const intervals = [];
+        let cursor = 0;
+        for (const s of trimSpans) {
+            if (s.start > cursor)
+                intervals.push({ start: cursor, end: s.start });
+            cursor = Math.max(cursor, s.end);
+        }
+        if (cursor < oldTrimLen)
+            intervals.push({ start: cursor, end: oldTrimLen });
+        for (const run of oldRuns) {
+            const inline = inlineFromSnapshotRun(run, normalize);
+            for (const iv of intervals) {
+                const a = Math.max(run.start, iv.start);
+                const b = Math.min(run.end, iv.end);
+                if (b <= a)
+                    continue;
+                const d = deltaBefore(a); // constant across an untouched interval
+                await applyRange(a + d, b + d, inline);
+            }
+        }
+        // Each replacement span inherits the marks of the run it starts in.
+        for (const s of trimSpans) {
+            if (s.replaceLen === 0)
+                continue;
+            const anchorRun = oldRuns.find((run) => s.start >= run.start && s.start < run.end) ?? oldRuns[oldRuns.length - 1];
+            const newStart = s.start + deltaBefore(s.start);
+            await applyRange(newStart, newStart + s.replaceLen, inlineFromSnapshotRun(anchorRun, normalize));
+        }
+        return applied > 0 ? { restoredRunRanges: applied } : null;
+    }
+    catch (err) {
+        return { skipped: reasonOf(err) };
+    }
+}
+async function preserveRunPatternAfterRewrite(doc, nodeId, oldText, oldRuns, newText) {
+    // Nothing to restore when the block was uniformly plain; a single STYLED run
+    // still needs restoring (whole-block replaces drop even uniform marks).
+    if (!oldRuns || oldRuns.length === 0)
+        return null;
+    if (!oldRuns.some((run) => Object.keys(inlineFromSnapshotRun(run, new Set())).length > 0))
+        return null;
+    const formatFn = maybeMethod(doc, ['format', 'apply']);
+    if (!formatFn)
+        return null;
+    // Boolean marks any old run carried: plain ranges must explicitly clear
+    // these, because the rewritten single run may have smeared them everywhere.
+    const normalize = new Set(RUN_BOOL_MARKS.filter((key) => oldRuns.some((run) => run[key])));
+    // query.match run offsets are relative to the trimmed text used to match.
+    const oldTrim = oldText.trim();
+    const newTrimStart = newText.length - newText.trimStart().length;
+    const newTrim = newText.trim();
+    let prefix = 0;
+    const maxCommon = Math.min(oldTrim.length, newTrim.length);
+    while (prefix < maxCommon && oldTrim[prefix] === newTrim[prefix])
+        prefix += 1;
+    let suffix = 0;
+    while (suffix < maxCommon - prefix && oldTrim[oldTrim.length - 1 - suffix] === newTrim[newTrim.length - 1 - suffix])
+        suffix += 1;
+    const delta = newTrim.length - oldTrim.length;
+    let applied = 0;
+    const applyRange = async (start, end, inline) => {
+        if (end <= start || Object.keys(inline).length === 0)
+            return;
+        // Always direct, even under tracked mode. This pass RESTORES the marks the
+        // rewrite flattened; it is not new authorial formatting, and the text
+        // revision already owns the span's accept/reject fate. Applying it tracked
+        // adds a second reviewable change per rewrite (SD-4309's conformance matrix
+        // counts one per action), and rejecting that change alone would strand the
+        // text in the flattened look the rewrite produced.
+        const changed = await applyInlineQuiet(formatFn, {
+            blockId: nodeId,
+            start: newTrimStart + start,
+            end: newTrimStart + end,
+            inline,
+        });
+        if (changed)
+            applied += 1;
+    };
+    try {
+        for (const run of oldRuns) {
+            const inline = inlineFromSnapshotRun(run, normalize);
+            // Portion of the run inside the unchanged prefix.
+            await applyRange(run.start, Math.min(run.end, prefix), inline);
+            // Portion inside the unchanged suffix, shifted by the length delta.
+            const sufStart = Math.max(run.start, oldTrim.length - suffix);
+            if (run.end > sufStart)
+                await applyRange(sufStart + delta, run.end + delta, inline);
+        }
+        // The CHANGED middle keeps whatever the engine smeared; give it the marks
+        // of the run the change continues from (the one containing the last
+        // unchanged prefix character).
+        const middleEnd = newTrim.length - suffix;
+        if (middleEnd > prefix) {
+            const anchorRun = oldRuns.find((run) => prefix > run.start && prefix <= run.end) ?? oldRuns[oldRuns.length - 1];
+            await applyRange(prefix, middleEnd, inlineFromSnapshotRun(anchorRun, normalize));
+        }
+        return applied > 0 ? { restoredRunRanges: applied } : null;
+    }
+    catch (err) {
+        return { skipped: reasonOf(err) };
+    }
+}
 const NAMED_COLORS = {
     black: '000000',
     blue: '0000FF',
@@ -3351,7 +4216,7 @@ async function runInsertTableRow(doc, args) {
         ];
         if (args.dryRun !== true && args.cellTexts && args.cellTexts.length > 0) {
             const insertedRowIndex = position === 'below' ? rowIndex + 1 : rowIndex;
-            const cells = args.cellTexts.map((text, columnIndex) => ({ rowIndex: insertedRowIndex, columnIndex, text }));
+            const cells = args.cellTexts.map((cell, columnIndex) => cellTextFromSpec(cell, insertedRowIndex, columnIndex));
             const applied = await applyTableCellTexts(doc, table.nodeId, table.ordinal, cells, args.changeMode);
             if (applied.length > 0) {
                 executed.push({
@@ -3359,6 +4224,28 @@ async function runInsertTableRow(doc, args) {
                     rationale: `Populated ${applied.length} cell(s) in new row`,
                 });
             }
+            // Inherit the neighbouring row's look BEFORE explicit styling, so an
+            // agent-supplied mark still overrides it (same layering as list items).
+            // The neighbour is the TARGET row at its post-insert index: inserting
+            // above shifts it down by one, and sampling `rowIndex` there would read
+            // the new (still unstyled) row itself and copy nothing.
+            const neighbourRowIndex = position === 'above' ? rowIndex + 1 : rowIndex;
+            const match = await matchTableCellsToNeighbour(doc, table.ordinal, applied, (cell) => ({
+                rowIndex: neighbourRowIndex,
+                columnIndex: cell.columnIndex,
+            }));
+            if (match.matched > 0 || match.skipped) {
+                executed.push({
+                    operationId: 'doc.format.apply',
+                    rationale: match.skipped
+                        ? `Matched ${match.matched} cell(s) to row ${neighbourRowIndex}; skipped: ${match.skipped}`
+                        : `Matched ${match.matched} cell(s) to row ${neighbourRowIndex}`,
+                });
+            }
+            const styledCount = await styleTableCells(doc, applied, args.changeMode);
+            if (styledCount > 0) {
+                executed.push({ operationId: 'doc.format.apply', rationale: `Styled ${styledCount} cell(s) in new row` });
+            }
         }
         const postIdentity = await readDocumentIdentity(doc);
         const postTable = await getTableShape(doc, table.nodeId);
@@ -3421,11 +4308,45 @@ async function runInsertTableColumn(doc, args) {
         const executed = [
             { operationId: 'doc.tables.insertColumn', result: insertResult },
         ];
-        if (args.headerText) {
-            const headerColumnIndex = position === 'right' ? columnIndex + 1 : columnIndex;
-            const applied = await applyTableCellTexts(doc, table.nodeId, table.ordinal, [{ rowIndex: 0, columnIndex: headerColumnIndex, text: args.headerText }], args.changeMode);
+        const newColumnIndex = position === 'right' ? columnIndex + 1 : columnIndex;
+        // Per-row styled cells for the new column, or a single (optionally styled)
+        // header cell at row 0.
+        let columnCells = [];
+        if (args.cellTexts && args.cellTexts.length > 0) {
+            columnCells = args.cellTexts.map((cell, rowIndex) => cellTextFromSpec(cell, rowIndex, newColumnIndex));
+        }
+        else if (args.headerText) {
+            columnCells = [{ rowIndex: 0, columnIndex: newColumnIndex, text: args.headerText }];
+        }
+        if (columnCells.length > 0) {
+            // forceDirectFill: a new column's cells live in pre-existing rows, which
+            // carry no tracked-insertion marker, so a tracked fill fails closed.
+            const applied = await applyTableCellTexts(doc, table.nodeId, table.ordinal, columnCells, args.changeMode, true);
             if (applied.length > 0) {
-                executed.push({ operationId: 'doc.mutations.apply', rationale: 'Populated header cell' });
+                executed.push({
+                    operationId: 'doc.mutations.apply',
+                    rationale: `Populated ${applied.length} cell(s) in new column`,
+                });
+            }
+            // Inherit the ADJACENT COLUMN's look per row before explicit styling, so a
+            // header cell stays a header cell: a new column's cells are written into
+            // pre-existing rows and arrive with no run properties, which loses the
+            // header row's bold/colour and the body rows' face.
+            const match = await matchTableCellsToNeighbour(doc, table.ordinal, applied, (cell) => ({
+                rowIndex: cell.rowIndex,
+                columnIndex: columnIndex,
+            }));
+            if (match.matched > 0 || match.skipped) {
+                executed.push({
+                    operationId: 'doc.format.apply',
+                    rationale: match.skipped
+                        ? `Matched ${match.matched} cell(s) to column ${columnIndex}; skipped: ${match.skipped}`
+                        : `Matched ${match.matched} cell(s) to column ${columnIndex}`,
+                });
+            }
+            const styledCount = await styleTableCells(doc, applied, args.changeMode);
+            if (styledCount > 0) {
+                executed.push({ operationId: 'doc.format.apply', rationale: `Styled ${styledCount} cell(s) in new column` });
             }
         }
         const postIdentity = await readDocumentIdentity(doc);
@@ -3759,24 +4680,70 @@ async function runScopedReplace(doc, args) {
         planned.push(span);
         lastEnd = span.end;
     }
-    const steps = planned.map((span, index) => ({
-        id: `scoped-replace-${index + 1}`,
-        op: 'text.rewrite',
-        where: {
-            by: 'target',
-            target: {
-                kind: 'selection',
-                start: { kind: 'text', blockId: nodeId, offset: span.start },
-                end: { kind: 'text', blockId: nodeId, offset: span.end },
+    // The v2 engine resolves `where` by block/select/ref only — a
+    // selection-targeted step ("by: 'target'") dies in resolveStepRef with
+    // "requires a ref produced by query.match/find".
+    const expected = planned.reduceRight((text, span) => text.slice(0, span.start) + span.replace + text.slice(span.end), block.text);
+    const tracked = (args.changeMode ?? 'direct') === 'tracked';
+    // Tracked mode: redline ONLY the spans. A whole-block rewrite in tracked
+    // mode records the entire paragraph as deleted+reinserted, which buries a
+    // one-word edit in a full-paragraph redline. Each span becomes a
+    // select-scoped rewrite pinned to this block via `within`; duplicate find
+    // strings would re-resolve ambiguously against tracked-visible deleted
+    // text, so those fall back to the whole-block path below.
+    let result = null;
+    // Dedupe on the same basis the selector will match on: under a
+    // case-sensitive request `Foo` and `foo` are distinct targets, and folding
+    // them together would push a legitimately unique pair onto the fallback.
+    const uniqueFinds = new Set(planned.map((s) => (caseSensitive ? s.find : s.find.toLowerCase())));
+    if (tracked && uniqueFinds.size === planned.length) {
+        const spanSteps = planned.map((span, index) => ({
+            id: `scoped-replace-${index + 1}`,
+            op: 'text.rewrite',
+            where: {
+                by: 'select',
+                // The planner honours caseSensitive, so the selector must match on the
+                // same terms. Without it a case-sensitive request can redline a
+                // differently cased occurrence and still verify, because verification
+                // only looks for the replacement text somewhere in the block.
+                select: { type: 'text', pattern: span.find, mode: 'contains', caseSensitive },
+                require: 'first',
+                within: { kind: 'block', nodeType: block.nodeType, nodeId },
             },
-        },
-        args: { replacement: { text: span.replace } },
-    }));
-    const result = await executeMutations(doc, steps, args.changeMode);
+            args: { replacement: { text: span.replace } },
+        }));
+        // Select rewrites flatten the block's runs, so the tracked lane needs the
+        // same restoration the whole-block lane below performs. The preserve pass
+        // applies directly, so restoring marks adds no second reviewable change.
+        const trackedPreRuns = await captureBlockRuns(doc, nodeId, block.text);
+        try {
+            result = await executeMutations(doc, spanSteps, args.changeMode);
+            if (result != null)
+                await preserveScopedRunPattern(doc, nodeId, block.text, trackedPreRuns, planned);
+        }
+        catch {
+            result = null; // select lane unavailable (e.g. case mismatch) — fall back
+        }
+    }
+    if (result == null) {
+        // Direct mode (or tracked fallback): rewrite the whole block once, then
+        // restore the intra-paragraph run pattern span-aware — every interval the
+        // spans did NOT touch keeps its original run formatting at the mapped
+        // offsets, and each replacement inherits the marks of the run it starts in.
+        const preRuns = await captureBlockRuns(doc, nodeId, block.text);
+        const steps = [
+            {
+                id: 'scoped-replace-1',
+                op: 'text.rewrite',
+                where: { by: 'block', nodeType: block.nodeType, nodeId },
+                args: { replacement: { text: expected }, style: preserveRewriteStyle() },
+            },
+        ];
+        result = await executeMutations(doc, steps, args.changeMode);
+        await preserveScopedRunPattern(doc, nodeId, block.text, preRuns, planned);
+    }
     const post = await buildDocumentSnapshot(doc, { includeDomains: ['blocks', 'tables'] });
     const postBlock = findTextTarget(post, nodeId);
-    const expected = planned.reduceRight((text, span) => text.slice(0, span.start) + span.replace + text.slice(span.end), block.text);
-    const tracked = (args.changeMode ?? 'direct') === 'tracked';
     // In tracked mode the deleted text is still present in the block, so only
     // require the inserted text to be visible.
     const passed = postBlock != null &&
@@ -3820,6 +4787,301 @@ async function runScopedReplace(doc, args) {
  * so both copy the SAME set of run properties in one place. Only emits keys the
  * row actually carries — an empty result means "nothing to match".
  */
+/** Points → twips: the node read side reports points, mutations take twips. */
+const TWIPS_PER_POINT = 20;
+/**
+ * Build `format.paragraph.setMarkRunProps` input from agent run marks.
+ *
+ * The mark's colour is a discriminated model object, not the plain hex string
+ * `format.apply` takes, and the hex is stored without the leading `#`.
+ * Returns null when the marks say nothing about the mark's appearance.
+ */
+function markRunPropsFromMarks(marks) {
+    if (!marks)
+        return null;
+    const props = {};
+    if (typeof marks.bold === 'boolean')
+        props.bold = marks.bold;
+    if (typeof marks.italic === 'boolean')
+        props.italic = marks.italic;
+    if (typeof marks.fontFamily === 'string' && marks.fontFamily)
+        props.fontFamily = marks.fontFamily;
+    if (typeof marks.fontSize === 'number' && Number.isFinite(marks.fontSize))
+        props.fontSize = marks.fontSize;
+    if (typeof marks.color === 'string' && marks.color) {
+        props.color = { model: 'rgb', value: marks.color.replace(/^#/, '') };
+    }
+    return Object.keys(props).length > 0 ? props : null;
+}
+/**
+ * Pull a paragraph's MARK run properties (`w:pPr/w:rPr`) out of a `getNodeById`
+ * payload, ready to hand straight back to `format.paragraph.setMarkRunProps`
+ * (same internal shape, so the values round-trip). Node-shape tolerant like
+ * paragraphIndentOf. Returns null when the paragraph mark carries nothing.
+ */
+function paragraphMarkRunPropsOf(payload) {
+    const node = isRecord(payload) ? payload.node : null;
+    if (!isRecord(node))
+        return null;
+    const candidates = [isRecord(node.paragraph) ? node.paragraph.props : null, node.props];
+    for (const props of candidates) {
+        const mark = isRecord(props) ? props.markRunProps : null;
+        if (isRecord(mark) && Object.keys(mark).length > 0)
+            return mark;
+    }
+    return null;
+}
+/**
+ * Delimiters that separate a list item's lead-in label from its body text.
+ * Spaced dashes are listed separately from bare ones because the label run
+ * usually stops BEFORE the space ("JavaScript / TypeScript" + " — SuperDoc…").
+ */
+/**
+ * How many blocks the per-block replace lane will capture runs for. Each target
+ * costs a `query.match` read, so the lane is bounded; edits reaching past it
+ * fall through to the select lane rather than being silently truncated.
+ */
+const PRESERVE_TARGET_CAP = 20;
+const LEAD_IN_DELIMITERS = [':', ' — ', ' – ', ' - ', '—', '–'];
+/** A lead-in is a LABEL, not a sentence — longer spans are prose, not a pattern. */
+const LEAD_IN_MAX_CHARS = 90;
+/** Sentence characters sampled past the label, to read the body's own look. */
+const LEAD_IN_BODY_SAMPLE_CHARS = 40;
+/**
+ * Where an item's lead-in label ends.
+ *
+ * The SIBLINGS' delimiter wins whenever the item uses it: with a dash-style
+ * list, "Rust: Advanced — details" splits at the dash, not at the colon inside
+ * the label. Falling back to the earliest known delimiter is only for items
+ * that do not use the siblings' one at all.
+ */
+function leadInEndOf(text, preferred) {
+    const at = (delimiter) => {
+        const index = text.indexOf(delimiter);
+        return index > 0 && index <= LEAD_IN_MAX_CHARS ? index : null;
+    };
+    if (preferred) {
+        const preferredAt = at(preferred);
+        if (preferredAt != null)
+            return preferredAt;
+    }
+    const found = LEAD_IN_DELIMITERS.map(at).filter((index) => index != null);
+    return found.length > 0 ? Math.min(...found) : null;
+}
+/** Quote characters a defined term is wrapped in ("Deliverables" means …). */
+const LEAD_IN_QUOTES = ['"', '\u201c', '\u2018', "'"];
+/**
+ * Delimiters allowed to sit INSIDE the label run. Wider than the set used to
+ * split at a delimiter that follows the label, because a sentence period only
+ * counts as a label boundary when the reference's own emphasised run ends with
+ * it — "1.7. Records. " — which is evidence no bare text scan can provide.
+ */
+const LEAD_IN_TAIL_DELIMITERS = ['. ', ': ', ...LEAD_IN_DELIMITERS];
+/**
+ * Read the label shape a reference block uses, from its text and its label run.
+ *
+ * The delimiter has to sit at the label's edge: immediately AFTER it ("Label:
+ * sentence"), or at its own tail ("1.7. Records. " — a numbered clause whose
+ * marker and label share one run). That adjacency is what distinguishes a label
+ * from an ordinary emphasised opening clause.
+ */
+function leadInShapeOf(blockText, labelText, quote) {
+    if (quote)
+        return { kind: 'quoted', quote };
+    const after = LEAD_IN_DELIMITERS.find((d) => blockText.startsWith(d, labelText.length));
+    if (after)
+        return { kind: 'before', delimiter: after };
+    const trimmed = labelText.trimEnd();
+    const inside = LEAD_IN_TAIL_DELIMITERS.find((d) => trimmed.endsWith(d.trimEnd()) && trimmed.length > d.trimEnd().length);
+    if (inside) {
+        const occurrence = labelText.split(inside).length - 1;
+        if (occurrence > 0)
+            return { kind: 'inside', delimiter: inside, occurrence };
+    }
+    return null;
+}
+/** The span of `text` that carries the label look, or null when it has none. */
+function leadInSpanOf(text, shape) {
+    if (shape.kind === 'quoted') {
+        const opener = text.slice(0, 2).indexOf(shape.quote);
+        if (opener < 0)
+            return null;
+        const close = text.indexOf(shape.quote, opener + 1);
+        if (close < 0 || close - opener - 1 <= 0 || close > LEAD_IN_MAX_CHARS)
+            return null;
+        return { start: opener + 1, end: close };
+    }
+    if (shape.kind === 'inside') {
+        // Mirror the reference's STRUCTURE: "1.7. Records. " ends at its second
+        // ". ", so "1.8. Review. The parties…" must end at its second one too —
+        // stopping at the first would emphasise the number alone.
+        let at = -1;
+        for (let seen = 0; seen < shape.occurrence; seen += 1) {
+            at = text.indexOf(shape.delimiter, at + 1);
+            if (at < 0)
+                return null;
+        }
+        if (at <= 0 || at > LEAD_IN_MAX_CHARS)
+            return null;
+        return { start: 0, end: at + shape.delimiter.length };
+    }
+    const end = leadInEndOf(text, shape.delimiter);
+    return end == null ? null : { start: 0, end };
+}
+/**
+ * Cut `text` at `end` without splitting a surrogate pair: half an emoji is not
+ * document text, and `query.match` finds nothing when handed a lone surrogate —
+ * which reads as "the siblings have no pattern" and drops the styling.
+ */
+function sliceWholeChars(text, end) {
+    if (end >= text.length)
+        return text;
+    const code = text.charCodeAt(end - 1);
+    const splitsPair = code >= 0xd800 && code <= 0xdbff;
+    return text.slice(0, splitsPair ? end - 1 : end);
+}
+function matchRunStyle(run) {
+    const styles = asRecord(asRecord(run)?.styles);
+    const effective = asRecord(styles?.effective);
+    const sizePt = asNumber(styles?.fontSizePt);
+    const fontFamily = asString(styles?.fontFamily);
+    const color = asString(styles?.color);
+    return {
+        bold: effective?.bold === true,
+        italic: effective?.italic === true,
+        ...(sizePt != null && Number.isFinite(sizePt) ? { fontSize: sizePt } : {}),
+        ...(fontFamily ? { fontFamily } : {}),
+        ...(color ? { color } : {}),
+    };
+}
+/**
+ * A sampled style as a `format.apply` `inline` payload.
+ *
+ * A toggle that is OFF is dropped rather than sent as an explicit `false`: new
+ * text starts unformatted, so "not bold" needs no write — and writing it would
+ * stamp an explicit `w:b w:val="0"` the sampled siblings themselves don't carry.
+ * The exception is a toggle that must be CLEARED because an earlier layer
+ * (`against`) turned it on.
+ */
+function inlineFromMatchStyle(style, against) {
+    const inline = {};
+    if (style.bold || against?.bold === true)
+        inline.bold = style.bold;
+    if (style.italic || against?.italic === true)
+        inline.italic = style.italic;
+    if (style.fontSize != null)
+        inline.fontSize = style.fontSize;
+    if (style.fontFamily)
+        inline.fontFamily = style.fontFamily;
+    if (style.color)
+        inline.color = style.color;
+    return inline;
+}
+/**
+ * Read an existing list item's RUN PATTERN — the body look plus the "bold
+ * label: plain sentence" lead-in convention its siblings share — through
+ * `query.match`, the only read that reports run styling.
+ *
+ * Why the pattern and not just one look: real lists carry the emphasis INSIDE
+ * the item ("Format Painter Feature Request: Joey requested…" — first run bold,
+ * rest plain). Copying a single sampled look either bolds the whole new item or
+ * none of it; both read as "the agent's item doesn't match the list".
+ *
+ * A LABEL is the first run when a delimiter sits immediately after it and its
+ * style differs from the body's; the body look then comes from the run right
+ * AFTER the label (the sentence it introduces), so neither the bold label nor a
+ * later emphasized phrase becomes the whole item's look.
+ *
+ * Only the head of the item is sampled, not all of it: run decomposition
+ * collapses to a single empty-text run once the matched range spans a
+ * HYPERLINK (these items end in "(00:31:34)" timestamp links), and a window
+ * that stops before the links keeps the label/body split readable.
+ */
+async function listItemRunPattern(doc, text, blockId) {
+    const queryFn = maybeMethod(doc, ['query', 'match']);
+    if (!queryFn || !text.trim())
+        return null;
+    // Window: through the label's delimiter plus enough of the sentence to sample
+    // it, or a plain head when the item carries no label at all.
+    const delimiterAt = leadInEndOf(text);
+    const windowEnd = delimiterAt != null ? delimiterAt + LEAD_IN_BODY_SAMPLE_CHARS : LEAD_IN_BODY_SAMPLE_CHARS;
+    const pattern = sliceWholeChars(text, windowEnd);
+    const result = asRecord(await queryFn({ select: { type: 'text', pattern } }));
+    const items = Array.isArray(result?.items) ? result.items : [];
+    for (const item of items) {
+        const blocks = Array.isArray(asRecord(item)?.blocks) ? asRecord(item).blocks : [];
+        for (const block of blocks) {
+            const rec = asRecord(block);
+            if (asString(rec?.blockId) !== blockId)
+                continue;
+            const runTextOf = (r) => asString(asRecord(r)?.text, '') ?? '';
+            const runs = (Array.isArray(rec?.runs) ? rec.runs : []).filter((r) => runTextOf(r).length > 0);
+            if (runs.length === 0)
+                continue;
+            const blockText = asString(rec?.text, '') ?? '';
+            // A quoted defined term keeps its opening quote in a run of its own —
+            // `"` + **Deliverables** + `" means …` — so the label is the SECOND run
+            // and the quotes stay unemphasised.
+            const opener = runTextOf(runs[0]).trim();
+            const quote = LEAD_IN_QUOTES.find((q) => opener === q);
+            const labelIndex = quote && runs.length > 2 ? 1 : 0;
+            const label = runs[labelIndex];
+            const labelText = runTextOf(label);
+            const leadStyle = matchRunStyle(label);
+            // A source block that is ONLY a short emphasised label (a heading-ish "LLM
+            // Integration", a signature-block name) has no body look to copy — and
+            // copying its label look over a whole new block would emphasise the
+            // entire thing. Treat it as a lead-in whose span the new text decides.
+            if (runs.length === 1) {
+                const labelOnly = labelText.length <= LEAD_IN_MAX_CHARS && (leadStyle.bold || leadStyle.italic);
+                return labelOnly
+                    ? { body: {}, lead: { look: inlineFromMatchStyle(leadStyle), shape: { kind: 'before', delimiter: null } } }
+                    : { body: inlineFromMatchStyle(leadStyle) };
+            }
+            // The body is the run the label INTRODUCES, not the longest run in the
+            // block: a later emphasised phrase is part of the prose, and sampling it
+            // would stamp its emphasis across the whole new block.
+            const bodyStyle = matchRunStyle(runs[labelIndex + 1]);
+            const differs = ['bold', 'italic', 'fontSize', 'fontFamily', 'color'].some((k) => leadStyle[k] !== bodyStyle[k]);
+            const shape = leadInShapeOf(blockText, labelText, labelIndex > 0 ? quote : undefined);
+            const isLabel = differs && shape != null && labelText.length > 0 && labelText.length <= LEAD_IN_MAX_CHARS;
+            return {
+                body: inlineFromMatchStyle(bodyStyle),
+                ...(isLabel ? { lead: { look: inlineFromMatchStyle(leadStyle, bodyStyle), shape: shape } } : {}),
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Pull a paragraph's direct indentation out of a `getNodeById` payload and
+ * convert it to the twips that `format.paragraph.setIndentation` expects.
+ *
+ * The node shape nests the properties under the block kind
+ * (`node.paragraph.props.indent`); older/other shapes put them at
+ * `node.props.indent`. Both are accepted so a shape change degrades to "no
+ * indent copied" rather than a thrown read.
+ */
+function paragraphIndentOf(payload) {
+    const node = isRecord(payload) ? payload.node : null;
+    if (!isRecord(node))
+        return null;
+    const candidates = [isRecord(node.paragraph) ? node.paragraph.props : null, node.props];
+    for (const props of candidates) {
+        const indent = isRecord(props) ? props.indent : null;
+        if (!isRecord(indent))
+            continue;
+        const twips = {};
+        for (const key of ['left', 'right', 'firstLine', 'hanging']) {
+            const value = indent[key];
+            if (typeof value === 'number' && Number.isFinite(value))
+                twips[key] = Math.round(value * TWIPS_PER_POINT);
+        }
+        if (Object.keys(twips).length > 0)
+            return twips;
+    }
+    return null;
+}
 function inlineLookFromRow(row) {
     const inline = {};
     if (row.fontFamily)
@@ -3835,6 +5097,229 @@ function inlineLookFromRow(row) {
         inline.italic = true;
     return inline;
 }
+/**
+ * Build a `doc.format.apply` `inline` payload from agent-supplied run marks.
+ * Same key set + semantics as inlineLookFromRow (so anchor auto-match and
+ * explicit per-run styling stack cleanly), plus underline/strike/highlight.
+ * Booleans are emitted whether true or false so an explicit `false` can CLEAR a
+ * mark the anchor/whole-item default set. Returns {} when nothing is requested.
+ */
+/**
+ * The inline bag for ONE run of an explicit run pattern, relative to whatever
+ * the item already carries.
+ *
+ * An inserted item inherits its neighbour's look, and the whole-item layer may
+ * add more, so a run that asks for nothing is not automatically plain: without
+ * explicit `false` values a pattern like [plain, bold] renders entirely bold
+ * when the item inherited bold. Boolean marks active in the baseline are
+ * therefore cleared on any run that does not ask for them itself.
+ */
+function runInlineAgainstBaseline(marks, baseline) {
+    const inline = marksToInline(marks);
+    for (const key of RUN_BOOL_MARKS) {
+        if (baseline[key] === true && inline[key] === undefined)
+            inline[key] = false;
+    }
+    return inline;
+}
+function marksToInline(marks) {
+    const inline = {};
+    if (!marks)
+        return inline;
+    if (typeof marks.bold === 'boolean')
+        inline.bold = marks.bold;
+    if (typeof marks.italic === 'boolean')
+        inline.italic = marks.italic;
+    if (typeof marks.underline === 'boolean')
+        inline.underline = marks.underline;
+    if (typeof marks.strikethrough === 'boolean')
+        inline.strike = marks.strikethrough;
+    if (typeof marks.fontFamily === 'string' && marks.fontFamily)
+        inline.fontFamily = marks.fontFamily;
+    if (typeof marks.fontSize === 'number' && Number.isFinite(marks.fontSize))
+        inline.fontSize = marks.fontSize;
+    if (typeof marks.color === 'string' && marks.color)
+        inline.color = marks.color;
+    if (typeof marks.highlight === 'string' && marks.highlight)
+        inline.highlight = marks.highlight;
+    return inline;
+}
+/** Parse a raw agent mark bag, keeping only recognized keys with valid types. */
+function normalizeMarks(raw) {
+    if (!isRecord(raw))
+        return undefined;
+    const m = {};
+    if (typeof raw.bold === 'boolean')
+        m.bold = raw.bold;
+    if (typeof raw.italic === 'boolean')
+        m.italic = raw.italic;
+    if (typeof raw.underline === 'boolean')
+        m.underline = raw.underline;
+    if (typeof raw.strikethrough === 'boolean')
+        m.strikethrough = raw.strikethrough;
+    if (typeof raw.fontFamily === 'string')
+        m.fontFamily = raw.fontFamily;
+    const sz = asNumber(raw.fontSize);
+    if (sz != null && Number.isFinite(sz))
+        m.fontSize = sz;
+    if (typeof raw.color === 'string')
+        m.color = raw.color;
+    if (typeof raw.highlight === 'string')
+        m.highlight = raw.highlight;
+    return Object.keys(m).length > 0 ? m : undefined;
+}
+/**
+ * Normalize one agent-supplied list item (string or object) into an
+ * AgentListItemSpec. Accepts `{ text }`, `{ runs:[{text,marks}] }`, an optional
+ * whole-item `marks`, and a relative `level`. Returns null for junk.
+ */
+function normalizeItemSpec(raw) {
+    if (typeof raw === 'string')
+        return { text: raw, level: 0 };
+    if (!isRecord(raw))
+        return null;
+    const spec = {};
+    const lvl = asNumber(raw.level);
+    spec.level = lvl != null ? Math.floor(lvl) : 0;
+    const itemMarks = normalizeMarks(raw.marks);
+    if (itemMarks)
+        spec.marks = itemMarks;
+    if (Array.isArray(raw.runs)) {
+        const runs = [];
+        for (const r of raw.runs) {
+            if (typeof r === 'string') {
+                runs.push({ text: r });
+            }
+            else if (isRecord(r) && typeof r.text === 'string') {
+                const rm = normalizeMarks(r.marks);
+                runs.push(rm ? { text: r.text, marks: rm } : { text: r.text });
+            }
+        }
+        if (runs.length > 0) {
+            spec.runs = runs;
+            return spec;
+        }
+    }
+    if (typeof raw.text === 'string') {
+        spec.text = raw.text;
+        return spec;
+    }
+    return null;
+}
+/** The plain text an item renders as (concatenated runs, or its `text`). */
+function itemSpecText(spec) {
+    if (spec.runs && spec.runs.length > 0)
+        return spec.runs.map((r) => r.text).join('');
+    return spec.text ?? '';
+}
+/**
+ * Resolve a 1-based `listOrdinal` (as reported by inspect) to the nodeId of that
+ * list's last item, so a listOrdinal-addressed add can anchor by nodeId and go
+ * through runAddListItems (which applies numbering + per-run formatting) instead
+ * of the text-only workflow path. Best-effort: undefined if it can't resolve.
+ */
+async function resolveListAnchorNodeId(doc, listOrdinal) {
+    try {
+        const snap = await buildDocumentSnapshot(doc, { includeDomains: ['lists'] });
+        const lists = Array.isArray(snap?.lists) ? snap.lists : [];
+        const items = lists[listOrdinal - 1]?.items;
+        if (!Array.isArray(items))
+            return undefined;
+        for (let i = items.length - 1; i >= 0; i -= 1) {
+            const id = items[i]?.nodeId;
+            if (typeof id === 'string' && id)
+                return id;
+        }
+    }
+    catch {
+        // best-effort — fall back to the ghost/workflow path
+    }
+    return undefined;
+}
+/**
+ * Apply whole-item + per-run marks to already-created list items, aligned by
+ * index with `specs`. Layered per item (later overrides earlier on overlapping
+ * keys): optional `baseInline` over the whole item, then the item's `marks`,
+ * then each run's `marks` over its char range. This runs as a post-insert pass
+ * (via doc.format.apply on the created nodeId), so it works no matter which
+ * insert path created the item — including the text-only list workflow, which
+ * is the only insert path some runtimes expose. Best-effort: a format failure
+ * never invalidates an otherwise-landed insert.
+ */
+async function applyItemStyling(doc, nodeIds, specs, changeMode, baseInline) {
+    const formatFn = maybeMethod(doc, ['format', 'apply']);
+    if (!formatFn)
+        return { skipped: 'format.apply unavailable' };
+    let layers = 0;
+    let redundantLayers = 0;
+    const applyRange = async (blockId, start, end, inline) => {
+        if (Object.keys(inline).length === 0 || end <= start)
+            return;
+        const params = { blockId, start, end, inline };
+        if (changeMode === 'tracked')
+            params.changeMode = changeMode;
+        try {
+            await formatFn(params);
+            layers += 1;
+        }
+        catch (err) {
+            // Inserted content often ALREADY carries part of the requested look
+            // (it inherits from its neighbour), and format.apply answers a redundant
+            // range with NO_OP. That means "nothing left to do here", never "stop
+            // styling": isolating it per range keeps later ranges — and later items —
+            // from silently losing their marks. Genuine failures still propagate.
+            if (!isNoOp(err))
+                throw err;
+            redundantLayers += 1;
+        }
+    };
+    try {
+        const seenNodeIds = new Set();
+        for (let i = 0; i < nodeIds.length; i += 1) {
+            const nodeId = nodeIds[i];
+            const spec = specs[i];
+            if (!nodeId || !spec)
+                continue;
+            // A single target should be styled once — merged table cells can resolve
+            // several requested coordinates to the same paragraph nodeId, and styling
+            // it twice would overlap/overwrite.
+            if (seenNodeIds.has(nodeId))
+                continue;
+            seenNodeIds.add(nodeId);
+            const text = itemSpecText(spec);
+            // Run offsets are block-relative to a SINGLE paragraph. A value spanning
+            // multiple paragraphs (newlines) can't be mapped to one nodeId without the
+            // ranges overflowing the block, so skip styling it (text is still applied).
+            if (text.includes('\n'))
+                continue;
+            const runs = spec.runs && spec.runs.length > 0 ? spec.runs : [{ text: spec.text ?? '' }];
+            const len = Math.max(text.length, 1);
+            if (baseInline)
+                await applyRange(nodeId, 0, len, baseInline);
+            await applyRange(nodeId, 0, len, marksToInline(spec.marks));
+            // Same baseline reasoning as the list path: an unmarked run must clear
+            // boolean marks the base/whole-item layers put underneath it.
+            const runBaseline = { ...baseInline, ...marksToInline(spec.marks) };
+            const explicitRunPattern = (spec.runs?.length ?? 0) > 1 || (spec.runs ?? []).some((r) => r.marks != null);
+            let offset = 0;
+            for (const run of runs) {
+                const runLen = run.text.length;
+                const runInline = explicitRunPattern
+                    ? runInlineAgainstBaseline(run.marks, runBaseline)
+                    : marksToInline(run.marks);
+                if (Object.keys(runInline).length > 0)
+                    await applyRange(nodeId, offset, offset + runLen, runInline);
+                offset += runLen;
+            }
+        }
+        if (layers > 0)
+            return { layers, ...(redundantLayers > 0 ? { alreadyMatched: redundantLayers } : {}) };
+        return redundantLayers > 0 ? { layers: 0, alreadyMatched: redundantLayers } : { skipped: 'no marks requested' };
+    }
+    catch (err) {
+        return { skipped: reasonOf(err) };
+    }
+}
 async function listBlockRows(doc) {
     const fn = maybeMethod(doc, ['blocks', 'list']);
     if (!fn)
@@ -3846,6 +5331,11 @@ function blockNumbering(row) {
     const numbering = row?.numbering;
     return numbering && (numbering.marker || numbering.path) ? numbering : null;
 }
+/** A list row's outline level, or null when the row carries no numbering. */
+function levelOfRow(row) {
+    const path = blockNumbering(row)?.path;
+    return Array.isArray(path) ? Math.max(0, path.length - 1) : null;
+}
 /** One real list across a contiguous paragraph range (lists.create fromParagraphs). */
 async function createListFromParagraphRange(createFn, kind, fromNodeId, toNodeId, changeMode) {
     // Dual dialect — see executeCreateParagraph: input key for the CLI
@@ -4137,7 +5627,7 @@ async function runConvertList(doc, args) {
         // level does not exist in the abstract definition"). lists.create
         // converts the paragraph range into a fresh real list instead — the
         // correct result in every one of these cases.
-        const message = error instanceof Error ? error.message : String(error);
+        const message = reasonOf(error);
         const recoverable = /numbering metadata|abstract definition|level does not exist/i.test(message);
         if (!recoverable || !createFn) {
             throw error;
@@ -4153,7 +5643,7 @@ async function runConvertList(doc, args) {
             // "Ghost" list items: listItem nodes with no numbering metadata.
             // setType/applyPreset/create all refuse them — detach to plain
             // paragraphs first (nodeIds are stable), then create the real list.
-            const second = secondError instanceof Error ? secondError.message : String(secondError);
+            const second = reasonOf(secondError);
             const detachFn = maybeMethod(doc, ['lists', 'detach']);
             if (!/already list items/i.test(second) || !detachFn) {
                 throw secondError;
@@ -4405,7 +5895,7 @@ function indentsEqual(a, b) {
     const keys = ['left', 'right', 'firstLine', 'hanging'];
     return keys.every((k) => (a?.[k] ?? 0) === (b?.[k] ?? 0));
 }
-async function matchOneBlock(doc, postBlocks, preIds, created, createdIndex, anchorRow, allowNumberingAttach, isTitle = false) {
+async function matchOneBlock(doc, postBlocks, preIds, created, createdIndex, anchorRow, allowNumberingAttach, isTitle = false, allowLeadPattern = true, createdText = '') {
     try {
         // Reference: placement anchor first, then nearest same-type sibling
         // (previous preferred), skipping empties and other fresh blocks.
@@ -4450,7 +5940,7 @@ async function matchOneBlock(doc, postBlocks, preIds, created, createdIndex, anc
                 }
                 catch (err) {
                     // style/format matching continues, but the receipt must say so
-                    applied.numberingSkipped = err instanceof Error ? err.message : String(err);
+                    applied.numberingSkipped = reasonOf(err);
                 }
             }
         }
@@ -4506,14 +5996,176 @@ async function matchOneBlock(doc, postBlocks, preIds, created, createdIndex, anc
                 applied.indent = refIndent;
             }
         }
+        // Lead-marker pattern: manually lettered/numbered sections style the
+        // marker run differently from the body ("(m) " bold, rest plain) — a
+        // per-run pattern blocks.list rows cannot express. When the reference
+        // block opens with such a styled marker and the created text opens with a
+        // similar marker token, reproduce the reference's marker/body split on the
+        // created block. Skipped when the caller supplied explicit runs/marks.
+        if (allowLeadPattern) {
+            const lead = await matchLeadMarkerPattern(doc, reference, created, createdText);
+            if (lead)
+                applied.leadMarker = lead;
+            // matchLeadMarkerPattern only knows a shared literal lead ("WHEREAS") and
+            // numbered tokens ("1.", "(m)"), and it needs the reference split across
+            // two runs. Sample the reference's RUNS for everything else: a quoted
+            // defined term (`"Deliverables" means …`), a "1.7. Records. " clause whose
+            // marker and label share a run, and — the case nothing covered — a
+            // UNIFORM reference, where the whole look transfers (a bold signature-block
+            // name beside which the new one landed plain).
+            else {
+                const runPattern = await matchBlockRunPattern(doc, reference, created, createdText);
+                // Assigning `undefined` would still create the key, and an `applied` with
+                // keys reads as "this block was matched" — hiding a block that got nothing.
+                if (runPattern)
+                    applied.runPattern = runPattern;
+            }
+        }
         if (Object.keys(applied).length > 0) {
             return { matchedSibling: reference.nodeId, applied };
         }
         return null;
     }
     catch (err) {
-        return { matchedSibling: null, skipped: err instanceof Error ? err.message : String(err) };
+        return { matchedSibling: null, skipped: reasonOf(err) };
+    }
+}
+/** A lead-in marker token like "(m)", "1.", "a)", "(iv)" at the start of clause text. */
+const LEAD_MARKER_PATTERN = /^\(?(?:[a-zA-Z]{1,3}|\d{1,3})[).:\]]/;
+/**
+ * Reproduce a reference block's lead/body run split on a freshly-created
+ * block. Fires only when the reference genuinely has the pattern — its first
+ * run is a SHORT lead-in styled differently from the body — and the created
+ * text opens with a matching lead of its own. Two lead shapes are recognized:
+ *  - literal lead words shared by siblings ("WHEREAS", "NOW, THEREFORE"): the
+ *    created text starts with the reference's exact lead text;
+ *  - marker tokens ("(m)", "1.", "a)"): the token text differs per clause, so
+ *    the created lead is its OWN token matched by shape.
+ * Applies the reference lead's marks to the created lead span and the
+ * reference body's marks to the rest — with explicit false for boolean marks
+ * only one side has, so formatting inherited from a mis-styled anchor is
+ * corrected, not compounded.
+ */
+async function matchLeadMarkerPattern(doc, reference, created, createdText) {
+    const createdPreview = created.textPreview ?? '';
+    if (!reference.nodeId || !created.nodeId || !createdPreview)
+        return null;
+    const queryFn = maybeMethod(doc, ['query', 'match']);
+    const formatFn = maybeMethod(doc, ['format', 'apply']);
+    if (!queryFn || !formatFn)
+        return null;
+    // A short unique-enough prefix of the reference is all we need: the runs
+    // returned tile the MATCHED range, covering the lead and the body start.
+    // blocks.list truncates textPreview with a trailing ellipsis — strip it, the
+    // remaining prefix IS document text so query.match can find it.
+    const refProbe = (reference.textPreview ?? '')
+        .replace(/…\s*$/, '')
+        .slice(0, 60)
+        .trim();
+    if (!refProbe)
+        return null;
+    const refRuns = await matchRunsForBlock(queryFn, refProbe, reference.nodeId);
+    if (refRuns.length < 2)
+        return null; // uniform reference — no split to copy
+    const leadRun = refRuns[0];
+    const bodyRun = refRuns[1];
+    // The pattern requires a real FORMATTING transition between lead and body
+    // (bold/italic/underline/strike). Runs split only by font/color/hyperlink
+    // boundaries are ordinary prose — restyling from those would misfire.
+    if (RUN_BOOL_MARKS.every((key) => Boolean(leadRun[key]) === Boolean(bodyRun[key])))
+        return null;
+    const refLead = leadRun.text.trimEnd();
+    // The first run must be a short lead-in (a token or a word or two), not
+    // half the sentence.
+    if (refLead.length === 0 || refLead.length > 40 || leadRun.start !== 0)
+        return null;
+    // The caller knows the text it inserted; the blocks.list preview is truncated.
+    const fullText = createdText || createdPreview.replace(/…\s*$/, '');
+    // The created block's own lead span (ASCII markers only by design).
+    let createdLeadLen = 0;
+    const boundaryAfter = (len) => len >= fullText.length || !/[A-Za-z0-9]/.test(fullText[len]);
+    if (fullText.startsWith(refLead) && boundaryAfter(refLead.length)) {
+        // Literal shared lead word(s) — "WHEREAS, …" after a "WHEREAS, …" sibling.
+        // Exact-case with a token boundary so "Note" never claims "Notebook".
+        createdLeadLen = refLead.length;
+    }
+    else {
+        const refMarker = LEAD_MARKER_PATTERN.exec(refLead);
+        const createdMarker = LEAD_MARKER_PATTERN.exec(fullText);
+        // Marker tokens: the reference's first run must BE the token, and the
+        // created text must open with a token of the same category (letters
+        // with letters, digits with digits — "(m)" doesn't restyle "1.").
+        if (refMarker &&
+            createdMarker &&
+            refMarker[0] === refLead &&
+            /\d/.test(refMarker[0]) === /\d/.test(createdMarker[0])) {
+            createdLeadLen = createdMarker[0].length;
+        }
+    }
+    if (createdLeadLen === 0)
+        return null;
+    const normalize = new Set(RUN_BOOL_MARKS.filter((key) => leadRun[key] !== bodyRun[key]));
+    const markerInline = inlineFromSnapshotRun(leadRun, normalize);
+    const bodyInline = inlineFromSnapshotRun(bodyRun, normalize);
+    if (Object.keys(markerInline).length === 0 && Object.keys(bodyInline).length === 0)
+        return null;
+    let changed = false;
+    if (Object.keys(markerInline).length > 0) {
+        changed =
+            (await applyInlineQuiet(formatFn, {
+                blockId: created.nodeId,
+                start: 0,
+                end: createdLeadLen,
+                inline: markerInline,
+            })) || changed;
+    }
+    if (Object.keys(bodyInline).length > 0 && fullText.length > createdLeadLen) {
+        changed =
+            (await applyInlineQuiet(formatFn, {
+                blockId: created.nodeId,
+                start: createdLeadLen,
+                end: fullText.length,
+                inline: bodyInline,
+            })) || changed;
+    }
+    return { marker: fullText.slice(0, createdLeadLen), markerInline, bodyInline, changed };
+}
+/**
+ * Copy a reference block's RUN pattern onto a created block: the body look over
+ * the whole block, then the label look over the new block's own label span.
+ *
+ * Complements matchLeadMarkerPattern, which requires either a shared literal
+ * lead word or a marker token AND a two-run reference. This one reads the
+ * reference's runs (`query.match`, the only read that reports run styling) and
+ * handles the shapes that leaves out — including a reference with a single
+ * uniform run, whose look simply transfers.
+ */
+async function matchBlockRunPattern(doc, reference, created, createdText) {
+    const formatFn = maybeMethod(doc, ['format', 'apply']);
+    const referenceText = (reference.textPreview ?? '').replace(/…\s*$/, '').trim();
+    const fullText = createdText || (created.textPreview ?? '').replace(/…\s*$/, '');
+    if (!formatFn || !reference.nodeId || !created.nodeId || !referenceText || !fullText)
+        return null;
+    const pattern = await listItemRunPattern(doc, referenceText, reference.nodeId);
+    if (!pattern)
+        return null;
+    const end = Math.max(fullText.length, 1);
+    const applied = {};
+    if (Object.keys(pattern.body).length > 0) {
+        if (await applyInlineQuiet(formatFn, { blockId: created.nodeId, start: 0, end, inline: pattern.body })) {
+            applied.body = pattern.body;
+        }
+    }
+    if (pattern.lead) {
+        const span = leadInSpanOf(fullText, pattern.lead.shape);
+        // A uniform reference has no body look and no delimiter of its own: its look
+        // belongs to the whole created block, not to a label span inside it.
+        const range = span ?? (Object.keys(pattern.body).length === 0 ? { start: 0, end } : null);
+        if (range && (await applyInlineQuiet(formatFn, { blockId: created.nodeId, ...range, inline: pattern.lead.look }))) {
+            applied.lead = { ...pattern.lead.look, range: [range.start, range.end] };
+        }
     }
+    return Object.keys(applied).length > 0 ? { matchedSibling: reference.nodeId, ...applied } : null;
 }
 async function matchInsertedBlockFormatting(doc, preBlocks, receipt, args) {
     if (receipt.status !== 'ok')
@@ -4532,6 +6184,17 @@ async function matchInsertedBlockFormatting(doc, preBlocks, receipt, args) {
         const anchorSelector = placement && isRecord(placement.selector) ? placement.selector : null;
         const anchorId = anchorSelector && typeof anchorSelector.nodeId === 'string' ? anchorSelector.nodeId : null;
         const anchorRow = anchorId ? (postBlocks.find((b) => b.nodeId === anchorId) ?? null) : null;
+        // When the caller styled any entry explicitly (runs/marks), it took
+        // ownership of intra-paragraph formatting — the automatic lead-marker
+        // pattern pass must not fight it.
+        const rawTexts = Array.isArray(args?.texts) ? args.texts : [];
+        const hasExplicitStyling = rawTexts.some((entry) => isRecord(entry) && (Array.isArray(entry.runs) || entry.marks != null));
+        const insertedTexts = rawTexts.map((entry) => {
+            if (typeof entry === 'string')
+                return entry;
+            const spec = normalizeItemSpec(entry);
+            return spec ? itemSpecText(spec) : '';
+        });
         const allApplied = [];
         for (let ci = 0; ci < createdRows.length; ci += 1) {
             const { row: created, index: createdIndex } = createdRows[ci];
@@ -4539,7 +6202,24 @@ async function matchInsertedBlockFormatting(doc, preBlocks, receipt, args) {
             // read like a heading (flush-left), so it must NOT inherit the body
             // sibling's left indent even though it matches the same anchor.
             const isTitle = createdRows.length > 1 && ci === 0;
-            const result = await matchOneBlock(doc, postBlocks, preIds, created, createdIndex, anchorRow, createdRows.length === 1, isTitle);
+            const createdText = insertedTexts[ci] ?? '';
+            const match = (anchor) => matchOneBlock(doc, postBlocks, preIds, created, createdIndex, anchor, createdRows.length === 1, isTitle, !hasExplicitStyling, 
+            // The texts the caller inserted, in order — the truncated preview
+            // cannot measure a label span or the end of the block.
+            createdText);
+            let result = await match(anchorRow);
+            // A GROUP of paragraphs usually repeats the group before it: a signature
+            // block is name / "By:" / "Name:", and the new name line should look like
+            // the previous NAME line, not like the "Name:" line directly above it.
+            // Only tried when matching against the neighbour found nothing, so this
+            // cannot change a case that already had an answer.
+            const applied = isRecord(result?.applied) ? result.applied : null;
+            if (createdRows.length > 1 && (!applied || Object.keys(applied).length === 0)) {
+                const parallel = postBlocks[createdIndex - createdRows.length];
+                if (parallel && preIds.has(parallel.nodeId) && !parallel.isEmpty) {
+                    result = (await match(parallel)) ?? result;
+                }
+            }
             if (result)
                 allApplied.push(result);
         }
@@ -4552,7 +6232,7 @@ async function matchInsertedBlockFormatting(doc, preBlocks, receipt, args) {
         // insert because of it — but the receipt says it was skipped.
         return {
             ...receipt,
-            contextualFormatting: { skipped: err instanceof Error ? err.message : String(err) },
+            contextualFormatting: { skipped: reasonOf(err) },
         };
     }
 }
@@ -4763,10 +6443,20 @@ export async function superdocPerformAction(doc, args) {
     }
     switch (action) {
         case 'insert_paragraphs': {
-            // Accept either `texts` (in order) or a single `text` for one paragraph.
-            const singleText = asString(args.text);
-            const texts = parseStringArray(args.texts) ?? (singleText ? [singleText] : undefined);
-            if (!texts || texts.length === 0) {
+            // Accept `texts` (in order) or a single `text`. Each entry may be a
+            // plain string or a {text, runs, marks} spec — styled entries get a
+            // post-insert format.apply pass (mirrors add_list_items / cellTexts).
+            const rawEntries = Array.isArray(args.texts) ? args.texts : args.text != null ? [args.text] : [];
+            const texts = [];
+            const textSpecs = [];
+            for (const raw of rawEntries) {
+                const spec = normalizeItemSpec(raw);
+                if (!spec)
+                    continue;
+                texts.push(itemSpecText(spec));
+                textSpecs.push((spec.runs && spec.runs.length > 0) || spec.marks != null ? spec : null);
+            }
+            if (texts.length === 0) {
                 throw new SuperDocCliError('insert_paragraphs requires a non-empty "texts" array (or a "text" string for a single paragraph)', {
                     code: 'INVALID_ARGUMENT',
                 });
@@ -4776,6 +6466,7 @@ export async function superdocPerformAction(doc, args) {
             const receipt = await runInsertParagraphs(doc, {
                 action,
                 texts,
+                textSpecs,
                 placement: parsePlacement(args.placement),
                 changeMode: parseChangeMode(args.changeMode),
                 headingLevel: headingLevel != null && Number.isInteger(headingLevel) && headingLevel >= 1 && headingLevel <= 6
@@ -5104,7 +6795,7 @@ export async function superdocPerformAction(doc, args) {
                 args.position === 'below'
                 ? args.position
                 : undefined;
-            const cellTexts = parseLooseStringArray(args.cellTexts);
+            const cellTexts = parseCellArray(args.cellTexts);
             return runInsertTableRow(doc, {
                 action,
                 tableOrdinal: tableOrdinal != null && Number.isInteger(tableOrdinal) && tableOrdinal >= 1 ? tableOrdinal : undefined,
@@ -5125,6 +6816,7 @@ export async function superdocPerformAction(doc, args) {
                 columnIndex: columnIndex != null && Number.isInteger(columnIndex) && columnIndex >= 0 ? columnIndex : undefined,
                 position,
                 headerText: asString(args.headerText),
+                cellTexts: parseCellArray(args.cellTexts) ?? undefined,
                 changeMode: parseChangeMode(args.changeMode),
             });
         }
@@ -5290,25 +6982,21 @@ export async function superdocPerformAction(doc, args) {
             const anchorText = asString(args.anchorText) ?? '';
             const listOrdinalRaw = asNumber(args.listOrdinal);
             const listOrdinal = listOrdinalRaw != null && Number.isInteger(listOrdinalRaw) && listOrdinalRaw >= 1 ? listOrdinalRaw : undefined;
+            // Parse entries + items — either may carry per-run styling (runs/marks).
+            // `items` is an alias for `entries` at the list's base level.
+            const entries = [];
             const rawEntries = Array.isArray(args.entries) ? args.entries : [];
-            const entries = rawEntries
-                .map((e) => {
-                if (typeof e === 'string')
-                    return { text: e, level: 0 };
-                if (isRecord(e) && typeof e.text === 'string') {
-                    // Preserve NEGATIVE levels (dedent toward the top); runAddListItems
-                    // clamps the final outline level at 0.
-                    const lvl = asNumber(e.level);
-                    return { text: e.text, level: lvl != null ? Math.floor(lvl) : 0 };
+            for (const e of rawEntries) {
+                const spec = normalizeItemSpec(e);
+                if (spec)
+                    entries.push(spec);
+            }
+            if (entries.length === 0 && Array.isArray(args.items)) {
+                for (const it of args.items) {
+                    const spec = normalizeItemSpec(it);
+                    if (spec)
+                        entries.push(spec);
                 }
-                return null;
-            })
-                .filter((e) => e != null);
-            // `items` is a plain-string alias for `entries` at the list's base level.
-            const plainItems = parseStringArray(args.items);
-            if (entries.length === 0 && plainItems) {
-                for (const t of plainItems)
-                    entries.push({ text: t, level: 0 });
             }
             if (entries.length === 0) {
                 throw new SuperDocCliError('add_list_items requires non-empty "entries" or "items"', {
@@ -5321,17 +7009,27 @@ export async function superdocPerformAction(doc, args) {
                 });
             }
             const changeMode = parseChangeMode(args.changeMode);
-            // Preferred path: a real NUMBERED list found by anchorText — attaches each
-            // entry at the right nesting level, reusing the list's marker scheme.
+            // Preferred path: attach each entry to a real NUMBERED list (reuses the
+            // list's markers + numbering, and applies anchor + whole-item + per-run
+            // formatting). Locate the list by anchorText, else by resolving
+            // listOrdinal to its last item's nodeId — the latter lets styled inserts
+            // reach this path even when the model addressed the list by ordinal.
+            let anchored = null;
             if (anchorText) {
-                const attached = await runAddListItems(doc, { action, anchorText, entries, changeMode }, { fallbackOnMissing: true });
-                if (attached)
-                    return attached;
+                anchored = await runAddListItems(doc, { action, anchorText, entries, changeMode }, { fallbackOnMissing: true });
+            }
+            if (!anchored && listOrdinal != null) {
+                const anchorNodeId = await resolveListAnchorNodeId(doc, listOrdinal);
+                if (anchorNodeId) {
+                    anchored = await runAddListItems(doc, { action, anchorNodeId, entries, changeMode }, { fallbackOnMissing: true });
+                }
             }
+            if (anchored)
+                return anchored;
             // Fallback: ghost lists (imported list-looking paragraphs with no
-            // numbering) and listOrdinal addressing. Nesting collapses to the base
-            // level on this path.
-            const flatItems = entries.map((e) => e.text);
+            // numbering) and listOrdinal addressing. This path is text-only, so any
+            // requested per-run styling is dropped here.
+            const flatItems = entries.map(itemSpecText);
             const ghost = await insertListItemsIntoGhostList(doc, {
                 items: flatItems,
                 anchorText: anchorText || undefined,
@@ -5340,7 +7038,7 @@ export async function superdocPerformAction(doc, args) {
             });
             if (ghost)
                 return ghost;
-            return runInsertListItems(doc, { items: flatItems, listOrdinal, changeMode });
+            return runInsertListItems(doc, { items: flatItems, listOrdinal, styled: entries, changeMode });
         }
     }
 }
@@ -5391,6 +7089,23 @@ function parseEdits(value) {
     }
     return result;
 }
+/** Parse one cell input: a plain string, or a styled {text, runs, marks} object.
+ *  Unparseable input coerces to an empty cell so a grid isn't voided by one bad cell. */
+function parseCellCandidate(cell) {
+    if (typeof cell === 'string')
+        return cell;
+    if (isRecord(cell)) {
+        const spec = normalizeItemSpec(cell);
+        if (spec)
+            return { text: spec.text, runs: spec.runs, marks: spec.marks };
+    }
+    return '';
+}
+function parseCellArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    return value.map(parseCellCandidate);
+}
 function parseCellTexts(value) {
     if (!Array.isArray(value))
         return undefined;
@@ -5398,13 +7113,7 @@ function parseCellTexts(value) {
     for (const row of value) {
         if (!Array.isArray(row))
             return undefined;
-        const cells = [];
-        for (const cell of row) {
-            if (typeof cell !== 'string')
-                return undefined;
-            cells.push(cell);
-        }
-        result.push(cells);
+        result.push(row.map(parseCellCandidate));
     }
     return result;
 }