@copylee/dsh-office 0.2.1 → 0.2.3

package/README.md

@@ -15,12 +15,15 @@
 | 不需要窗口在前台 | 修改不靠鼠标键盘，Office 窗口被挡住或在后台也照常进行，你可以同时用电脑做别的事 |
 | 跟随与静默 | 默认“跟随”：AI 改到哪里，窗口自动滚动到哪里（Word 滚到那一段，Excel 滚到那片单元格，PowerPoint 切到那一页），不动你的光标和选区。关闭即静默执行，不动你的视图 |
 | 逐字写入 | 文字分小段写出，像打字一样出现，表格逐行填入，而不是整块贴上去。每段最多多花约 1 秒，可关闭 |
-| 迷你卡片 | AI 编辑时屏幕右下角出现一张小卡片：正在改哪个文档、改到第几项，带“跟随”“逐字”两个开关，点一下立即生效（正在进行的这一批也跟着变）。可拖动，不抢焦点，AI 停手几秒后自动消失 |
+| 迷你卡片 | AI 打开或编辑文档时屏幕右下角出现一张小卡片：正在改哪个文档、改到第几项，带“跟随”“逐字”两个开关，点一下立即生效（正在进行的这一批也跟着变）。点“跟随”会把文档窗口带到前台并开始跟随；你切到别的窗口后它自动熄灭，再点一次回来。可拖动，不抢焦点，AI 停手几秒后自动消失 |
 | Word 原生公式 | AI 在文字里用 `$...$`（行内）和 `$$...$$`（单独一行）写 LaTeX，插件转成 Word 原生公式（分式、根号、上下标、希腊字母、求和、积分、上划线等常用写法）；单独一行的公式末尾加 `\tag{1}` 即在右侧对齐编号 |
 | 填模板 | 报告模板常把正文放在大单元格里。这类表格会按段落展开给模型看，正文、公式、表格都写进单元格里面，而不是堆到文档末尾；新写的正文沿用旁边正文的字体、字号和行距 |
 | 规范的图表题注 | 插入表格或图片时给出题注，插件按规范排：自动编号（“表 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,7 +64,7 @@ AI 只有在调用保存时才写入文件，不会替你关闭文档。
 | `office_status` | 列出三个应用里现在打开了什么、哪些有未保存的修改 |
 | `office_read` | 把打开的文档读成文本（段落 / 单元格 / 形状） |
 | `office_edit` | 按顺序执行一批修改，不保存 |
-| `office_render` | 把一页 / 一张幻灯片 / 一个单元格区域渲染成图片；Word 和 PowerPoint 一次最多看 4 页 |
+| `office_render` | 把一页 / 一张幻灯片 / 一个单元格区域渲染成图片；Word 和 PowerPoint 一次最多看 4 页，或用总览把全部页面拼成一张图 |
 | `office_save` | 保存；给出路径时另存为，扩展名为 `.pdf` 时导出 PDF；改完没看过成品时附带各页图片 |
 
 `office_edit` 支持的操作：
@@ -78,8 +81,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 |

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);
@@ -119,6 +129,20 @@ class Card : Form
     readonly System.Windows.Forms.Timer timer = new System.Windows.Forms.Timer();
 
     [DllImport("user32.dll")] static extern bool ShowWindow(IntPtr handle, int command);
+    [DllImport("user32.dll")] static extern IntPtr GetForegroundWindow();
+    [DllImport("user32.dll")] static extern bool SetForegroundWindow(IntPtr handle);
+    [DllImport("user32.dll")] static extern bool IsIconic(IntPtr handle);
+
+    /// The user is looking at the document: its window is the foreground one.
+    static bool Watching()
+    {
+        IntPtr doc = Program.DocWindow;
+        return doc != IntPtr.Zero && GetForegroundWindow() == doc;
+    }
+
+    // Following means "keep the document in front of me and scroll to the edits". It holds while the user
+    // stays in that window; once they go elsewhere it switches itself off, and the button brings them back.
+    bool wasWatching, lit;
 
     protected override bool ShowWithoutActivation { get { return true; } }
 
@@ -147,7 +171,21 @@ class Card : Form
         Location = new Point(area.Right - Width - S(18), area.Bottom - Height - S(18));
         using (System.Drawing.Drawing2D.GraphicsPath path = Rounded(new Rectangle(0, 0, Width, Height), S(10))) Region = new Region(path);
         timer.Interval = 500;
