@copylee/dsh-office 0.2.2 → 0.3.0

package/README.md

@@ -14,13 +14,18 @@
 | 实时可见，可以一起改 | 每一步修改即时出现在 Word / Excel / PowerPoint 窗口里。你可以同时在里面打字、调格式，AI 每次动手前读到的都是文档当下的样子 |
 | 不需要窗口在前台 | 修改不靠鼠标键盘，Office 窗口被挡住或在后台也照常进行，你可以同时用电脑做别的事 |
 | 跟随与静默 | 默认“跟随”：AI 改到哪里，窗口自动滚动到哪里（Word 滚到那一段，Excel 滚到那片单元格，PowerPoint 切到那一页），不动你的光标和选区。关闭即静默执行，不动你的视图 |
-| 逐字写入 | 文字分小段写出，像打字一样出现，表格逐行填入，而不是整块贴上去。每段最多多花约 1 秒，可关闭 |
-| 迷你卡片 | AI 打开或编辑文档时屏幕右下角出现一张小卡片：正在改哪个文档、改到第几项，带“跟随”“逐字”两个开关，点一下立即生效（正在进行的这一批也跟着变）。点“跟随”会把文档窗口带到前台并开始跟随；你切到别的窗口后它自动熄灭，再点一次回来。可拖动，不抢焦点，AI 停手几秒后自动消失 |
-| Word 原生公式 | AI 在文字里用 `$...$`（行内）和 `$$...$$`（单独一行）写 LaTeX，插件转成 Word 原生公式（分式、根号、上下标、希腊字母、求和、积分、上划线等常用写法）；单独一行的公式末尾加 `\tag{1}` 即在右侧对齐编号 |
+| 逐字写入 | 文字分小段写出，像打字一样出现，表格逐行填入，而不是整块贴上去。每段约多花 0.3 秒，可关闭 |
+| 迷你卡片 | AI 每次动手修改文档时，屏幕右下角出现一张小卡片：正在改哪个文档、改到第几项，带“查看”“逐字”两个开关，点一下立即生效（正在进行的这一批也跟着变）。点“查看”会把文档窗口带到前台并跟随修改位置，按钮变成“查看中”；你切到别的窗口后它自动熄灭，再点一次回来。可拖动，不抢焦点；这一批改完就消失，下一批开始时再出现 |
+| Word 原生公式 | AI 在文字里用 `$...$`（行内）和 `$$...$$`（单独一行）写 LaTeX，插件转成 Word 原生公式：分式、根号、上下标、希腊字母、求和与积分、范数、矩阵（`pmatrix` 等）、分段函数（`cases`）等常用写法；单独一行的公式末尾加 `\tag{1}` 即在右侧对齐编号。正文、表格单元格、题注、查找替换的内容里都可以写 |
+| 引用与参考文献 | 正文里写 `\cite{1}`、`\cite{2,5}`、`\cite{3-6}`，变成上标 [1]、[2,5]、[3-6]；`insert_references` 生成参考文献列表。引用是 Word 的交叉引用域，按住 Ctrl 点击跳到对应文献 |
+| 样式与版式 | 直接修改样式本身（标题用什么字体字号、是否自动编号，正文的字体、行距、首行缩进），所有用到它的段落一起变；设置纸张和页边距、页码、页眉、目录（保存时自动刷新）、某段另起一页。这些都不需要再去点 Word 的对话框 |
 | 填模板 | 报告模板常把正文放在大单元格里。这类表格会按段落展开给模型看，正文、公式、表格都写进单元格里面，而不是堆到文档末尾；新写的正文沿用旁边正文的字体、字号和行距 |
 | 规范的图表题注 | 插入表格或图片时给出题注，插件按规范排：自动编号（“表 1”“图 1”，是 Word 题注域，增删后自动重排）、居中、表题在上、图题在下；图表前后留出段间距，图片居中 |
 | 不被自带技能带偏 | DSH 桌面版自带的 Office 技能会让模型写脚本生成文件，这样你看不到过程，文件开着时还会写入失败。插件在模型第一次加载这些技能时把它引回来，确有需要（批量转换、应用打不开的文件）再次请求即放行 |
-| 交付前整体视觉检查 | 保存时如果 AI 改完之后还没看过成品，保存结果会自动附上各页（最多 8 页）的渲染图让它过一遍，有问题先修再保存 |
+| 交付前整体视觉检查 | 保存时如果 AI 改完之后还没看过成品，保存结果会自动附上整份文档的总览图让它过一遍，有问题先修再保存。总览图把各页（或各张幻灯片）带页码拼在一张图里，一张最多 6 页，最多 18 页；模型也可以随时主动调出总览，再放大某一页细看 |
+| 不拆词、不重复编号 | 插件写入的段落、表格、题注一律按整词换行（有些模板的样式带着“允许西文在单词中间换行”，会把 37000 拆成 37 和 000）；标题文字自带编号而样式又自动编号时，去掉自动的那个 |
+| 提醒纯文本公式 | 正文里出现 d_k、10^18 这类没写成公式的下标和幂时，结果里会提醒模型改用公式 |
+| 表格跨页 | 表头行在下一页重复，单行不被拆到两页，表题不会单独留在页尾 |
 | 批量编辑 | `office_edit` 一次调用按顺序执行一批修改（写一整篇文档、填一张表加公式加图表、做几页幻灯片），中途某一项失败就停下并报告已完成哪些 |
 | 改错位置的防护 | Word 按“段落编号 + 这段开头的文字”定位。你刚改过导致编号对不上时，这一步会被拒绝并要求重新读取；改写和删除段落必须带开头文字 |
 | Word 一次撤销 | AI 的一批修改在 Word 里是一个撤销步骤，按一次 Ctrl+Z 整批撤回 |
@@ -61,12 +66,13 @@ AI 只有在调用保存时才写入文件，不会替你关闭文档。
 | `office_status` | 列出三个应用里现在打开了什么、哪些有未保存的修改 |
 | `office_read` | 把打开的文档读成文本（段落 / 单元格 / 形状） |
 | `office_edit` | 按顺序执行一批修改，不保存 |
-| `office_render` | 把一页 / 一张幻灯片 / 一个单元格区域渲染成图片；Word 和 PowerPoint 一次最多看 4 页 |
+| `office_render` | 把一页 / 一张幻灯片 / 一个单元格区域渲染成图片；Word 和 PowerPoint 一次最多看 4 页，或用总览把全部页面拼成一张图 |
 | `office_save` | 保存；给出路径时另存为，扩展名为 `.pdf` 时导出 PDF；改完没看过成品时附带各页图片 |
+| `office_close` | 关闭 AI 自己打开或新建的文档；你原本开着的文档会被拒绝，有未保存修改时必须明确说保存还是丢弃 |
 
 `office_edit` 支持的操作：
 
-- Word：`insert_paragraphs`、`set_text`、`replace_text`、`format_text`、`delete_range`、`insert_table`、`set_cell`、`insert_image`
+- Word：`insert_paragraphs`、`set_text`、`replace_text`、`format_text`、`delete_range`、`insert_table`、`set_cell`、`insert_image`、`insert_references`、`style_format`、`page_setup`、`page_numbers`、`header`、`page_break`、`insert_toc`、`update_fields`
 - Excel：`write_range`（值或公式）、`format_range`、`autofit`、`insert_rows`、`delete_rows`、`add_sheet`、`rename_sheet`、`delete_sheet`、`add_chart`
 - PowerPoint：`add_slide`、`set_text`、`add_textbox`、`add_image`、`set_shape`、`delete_shape`、`delete_slide`、`move_slide`、`set_notes`
 
@@ -78,8 +84,8 @@ AI 只有在调用保存时才写入文件，不会替你关闭文档。
 |---|---|---|
 | 跟随 AI 的修改位置 | 开 | 窗口自动滚动到 AI 正在修改的位置；关闭为静默执行 |
 | 逐字写入 | 开 | 文字像打字一样逐步出现；关闭后写得最快 |
-| 迷你卡片 | 开 | AI 编辑时在右下角显示带“跟随”“逐字”开关的小卡片。在卡片上切换过的开关（包括你离开文档窗口后自动熄灭的“跟随”），到 DSH 重启前以卡片为准 |
-| 交付前整体视觉检查 | 开 | 保存时自动把各页渲染图交给 AI 检查；会多用一些 token |
+| 迷你卡片 | 开 | AI 修改文档期间在右下角显示带“查看”“逐字”开关的小卡片。在卡片上切换过的开关（包括你离开文档窗口后自动熄灭的“查看”），到 DSH 重启前以卡片为准 |
+| 交付前整体视觉检查 | 开 | 保存时自动把整份文档的总览图交给 AI 检查；会多用一些 token |
 | 优先在真实 Office 里操作 | 开 | DSH 桌面版自带 office-docx / office-xlsx / office-pptx 技能，用脚本生成文件。开启后，AI 第一次想加载这些技能时会被引回本插件（对应的 Office 应用已安装时才拦）；它再次请求时放行 |
 | 打开文档时显示到前台 | 开 | 关闭后文档仍会打开，只是不抢当前窗口 |
 | 核对排版的图片宽度 | 1100 像素 | `office_render` 给模型的图片宽度；越大越清晰，也越费 token |
@@ -91,7 +97,8 @@ AI 只有在调用保存时才写入文件，不会替你关闭文档。
 - Excel 和 PowerPoint 里 AI 的修改无法用 Ctrl+Z 撤回（Excel 的外部修改不进撤销栈，并且会清空已有的撤销记录）。只有 Word 支持整批撤销。
 - 你正在单元格里输入、或 Office 开着模态对话框时，修改会被 Office 拒绝；插件等待约 5 秒后报告“应用忙”。
 - Excel 区域的图片是通过剪贴板取得的，渲染时剪贴板里的文字会被保留，图片、文件等其他内容会丢失。
-- 公式只支持 Word，PowerPoint 和 Excel 里还不能写原生公式；LaTeX 只转换常用写法，矩阵、多行对齐等环境不支持。
+- 公式只支持 Word，PowerPoint 和 Excel 里还不能写原生公式；LaTeX 只转换常用写法，没转成功的公式保留为文本并在结果里提示。
+- 引用按编号书写，插入或删除文献后不会自动重新编号。
 - 兼容模式（Word 97–2003 格式）的文档里不能建立原生公式。
 - 目前不支持 WPS。
 - 没有打开 Office 时处理文件、批量转换格式不在本插件范围内。

