@copylee/dsh-office 0.2.3 → 0.3.0

package/README.md

@@ -14,9 +14,11 @@
 | 实时可见，可以一起改 | 每一步修改即时出现在 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 技能会让模型写脚本生成文件，这样你看不到过程，文件开着时还会写入失败。插件在模型第一次加载这些技能时把它引回来，确有需要（批量转换、应用打不开的文件）再次请求即放行 |
@@ -66,10 +68,11 @@ AI 只有在调用保存时才写入文件，不会替你关闭文档。
 | `office_edit` | 按顺序执行一批修改，不保存 |
 | `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`
 
@@ -81,7 +84,7 @@ AI 只有在调用保存时才写入文件，不会替你关闭文档。
 |---|---|---|
 | 跟随 AI 的修改位置 | 开 | 窗口自动滚动到 AI 正在修改的位置；关闭为静默执行 |
 | 逐字写入 | 开 | 文字像打字一样逐步出现；关闭后写得最快 |
-| 迷你卡片 | 开 | AI 编辑时在右下角显示带“跟随”“逐字”开关的小卡片。在卡片上切换过的开关（包括你离开文档窗口后自动熄灭的“跟随”），到 DSH 重启前以卡片为准 |
+| 迷你卡片 | 开 | AI 修改文档期间在右下角显示带“查看”“逐字”开关的小卡片。在卡片上切换过的开关（包括你离开文档窗口后自动熄灭的“查看”），到 DSH 重启前以卡片为准 |
 | 交付前整体视觉检查 | 开 | 保存时自动把整份文档的总览图交给 AI 检查；会多用一些 token |
 | 优先在真实 Office 里操作 | 开 | DSH 桌面版自带 office-docx / office-xlsx / office-pptx 技能，用脚本生成文件。开启后，AI 第一次想加载这些技能时会被引回本插件（对应的 Office 应用已安装时才拦）；它再次请求时放行 |
 | 打开文档时显示到前台 | 开 | 关闭后文档仍会打开，只是不抢当前窗口 |
@@ -94,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

@@ -119,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;
@@ -184,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();
     }
@@ -226,7 +228,7 @@ class Card : Form
             int right = Width - S(10);
             Chip(g, font, "逐字", Program.Typing, ref right, out typingBox);
             bool following = Program.Following && Watching();
-            Chip(g, font, following ? "跟随中" : "跟随", following, ref right, out followBox);
+            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);
@@ -507,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);
@@ -621,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;
     }
@@ -650,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)
@@ -755,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;
     }
@@ -777,7 +787,7 @@ static class Program
         {
             doc.Range(at, at).InsertAfter(piece);
             at += piece.Length;
-            Thread.Sleep(22);
+            Thread.Sleep(14);
         }
         return at;
     }
@@ -797,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" },
@@ -842,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;
@@ -853,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.
@@ -892,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(' ');
                     }
@@ -905,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; }
@@ -934,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);
@@ -952,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 ─────────────────────────
@@ -1132,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.
@@ -1311,22 +1400,34 @@ 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)
             {
@@ -1345,14 +1446,20 @@ static class Program
                     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)" : "") + lint;
+            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)
         {
@@ -1366,8 +1473,8 @@ static class Program
             range.Text = "";
             Write(doc, (int)p.Range.Start, Lines(op.Raw("text") ?? ""));
             Whole(p.Range);
-            int built = Mathify(doc, p.Range);
-            return "paragraph " + op.Int("para", 0) + " rewritten" + (built > 0 ? ", " + built + " equation(s)" : "");
+            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")
         {
@@ -1412,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");
@@ -1446,7 +1554,8 @@ 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);
                 }
@@ -1469,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")
         {
@@ -1479,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")
         {
@@ -1500,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)
@@ -1821,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)
@@ -1937,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();
@@ -1959,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;

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: "迷你卡片",

package/lib/index.js

@@ -252,7 +252,8 @@ function promptText() {
 		"- 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 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.",
+		"- 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. */
@@ -6265,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) || "新文档"}`)
@@ -6459,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 {
@@ -6483,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
@@ -6496,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.3",
+  "version": "0.3.0",
   "description": "DeepSeek Harness Office 插件（Windows）：AI 直接在你打开的 Word / Excel / PowerPoint 里改文档，改动实时出现在窗口中，你可以同时编辑；读结构、批量编辑、渲染成图核对、保存。",
   "type": "module",
   "author": "copylee",