-        timer.Tick += delegate { if (Visible && (DateTime.UtcNow - shown).TotalSeconds > 6) Hide(); };
+        timer.Tick += delegate
+        {
+            bool watching = Watching();
+            if (watching) wasWatching = true;
+            else if (wasWatching && Program.Following)
+            {
+                // The user left the document for another window.
+                wasWatching = false;
+                Program.Following = false;
+                FollowChosen = true;
+            }
+            bool nowLit = Program.Following && watching;
+            if (nowLit != lit) { lit = nowLit; Invalidate(); }
+            if (Visible && (DateTime.UtcNow - shown).TotalSeconds > 6) Hide();
+        };
         timer.Start();
     }
 
@@ -187,7 +225,8 @@ class Card : Form
         {
             int right = Width - S(10);
             Chip(g, font, "逐字", Program.Typing, ref right, out typingBox);
-            Chip(g, font, "跟随", Program.Following, 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);
@@ -208,7 +247,23 @@ class Card : Form
     {
         pressed = false;
         if (dragged) return;
-        if (followBox.Contains(e.Location)) { Program.Following = !Program.Following; FollowChosen = true; }
+        if (followBox.Contains(e.Location))
+        {
+            FollowChosen = true;
+            if (Program.Following && Watching()) Program.Following = false;
+            else
+            {
+                // Bring the document to the front and follow from here on.
+                Program.Following = true;
+                wasWatching = true;
+                IntPtr doc = Program.DocWindow;
+                if (doc != IntPtr.Zero)
+                {
+                    if (IsIconic(doc)) ShowWindow(doc, 9);
+                    SetForegroundWindow(doc);
+                }
+            }
+        }
         else if (typingBox.Contains(e.Location)) { Program.Typing = !Program.Typing; TypingChosen = true; }
         shown = DateTime.UtcNow;
         Invalidate();
@@ -560,6 +615,7 @@ static class Program
         }
         Dictionary<string, object> info = Info(kind, doc, Active(kind, app));
         info["how"] = how;
+        Remember(doc);
         if (a.Flag("card", false))
         {
             if (!cardStarted) { cardStarted = true; Card.Start(); }
@@ -680,6 +736,14 @@ static class Program
 
     /// Scroll the window to where the agent is working (off = silent mode: the user's view is left alone).
     public static volatile bool Following;
+    /// The window of the document being worked on (0 when unknown), for the card to bring forward.
+    public static IntPtr DocWindow = IntPtr.Zero;
+
+    static void Remember(dynamic doc)
+    {
+        try { DocWindow = new IntPtr(Convert.ToInt64(doc.Windows[1].Hwnd)); }
+        catch (Exception) { DocWindow = IntPtr.Zero; }
+    }
     /// Write text a few characters at a time, the way a person types, instead of all at once.
     public static volatile bool Typing;
 
@@ -1094,6 +1158,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)
     {
@@ -1105,8 +1200,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;
@@ -1146,10 +1260,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);
@@ -1210,6 +1327,7 @@ static class Program
             if (items == null) { items = new ArrayList(); items.Add(new Dictionary<string, object> { { "text", op.Need("text") } }); }
             dynamic current = null;
             int made = 0, equations = 0;
+            string lint = "";
             foreach (object raw in items)
             {
                 Bag item = raw is string ? new Bag(new Dictionary<string, object> { { "text", raw } }) : new Bag(raw);
@@ -1225,13 +1343,16 @@ 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);
+                    Whole(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)" : "") + lint;
         }
         if ((type == "set_text" || (type == "delete_range" && op.Has("para"))) && op.Raw("expect") == null)
         {
@@ -1244,6 +1365,7 @@ static class Program
             range.MoveEnd(1, -1);
             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)" : "");
         }
@@ -1306,6 +1428,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) { }
@@ -1328,7 +1451,13 @@ static class Program
                     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
             {
@@ -1504,8 +1633,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);
     }
@@ -1793,6 +1922,7 @@ static class Program
         if (!Card.FollowChosen) Following = a.Flag("follow", false);
         if (!Card.TypingChosen) Typing = a.Flag("typing", false);
         bool card = a.Flag("card", false);
+        Remember(doc);
         if (card && !cardStarted) { cardStarted = true; Card.Start(); }
         string docName = (string)doc.Name;
         dynamic undo = null;
@@ -1837,8 +1967,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 的修改位置",
@@ -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,7 +251,7 @@ 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.",
+		"- 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.",
 		"- 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.",
@@ -6178,6 +6178,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) {
@@ -6344,7 +6376,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 +6392,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 +6410,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);
@@ -6424,10 +6470,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 } : {}
 				};

package/package.json

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