package/helper/OfficeHelper.cs

@@ -68,6 +68,16 @@ class Bag
         object v = Raw(key);
         return v is bool ? (bool)v : fallback;
     }
+    /// A switch given loosely: true, "thin", "all", 1 are on; false, "none", "off", 0 and absent are off.
+    public bool On(string key)
+    {
+        object v = Raw(key);
+        if (v == null) return false;
+        if (v is bool) return (bool)v;
+        string text = Convert.ToString(v, System.Globalization.CultureInfo.InvariantCulture).Trim().ToLowerInvariant();
+        return text.Length > 0 && text != "false" && text != "none" && text != "off" && text != "no" && text != "0";
+    }
+
     public IList List(string key)
     {
         object v = Raw(key);
@@ -109,6 +119,8 @@ class Card : Form
     static readonly ManualResetEvent Ready = new ManualResetEvent(false);
     /// Set once the user has flipped a switch here: from then on the card, not the settings page, decides.
     public static volatile bool FollowChosen, TypingChosen;
+    /// Set for as long as an edit is running: the card stays up through it, however long one operation takes, and goes when it ends.
+    public static volatile bool Hold;
 
     string line = "";
     DateTime shown = DateTime.MinValue;
@@ -174,7 +186,7 @@ class Card : Form
             }
             bool nowLit = Program.Following && watching;
             if (nowLit != lit) { lit = nowLit; Invalidate(); }
-            if (Visible && (DateTime.UtcNow - shown).TotalSeconds > 6) Hide();
+            if (Visible && !Hold && (DateTime.UtcNow - shown).TotalSeconds > 1) Hide();
         };
         timer.Start();
     }
@@ -215,7 +227,8 @@ class Card : Form
         {
             int right = Width - S(10);
             Chip(g, font, "逐字", Program.Typing, ref right, out typingBox);
-            Chip(g, font, "跟随", Program.Following && Watching(), ref right, out followBox);
+            bool following = Program.Following && Watching();
+            Chip(g, font, following ? "查看中" : "查看", following, ref right, out followBox);
             using (SolidBrush dot = new SolidBrush(Color.FromArgb(217, 119, 87))) g.FillEllipse(dot, S(12), (Height - S(8)) / 2, S(8), S(8));
             Rectangle text = new Rectangle(S(26), 0, right - S(30), Height);
             TextRenderer.DrawText(g, line, font, text, Color.FromArgb(235, 235, 240), TextFormatFlags.Left | TextFormatFlags.VerticalCenter | TextFormatFlags.EndEllipsis | TextFormatFlags.NoPrefix);
@@ -496,6 +509,13 @@ static class Program
     static object Run(string cmd, Bag a)
     {
         if (cmd == "ping") return "pong";
+        if (cmd == "card")
+        {
+            // The agent's turn ended: say so and let the card go.
+            Card.Hold = a.Flag("hold", false);
+            if (cardStarted) Card.Report(a.Str("text", "AI 已完成"));
+            return "ok";
+        }
         if (cmd == "status") return Status();
         string kind = Kind(a);
         if (cmd == "open") return Open(kind, a);
@@ -610,7 +630,7 @@ static class Program
             if (!cardStarted) { cardStarted = true; Card.Start(); }
             Following = Card.FollowChosen ? Following : a.Flag("follow", false);
             Typing = Card.TypingChosen ? Typing : a.Flag("typing", false);
-            Card.Report("AI 打开了 " + (string)doc.Name);
+            // No card here: it shows while an edit is running.
         }
         return info;
     }
@@ -639,6 +659,7 @@ static class Program
 
     static object Save(string kind, dynamic app, dynamic doc, Bag a)
     {
+        if (kind == "word") Refresh(doc);
         string path = a.Str("path", null);
         Dictionary<string, object> result = new Dictionary<string, object>();
         if (path == null)
@@ -744,11 +765,11 @@ static class Program
         try { doc.Windows[1].ScrollIntoView(range, true); } catch (Exception) { }
     }
 
-    /// Pieces to write a text in: up to 40 of them, so that a long paragraph still takes about a second.
+    /// Pieces to write a text in: up to 14 of them, so that a long paragraph takes about a third of a second.
     static List<string> Pieces(string text)
     {
         List<string> pieces = new List<string>();
-        int size = Math.Max(2, (int)Math.Ceiling(text.Length / 40.0));
+        int size = Math.Max(3, (int)Math.Ceiling(text.Length / 14.0));
         for (int i = 0; i < text.Length; i += size) pieces.Add(text.Substring(i, Math.Min(size, text.Length - i)));
         return pieces;
     }
@@ -766,7 +787,7 @@ static class Program
         {
             doc.Range(at, at).InsertAfter(piece);
             at += piece.Length;
-            Thread.Sleep(22);
+            Thread.Sleep(14);
         }
         return at;
     }
@@ -786,6 +807,9 @@ static class Program
         { "to", "→" }, { "rightarrow", "→" }, { "leftarrow", "←" }, { "Rightarrow", "⇒" }, { "Leftrightarrow", "⇔" }, { "in", "∈" }, { "notin", "∉" },
         { "subset", "⊂" }, { "cup", "∪" }, { "cap", "∩" }, { "forall", "∀" }, { "exists", "∃" }, { "angle", "∠" }, { "perp", "⊥" }, { "parallel", "∥" },
         { "circ", "∘" }, { "degree", "°" }, { "ldots", "…" }, { "cdots", "⋯" }, { "dots", "…" }, { "prime", "′" }, { "hbar", "ℏ" }, { "ell", "ℓ" },
+        { "Vert", "‖" }, { "lVert", "‖" }, { "rVert", "‖" }, { "vert", "|" }, { "lvert", "|" }, { "rvert", "|" }, { "mid", "|" },
+        { "top", "⊤" }, { "langle", "⟨" }, { "rangle", "⟩" }, { "otimes", "⊗" }, { "oplus", "⊕" }, { "neg", "¬" }, { "ast", "∗" },
+        { "det", "det" }, { "rank", "rank" }, { "dim", "dim" }, { "sup", "sup" }, { "inf", "inf" }, { "arg", "arg" }, { "cond", "cond" },
         { "quad", " " }, { "qquad", "  " }, { "left", "" }, { "right", "" }, { "displaystyle", "" }, { "limits", "" }, { "lim", "lim" },
         { "sin", "sin" }, { "cos", "cos" }, { "tan", "tan" }, { "cot", "cot" }, { "ln", "ln" }, { "log", "log" }, { "exp", "exp" }, { "max", "max" }, { "min", "min" },
         { "arcsin", "arcsin" }, { "arccos", "arccos" }, { "arctan", "arctan" }, { "sinh", "sinh" }, { "cosh", "cosh" }, { "tanh", "tanh" },
@@ -831,9 +855,19 @@ static class Program
     {
         StringBuilder o = new StringBuilder();
         int i = 0;
+        // A sum, product or integral was written and its limits may still follow; what comes after them is its
+        // operand, which Word's linear format introduces with "▒" (left out, Word draws an empty box there).
+        bool nary = false;
         while (i < s.Length)
         {
             char c = s[i];
+            if (nary && c != '^' && c != '_' && c != ' ')
+            {
+                if (c == '\\' && string.CompareOrdinal(s, i, "\\limits", 0, 7) == 0) { i += 7; continue; }
+                if (c == '\\' && string.CompareOrdinal(s, i, "\\nolimits", 0, 9) == 0) { i += 9; continue; }
+                o.Append('▒');
+                nary = false;
+            }
             if (c == '\\')
             {
                 int start = ++i;
@@ -842,12 +876,51 @@ static class Program
                 {
                     // \, \; \! \  are spacing; \{ \} \% and the like are the character itself.
                     char next = i < s.Length ? s[i++] : ' ';
-                    if (next == ',' || next == ';' || next == ':' || next == ' ') o.Append(' ');
+                    if (next == '|') o.Append('‖');
+                    else if (next == ',' || next == ';' || next == ':' || next == ' ') o.Append(' ');
                     else if (next == '\\') o.Append(' ');
                     else if (next != '!') o.Append(next);
                     continue;
                 }
                 string name = s.Substring(start, i - start);
+                if (name == "begin")
+                {
+                    // \begin{pmatrix} a & b \\ c & d \end{pmatrix}: Word's linear form is (■(a&b@c&d)).
+                    int close = s.IndexOf('}', i);
+                    string env = close > i ? s.Substring(i + 1, close - i - 1).Trim() : "";
+                    string ending = "\\end{" + env + "}";
+                    int stop = close > i ? s.IndexOf(ending, close, StringComparison.Ordinal) : -1;
+                    if (stop > 0)
+                    {
+                        string body = s.Substring(close + 1, stop - close - 1);
+                        i = stop + ending.Length;
+                        if (env == "array" && body.TrimStart().StartsWith("{", StringComparison.Ordinal)) body = body.Substring(body.IndexOf('}') + 1);
+                        List<string> rows = new List<string>();
+                        foreach (string row in body.Replace("\\\\", "\u0001").Split('\u0001'))
+                        {
+                            if (row.Trim().Length == 0) continue;
+                            List<string> cells = new List<string>();
+                            foreach (string cell in row.Split('&')) cells.Add(Tex(cell.Trim()));
+                            rows.Add(string.Join("&", cells.ToArray()));
+                        }
+                        string grid = string.Join("@", rows.ToArray());
+                        if (env == "pmatrix") o.Append("(■(" + grid + "))");
+                        else if (env == "bmatrix") o.Append("[■(" + grid + ")]");
+                        else if (env == "vmatrix") o.Append("|■(" + grid + ")|");
+                        else if (env == "Vmatrix") o.Append("‖■(" + grid + ")‖");
+                        else if (env == "cases") o.Append("{█(" + grid + ")┤");
+                        else if (env == "aligned" || env == "align" || env == "split" || env == "gathered") o.Append("█(" + grid + ")");
+                        else o.Append("■(" + grid + ")");
+                        continue;
+                    }
+                }
+                if (name == "mathbb")
+                {
+                    string letter = TexArg(s, ref i);
+                    string doubled = letter == "R" ? "ℝ" : letter == "N" ? "ℕ" : letter == "Z" ? "ℤ" : letter == "Q" ? "ℚ" : letter == "C" ? "ℂ" : letter;
+                    o.Append(doubled);
+                    continue;
+                }
                 if (name == "frac" || name == "dfrac" || name == "tfrac") {
                     string top = TexArg(s, ref i), bottom = TexArg(s, ref i);
                     // A factor written right before the fraction (2rac{a}{b}) must not be read into its numerator.
@@ -881,6 +954,7 @@ static class Program
                     if (TexSymbols.TryGetValue(name, out symbol))
                     {
                         o.Append(symbol);
+                        if (symbol == "∑" || symbol == "∏" || symbol == "∫" || symbol == "∮") nary = true;
                         // A function name is applied to what follows: Word needs a space after it.
                         if (symbol.Length > 1 && symbol == name && i < s.Length && s[i] != ' ' && s[i] != '^' && s[i] != '_') o.Append(' ');
                     }
@@ -894,8 +968,8 @@ static class Program
                 bool braced = i < s.Length && s[i] == '{';
                 string arg = TexArg(s, ref i);
                 o.Append(c).Append(braced && arg.Length > 1 ? "(" + arg + ")" : arg);
-                // Otherwise Word reads the next letter into the script: x^2y.
-                if (i < s.Length && (char.IsLetterOrDigit(s[i]) || s[i] == '\\')) o.Append(' ');
+                // A space ends the script; otherwise Word reads what follows into it: x^2y, λ_max(A).
+                if (!nary && i < s.Length && "^_ )]},.;:，。、".IndexOf(s[i]) < 0) o.Append(' ');
                 continue;
             }
             if (c == '{') { string group = TexArg(s, ref i); o.Append("〖" + group + "〗"); continue; }
@@ -923,6 +997,30 @@ static class Program
             System.Text.RegularExpressions.Match m = found[k];
             bool display = m.Groups[1].Success;
             string source = (display ? m.Groups[1].Value : m.Groups[2].Value).Trim();
+            try
+            {
+                if (BuildOne(doc, range, start, m, display, source)) made++;
+                else MathFailed++;
+            }
+            catch (Exception) { MathFailed++; }
+        }
+        return made;
+    }
+
+    /// Formulas that could not be turned into equations during the current operation (they stay as text).
+    static int MathFailed;
+
+    static string MathNote()
+    {
+        if (MathFailed == 0) return "";
+        string note = " — NOTE " + MathFailed + " formula(s) could not be built and were left as text: check them with office_render and rewrite them more simply";
+        MathFailed = 0;
+        return note;
+    }
+
+    static bool BuildOne(dynamic doc, dynamic range, int start, System.Text.RegularExpressions.Match m, bool display, string source)
+    {
+        {
             // 	ag{1} numbers a display equation: Word sets "#(1)" flush right on the equation's line.
             string tag = null;
             System.Text.RegularExpressions.Match tagged = Tag.Match(source);
@@ -941,11 +1039,10 @@ static class Program
                 dynamic math = doc.OMaths.Add(spot);
                 math.OMaths[1].BuildUp();
                 if (display) { try { math.OMaths[1].Type = 0; math.OMaths[1].Justification = 1; } catch (COMException) { } }
-                made++;
+                return true;
             }
-            catch (COMException) { }
+            catch (COMException) { return false; }
         }
-        return made;
     }
 
     // ───────────────────────── Word ─────────────────────────
@@ -1121,6 +1218,9 @@ static class Program
         if (op.Has("spaceBefore")) range.ParagraphFormat.SpaceBefore = (float)op.Num("spaceBefore", 0);
         if (op.Has("spaceAfter")) range.ParagraphFormat.SpaceAfter = (float)op.Num("spaceAfter", 0);
         if (op.Has("lineSpacing")) { range.ParagraphFormat.LineSpacingRule = 5; range.ParagraphFormat.LineSpacing = (float)(op.Num("lineSpacing", 1) * 12); }
+        if (op.Has("indentChars")) { range.ParagraphFormat.FirstLineIndent = 0; range.ParagraphFormat.CharacterUnitFirstLineIndent = (float)op.Num("indentChars", 2); }
+        if (op.Has("superscript")) range.Font.Superscript = op.Flag("superscript", false) ? 1 : 0;
+        if (op.Has("subscript")) range.Font.Subscript = op.Flag("subscript", false) ? 1 : 0;
     }
 
     /// A new empty paragraph where an insert operation points: after / before paragraph "para", or at the start / end.
@@ -1147,6 +1247,37 @@ static class Program
         return doc.Range(start, start).Paragraphs[1];
     }
 
+    static readonly System.Text.RegularExpressions.Regex Numbered = new System.Text.RegularExpressions.Regex(@"^\s*(第?[一二三四五六七八九十百]+[、．.章节]|[（(][一二三四五六七八九十\d]+[)）]|\d+(\.\d+)*[\s、．.])");
+
+    static readonly System.Text.RegularExpressions.Regex PlainMath = new System.Text.RegularExpressions.Regex(@"[A-Za-z0-9\)\}]_(\{[^}]+\}|[A-Za-z0-9])|[A-Za-z0-9\)]\^(\{[^}]+\}|\(?-?\d)|\\(frac|sqrt|sum|int|alpha|beta|theta|pi)\b");
+
+    /// Subscripts and powers written as plain text (d_k, 10^18) outside $...$: say so, with the first one found.
+    static string Lint(string text)
+    {
+        if (text == null) return "";
+        string outside = Dollars.Replace(text, " ");
+        System.Text.RegularExpressions.Match m = PlainMath.Match(outside);
+        if (!m.Success) return "";
+        int start = Math.Max(0, m.Index - 6);
+        return " — NOTE plain-text formula \"" + outside.Substring(start, Math.Min(outside.Length - start, m.Length + 12)).Trim() + "\": write formulas, subscripts and powers between dollar signs ($d_k$, $10^{18}$) so they are typeset";
+    }
+
+    /// Keep Latin words and numbers whole at the end of a line. Some templates carry "allow Latin text to wrap in
+    /// the middle of a word" in a style, and every paragraph written after it inherits that: 37 / 000, mode / l.
+    /// (Word's object model names this backwards: WordWrap = True is the whole-word setting.)
+    static void Whole(dynamic range)
+    {
+        try { range.ParagraphFormat.WordWrap = -1; } catch (Exception) { }
+    }
+
+    /// The text already starts with its number ("一、", "2.1 ") and the style would add another: drop the automatic one.
+    static void Unnumber(dynamic paragraph, string text)
+    {
+        if (!Numbered.IsMatch(text)) return;
+        try { if ((int)paragraph.Range.ListFormat.ListType != 0) paragraph.Range.ListFormat.RemoveNumbers(); }
+        catch (Exception) { }
+    }
+
     /// A new empty paragraph right after the given one.
     static dynamic After(dynamic doc, dynamic paragraph)
     {
@@ -1158,8 +1289,27 @@ static class Program
         try
         {
             made.Style = paragraph.Style;
-            made.Range.ParagraphFormat = paragraph.Range.ParagraphFormat.Duplicate;
-            made.Range.Font = paragraph.Range.Font.Duplicate;
+            dynamic from = paragraph.Range.ParagraphFormat, to = made.Range.ParagraphFormat;
+            to.Alignment = from.Alignment;
+            to.LeftIndent = from.LeftIndent; to.RightIndent = from.RightIndent;
+            to.CharacterUnitFirstLineIndent = from.CharacterUnitFirstLineIndent; to.FirstLineIndent = from.FirstLineIndent;
+            to.SpaceBefore = from.SpaceBefore; to.SpaceAfter = from.SpaceAfter;
+            to.LineSpacingRule = from.LineSpacingRule;
+            if ((int)from.LineSpacingRule >= 3) to.LineSpacing = from.LineSpacing;
+            dynamic font = paragraph.Range.Font, target = made.Range.Font;
+            // 9999999 / empty mean "mixed" in the source paragraph: leave those to the style.
+            string name = (string)font.Name, farEast = (string)font.NameFarEast;
+            if (!string.IsNullOrEmpty(name)) target.Name = name;
+            if (!string.IsNullOrEmpty(farEast)) target.NameFarEast = farEast;
+            float size = (float)font.Size;
+            if (size > 0 && size < 1000) target.Size = size;
+            foreach (string flag in new string[] { "Bold", "Italic" })
+            {
+                int value = flag == "Bold" ? (int)font.Bold : (int)font.Italic;
+                if (value == 0 || value == -1) { if (flag == "Bold") target.Bold = value; else target.Italic = value; }
+            }
+            int color = (int)font.Color;
+            if (color != 9999999) target.Color = color;
         }
         catch (COMException) { }
         return made;
@@ -1199,10 +1349,13 @@ static class Program
         {
             dynamic range = caption.Range;
             range.ParagraphFormat.Alignment = 1;
+            Whole(range);
             range.ParagraphFormat.CharacterUnitFirstLineIndent = 0; range.ParagraphFormat.FirstLineIndent = 0;
             range.Font.Bold = 0; range.Font.Italic = 0; range.Font.Color = -16777216; range.Font.Size = 10.5f;
             if (!string.IsNullOrEmpty(fontName)) range.Font.Name = fontName;
             if (!string.IsNullOrEmpty(fontFarEast)) range.Font.NameFarEast = fontFarEast;
+            // A table's caption must not be left alone at the foot of a page.
+            if (table) range.ParagraphFormat.KeepWithNext = -1;
             range.ParagraphFormat.SpaceBefore = table ? Air : 3f;
             range.ParagraphFormat.SpaceAfter = table ? 3f : Air;
             Mathify(doc, caption.Range);
@@ -1247,22 +1400,35 @@ static class Program
             bool all = op.Flag("all", true), matchCase = op.Flag("matchCase", true);
             dynamic range = doc.Content;
             int count = 0;
-            while (count < 5000 && (bool)range.Find.Execute(FindText: find, MatchCase: matchCase, Forward: true, Wrap: 0))
+            // "^" starts a special code in Word's find box; here the text is always meant literally.
+            string literal = find.Replace("^", "^^");
+            bool rich = replace.IndexOf('$') >= 0 || replace.IndexOf("\\cite", StringComparison.Ordinal) >= 0;
+            string extra = "";
+            while (count < 5000 && (bool)range.Find.Execute(FindText: literal, MatchCase: matchCase, MatchWildcards: false, Forward: true, Wrap: 0))
             {
                 range.Text = replace;
-                range.Collapse(0);
+                if (rich)
+                {
+                    // Building formulas changes the length: keep the place by its distance from the end.
+                    int tail = (int)doc.Content.End - (int)range.End;
+                    extra = Enrich(doc, range);
+                    int resume = (int)doc.Content.End - tail;
+                    range = doc.Range(resume, resume);
+                }
+                else range.Collapse(0);
                 count++;
                 if (!all) break;
             }
             if (count == 0) throw new Fail("NOT_FOUND", "The text \"" + Clip(find, 60) + "\" does not occur in the document.");
-            return "replaced " + count;
+            return "replaced " + count + extra + Lint(replace);
         }
         if (type == "insert_paragraphs")
         {
             IList items = op.List("items");
             if (items == null) { items = new ArrayList(); items.Add(new Dictionary<string, object> { { "text", op.Need("text") } }); }
             dynamic current = null;
-            int made = 0, equations = 0;
+            int made = 0, equations = 0, cites = 0;
+            string lint = "";
             foreach (object raw in items)
             {
                 Bag item = raw is string ? new Bag(new Dictionary<string, object> { { "text", raw } }) : new Bag(raw);
@@ -1278,13 +1444,22 @@ static class Program
                     WordFormat(p.Range, StyleLess(item));
                     Follow(doc, p.Range);
                     Write(doc, (int)p.Range.Start, text);
+                    if (lint.Length == 0) lint = Lint(text);
+                    Unnumber(p, text);
+                    try
+                    {
+                        if (Unnumbered.Count > 0 && Unnumbered.Contains((string)doc.FullName + "|" + (string)p.Style.NameLocal) && (int)p.Range.ListFormat.ListType != 0) p.Range.ListFormat.RemoveNumbers();
+                    }
+                    catch (Exception) { }
+                    Whole(p.Range);
+                    cites += Cite(doc, p.Range);
                     equations += Mathify(doc, p.Range);
                     current = p;
                     made++;
                 }
             }
             int lastIndex = Index(doc, current);
-            return "inserted " + made + " paragraph(s), now paragraphs " + (lastIndex - made + 1) + "–" + lastIndex + " of " + (int)doc.Paragraphs.Count + (equations > 0 ? ", " + equations + " equation(s)" : "");
+            return "inserted " + made + " paragraph(s), now paragraphs " + (lastIndex - made + 1) + "–" + lastIndex + " of " + (int)doc.Paragraphs.Count + (equations > 0 ? ", " + equations + " equation(s)" : "") + (cites > 0 ? ", " + cites + " citation(s)" : "") + MathNote() + lint;
         }
         if ((type == "set_text" || (type == "delete_range" && op.Has("para"))) && op.Raw("expect") == null)
         {
@@ -1297,8 +1472,9 @@ static class Program
             range.MoveEnd(1, -1);
             range.Text = "";
             Write(doc, (int)p.Range.Start, Lines(op.Raw("text") ?? ""));
-            int built = Mathify(doc, p.Range);
-            return "paragraph " + op.Int("para", 0) + " rewritten" + (built > 0 ? ", " + built + " equation(s)" : "");
+            Whole(p.Range);
+            string built = Enrich(doc, p.Range);
+            return "paragraph " + op.Int("para", 0) + " rewritten" + built + Lint(Lines(op.Raw("text") ?? ""));
         }
         if (type == "format_text" || type == "set_style")
         {
@@ -1343,6 +1519,7 @@ static class Program
             catch (Exception) { }
             Plain(p, "Normal");
             Follow(doc, p.Range);
+            string cellLint = "";
             dynamic table = doc.Tables.Add(p.Range, rows, cols);
             // The cells take the formatting of the paragraph that follows (a heading, say): make them plain.
             SetStyle(table.Range, "Normal");
@@ -1359,6 +1536,7 @@ static class Program
                 if (!string.IsNullOrEmpty(fontFarEast)) table.Range.Font.NameFarEast = fontFarEast;
                 if (fontSize > 4 && fontSize < 100) table.Range.Font.Size = fontSize;
                 table.Range.ParagraphFormat.Alignment = 1;
+                Whole(table.Range);
                 table.Range.Cells.VerticalAlignment = 1;
             }
             catch (COMException) { }
@@ -1376,12 +1554,19 @@ static class Program
                         dynamic cell = table.Cell(r + 1, c + 1).Range;
                         string value = Convert.ToString(cells[c], System.Globalization.CultureInfo.InvariantCulture);
                         cell.Text = value;
-                        if (value.IndexOf('$') >= 0) Mathify(doc, table.Cell(r + 1, c + 1).Range);
+                        if (value.IndexOf('$') >= 0 || value.IndexOf("\\cite", StringComparison.Ordinal) >= 0) Enrich(doc, table.Cell(r + 1, c + 1).Range);
+                        else if (cellLint.Length == 0) cellLint = Lint(value);
                     }
                     if (Typing) Thread.Sleep(25);
                 }
             }
-            if (op.Flag("header", true)) table.Rows[1].Range.Font.Bold = 1;
+            if (op.Flag("header", true))
+            {
+                table.Rows[1].Range.Font.Bold = 1;
+                // On a page break the header row is repeated at the top of the next page.
+                try { table.Rows[1].HeadingFormat = -1; } catch (COMException) { }
+            }
+            try { table.Rows.AllowBreakAcrossPages = 0; } catch (COMException) { }
             if (op.Has("caption")) Caption(doc, table.Range, true, op.Need("caption"), fontName, fontFarEast);
             else
             {
@@ -1393,7 +1578,7 @@ static class Program
             int tableEnd = (int)doc.Range(0, table.Range.End).Paragraphs.Count;
             bool nested = false;
             try { nested = (int)table.NestingLevel > 1; } catch (Exception) { }
-            return (nested ? "table inserted inside a cell of table " + (int)doc.Range(0, table.Range.End).Tables.Count : "table " + (int)doc.Range(0, table.Range.End).Tables.Count + " inserted") + " (" + rows + "×" + cols + "), now paragraphs " + (tableEnd - (int)table.Range.Paragraphs.Count + 1) + "–" + tableEnd + " of " + (int)doc.Paragraphs.Count;
+            return (nested ? "table inserted inside a cell of table " + (int)doc.Range(0, table.Range.End).Tables.Count : "table " + (int)doc.Range(0, table.Range.End).Tables.Count + " inserted") + " (" + rows + "×" + cols + "), now paragraphs " + (tableEnd - (int)table.Range.Paragraphs.Count + 1) + "–" + tableEnd + " of " + (int)doc.Paragraphs.Count + cellLint;
         }
         if (type == "set_cell")
         {
@@ -1403,8 +1588,8 @@ static class Program
             Follow(doc, cell.Range);
             cell.Range.Text = "";
             Write(doc, (int)cell.Range.Start, Lines(op.Raw("text") ?? ""));
-            int built = Mathify(doc, doc.Tables[n].Cell(op.Int("row", 1), op.Int("col", 1)).Range);
-            return "cell set" + (built > 0 ? ", " + built + " equation(s)" : "");
+            string built = Enrich(doc, doc.Tables[n].Cell(op.Int("row", 1), op.Int("col", 1)).Range);
+            return "cell set" + built + Lint(Lines(op.Raw("text") ?? ""));
         }
         if (type == "insert_image")
         {
@@ -1424,17 +1609,254 @@ static class Program
             else p.Range.ParagraphFormat.SpaceAfter = Air;
             return "image inserted";
         }
+        if (type == "insert_references") return References(doc, op);
+        if (type == "style_format") return StyleFormat(doc, op);
+        if (type == "page_setup") return PageSetup(doc, op);
+        if (type == "page_numbers") return PageNumbers(doc, op);
+        if (type == "insert_toc") return Toc(doc, op);
+        if (type == "page_break")
+        {
+            dynamic p = Para(doc, op.Int("para", 0), op.Str("expect", null));
+            p.Range.ParagraphFormat.PageBreakBefore = op.Flag("on", true) ? -1 : 0;
+            return "paragraph " + op.Int("para", 0) + " now starts a new page";
+        }
+        if (type == "header")
+        {
+            dynamic header = doc.Sections[1].Headers[1].Range;
+            header.Text = Lines(op.Raw("text") ?? "");
+            header.ParagraphFormat.Alignment = 1;
+            if (op.Has("size")) header.Font.Size = (float)op.Num("size", 9);
+            return "page header set";
+        }
+        if (type == "update_fields") { Refresh(doc); return "table of contents and cross-references refreshed"; }
         throw new Fail("BAD_ARGS", "Unknown Word operation \"" + type + "\".");
     }
 
     static Bag StyleLess(Bag source)
     {
         Dictionary<string, object> copy = new Dictionary<string, object>();
-        foreach (string key in new string[] { "font", "size", "bold", "italic", "underline", "color", "align", "firstLineIndent", "spaceBefore", "spaceAfter", "lineSpacing" })
+        foreach (string key in new string[] { "font", "size", "bold", "italic", "underline", "color", "align", "firstLineIndent", "spaceBefore", "spaceAfter", "lineSpacing", "indentChars", "superscript", "subscript" })
             if (source.Has(key)) copy[key] = source.Raw(key);
         return new Bag(copy);
     }
 
+
+    // ───────────────────────── citations ─────────────────────────
+
+    static readonly System.Text.RegularExpressions.Regex Cites = new System.Text.RegularExpressions.Regex(@"\\cite\s*\{([0-9,\-–\s]+)\}");
+
+    /// One citation number at a position, as a superscript that jumps to the reference: a cross-reference field
+    /// when the reference list is already there, otherwise a link to the bookmark the list will bring.
+    static void CiteNumber(dynamic doc, int at, string number)
+    {
+        string mark = "cite_" + number;
+        dynamic spot = doc.Range(at, at);
+        if ((bool)doc.Bookmarks.Exists(mark))
+        {
+            // MERGEFORMAT keeps the superscript when the field is refreshed.
+            dynamic field = doc.Fields.Add(spot, -1, "REF " + mark + " \\h \\* MERGEFORMAT", false);
+            field.Result.Font.Superscript = 1;
+        }
+        else
+        {
+            dynamic link = doc.Hyperlinks.Add(Anchor: spot, Address: "", SubAddress: mark, TextToDisplay: number);
+            link.Range.Font.Superscript = 1;
+            link.Range.Font.Underline = 0;
+            link.Range.Font.Color = -16777216;
+        }
+    }
+
+    /// \cite{1}, \cite{2,5}, \cite{3-6} in a range become superscript [1], [2,5], [3-6] whose numbers jump to the references.
+    static int Cite(dynamic doc, dynamic range)
+    {
+        string text = (string)range.Text;
+        if (text == null || text.IndexOf("\\cite", StringComparison.Ordinal) < 0) return 0;
+        int made = 0;
+        System.Text.RegularExpressions.MatchCollection found = Cites.Matches(text);
+        for (int k = found.Count - 1; k >= 0; k--)
+        {
+            System.Text.RegularExpressions.Match m = found[k];
+            dynamic search = range.Duplicate;
+            if (!(bool)search.Find.Execute(FindText: m.Value, MatchCase: true, MatchWildcards: false, Forward: true, Wrap: 0)) continue;
+            int at = (int)search.Start;
+            search.Text = "";
+            // Written back to front at one position, so each piece lands before the one after it.
+            List<string> pieces = new List<string>();
+            pieces.Add("[");
+            foreach (string part in m.Groups[1].Value.Replace("–", "-").Replace(" ", "").Split(','))
+            {
+                if (part.Length == 0) continue;
+                if (pieces.Count > 1) pieces.Add(",");
+                string[] ends = part.Split('-');
+                pieces.Add("#" + ends[0]);
+                if (ends.Length > 1 && ends[1].Length > 0) { pieces.Add("-"); pieces.Add("#" + ends[1]); }
+            }
+            pieces.Add("]");
+            for (int p = pieces.Count - 1; p >= 0; p--)
+            {
+                string piece = pieces[p];
+                if (piece[0] == '#') { CiteNumber(doc, at, piece.Substring(1)); continue; }
+                doc.Range(at, at).InsertAfter(piece);
+                dynamic plain = doc.Range(at, at + piece.Length);
+                plain.Font.Superscript = 1;
+            }
+            made++;
+        }
+        return made;
+    }
+
+    /// Formulas and citations written in the text of a range.
+    static string Enrich(dynamic doc, dynamic range)
+    {
+        int cites = Cite(doc, range), equations = Mathify(doc, range);
+        return (equations > 0 ? ", " + equations + " equation(s)" : "") + (cites > 0 ? ", " + cites + " citation(s)" : "") + MathNote();
+    }
+
+    /// The reference list: "[n] ..." paragraphs whose numbers carry the bookmarks the citations point at.
+    static string References(dynamic doc, Bag op)
+    {
+        IList items = op.List("items");
+        if (items == null || items.Count == 0) throw new Fail("BAD_ARGS", "\"items\" must list the references, one string each.");
+        System.Text.RegularExpressions.Regex lead = new System.Text.RegularExpressions.Regex(@"^\s*\[(\d+)\]\s*");
+        dynamic current = null;
+        int number = 0;
+        foreach (object raw in items)
+        {
+            string body = Convert.ToString(raw).Trim();
+            System.Text.RegularExpressions.Match m = lead.Match(body);
+            if (m.Success) { number = int.Parse(m.Groups[1].Value); body = body.Substring(m.Length); }
+            else number++;
+            dynamic p = current == null ? NewParagraph(doc, op) : After(doc, current);
+            Plain(p, "Normal");
+            Follow(doc, p.Range);
+            string label = "[" + number + "] ";
+            Write(doc, (int)p.Range.Start, label + body);
+            Whole(p.Range);
+            try
+            {
+                dynamic format = p.Range.ParagraphFormat;
+                format.CharacterUnitFirstLineIndent = 0; format.FirstLineIndent = 0; format.Alignment = 3;
+                format.CharacterUnitLeftIndent = 0; format.LeftIndent = 21f; format.FirstLineIndent = -21f;
+            }
+            catch (COMException) { }
+            int start = (int)p.Range.Start;
+            string mark = "cite_" + number;
+            if ((bool)doc.Bookmarks.Exists(mark)) doc.Bookmarks[mark].Delete();
+            doc.Bookmarks.Add(mark, doc.Range(start + 1, start + 1 + number.ToString().Length));
+            current = p;
+        }
+        // Citations written before the list existed are links; now that their targets exist, make them cross-references.
+        int linked = 0;
+        for (int i = (int)doc.Hyperlinks.Count; i >= 1; i--)
+        {
+            dynamic link = doc.Hyperlinks[i];
+            string target = "";
+            try { target = (string)link.SubAddress; } catch (Exception) { }
+            if (target == null || !target.StartsWith("cite_", StringComparison.Ordinal) || !(bool)doc.Bookmarks.Exists(target)) continue;
+            dynamic spot = link.Range;
+            int at = (int)spot.Start;
+            link.Delete();
+            dynamic text = doc.Range(at, at + target.Length - 5);
+            text.Text = "";
+            dynamic field = doc.Fields.Add(doc.Range(at, at), -1, "REF " + target + " \\h \\* MERGEFORMAT", false);
+            field.Result.Font.Superscript = 1;
+            linked++;
+        }
+        return items.Count + " reference(s) listed" + (linked > 0 ? ", " + linked + " citation(s) in the text now cross-reference them" : "");
+    }
+
+    // ───────────────────────── styles and page layout ─────────────────────────
+
+    /// Styles the agent switched automatic numbering off for (document path | style name).
+    static readonly HashSet<string> Unnumbered = new HashSet<string>();
+
+    static dynamic StyleOf(dynamic doc, string name)
+    {
+        int builtin;
+        try { return WordStyles.TryGetValue(name, out builtin) ? doc.Styles[builtin] : doc.Styles[name]; }
+        catch (COMException) { throw new Fail("STYLE_MISSING", "This document has no style \"" + name + "\". Built-in names that always work: " + string.Join(", ", new List<string>(WordStyles.Keys).ToArray()) + "."); }
+    }
+
+    /// Change what a style looks like, for every paragraph that uses it.
+    static string StyleFormat(dynamic doc, Bag op)
+    {
+        string name = op.Need("style");
+        dynamic style = StyleOf(doc, name);
+        dynamic font = style.Font, format = style.ParagraphFormat;
+        if (op.Has("font")) { string f = op.Need("font"); font.Name = f; try { font.NameFarEast = f; } catch (COMException) { } }
+        if (op.Has("latinFont")) { string f = op.Need("latinFont"); try { font.NameAscii = f; font.NameOther = f; } catch (COMException) { } }
+        if (op.Has("size")) font.Size = (float)op.Num("size", 12);
+        if (op.Has("bold")) font.Bold = op.Flag("bold", false) ? 1 : 0;
+        if (op.Has("italic")) font.Italic = op.Flag("italic", false) ? 1 : 0;
+        if (op.Has("color")) font.Color = Bgr(op.Need("color"));
+        if (op.Has("align")) { string align = op.Need("align"); format.Alignment = align == "center" ? 1 : align == "right" ? 2 : align == "justify" ? 3 : 0; }
+        if (op.Has("indentChars")) { format.FirstLineIndent = 0; format.CharacterUnitFirstLineIndent = (float)op.Num("indentChars", 2); }
+        if (op.Has("firstLineIndent")) { format.CharacterUnitFirstLineIndent = 0; format.FirstLineIndent = (float)op.Num("firstLineIndent", 0); }
+        if (op.Has("spaceBefore")) format.SpaceBefore = (float)op.Num("spaceBefore", 0);
+        if (op.Has("spaceAfter")) format.SpaceAfter = (float)op.Num("spaceAfter", 0);
+        if (op.Has("lineSpacing")) { format.LineSpacingRule = 5; format.LineSpacing = (float)(op.Num("lineSpacing", 1) * 12); }
+        if (op.Has("pageBreakBefore")) format.PageBreakBefore = op.Flag("pageBreakBefore", false) ? -1 : 0;
+        if (op.Has("numbering") && !op.On("numbering"))
+        {
+            Unnumbered.Add((string)doc.FullName + "|" + (string)style.NameLocal);
+            // Stop the style from numbering its paragraphs by itself (headings that carry their number in the text).
+            try { style.LinkToListTemplate(null); } catch (Exception) { }
+            foreach (dynamic p in doc.Paragraphs)
+            {
+                try { if ((string)p.Style.NameLocal == (string)style.NameLocal && (int)p.Range.ListFormat.ListType != 0) p.Range.ListFormat.RemoveNumbers(); }
+                catch (Exception) { }
+            }
+        }
+        try { format.WordWrap = -1; } catch (Exception) { }
+        return "style \"" + (string)style.NameLocal + "\" changed";
+    }
+
+    static string PageSetup(dynamic doc, Bag op)
+    {
+        dynamic setup = doc.PageSetup;
+        const float cm = 28.3465f;
+        if (op.Has("paper")) { string paper = op.Need("paper").ToUpperInvariant(); setup.PaperSize = paper == "A3" ? 6 : paper == "LETTER" ? 2 : paper == "B5" ? 13 : 7; }
+        if (op.Has("orientation")) setup.Orientation = op.Need("orientation") == "landscape" ? 1 : 0;
+        if (op.Has("top")) setup.TopMargin = (float)op.Num("top", 2.54) * cm;
+        if (op.Has("bottom")) setup.BottomMargin = (float)op.Num("bottom", 2.54) * cm;
+        if (op.Has("left")) setup.LeftMargin = (float)op.Num("left", 3.17) * cm;
+        if (op.Has("right")) setup.RightMargin = (float)op.Num("right", 3.17) * cm;
+        return "page setup changed";
+    }
+
+    static string PageNumbers(dynamic doc, Bag op)
+    {
+        string align = op.Str("align", "center");
+        dynamic numbers = doc.Sections[1].Footers[1].PageNumbers;
+        numbers.Add(align == "left" ? 0 : align == "right" ? 2 : 1, op.Flag("firstPage", true));
+        if (op.Has("start")) { numbers.RestartNumberingAtSection = true; numbers.StartingNumber = op.Int("start", 1); }
+        return "page numbers added to the footer";
+    }
+
+    static string Toc(dynamic doc, Bag op)
+    {
+        dynamic p = NewParagraph(doc, op);
+        Plain(p, "Normal");
+        if (op.Has("title"))
+        {
+            p.Range.InsertBefore(op.Need("title"));
+            p.Range.ParagraphFormat.Alignment = 1; p.Range.ParagraphFormat.CharacterUnitFirstLineIndent = 0; p.Range.ParagraphFormat.FirstLineIndent = 0;
+            p.Range.Font.Bold = 1; p.Range.Font.Size = 16f;
+            p = After(doc, p);
+            Plain(p, "Normal");
+        }
+        Follow(doc, p.Range);
+        doc.TablesOfContents.Add(Range: p.Range, UseHeadingStyles: true, UpperHeadingLevel: 1, LowerHeadingLevel: Math.Max(1, Math.Min(9, op.Int("levels", 3))));
+        return "table of contents inserted (it is refreshed on every save)";
+    }
+
+    /// Bring fields up to date: the table of contents, cross-references, caption numbers.
+    static void Refresh(dynamic doc)
+    {
+        try { foreach (dynamic toc in doc.TablesOfContents) toc.Update(); } catch (Exception) { }
+        try { doc.Fields.Update(); } catch (Exception) { }
+    }
+
     // ───────────────────────── Excel ─────────────────────────
 
     static dynamic Sheet(dynamic book, Bag op)
@@ -1557,8 +1979,8 @@ static class Program
             range.HorizontalAlignment = align == "center" ? -4108 : align == "right" ? -4152 : -4131;
         }
         if (op.Has("wrap")) range.WrapText = op.Flag("wrap", false);
-        if (op.Flag("border", false)) range.Borders.LineStyle = 1;
-        if (op.Flag("merge", false)) range.Merge();
+        if (op.On("border")) range.Borders.LineStyle = 1;
+        if (op.On("merge")) range.Merge();
         if (op.Has("columnWidth")) range.ColumnWidth = op.Num("columnWidth", 10);
         if (op.Has("rowHeight")) range.RowHeight = op.Num("rowHeight", 15);
     }
@@ -1745,7 +2167,7 @@ static class Program
     {
         if (!Typing || text.Length < 4) { textRange.Text = text; return; }
         textRange.Text = "";
-        foreach (string piece in Pieces(text)) { textRange.InsertAfter(piece); Thread.Sleep(22); }
+        foreach (string piece in Pieces(text)) { textRange.InsertAfter(piece); Thread.Sleep(14); }
     }
 
     static void GoTo(dynamic deck, int slide)
@@ -1861,6 +2283,7 @@ static class Program
                 {
                     Bag op = new Bag(ops[i]);
                     type = op.Need("op");
+                    if (card) Card.Hold = true;
                     if (card) Card.Report("AI 正在编辑 " + docName + (ops.Count > 1 ? " · " + (i + 1) + "/" + ops.Count : ""));
                     string line = kind == "word" ? WordOp(doc, type, op) : kind == "excel" ? ExcelOp(app, doc, type, op) : PptOp(doc, type, op);
                     string ignored = op.Unread();
@@ -1883,7 +2306,7 @@ static class Program
         {
             if (undo != null) { try { undo.EndCustomRecord(); } catch (COMException) { } }
         }
-        if (card) Card.Report(result.ContainsKey("failed") ? "AI 的修改停在第 " + (done.Count + 1) + " 项" : "AI 已改好 " + docName);
+        if (card) Card.Hold = false;
         result["done"] = done;
         result["total"] = ops.Count;
         return result;
@@ -1891,8 +2314,97 @@ static class Program
 
     // ───────────────────────── rendering ─────────────────────────
 
+    /// One Word page as a picture of the given width.
+    static Bitmap WordPage(dynamic pages, int page, int width)
+    {
+        byte[] bits = (byte[])pages[page].EnhMetaFileBits;
+        using (MemoryStream stream = new MemoryStream(bits))
+        using (Metafile meta = new Metafile(stream))
+        {
+            int height = (int)Math.Round(width * (double)meta.Height / meta.Width);
+            // Drawn straight at the final size, hairlines (table borders) fall between pixels and vanish:
+            // draw the page large first, then scale the picture down.
+            int factor = Math.Max(2, (int)Math.Ceiling(3000.0 / width));
+            Bitmap bitmap = new Bitmap(width, height);
+            using (Bitmap large = new Bitmap(width * factor, height * factor))
+            {
+                using (Graphics g = Graphics.FromImage(large))
+                {
+                    g.Clear(Color.White);
+                    g.DrawImage(meta, 0, 0, large.Width, large.Height);
+                }
+                using (Graphics g = Graphics.FromImage(bitmap))
+                {
+                    g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
+                    g.DrawImage(large, 0, 0, width, height);
+                }
+            }
+            return bitmap;
+        }
+    }
+
+    /// Several pages or slides side by side in one picture, each with its number: the whole document at a glance.
+    static object Sheet(string kind, dynamic doc, Bag a)
+    {
+        string path = a.Need("out");
+        int cell = Math.Max(300, Math.Min(1000, a.Int("width", 640)));
+        dynamic pages = kind == "word" ? doc.Windows[1].Panes[1].Pages : null;
+        int total = kind == "word" ? (int)pages.Count : (int)doc.Slides.Count;
+        if (total == 0) throw new Fail("ANCHOR_MISSING", "There is nothing to picture yet.");
+        int first = Math.Max(1, a.Int("from", 1)), last = Math.Min(total, a.Int("to", total));
+        if (first > total) throw new Fail("ANCHOR_MISSING", "There is no " + (kind == "word" ? "page " : "slide ") + first + " (there are " + total + ").");
+        last = Math.Min(last, first + 11);
+        int count = last - first + 1, columns = Math.Min(count, kind == "word" ? 3 : 2), rows = (count + columns - 1) / columns;
+        List<Bitmap> pictures = new List<Bitmap>();
+        string temp = path + ".slide.png";
+        try
+        {
+            for (int n = first; n <= last; n++)
+            {
+                if (kind == "word") pictures.Add(WordPage(pages, n, cell));
+                else
+                {
+                    double ratio = (double)doc.PageSetup.SlideHeight / (double)doc.PageSetup.SlideWidth;
+                    doc.Slides[n].Export(temp, "PNG", cell, (int)Math.Round(cell * ratio));
+                    using (Image loaded = Image.FromFile(temp)) pictures.Add(new Bitmap(loaded));
+                }
+            }
+            int gap = 14, label = 30, height = 0;
+            foreach (Bitmap picture in pictures) height = Math.Max(height, picture.Height);
+            using (Bitmap sheet = new Bitmap(columns * cell + (columns + 1) * gap, rows * (height + label + gap) + gap))
+            {
+                using (Graphics g = Graphics.FromImage(sheet))
+                using (Font font = new Font("Microsoft YaHei UI", 14f, FontStyle.Bold, GraphicsUnit.Pixel))
+                using (Pen border = new Pen(Color.FromArgb(150, 150, 150)))
+                {
+                    g.Clear(Color.FromArgb(232, 232, 236));
+                    for (int k = 0; k < pictures.Count; k++)
+                    {
+                        int x = gap + (k % columns) * (cell + gap), y = gap + (k / columns) * (height + label + gap);
+                        g.DrawString((kind == "word" ? "page " : "slide ") + (first + k), font, Brushes.Black, x, y + 4);
+                        g.DrawImage(pictures[k], x, y + label);
+                        g.DrawRectangle(border, x, y + label, pictures[k].Width - 1, pictures[k].Height - 1);
+                    }
+                }
+                sheet.Save(path, ImageFormat.Png);
+            }
+        }
+        finally
+        {
+            foreach (Bitmap picture in pictures) picture.Dispose();
+            try { File.Delete(temp); } catch (Exception) { }
+        }
+        Dictionary<string, object> result = new Dictionary<string, object>();
+        result["what"] = (kind == "word" ? "pages " : "slides ") + first + "–" + last + " of " + total;
+        result["first"] = first; result["last"] = last; result["total"] = total;
+        result["path"] = path;
+        using (Image saved = Image.FromFile(path)) { result["width"] = saved.Width; result["height"] = saved.Height; }
+        return result;
+    }
+
     static object Render(string kind, dynamic app, dynamic doc, Bag a)
     {
+        if (a.Flag("sheet", false) && kind != "excel") return Sheet(kind, doc, a);
         string path = a.Need("out");
         int width = Math.Max(320, Math.Min(2400, a.Int("width", 1100)));
         Dictionary<string, object> result = new Dictionary<string, object>();

package/lib/client.js

@@ -491,7 +491,7 @@ window.__ModuleLoader__.load({
 			} }, !app.installed ? "未安装" : !app.running ? "已安装，未运行（需要时自动启动）" : app.documents.length === 0 ? "运行中，没有打开的文档" : `运行中：${app.documents.map((doc) => doc.name + (doc.saved ? "" : "（未保存）")).join("、")}`))), h("p", { style: S.hint }, "需要本机装有微软 Office。Word 里 AI 的一批修改可以用一次 Ctrl+Z 撤回；Excel 和 PowerPoint 的修改无法用 Ctrl+Z 撤回。你正在单元格里输入或开着对话框时，AI 会等你。")), h("section", { style: S.card }, h("h3", { style: S.cardTitle }, "行为"), h("div", { style: S.toggleRow }, h("div", { style: S.toggleText }, "跟随 AI 的修改位置", h("span", { style: {
 				...S.hint,
 				fontWeight: 400
-			} }, "AI 改到哪里，窗口就自动滚动到哪里（Word 滚到那一段，Excel 滚到那片单元格，PowerPoint 切到那一页），不用自己翻找。关闭即静默执行：AI 照常修改，但不动你的视图。想看时点迷你卡片上的“跟随”：文档窗口被带到前台并开始跟随；你切到别的窗口后它自动熄灭，再点一次回来。")), h(Switch, {
+			} }, "AI 改到哪里，窗口就自动滚动到哪里（Word 滚到那一段，Excel 滚到那片单元格，PowerPoint 切到那一页），不用自己翻找。关闭即静默执行：AI 照常修改，但不动你的视图。想看时点迷你卡片上的“查看”：文档窗口被带到前台并开始跟随，按钮变成“查看中”；你切到别的窗口后它自动熄灭，再点一次回来。")), h(Switch, {
 				checked: settings.follow,
 				disabled,
 				label: "跟随 AI 的修改位置",
@@ -501,7 +501,7 @@ window.__ModuleLoader__.load({
 			})), h("div", { style: S.toggleRow }, h("div", { style: S.toggleText }, "逐字写入", h("span", { style: {
 				...S.hint,
 				fontWeight: 400
-			} }, "文字像打字一样逐步出现，而不是整块贴上去；表格逐行填入。每段最多多花约 1 秒，关闭后写得最快。")), h(Switch, {
+			} }, "文字像打字一样逐步出现，而不是整块贴上去；表格逐行填入。每段约多花 0.3 秒，关闭后写得最快。")), h(Switch, {
 				checked: settings.typing,
 				disabled,
 				label: "逐字写入",
@@ -511,7 +511,7 @@ window.__ModuleLoader__.load({
 			})), h("div", { style: S.toggleRow }, h("div", { style: S.toggleText }, "迷你卡片", h("span", { style: {
 				...S.hint,
 				fontWeight: 400
-			} }, "AI 编辑时在屏幕右下角显示一张小卡片：正在改哪个文档、改到第几项，以及“跟随”“逐字”两个开关，点一下立即生效（连正在进行的这一批也会跟着变）。卡片可拖动，不抢焦点，AI 停手几秒后自动消失。在卡片上切换过的开关，本次运行期间以卡片为准。")), h(Switch, {
+			} }, "AI 每次动手修改文档时，屏幕右下角显示一张小卡片：正在改哪个文档、改到第几项，以及“查看”“逐字”两个开关，点一下立即生效（连正在进行的这一批也会跟着变）。卡片可拖动，不抢焦点；这一批改完就消失，下一批开始时再出现。在卡片上切换过的开关，本次运行期间以卡片为准。")), h(Switch, {
 				checked: settings.card,
 				disabled,
 				label: "迷你卡片",
@@ -521,7 +521,7 @@ window.__ModuleLoader__.load({
 			})), h("div", { style: S.toggleRow }, h("div", { style: S.toggleText }, "交付前整体视觉检查", h("span", { style: {
 				...S.hint,
 				fontWeight: 400
-			} }, "AI 保存时，如果它改完之后还没看过成品，就自动把文档各页（最多 8 页）渲染成图片交给它过一遍，发现问题先修再交付。会多用一些 token。")), h(Switch, {
+			} }, "AI 保存时，如果它改完之后还没看过成品，就自动把整份文档拼成带页码的总览图（一张图最多 6 页）交给它过一遍，发现问题先修再交付。会多用一些 token。")), h(Switch, {
 				checked: settings.finalCheck,
 				disabled,
 				label: "交付前整体视觉检查",

package/lib/index.js

@@ -251,8 +251,9 @@ function promptText() {
 		"- Put all the changes you can into one office_edit call; it runs them in order.",
 		"- The user may edit while you work. Read again before editing a part you have not just read, and pass \"expect\" on Word paragraphs.",
 		"- Use these tools, not python-docx / openpyxl / python-pptx or other file libraries, whenever the document is to be worked on in the user's Office app or is already open there; and check the result with office_render, not by converting the file with another renderer, which lays it out differently from Word.",
-		"- Finish with a polish pass, it is part of the job: office_render every page or slide you changed, look at the pictures the way a careful reader would, fix what is off with office_edit, and render again until it is right. Look for: content outside the frame or section it belongs to; fonts, sizes and line spacing that differ from the surrounding text or from what the template asks for; formulas left as plain text; tables that are too wide, uneven or uncentred; captions not next to their table or figure; leftover template hints and sample text; runs of blank paragraphs and half-empty pages. Then office_save. Nothing is saved until you call office_save; do not close the user's documents.",
-		"- In Word, formulas are LaTeX between dollar signs ($...$ inline, $$...$$ on its own line); they become native equations.",
+		"- Finish with a polish pass, it is part of the job: office_render with overview: true for the whole document at a glance, then the pages that need a closer look; look at the pictures the way a careful reader would, fix what is off with office_edit, and render again until it is right. Look for: content outside the frame or section it belongs to; fonts, sizes and line spacing that differ from the surrounding text or from what the template asks for; formulas left as plain text; tables that are too wide, uneven or uncentred; captions not next to their table or figure; leftover template hints and sample text; runs of blank paragraphs and half-empty pages. Then office_save. Nothing is saved until you call office_save; do not close the user's documents.",
+		"- In Word, formulas are LaTeX between dollar signs ($...$ inline, $$...$$ on its own line); they become native equations. Citations are \\cite{n} plus insert_references.",
+		"- Set the look through styles before writing a long document (style_format for Normal and the headings, page_setup); all of that is done with office_edit, not with mouse and keyboard in Word's dialogs.",
 		"- When filling in a template, keep its structure: put each part where its heading is, replace or delete the sample text and hints, and match the formatting the template asks for.",
 		"- If a call reports the app is busy, the user is typing or has a dialog open: wait a moment and retry.",
 		"- If you also have mouse / keyboard computer tools, use them on an Office window only for what office_edit cannot do, such as a setting that exists only in a dialog."
@@ -5958,6 +5959,15 @@ function formatPpt(read) {
 	}
 	return lines.join("\n");
 }
+/** Failures found before anything was touched. */
+const PRECHECKED = /* @__PURE__ */ new Set([
+	"BAD_ARGS",
+	"ANCHOR_MISSING",
+	"ANCHOR_MISMATCH",
+	"NOT_FOUND",
+	"STYLE_MISSING",
+	"BUSY"
+]);
 function formatEdit(result) {
 	const done = result.done.map((line, index) => `${index + 1}. ${line}`);
 	if (!result.failed) return [
@@ -5968,7 +5978,8 @@ function formatEdit(result) {
 	const { index, op, error } = result.failed;
 	return [
 		`Stopped at operation ${index + 1} (${op}): ${error}`,
-		done.length ? `Applied before it:\n${done.join("\n")}` : "Nothing was applied.",
+		done.length ? `Applied before it:\n${done.join("\n")}` : "Nothing before it was applied.",
+		PRECHECKED.has(result.failed.code) ? "" : "The failed operation itself may have changed part of the document: read it before you retry.",
 		result.total - index - 1 > 0 ? `The ${result.total - index - 1} operation(s) after it did not run.` : ""
 	].filter(Boolean).join("\n");
 }
@@ -6107,15 +6118,18 @@ const EDIT_GUIDE = `Edit a document that is open in Word, Excel or PowerPoint, l
 
 Word ops. para = paragraph number from office_read; pass expect = its first words so a number made stale by other edits is caught. where = after (default with para) | before | start | end (default without para: the very end of the document).
 In a form or template whose sections are table cells, write INSIDE the cell: give para = a paragraph of that cell. Without para the text or table lands after everything, outside the form.
-Formulas: write LaTeX between dollar signs in any text: $...$ inside a sentence, $$...$$ as a paragraph of its own. Number a display formula when the document numbers its formulas by ending it with \\tag{1}: $$T=2\\pi\\sqrt{l/g} \\tag{1}$$ puts (1) flush right. They become native Word equations (\\frac, \\sqrt, ^, _, Greek letters, \\bar, \\sum, \\int ...). Never write a formula as plain text such as T = 2π√(l/g).
+Formulas: write LaTeX between dollar signs in any text (paragraphs, table cells, captions, replace_text): $...$ inside a sentence, $$...$$ as a paragraph of its own. Every symbol, subscript, power, norm or matrix in running text goes between dollar signs too ($\\kappa(A)$, $\\|x\\|_2$, $10^{-8}$, \\begin{pmatrix}..\\end{pmatrix}, \\begin{cases}..\\end{cases}); do not type them with Unicode characters such as ‖x‖₂ or κ₂. Number a display formula when the document numbers its formulas by ending it with \\tag{1}: $$T=2\\pi\\sqrt{l/g} \\tag{1}$$ puts (1) flush right. They become native Word equations (\\frac, \\sqrt, ^, _, Greek letters, \\bar, \\sum, \\int ...). Never write a formula as plain text such as T = 2π√(l/g).
 - insert_paragraphs {items:[{text, style?}], para?, expect?, where?} — style: Normal, Title, Heading 1..6, List Bullet, List Number, Quote, or a style name the document has. Without style a paragraph is body text in the font, size and spacing of the text it is placed next to. A newline in text starts another paragraph. Items also take the format_text fields.
 - set_text {para, expect, text} — rewrite one paragraph, keeping its style. expect is required ("" for an empty paragraph).
-- replace_text {find, replace, all?}
-- format_text {para?, to?, find?, style?, font?, size?, bold?, italic?, underline?, color?, align?, firstLineIndent?, spaceBefore?, spaceAfter?, lineSpacing?} — para..to, or the first match of find.
+- replace_text {find, replace, all?} — find is literal text within one paragraph; replace may hold formulas and citations.
+- format_text {para?, to?, find?, style?, font?, size?, bold?, italic?, underline?, superscript?, subscript?, color?, align?, indentChars?, firstLineIndent?, spaceBefore?, spaceAfter?, lineSpacing?} — para..to, or the first match of find.
 - delete_range {para, expect, to?} — expect is required; para..to in one operation removes a run of paragraphs (leftover hints, surplus blank lines). Paragraph numbers shift after every insert or delete; each result tells you the new numbers.
 - insert_table {data:[[cell,..],..], caption?, para?, where?, header?} — with para inside a cell, the table goes inside that cell. set_cell {table, row, col, text}
 - Captions: give caption (the title only, no "表 1") on insert_table / insert_image. It is set the standard way: numbered automatically ("表 1", "图 1"), centred, above a table and below a figure. Do not write captions as ordinary paragraphs.
 - insert_image {path, caption?, para?, where?, width?} — the picture is centred on a line of its own.
+- Citations: write \\cite{1}, \\cite{2,5} or \\cite{3-6} in the text where the source is used; they become superscript [1] that jump to the reference. List the sources with insert_references {items:["Author. Title[M]. ...", ..], para?, where?} (numbered [1], [2].. in order; put it under a "参考文献" heading). Do not type [1] by hand.
+- style_format {style, font?, latinFont?, size?, bold?, italic?, color?, align?, indentChars?, spaceBefore?, spaceAfter?, lineSpacing?, pageBreakBefore?, numbering?: false} — change what a style looks like everywhere it is used (e.g. Heading 1 in 黑体 三号 without automatic numbers; Normal in 宋体 小四, 1.5 lines, 2-character first-line indent). Set the styles first, then write; this replaces fiddling with Word's style dialogs.
+- page_setup {paper?: A4|A3|B5|Letter, orientation?, top?, bottom?, left?, right?} (margins in cm); page_numbers {align?, start?}; header {text}; page_break {para, expect} (that paragraph starts a new page); insert_toc {title?, levels?, para?, where?}; update_fields {}
 
 Excel ops. sheet = sheet name (default: the active sheet).
 - write_range {range: top-left cell, values:[[..],..]} — a string starting with "=" is a formula; also takes the format_range fields.
@@ -6137,6 +6151,7 @@ function createTools(host) {
 	const { helper } = host;
 	const tools = [];
 	let current;
+	const own = /* @__PURE__ */ new Set();
 	const unseen = /* @__PURE__ */ new Set();
 	const keyOf = (on) => `${on.app}:${fileName(on.doc).toLowerCase()}`;
 	/** Pictures of the document as it is now: Word pages or PowerPoint slides first..last, or an Excel range. */
@@ -6178,6 +6193,38 @@ function createTools(host) {
 			...total === void 0 ? {} : { total }
 		};
 	};
+	/** The whole document at a glance: its pages (6 to a picture) or slides tiled with their numbers, up to 18. */
+	const overview = async (on) => {
+		if (on.app === "excel") return picture(on, 0, 0, {}, Math.min(host.settings().renderWidth, 1e3));
+		const folder = join(tmpdir(), "dsh-office");
+		await mkdir(folder, { recursive: true });
+		const lines = [];
+		const images = [];
+		let total = 1;
+		for (let from = 1; from <= Math.min(total, 18); from += 6) {
+			const out = join(folder, `sheet-${process.pid}-${Date.now()}-${from}.png`);
+			try {
+				const result = await helper.call("render", {
+					...on,
+					sheet: true,
+					from,
+					to: from + 5,
+					out,
+					width: 640
+				}, 11e4);
+				total = result.total;
+				images.push(toJson(await host.saveImage(await readFile(out), `${on.app}-overview-${from}.png`)));
+				lines.push(`${APP_NAMES[on.app]} ${result.what}, tiled in one picture.`);
+			} finally {
+				await rm(out, { force: true });
+			}
+		}
+		if (total > 18) lines.push(`Only the first 18 of ${total} are shown.`);
+		return {
+			lines,
+			images
+		};
+	};
 	/** The helper arguments naming the document; the app comes from doc / app only, never from a save-as path. */
 	const target = (args) => {
 		if (args.doc === void 0 && args.app === void 0) {
@@ -6233,6 +6280,7 @@ function createTools(host) {
 				app: kind,
 				doc: doc.path ?? doc.name
 			};
+			if (doc.how !== "attached") own.add(keyOf(current));
 			return { text: formatOpened(doc) };
 		},
 		presentCall: (args) => card(`打开 ${fileName(args.path) || "新文档"}`)
@@ -6344,7 +6392,7 @@ function createTools(host) {
 	}));
 	tools.push(defineTool({
 		name: "office_render",
-		description: "Get a picture of how the open document really looks: a Word page, a PowerPoint slide (with \"to\": up to 4 in a row), or an Excel range (default: the used range). Use it on every page you changed before you finish: it shows what office_read cannot, such as content that landed outside its frame, a table that is too wide, text that overflows. It pictures the document as Word itself lays it out, unsaved changes included, with the window in the background.",
+		description: "Get a picture of how the open document really looks: a Word page, a PowerPoint slide (with \"to\": up to 4 in a row), an Excel range (default: the used range), or with overview: true the whole document tiled into one picture. Use it on every page you changed before you finish: it shows what office_read cannot, such as content that landed outside its frame, a table that is too wide, text that overflows. It pictures the document as Word itself lays it out, unsaved changes included, with the window in the background.",
 		parameters: {
 			doc: DOC,
 			app: APP,
@@ -6360,6 +6408,10 @@ function createTools(host) {
 				type: "integer",
 				description: "Word / PowerPoint: last page or slide, to get up to 4 in one call."
 			},
+			overview: {
+				type: "boolean",
+				description: "Word / PowerPoint: every page or slide tiled into one picture (6 pages per picture, numbered): the whole document at a glance, for the final check. Then look closer at a page with page / slide."
+			},
 			sheet: {
 				type: "string",
 				description: "Excel: sheet name."
@@ -6374,9 +6426,19 @@ function createTools(host) {
 		async execute(args, exec) {
 			const input = args;
 			const on = target(input), kind = on.app;
-			if (kind === "ppt" && input.slide === void 0) throw new Error("slide is required for PowerPoint.");
+			if (kind === "ppt" && input.slide === void 0 && input.overview !== true) throw new Error("slide is required for PowerPoint (or pass overview: true).");
 			if (!await host.vision(exec)) return { text: "The current model cannot view images; check the result with office_read instead." };
-			const { doc: _doc, app: _app, to, page: _page, slide: _slide, ...rest } = input;
+			if (input.overview === true && kind !== "excel") {
+				const all = await overview(on);
+				unseen.delete(keyOf(on));
+				const [image, ...more] = all.images;
+				return {
+					text: all.lines.join("\n"),
+					...image === void 0 ? {} : { image },
+					...more.length ? { more } : {}
+				};
+			}
+			const { doc: _doc, app: _app, to, page: _page, slide: _slide, overview: _overview, ...rest } = input;
 			const first = kind === "word" ? input.page ?? 1 : kind === "ppt" ? input.slide : 0;
 			const last = kind === "excel" || to === void 0 ? first : Math.min(Math.max(to, first), first + 3);
 			const { lines, images } = await picture(on, first, last, rest, host.settings().renderWidth);
@@ -6413,10 +6475,16 @@ function createTools(host) {
 			}, 11e4);
 			const moved = input.path !== void 0 && extname(input.path).toLowerCase() !== ".pdf";
 			const wasUnseen = unseen.delete(keyOf(on));
-			if (moved) current = {
-				app: on.app,
-				doc: result.path
-			};
+			if (moved) {
+				if (own.delete(keyOf(on))) own.add(keyOf({
+					app: on.app,
+					doc: result.path
+				}));
+				current = {
+					app: on.app,
+					doc: result.path
+				};
+			}
 			const text = `Saved ${result.path} (${result.bytes} bytes).${moved ? " The open document is now this file." : ""}`;
 			if (!wasUnseen || !host.settings().finalCheck || !await host.vision(exec)) return { text };
 			try {
@@ -6424,10 +6492,10 @@ function createTools(host) {
 					app: on.app,
 					doc: result.path
 				} : on;
-				const shown = await picture(now, 1, on.app === "excel" ? 1 : 8, {}, Math.min(host.settings().renderWidth, 800));
+				const shown = await overview(now);
 				const [image, ...more] = shown.images;
 				return {
-					text: `${text}\nFinal check: you edited after you last looked at the document, so here is ${on.app === "excel" ? "the sheet" : `${shown.images.length}${shown.total !== void 0 && shown.total > shown.images.length ? ` of ${shown.total}` : ""} ${on.app === "word" ? "page(s)" : "slide(s)"}`} as it is now. Go through every picture before you tell the user it is done. If anything is off (content outside its frame, uneven fonts or spacing, formulas as plain text, bad tables, leftover hints, blank gaps), fix it with office_edit and save again; if all is well, say so.`,
+					text: `${text}\nFinal check: you edited after you last looked at the document, so here is the whole of it as it is now. ${shown.lines.join(" ")}\nGo through every page before you tell the user it is done. If anything is off (content outside its frame, uneven fonts or spacing, formulas as plain text, bad tables, leftover hints, blank gaps, a nearly empty last page), look closer with office_render, fix it with office_edit and save again; if all is well, say so.`,
 					...image === void 0 ? {} : { image },
 					...more.length ? { more } : {}
 				};
@@ -6437,6 +6505,38 @@ function createTools(host) {
 		},
 		presentCall: (args) => card(`保存 ${fileName(args.path ?? args.doc) || "当前文档"}`)
 	}));
+	tools.push(defineTool({
+		name: "office_close",
+		description: "Close a document that YOU opened or created with office_open (a scratch file, a source you are done with). Documents the user already had open are theirs and are refused. Unsaved changes are refused unless you pass save.",
+		parameters: {
+			doc: DOC,
+			app: APP,
+			save: {
+				type: "boolean",
+				description: "true: save and close. false: close and drop unsaved changes."
+			}
+		},
+		output,
+		timeoutMs: 6e4,
+		async execute(args) {
+			const input = args;
+			const on = target(input);
+			if (!own.has(keyOf(on))) throw new Error("This document was open before you came to it, or was not opened by you: leave closing it to the user.");
+			if (input.save === void 0) {
+				const info = (await helper.call("status", {}, 3e4)).flatMap((app) => app.documents).find((doc) => doc.app === on.app && fileName(doc.path ?? doc.name).toLowerCase() === fileName(on.doc).toLowerCase());
+				if (info && !info.saved) throw new Error("It has unsaved changes: pass save: true to keep them or save: false to drop them.");
+			}
+			await helper.call("close", {
+				...on,
+				save: input.save === true
+			}, 5e4);
+			own.delete(keyOf(on));
+			unseen.delete(keyOf(on));
+			if (current && keyOf(current) === keyOf(on)) current = void 0;
+			return { text: `Closed ${fileName(on.doc)}.` };
+		},
+		presentCall: (args) => card(`关闭 ${fileName(args.doc) || "文档"}`)
+	}));
 	return tools;
 }
 //#endregion
@@ -6450,8 +6550,8 @@ const Config = z.object({
 		"en-US": { $description: "Scroll to where the AI is editing; off = silent, your view is left alone" }
 	}),
 	typing: z.boolean().default(true).volatile().i18n({
-		"zh-CN": { $description: "文字像打字一样逐步写出，而不是整块出现（每段最多约 1 秒）" },
-		"en-US": { $description: "Write text progressively like typing instead of all at once (about a second per paragraph at most)" }
+		"zh-CN": { $description: "文字像打字一样逐步写出，而不是整块出现（每段约多花 0.3 秒）" },
+		"en-US": { $description: "Write text progressively like typing instead of all at once (about 0.3 s more per paragraph)" }
 	}),
 	card: z.boolean().default(true).volatile().i18n({
 		"zh-CN": { $description: "AI 编辑时在屏幕右下角显示迷你卡片，可随时开关“跟随”和“逐字”" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@copylee/dsh-office",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "DeepSeek Harness Office 插件（Windows）：AI 直接在你打开的 Word / Excel / PowerPoint 里改文档，改动实时出现在窗口中，你可以同时编辑；读结构、批量编辑、渲染成图核对、保存。",
   "type": "module",
   "author": "copylee",