dsh-origin-bridge 0.4.6 → 0.4.8

package/README.md

@@ -11,13 +11,14 @@
 </p>
 
 <p align="center">
-  <sub>27 个工具 · <b>1118 例全链路测试全部通过</b> · 数据不出本机 · 支持工作站 <code>.txt</code> / <code>.bin</code></sub>
+  <sub>27 个工具 · <b>1126 例全链路测试全部通过</b> · 数据不出本机 · 支持工作站 <code>.txt</code> / <code>.bin</code></sub>
 </p>
 
 <p align="center">
   <a href="#安装"><img alt="platform" src="https://img.shields.io/badge/platform-Windows%20%2B%20Origin%202021%2B-blue"></a>
-  <img alt="tests" src="https://img.shields.io/badge/tests-1118%2F1118%20passing-brightgreen">
+  <img alt="tests" src="https://img.shields.io/badge/tests-1126%2F1126%20passing-brightgreen">
   <img alt="license" src="https://img.shields.io/badge/license-MIT-lightgrey">
+  <a href="https://github.com/caob23/dsh-origin-bridge/actions/workflows/offline-checks.yml"><img alt="offline checks" src="https://github.com/caob23/dsh-origin-bridge/actions/workflows/offline-checks.yml/badge.svg"></a>
 </p>
 
 <p align="center">
@@ -35,7 +36,7 @@
 - **数据不出本机。** 没有 API key、没有云端组件，dsh 拉起一个本地 Python 进程，通过 OriginLab 官方的 [`originpro`](https://pypi.org/project/originpro/) 驱动你机器上的 Origin。
 - **每一步都有证据。** Origin 的 X-Function 普遍"返回成功但什么都没发生"。这里画图后读回轴范围与数据跨度比对，导出后校验文件存在/体积/文件头魔数，样式逐项读回——读不回的进 `failed` 列表，不会假装成功。
 - **不是 74 个工具，是 27 个。** 每个都有实测用途，工具描述里写着实测限制，模型不会踩坑。
-- **1000+ 次真实测试，不是自称。** **1118 例**全链路用例跑在真实 stdio 服务器 + 本机 OriginPro 上，**1118 通过 / 0 失败**：27 个工具每个至少 15 例、最多 134 例，按副作用分五层（L0 纯解析 296、L1 只读 COM 61、L2 改会话 520、L3 落盘 163、L4 进程级 78）。提示词全部按人话写，跑之前先用在线 `tools/list` schema 校验用例本身，所以失败只会是产品问题，不会是题目写错。另有 **352 项**离线/单元/边界检查（asciiio 84、binio 30、lifecycle 37、smoke 129、edge 26、paths 28、json 18）**随包发布，你可以直接复跑**；那 1118 例题库含提示词与模拟数据，是开发侧资产，不随包分发。originpro 的十几个文档陷阱全部记录在案并绕开。
+- **1000+ 次真实测试，不是自称。** **1126 例**全链路用例跑在真实 stdio 服务器 + 本机 OriginPro 上，**1126 通过 / 0 失败**：27 个工具每个至少 15 例、最多 134 例，按副作用分五层（L0 纯解析 301、L1 只读 COM 63、L2 改会话 521、L3 落盘 163、L4 进程级 78）。提示词全部按人话写，跑之前先用在线 `tools/list` schema 校验用例本身，所以失败只会是产品问题，不会是题目写错。另有 **417 项**离线/单元/边界检查（asciiio 84、binio 30、lifecycle 42、smoke 129、edge 26、paths 35、json 26、readfile 12、labtalk 33）**随包发布，你可以直接复跑**；那 1126 例题库含提示词与模拟数据，是开发侧资产，不随包分发。originpro 的十几个文档陷阱全部记录在案并绕开。
 
 ## 它能做什么
 
@@ -50,7 +51,7 @@
 | "做一张 XPS 图" | `origin_chart_render`（40 个科研预设：轴标题/图类型/建议拟合） |
 | "热力图显示这个矩阵" | `origin_matrix`（heat_map / cmap / mesh / contline，Origin 自带图模） |
 
-数据源支持：`.dat` `.csv` `.txt` `.tsv`（自动嗅探分隔符；编码覆盖 UTF-8 / GBK / **UTF-16（有无 BOM 都行）** / cp1252；多行表头、Fortran 指数、`NA`/`-`；还有 `<0.001` 检出限、`2.5±0.1`、`25 mV`、`1,234.5`、`(500)`、`2.5*` 这类被装饰过的数值——每解一种都会在 `warnings` 里写清代入了什么）、`.xls` `.xlsx`、电化学工作站（CH Instruments 等）导出的 `.txt`（几十行仪器说明自动收进 `metadata`，不会把首行日期当成列名），以及头部为 `80 F2 1B 00` 的电化学工作站二进制 `.bin`。
+数据源支持：`.dat` `.csv` `.txt` `.tsv`（`origin_read_file` 只读这些文本类；`.xls/.xlsx/.wks` 会明确报 `unsupported_file_type` 让你改用 `origin_import`。自动嗅探分隔符；编码覆盖 UTF-8 / GBK / **UTF-16（有无 BOM 都行）** / cp1252；多行表头、Fortran 指数、`NA`/`-`；还有 `<0.001` 检出限、`2.5±0.1`、`25 mV`、`1,234.5`、`(500)`、`2.5*` 这类被装饰过的数值——每解一种都会在 `warnings` 里写清代入了什么）、`.xls` `.xlsx`、电化学工作站（CH Instruments 等）导出的 `.txt`（几十行仪器说明自动收进 `metadata`，不会把首行日期当成列名），以及头部为 `80 F2 1B 00` 的电化学工作站二进制 `.bin`。
 
 ## 安装
 
@@ -87,6 +88,12 @@ dsh plugin --profile desktop add @caob23/dsh-origin-bridge  # 转发壳，依赖
 pip install originpro numpy        # 国内网络慢就加 -i https://pypi.tuna.tsinghua.edu.cn/simple
 ```
 
+> **前置缺了会怎样，两种情况不一样**（2026-10-19 实测，别猜）：
+> - **解释器在、`originpro` 不在**：27 个工具**照常注册**，每一次调用都返回 `code=missing_originpro` 和原因（`No module named 'originpro'`），`isError: true`——看得见、知道修什么。
+> - **PATH 上没有 `python`**（补丁默认命令就是 `python`）：桥进程起不来，`failOnStartupError: false` 保证 dsh 照常启动，代价是那一轮**工具完全不注册**、也没有报错。这时先设 `ORIGIN_BRIDGE_PYTHON`。
+>
+> Origin 没开**不影响**注册：COM 连接是第一次工具调用时才建立的。
+
 包内补丁的默认取值是 `python`（PATH 上那个）和 `profiles/desktop`。依赖装在 venv 里、或者你用的是别的 profile，就设这两个用户环境变量（设完要重开终端、再彻底重启 dsh）：
 
 ```powershell
@@ -124,12 +131,14 @@ pip install -r requirements.txt      # 国内网络慢就加 -i https://pypi.tun
 .\.venv\Scripts\python.exe edge_checks.py             # 26 项边界
 .\.venv\Scripts\python.exe test_asciiio.py            # 84 项，不需要 Origin
 .\.venv\Scripts\python.exe test_binio.py              # 30 项，不需要 Origin；有真实 .bin 时会跟厂商 .txt 逐点对账
-.\.venv\Scripts\python.exe test_lifecycle.py          # 37 项，不需要 Origin：实例分类/回收/掉线重连的安全边界
-.\.venv\Scripts\python.exe test_paths.py              # 28 项，不需要 Origin：导出/保存目标路径的规范化与拒绝
-.\.venv\Scripts\python.exe test_json_safety.py        # 18 项，不需要 Origin：返回值必须是严格 JSON
+.\.venv\Scripts\python.exe test_lifecycle.py          # 42 项，不需要 Origin：实例分类/回收/掉线重连的安全边界
+.\.venv\Scripts\python.exe test_paths.py              # 35 项，不需要 Origin：导出/保存目标路径的规范化与拒绝
+.\.venv\Scripts\python.exe test_json_safety.py        # 26 项，不需要 Origin：返回值必须是严格 JSON
+.\.venv\Scripts\python.exe test_readfile.py        # 12 项，不需要 Origin：read_file 的 sample 与二进制表格拒绝
+.\.venv\Scripts\python.exe test_labtalk_guard.py    # 33 项，不需要 Origin：LabTalk 黑名单匹配
 ```
 
-上面这 352 项随包发布，你可以自己复跑。另外那 **1118 例全链路题库是开发侧资产**（`cases/` + `run_cases.py`），跑的是真实 stdio 服务器 + 本机 Origin，用它的提示词和你的原始数据都不适合公开，所以没有进仓库、也没有进 npm 包；本文里的覆盖数字都来自它的实际运行结果。
+上面这 417 项随包发布，你可以自己复跑。另外那 **1126 例全链路题库是开发侧资产**（`cases/` + `run_cases.py`），跑的是真实 stdio 服务器 + 本机 Origin，用它的提示词和你的原始数据都不适合公开，所以没有进仓库、也没有进 npm 包；本文里的覆盖数字都来自它的实际运行结果。
 
 ### 不是 dsh，是别的 MCP 客户端
 
@@ -179,7 +188,7 @@ powershell -ExecutionPolicy Bypass -File .\install_dsh.ps1 -Profile desktop
 | 工具 | 用途 |
 |---|---|
 | `origin_status` | 连接检查、Origin 版本、已开页面。**动手前先调它** |
-| `origin_read_file` | 只解析文件不碰 Origin：编码、分隔符、表头行、每列长名/单位/有效行数；`.bin` 走另一条路线给出技术/点数/方法参数/轴来源 |
+| `origin_read_file` | 只解析文件不碰 Origin：编码、分隔符、表头行、每列长名/单位/有效行数、**前 3 个原始值（`sample`，缺值为 null，用来抽查没串列）**；`.xls/.xlsx/.wks` 明确拒绝并让你改用 `origin_import`；`.bin` 走另一条路线给出技术/点数/方法参数/轴来源 |
 | `origin_import` | 导入 `.dat/.csv/.txt/.tsv/.xls/.xlsx/.wks` 和工作站二进制 `.bin`，返回 `ws-N` 句柄和列清单 |
 | `origin_write` | 内联数据建表：窄表 `columns={列名:[值…]}`，宽表 `headers`+`rows`（一次写完） |
 | `origin_formula` | 给列设计算公式（Fx）做派生列，读回算出的行数与首末值 |
@@ -267,6 +276,10 @@ Origin Bridge 的做法：
 | 编码候选顺序 | 仪器"另存为 Unicode 文本"导出的 UTF-16（有/无 BOM）此前直接报 `找不到数值数据行`；而 cp1252 写的 `µ`/`°` 会被 gb18030 **抢先**解成 `祍`/`癈`——它不报错，所以错误一路静默到列名 | `read_text` 先认 BOM，无 BOM 时按 NUL 占比猜 utf-16 并在 `encoding` 里写明是猜的；再用"高位字节成对=GBK、孤立单字节=cp1252"决定候选顺序（`high_byte_runs`） |
 | 装饰过的数值格子 | `<0.001`、`2.5±0.1`、`25 mV`、`1,234.5`、`2.5*`、`(500)`、`1e400` 这些形态此前让整列被判"全为空"直接丢弃——用户看到的是少一列数据，不是报错 | `cell_number` 逐形态解开并回一条 `warnings` 说明代入了什么；溢出/Infinity 一律按缺值，绝不把 inf 送出桥 |
 | 分隔符嗅探 | 欧陆 `Zeit;Signal / 0,0;1,5` 会被逗号拆开，而且错的拆法因为"列更多"在评分里胜出 | 评分改成：数值列数 → 行宽一致性 → 列数更少者优先；表头行不参与数值比 |
+| `origin_open` 与句柄 | 开工程会替换所有页面，之前发出去的 `ws-/gr-` 句柄全部指向已销毁的对象；死对象上的 `save_fig` 会"成功"但什么都不写（1124 例跑里正是它让连续三个导出失败） | `open_project` 成功与失败都清空句柄表并在返回里给 `handles_reset: true`；旧句柄再用会得到 `worksheet_not_found`/`graph_not_found`，不会静默操作死页面 |
+| LabTalk 黑名单 | 原来按子串匹配，2026-10-20 用 45 条高危语句实测 **37 条能过**：`win -cd` 销毁页面、`doc -n` 新建工程丢当前项目、`del/delete` 删数据集、`run -p`/`run.file` 执行外部程序、`exit`、以及能绕过句柄重置的 `doc -o` | 改成按语句（`;`/换行/`{}` 切分）+ 词边界规则：`doc -`、`win -c`、`del/delete`、`layer -d`、`page -d`、`quit/exit`、`run.`/`run -`、`system/shell`、`rmdir/mkdir`、`type -`、`close`、`saveas` 全拦；`test_labtalk_guard.py` 32 项锁住"该拦的拦、该放的放"。仍是劝告式护栏，不是沙箱 |
+| dsh 新 profile 的补丁模板 | `cordis.patch.yml` 模板内容就是一行 `[]`（顶层数组占位）。往它后面**追加** `- insert:` 会得到两个 YAML 文档，dsh 直接 `failed to parse overlay` 起不来——`install_dsh.ps1` 2026-10-20 前正是这样，全新环境按 README 用脚本装会把配置写坏 | 安装器现在把"只有注释/只有一个 `[]`"的文件当空文件处理，插块成为数组本身；装完会用 PyYAML 校验一次，解析失败就提示从备份恢复 |
+| `save_fig` 的 `width` | 传了也不生效：`save_fig(path)` 只有 path 时用页面尺寸，**必须同时给 type** 才认 width （实测 400 和 12000 导出都是 3216×2461、字节数相同）。我们的 `origin_export` 以前恰好只传 path | `save_fig(path, fmt, width=N)` + 缺文件时回退纯 path；PNG 导完比对 `dimensions.0` 与请求值，不一致就回 warning。题库宽度用例从"有 dimensions"改成**断言等于请求宽度** |
 | 非标准 JSON | `json.dumps` 默认把 inf/nan 写成裸 `Infinity`/`NaN`，那不是合法 JSON——dsh 侧整条响应解析失败，看起来像"桥挂了"而不是"一个数不对" | `sanitize()` 把 ±inf/nan 归 None；`server.py` 写出走 `allow_nan=False`，兜不住就降级成带原 id 的 JSON-RPC 错误；`smoke_test` 客户端用 `strict_loads` 拒绝，测试不会替产品掩盖它（`test_json_safety.py` 18 项） |
 
 ## 已知边界
@@ -278,7 +291,7 @@ Origin Bridge 的做法：
 - 交付路径：中文目录、中文文件名、含空格、200+ 字符长路径、自动建多级目录、`tiff→tif`/`jpeg→jpg` 改名——2026-10-12 在真机上逐条实测可用（PNG/TIF/PDF/SVG/EMF 和 `.opju` 都试过）。**不行的是网络路径**：UNC 与未映射盘返回 `bad_path`，不去猜认证。另有两条 Origin 自己的怪脾气已经兜住：文件名里的 `#` 会被导出滤镜换成编号（桥发现后会改名回你要的名字并在 `warnings` 里说明），路径组件尾部的空格/点会被 Windows 悄悄截掉（桥先截一遍再比较，不会报"文件不存在"）。
 - 千分位和逗号分隔符同形的文件（不加引号的 `0,1,234.5`）没法机械还原：桥按最宽行补齐并报"行长度不一致"，不会假装列数对得上。欧陆小数点（`0,5`）只在分隔符是 `;` 或 tab 时才认。
 - Origin 以管理员运行而 Python 不是（或反之）时 COM 连不上，两侧权限要一致。
-- 长会话攒太多页面会让 COM 桥报"无效指针"。`origin_close_pages` 能清，根治是 `origin_exit` 后重连。
+- 长会话攒太多页面会让 COM 桥报"无效指针"。`origin_close_pages` 能清，根治是 `origin_exit` 后重连。2026-10-20 实测到 300 页仍不崩，但每张图的耗时从 0.7 秒（前 100 页）涨到 2.8 秒（200–300 页）——所以 `origin_plot`/`origin_matrix` 每新建 50 个页面会在 `warnings` 里提醒一次（计数不花额外 COM 调用，`origin_close_pages`/`origin_exit`/`origin_open` 会清零）。
 - **Origin 实例不会跟着客户端退出**：originpro 需要时自己拉一个 Origin，Python 进程结束那个实例还在。攒够就会报"实例超过上限"。现在插件在进程退出时回收**自己起的、且没有窗口的**实例（`atexit`），历史残留用 `origin_reclaim` 清；有窗口的实例永远不动，因为那可能是你正开着的项目。
 - 统计批处理（t 检验 / ANOVA / PCA / 生存分析）没有，originpro 本身也不提供。
 - **无并发保护**：两个会话同时驱动 Origin 会互相踩。
@@ -315,10 +328,10 @@ dsh-origin-bridge/
 ├── icon.svg             # 卡片图标（scripts/make_icon.py 生成）
 ├── locale/*.json        # dsh 卡片显示名与描述
 ├── scripts/make_preview.py # 重新生成 docs/preview.png（关掉图例后才导出）
-└── test_*.py / smoke_test.py / edge_checks.py   # 352 项离线与单元检查（随包发布）
+└── test_*.py / smoke_test.py / edge_checks.py   # 417 项离线与单元检查（随包发布）
 ```
 
-开发侧另有 `cases/` + `run_cases.py` 的 1118 例全链路题库和 `render_realdata.py` 的真实数据逐文件出图脚本，两者都不随包发布（见上文）。
+开发侧另有 `cases/` + `run_cases.py` 的 1126 例全链路题库和 `render_realdata.py` 的真实数据逐文件出图脚本，两者都不随包发布（见上文）。
 
 重新生成图标：`python scripts/make_icon.py`（只需要 numpy，PNG 由 stdlib 手写）。
 

package/bin/origin-bridge.mjs

@@ -22,10 +22,24 @@ const candidates = [
   'python',
 ].filter(Boolean);
 
+// Same environment the dsh patch sets, so logs are UTF-8 instead of the console
+// code page and the child flushes line by line.
+const env = { ...process.env };
+if (!env.PYTHONIOENCODING) env.PYTHONIOENCODING = 'utf-8';
+if (!env.PYTHONUNBUFFERED) env.PYTHONUNBUFFERED = '1';
+
 const child = spawn(
   candidates.find((c) => c === 'python' || existsSync(c)) || 'python',
-  ['-u', server],
-  { stdio: 'inherit', cwd: root },
+  ['-u', '-X', 'utf8', server],
+  { stdio: 'inherit', cwd: root, env },
 );
 
-child.on('exit', (code) => process.exit(code ?? 0));
+// A child killed by a signal is a crash, not a clean exit: reporting 0 here would
+// make an MCP client treat a dead server as "finished normally".
+child.on('exit', (code, signal) => {
+  if (signal) {
+    console.error(`[origin-bridge] python exited on ${signal}`);
+    process.exit(1);
+  }
+  process.exit(code ?? 1);
+});

package/cordis.patch.yml

@@ -17,8 +17,12 @@
 #   manual install -> set ORIGIN_BRIDGE_HOME to the folder holding server.py
 #   interpreter    -> set ORIGIN_BRIDGE_PYTHON to your venv python.exe
 #
-# failOnStartupError: false keeps dsh bootable when Origin is missing or a modal
-# dialog stalls the COM server; the tools just do not register that session.
+# failOnStartupError: false keeps dsh bootable when this entry cannot start at all —
+# measured (2026-10-19) that means only a missing interpreter: the default command is
+# `python` from PATH. A missing originpro does NOT hide the tools: all 27 still
+# register and every call answers `missing_originpro` with the fix to run. Origin
+# itself being closed is irrelevant to startup — the COM connection is made lazily
+# inside the first tool call, not here.
 
 - insert:
     - id: mcp-origin-bridge

package/install_dsh.ps1

@@ -90,18 +90,25 @@ $block += "        toolCallTimeoutMs: 180000`r`n"
 # second copy of the server to drift out of sync with C:\...\origin-bridge.
 $pkgName = 'dsh-origin-bridge'
 $pkgDir = Join-Path $profileDir "node_modules\$pkgName"
+# Read the real version instead of hard-coding it: the card in dsh shows this
+# value, and a stale 0.4.0 makes the installed plugin look ancient.
+$pkgVersion = '0.0.0'
+$manifest = Join-Path $src 'package.json'
+if (Test-Path $manifest) {
+    try { $pkgVersion = (Get-Content $manifest -Raw -Encoding UTF8 | ConvertFrom-Json).version } catch { }
+}
 if (-not (Test-Path (Join-Path $pkgDir 'index.js'))) {
     New-Item -ItemType Directory -Force -Path $pkgDir | Out-Null
-    @'
+    @"
 {
   "name": "dsh-origin-bridge",
-  "version": "0.4.0",
+  "version": "$pkgVersion",
   "description": "Origin Bridge: natural language" -> local Origin/OriginPro -> editable .opju + publication images",
   "main": "./index.js",
   "type": "module",
   "license": "MIT"
 }
-'@ | Set-Content -Path (Join-Path $pkgDir 'package.json') -Encoding ASCII
+"@ | Set-Content -Path (Join-Path $pkgDir 'package.json') -Encoding ASCII
     @'
 // Registration-only bundle. The Origin tools come from server.py in this
 // package's own folder, registered by the mcp-origin-bridge insert in the
@@ -126,6 +133,13 @@ $block += "      name: $pkgName`r`n"
 
 $existing = if (Test-Path $patch) { Get-Content $patch -Raw -Encoding UTF8 } else { '' }
 
+# A fresh dsh profile ships `cordis.patch.yml` containing just `[]` (plus comments).
+# Appending a `- insert:` entry after that produces TWO YAML documents and dsh
+# refuses to parse the overlay — the installer used to break a brand-new profile.
+# Treat a comments-only / empty-array file as empty so the block becomes the array.
+$meaningful = ($existing -split "`r?`n" | Where-Object { $_ -notmatch '^\s*#' -and $_.Trim() -ne '' }) -join "`n"
+if ($meaningful.Trim() -eq '[]' -or $meaningful.Trim() -eq '') { $existing = '' }
+
 # -RemoveOld: drop the previous plugin's insert block. Both entries pointed at
 # C:\...\originlab-bridge, and a dead stdio server still shows up as a tool
 # provider, so leaving it in place would mean two overlapping tool sets.

package/originlab.py

@@ -351,6 +351,28 @@ atexit.register(_release_on_exit)
 
 _handles = {}
 _names = {}
+
+# Measured 2026-10-20: 300 graph pages do not break the bridge, but each plot slows
+# from ~0.7 s (first 100) to ~2.8 s (200-300), because Origin's COM surface grows with
+# the project. Counting pages we create costs nothing (no extra COM call), so we can
+# tell the caller before it becomes painful.
+_page_growth = [0]
+_GROWTH_HINT_EVERY = 50
+
+
+def _growth_warning(created=True):
+    if not created:
+        return None
+    _page_growth[0] += 1
+    n = _page_growth[0]
+    if n % _GROWTH_HINT_EVERY:
+        return None
+    return ("本次会话已新建约 %d 个图页且未清理：实测 300 页时每张图约 2.8 秒（100 页时约 0.7 秒）。"
+            "长会话建议 origin_close_pages(kind='graph')，或 origin_exit 后重开" % n)
+
+
+def _reset_growth():
+    _page_growth[0] = 0
 _seq = [0]
 _project_file = ""
 
@@ -669,7 +691,16 @@ def read_file(path, comment=None):
     path = os.path.abspath(os.path.expanduser(path))
     if not os.path.isfile(path):
         raise OriginError("file_not_found", "文件不存在：%s" % path)
-    if os.path.splitext(path)[1].lower() == ".bin":
+    ext = os.path.splitext(path)[1].lower()
+    if ext in (".xls", ".xlsx", ".wks"):
+        # Decoding a zip/OLE container as text "succeeds" into mojibake and then reports
+        # "只有表头？", blaming the user's file for our mistake (measured 2026-10-19).
+        raise OriginError(
+            "unsupported_file_type",
+            "%s 是二进制表格，origin_read_file 只读文本类数据" % ext,
+            ["用 origin_import 直接导入（走 Origin 原生导入）",
+             "或先在 Excel 里另存为 .csv，再用 origin_read_file 预览结构"])
+    if ext == ".bin":
         try:
             decoded = binio.read_bin(path)
         except binio.BinFormatError as exc:
@@ -689,8 +720,14 @@ def read_file(path, comment=None):
     except ValueError as exc:
         raise OriginError("parse_failed", str(exc),
                           ["确认文件里有数值行", "给 comment 指定实际的注释前缀"])
-    parsed["columns"] = [{k: v for k, v in c.items() if k != "values"}
-                         for c in parsed["columns"]]
+    # Three raw values per column: enough for the model to spot a shifted column or a
+    # column that parsed to nothing, without putting the whole dataset in context.
+    parsed["columns"] = [
+        dict({k: v for k, v in c.items() if k != "values"},
+             sample=(c.get("values") or [])[:3])
+        for c in parsed["columns"]]
+    parsed["sample_note"] = ("sample 是每列前 3 个原始值（缺值为 null），只用来抽查解析是否正确；"
+                             "完整数据用 origin_import 进 Origin")
     parsed["proof_level"] = "verified"
     return sanitize(parsed)
 
@@ -1016,6 +1053,9 @@ def plot(worksheet, x=1, y=2, plot_type="line", graph_name="", title="",
         if review:
             span["warnings"] = [review]
             span["next_actions"] = list(REVIEW_OPTIONS)
+        grown = _growth_warning(created=(int(layer) == 0))
+        if grown:
+            span.setdefault("warnings", []).append(grown)
         return sanitize({"graph": _bind("gr", gr, gr.name), "plot_type": plot_type,
                          "channel": channel, "template": tpl,
                          "source_sheet": _safe(lambda: ws.name, ""),
@@ -1355,8 +1395,25 @@ def _layer_count(gr):
     return n
 
 
+def _image_width(value, default, hi):
+    """Validate a rendering width. Both ends matter: 0 or negative is nonsense, and
+    a huge number makes Origin render a file too big to hand back."""
+    try:
+        width = int(value)
+    except (TypeError, ValueError):
+        width = default
+    if width <= 0:
+        raise OriginError("bad_arguments", "width 必须是正整数，收到 %r" % (value,))
+    if width > hi:
+        raise OriginError("bad_arguments", "width 太大：上限 %d，收到 %d" % (hi, width),
+                          ["出版图给 1600–3000 就够；预览图给 900"])
+    return max(100, width)
+
+
 def view(graph, width=900):
     """Render the graph to a small PNG and hand the bytes back for visual check."""
+    width = _image_width(width, 900, 2400)
+
     def run():
         import base64
         import tempfile
@@ -1389,8 +1446,42 @@ def view(graph, width=900):
     return call(run)
 
 
-LABTALK_DENY = ("doc -s", "doc -c", "saveas", "quit", "exitloop", "type -m", "openb", "run.x",
-                "close;", "close ", "system ", "shell ", "run.section", "run.open", "fopen")
+# Substring matching let 37 of 45 dangerous statements through (measured 2026-10-20):
+# `win -cd` destroyed a page, `doc -n` replaced the project, `run -p`/`run.file` run
+# external code, and `doc -o` bypassed the handle reset that origin_open performs.
+# These are anchored per statement (split on ';', newline and '{') with word
+# boundaries, so option spelling and whitespace no longer decide the outcome.
+LABTALK_DENY = ("saveas", "openb", "fopen", "exitloop")
+LABTALK_DENY_STATEMENTS = (
+    # Only `doc -a` (activate) is harmless; every other switch can save, replace,
+    # open or close the project. Inverting the match keeps unknown switches blocked.
+    (r"doc\s+-(?![aA](?:\s|;|$))", "doc 开关（-s 存、-n 新建、-o 打开都会丢当前工程；只放 -a）"),
+    (r"win\s+-c", "关闭/销毁页面（-c、-cd）"),
+    (r"(?:del|delete)(?:\s|$)", "删除数据集"),
+    (r"layer\s+-d", "删除图层"),
+    (r"page\s+-d", "删除页面"),
+    (r"(?:quit|exit)(?:\s|$)", "退出 Origin"),
+    (r"run(?:\.|\s+-)", "执行外部脚本或程序"),
+    (r"(?:system|shell)(?:\s|$)", "调用系统命令"),
+    (r"(?:rmdir|mkdir)(?:\s|$)", "创建/删除目录"),
+    (r"type\s+-", "type 开关（-a 会用外部程序打开文件）"),
+    (r"close(?:\s|$)", "关闭窗口"),
+)
+
+
+def labtalk_denied(script):
+    """Return the reasons a LabTalk script is refused (empty list = allowed).
+
+    Exposed as a function so the test suite exercises the same matcher the tool uses
+    instead of a copy that silently drifts.
+    """
+    low = re.sub(r"\s+", " ", str(script).lower())
+    blocked = [p for p in LABTALK_DENY if p in low]
+    statements = [st.strip() for st in re.split('[;\\n{}]', low) if st.strip()]
+    for rule, why in LABTALK_DENY_STATEMENTS:
+        if any(re.search(r"(?:^|[\s,(=])" + rule, st) for st in statements):
+            blocked.append(why)
+    return blocked
 
 
 def labtalk(script, readback=(), numeric=()):
@@ -1405,11 +1496,11 @@ def labtalk(script, readback=(), numeric=()):
     # Advisory guardrail, not a sandbox: it stops the model from wiping the
     # session by accident, not from trying hard. Whitespace is collapsed so
     # 'doc  -s' does not slip past the literal match.
-    low = re.sub(r"\s+", " ", str(script).lower())
-    blocked = [p for p in LABTALK_DENY if p in low]
+    blocked = labtalk_denied(script)
     if blocked:
         raise OriginError("labtalk_denied", "这些命令不允许通过 origin_labtalk 执行：%s" % blocked,
-                          ["关工程/退 Origin 请用 origin_exit 或 origin_save_project"])
+                          ["关工程/退 Origin 请用 origin_exit 或 origin_save_project",
+                           "句柄/页面管理用 origin_close_pages、保存用 origin_save_project"])
 
     def run():
         op = origin()
@@ -1554,6 +1645,7 @@ def fit(worksheet, x=1, y=2, kind="linear", func="", fixed=None, starts=None,
 
 
 def export(graph, path="", fmt="png", width=1600):
+    width = _image_width(width, 1600, 12000)
     fmt = str(fmt).lstrip(".").lower()
     # Origin's export filter only recognises the short names: asking for a.tiff
     # leaves no file behind, which reads as a failed export.
@@ -1573,7 +1665,13 @@ def export(graph, path="", fmt="png", width=1600):
         raw_path = str(path or "").strip()
         target_path = _norm_target(raw_path or os.path.join(folder, "%s.%s" % (name, fmt)), fmt)
         _prepare_write(target_path)
-        _safe(lambda: page.save_fig(target_path))
+        # width only applies when a type is passed as well; the old call passed
+        # neither, so `width` never did anything (measured: 400 and 12000 both came
+        # back as the page size, 3216 px). Fall back to the plain call if the typed
+        # one does not produce a file.
+        _safe(lambda: page.save_fig(target_path, fmt, width=int(width)))
+        if not os.path.isfile(target_path):
+            _safe(lambda: page.save_fig(target_path))
         written, note = _written_or_mangled(target_path)
         if not written:
             raise OriginError("export_failed", "Origin 说导出了但文件不存在：%s" % target_path,
@@ -1585,6 +1683,11 @@ def export(graph, path="", fmt="png", width=1600):
                               ["图页可能是空的：origin_inspect 看 plots 数"])
         if note:
             info["warnings"] = [note]
+        dims = info.get("dimensions")
+        if dims and fmt == "png" and abs(int(dims[0]) - int(width)) > max(2, int(width) * 0.02):
+            # Tell the caller instead of pretending the request was honoured.
+            info["warnings"] = (info.get("warnings") or []) + [
+                "width=%d 没有生效：实际导出 %dx%d（Origin 对该图/滤镜接受了别的尺寸）" % (width, dims[0], dims[1])]
         rel = _rel_note(path)
         if rel:
             info["warnings"] = (info.get("warnings") or []) + [rel]
@@ -1662,12 +1765,27 @@ def open_project(path):
     def run():
         global _project_file
         op = origin()
-        if not op.open(path):
+        # Opening a project replaces every page, so every handle handed out earlier is
+        # dead — and a *refused* open can still have closed the current project. Both
+        # ways the table has to go: leaving it behind makes later calls act on dead
+        # pages, where originpro's wrapper "succeeds" and Origin quietly writes nothing
+        # (that is how three exports failed in the 1124-case run).
+        try:
+            ok = bool(op.open(path))
+        finally:
+            _handles.clear()
+            _names.clear()
+        if not ok:
+            _project_file = ""
             raise OriginError("open_failed", "Origin 拒绝打开这个工程：%s" % path,
                               ["确认文件是 .opju/.opj 且没被另一个 Origin 实例锁住",
-                               "Origin 版本低于该工程保存版本时也打不开"])
+                               "Origin 版本低于该工程保存版本时也打不开",
+                               "打开失败后旧句柄已作废，请重新 origin_inspect 看当前页面"])
         _project_file = path
-        return sanitize({"opened": path, "open_pages": [p.name for p in op.pages()]})
+        _reset_growth()
+        return sanitize({"opened": path, "open_pages": [p.name for p in op.pages()],
+                         "handles_reset": True,
+                         "note": "之前拿到的 ws-/gr- 句柄全部作废（工程换了页面），请用这里的页面名或重新导入"})
 
     return call(run)
 
@@ -1712,6 +1830,7 @@ def exit_origin(save_to=""):
         _names.clear()
         _project_file = ""
         _reset_connection()
+        _reset_growth()
         return sanitize({"exited": True, "saved": saved})
 
     return call(run)
@@ -1844,6 +1963,9 @@ def matrix_plot(rows, template="heat_map", book_name="", graph_name="",
                "xlim": _safe(lambda: list(lay.xlim)), "ylim": _safe(lambda: list(lay.ylim)),
                "zlim": _safe(lambda: list(lay.zlim)),
                "proof_level": "verified"}
+        grown = _growth_warning()
+        if grown:
+            out.setdefault("warnings", []).append(grown)
         if export_path:
             out["export"] = _export_on_com_thread(gr, export_path)
         if project_path:
@@ -1950,6 +2072,8 @@ def close_pages(kind="graph", names=None, dry_run=False):
     for ref in [r for r, nm in _names.items() if nm and nm in closed]:
         _handles.pop(ref, None)
         _names.pop(ref, None)
+    if closed:
+        _reset_growth()
     return sanitize({"asked": wanted, "closed": closed,
                      "refused": [n for n in wanted if n not in closed],
                      "errors": errors,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-origin-bridge",
-  "version": "0.4.6",
+  "version": "0.4.8",
   "description": "在对话里驱动本机 Origin / OriginPro：导入 .dat/.csv/.txt 与电化学工作站 .bin，绘图、拟合、改样式，导出图片并保存可在 Origin 里继续编辑的 .opju 工程。dsh 插件，27 个 MCP 工具。第三方工具，与 OriginLab Corporation 无关联、未获认可。",
   "license": "MIT",
   "type": "module",
@@ -52,6 +52,8 @@
     "edge_checks.py",
     "test_paths.py",
     "test_json_safety.py",
+    "test_readfile.py",
+    "test_labtalk_guard.py",
     "test_asciiio.py",
     "test_binio.py",
     "test_lifecycle.py",

package/requirements.txt

@@ -1,2 +1,4 @@
+# 实测环境：originpro 1.1.15 + OriginPro 2024 SR1 (10.100178) + Python 3.12
+# originpro 要求 Origin 2021+；2.x 没有验证过，暂不设上限。
 originpro>=1.1.0
 numpy>=1.24

package/server.py

@@ -20,7 +20,7 @@ sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 import originlab  # noqa: E402
 
 SERVER_NAME = "origin-bridge"
-SERVER_VERSION = "0.4.6"
+SERVER_VERSION = "0.4.8"
 PROTOCOL = "2024-11-05"
 
 
@@ -106,7 +106,7 @@ TOOLS = [
     },
     {
         "name": "origin_read_file",
-        "description": "只解析数据文件、不碰 Origin：返回编码、分隔符、表头行数、每列长名/单位/有效行数，以及仪器参数 metadata。拿到陌生 .dat/.csv/.txt 先用它看清结构，再决定 origin_import 用哪几列。支持 #、//、!、; 注释、BOM、GBK、空格对齐、Fortran 的 1.5d+00 指数、NA/- 缺失值、Origin 三行表头（Long Name/Units/Comments），也支持电化学工作站（CH Instruments 等）导出的 txt：前面几十行参数说明会被跳进 metadata，紧贴数据的 Potential/V, Current/A 这类表头按斜杠拆出列名和单位。.bin 走另一条解析路线：返回技术标签（CV/LSV/IMP/i-t）、点数、两个 float32 数组的范围和 role_confidence。",
+        "description": "只解析数据文件、不碰 Origin：返回编码、分隔符、表头行数、每列长名/单位/有效行数，以及仪器参数 metadata。拿到陌生 .dat/.csv/.txt 先用它看清结构，再决定 origin_import 用哪几列。支持 #、//、!、; 注释、BOM、GBK、空格对齐、Fortran 的 1.5d+00 指数、NA/- 缺失值、Origin 三行表头（Long Name/Units/Comments），也支持电化学工作站（CH Instruments 等）导出的 txt：前面几十行参数说明会被跳进 metadata，紧贴数据的 Potential/V, Current/A 这类表头按斜杠拆出列名和单位。编码覆盖 UTF-8 / GBK / UTF-16（有无 BOM）/ cp1252；<0.001、2.5±0.1、25 mV、1,234.5、(500)、2.5* 这类被装饰的数值会解出来并在 warnings 里说明代入了什么。每列还带 sample（前 3 个原始值，缺值为 null），用来抽查解析对不对——完整数据仍然只进 Origin。二进制表格 .xls/.xlsx/.wks 不在它的范围内，会明确返回 unsupported_file_type，请用 origin_import。.bin 走另一条解析路线：返回技术标签（CV/LSV/IMP/i-t）、点数、两个 float32 数组的范围和 role_confidence。",
         "inputSchema": {
             "type": "object",
             "properties": {
@@ -145,7 +145,7 @@ TOOLS = [
                 "symbol_interior": {"type": "integer", "enum": [0, 1, 2, 3],
                                      "description": "0 无符号 1 实心 2 空心 3 点心"},
                 "transparency": {"type": "number", "description": "0-100 百分比"},
-                "fill_area": {"type": "boolean", "description": "线下填充（面积图效果）"},
+                "fill_area": {"type": ["boolean", "integer"], "description": "线下填充（面积图效果，1/true 都行）"},
             },
             "required": ["graph"],
         },
@@ -168,7 +168,7 @@ TOOLS = [
             "properties": {
                 "worksheet": {"type": "string"},
                 "x": {"type": ["integer", "string"], "default": 1},
-                "y": {"type": ["integer", "string"], "default": 2},
+                "y": {"type": ["integer", "string", "array"], "default": 2},
                 "kind": {"type": "string", "enum": ["linear", "nlfitsing", "gauss", "lorentz",
                                                     "voigt", "expdec1", "expdec2", "sine", "power",
                                                     "logistic", "boltzmann", "doseresp", "cubic",
@@ -200,7 +200,7 @@ TOOLS = [
                 "path": {"type": "string", "description": "输出文件绝对路径；省略则用图页名放到当前目录"},
                 "fmt": {"type": "string", "enum": ["png", "tif", "jpg", "jpeg", "svg", "pdf", "emf"],
                         "default": "png"},
-                "width": {"type": "integer", "default": 1600},
+                "width": {"type": "integer", "minimum": 100, "maximum": 12000, "default": 1600},
             },
         },
         "run": lambda a: originlab.export(a.get("graph", ""), a.get("path", ""),
@@ -217,7 +217,7 @@ TOOLS = [
     },
     {
         "name": "origin_open",
-        "description": "打开已有的 .opju/.opj 工程，返回页面清单。",
+        "description": "打开已有的 .opju/.opj 工程，返回页面清单。打开会替换工程里的所有页面，所以之前拿到的 ws-/gr- 句柄全部作废（返回 handles_reset: true）——要用就用返回的页面名，或重新 origin_import/origin_plot 拿新句柄；打开失败时旧句柄同样作废。",
         "inputSchema": {
             "type": "object",
             "properties": {"path": {"type": "string"}},
@@ -243,14 +243,14 @@ TOOLS = [
                 "source": {"type": "string", "description": "数据文件路径（与 columns 二选一）"},
                 "columns": {"type": "object", "description": "内联数据 {列名: [值...]}，优先用 source"},
                 "x": {"type": ["integer", "string"], "default": 1},
-                "y": {"type": ["integer", "string"], "default": 2},
+                "y": {"type": ["integer", "string", "array"], "default": 2},
                 "plot_type": {"type": "string", "enum": ["line", "scatter", "line_symbol", "column"], "default": "line"},
                 "title": {"type": "string"},
                 "x_title": {"type": "string"},
                 "y_title": {"type": "string"},
                 "fmt": {"type": "string", "enum": ["png", "tif", "jpg", "jpeg", "svg", "pdf", "emf"],
                         "default": "png"},
-                "width": {"type": "integer", "default": 1600},
+                "width": {"type": "integer", "minimum": 100, "maximum": 12000, "default": 1600},
                 "output_dir": {"type": "string", "description": "交付目录：图片 + opju 都写到这。不给则只建图、不落盘"},
                 "export_path": {"type": "string"},
                 "project_path": {"type": "string"},
@@ -394,7 +394,7 @@ TOOLS = [
             "type": "object",
             "properties": {
                 "name": {"type": "string"},
-                "data": {"type": "string", "description": "数据文件路径，会先 origin_read_file 解析列名"},
+                "data": {"type": ["string", "object", "array"], "description": "数据文件路径；也接受内联的 {列名:[值]} 或列名列表"},
                 "columns": {"type": "array", "description": "或者直接给列名列表"},
             },
             "required": ["name"],
@@ -421,7 +421,7 @@ TOOLS = [
                 "with_legend": {"type": "boolean", "default": True},
                 "fmt": {"type": "string", "enum": ["png", "tif", "jpg", "jpeg", "svg", "pdf", "emf"],
                         "default": "png"},
-                "width": {"type": "integer", "default": 1600},
+                "width": {"type": "integer", "minimum": 100, "maximum": 12000, "default": 1600},
             },
             "required": ["name"],
         },
@@ -452,14 +452,14 @@ TOOLS = [
             "type": "object",
             "properties": {
                 "graph": {"type": "string", "description": "省略则用当前活动图页"},
-                "width": {"type": "integer", "default": 900},
+                "width": {"type": "integer", "minimum": 100, "maximum": 2400, "default": 900},
             },
         },
         "run": lambda a: originlab.view(a.get("graph", ""), a.get("width", 900)),
     },
     {
         "name": "origin_labtalk",
-        "description": "逃生舱：执行原始 LabTalk，并读回你点名的变量（numeric 读数值表达式，readback 读字符串变量）。实测限制：数值/表达式类语句可用（如 layer.x.type=2、win -a Graph1），但字符串赋值类语句（layer.x.title$=... 、set c1 -l ...）在这台机器上 lt_exec 会返回 False，轴标题等请用 origin_style。returned=false 就是真失败，别重试同一条。doc -s / saveas / exitloop 等破坏性命令被禁。",
+        "description": "逃生舱：执行原始 LabTalk，并读回你点名的变量（numeric 读数值表达式，readback 读字符串变量）。实测限制：数值/表达式类语句可用（如 layer.x.type=2、win -a Graph1），但字符串赋值类语句（layer.x.title$=... 、set c1 -l ...）在这台机器上 lt_exec 会返回 False，轴标题等请用 origin_style。returned=false 就是真失败，别重试同一条。破坏性命令会被拦下并返回 labtalk_denied：doc -s/-n/-o（存/新建/打开工程）、win -c/-cd（关/销毁页面）、del/delete、layer -d、page -d、run./run -、system/shell、type -、rmdir/mkdir、quit/exit、close、saveas。这是劝告式护栏、不是沙箱（变量拼接仍可能绕过），别拿它做破坏性操作；页面/句柄管理用 origin_close_pages，保存用 origin_save_project。",
         "inputSchema": {
             "type": "object",
             "properties": {
@@ -494,6 +494,44 @@ def _tool_result(call_id, payload, is_error=False):
     return {"jsonrpc": "2.0", "id": call_id, "result": {"content": content, "isError": is_error}}
 
 
+_JSON_TYPES = {"string": str, "integer": int, "number": (int, float), "boolean": bool,
+               "array": list, "object": dict}
+
+
+def _validate_args(name, args, schema):
+    """Reject wrong-shaped arguments as bad_arguments before the tool runs.
+
+    Only *types* are checked here. Enums and ranges stay with the engine, which
+    answers with a more specific code (`bad_position`, `bad_format`, `bad_layer_type`)
+    than a generic bad_arguments would. What this fixes is the type confusion: a
+    `path: 123` used to reach the engine and surface as `origin_unavailable` with a
+    raw TypeError, i.e. the model was told Origin was missing. Extra keys are fine.
+    """
+    props = (schema or {}).get("properties") or {}
+    problems = []
+    for key, spec in props.items():
+        if key not in args or args[key] is None:
+            continue
+        value = args[key]
+        types = spec.get("type")
+        types = types if isinstance(types, list) else ([types] if types else [])
+        if types:
+            def fits(t):
+                py = _JSON_TYPES.get(t)
+                if py is None:
+                    return True
+                if t in ("integer", "number") and isinstance(value, bool):
+                    return False
+                return isinstance(value, py)
+            if not any(fits(t) for t in types):
+                problems.append("%s 应为 %s，收到 %s"
+                                % (key, "/".join(types), type(value).__name__))
+                continue
+    if problems:
+        raise originlab.OriginError("bad_arguments", "%s 参数不合法：%s" % (name, "；".join(problems)),
+                                    ["按工具的 inputSchema 修正参数类型/范围后再调用"])
+
+
 def _handle(msg):
     if not isinstance(msg, dict):
         return {"jsonrpc": "2.0", "id": None,
@@ -532,6 +570,7 @@ def _handle(msg):
             return _tool_result(call_id, {"ok": False, "code": "bad_arguments",
                                           "message": "arguments 必须是对象"}, True)
         try:
+            _validate_args(name, args, tool.get("inputSchema"))
             out = tool["run"](args)
             if isinstance(out, dict):
                 out = {"ok": True, **out}
@@ -579,13 +618,31 @@ def main():
 
     stdin = sys.stdin.buffer
     stdout = sys.stdout.buffer
-    _log("ready; python=%s" % sys.executable)
+    # One JSON line is one request; an unbounded readline let a single huge
+    # `columns` payload allocate whatever the client sent. The cap only needs to be
+    # far above any real dataset (a 1M-point two-column write is ~30 MB of JSON).
+    max_line = int(os.environ.get("ORIGIN_BRIDGE_MAX_LINE", 64 * 1024 * 1024))
+    _log("ready; python=%s | max line %d" % (sys.executable, max_line))
 
     while True:
-        raw = stdin.readline()
+        raw = stdin.readline(max_line + 1)
         if not raw:
             _log("stdin closed; exiting")
             return 0
+        if len(raw) > max_line and not raw.endswith(b"\n"):
+            # Drain the rest of the oversized line so the next request is not read
+            # from the middle of this one, then answer with a clean error.
+            while True:
+                chunk = stdin.readline(max_line + 1)
+                if not chunk or chunk.endswith(b"\n"):
+                    break
+            _log("request over %d bytes refused" % max_line)
+            stdout.write((json.dumps({"jsonrpc": "2.0", "id": None,
+                                      "error": {"code": -32600,
+                                                "message": "请求太大：单行上限 %d 字节" % max_line}},
+                                     ensure_ascii=False) + "\n").encode("utf-8"))
+            stdout.flush()
+            continue
         raw = raw.strip()
         if not raw:
             continue

package/test_json_safety.py

@@ -91,6 +91,60 @@ def main():
     ok("answered with a JSON-RPC error", payload.get("error", {}).get("code") == -32603, payload)
     ok("error keeps the request id", payload.get("id") == 7, payload)
 
+    # ------------------------------------------------ oversized request line
+    # A single enormous request must be refused without allocating it whole, and the
+    # stream has to resync so the NEXT request still works.
+    child2 = (
+        "import io, json, os, sys\n"
+        "sys.path.insert(0, os.environ['BRIDGE_DIR'])\n"
+        "import server\n"
+        "big = json.dumps({'jsonrpc': '2.0', 'id': 1, 'method': 'tools/list',"
+        " 'pad': 'x' * 9000}) + chr(10)\n"
+        "good = json.dumps({'jsonrpc': '2.0', 'id': 2, 'method': 'tools/list'}) + chr(10)\n"
+        "sys.stdin = io.TextIOWrapper(io.BytesIO((big + good).encode('utf-8')), encoding='utf-8')\n"
+        "sys.exit(server.main() or 0)\n"
+    )
+    env2 = dict(env, ORIGIN_BRIDGE_MAX_LINE="4096")
+    proc2 = subprocess.run([sys.executable, "-c", child2], capture_output=True, env=env2, timeout=120)
+    lines2 = proc2.stdout.decode("utf-8", "replace").strip().splitlines()
+    ok("oversized request produced two replies", len(lines2) == 2, len(lines2))
+    first = {}
+    try:
+        first = strict(lines2[0])
+    except Exception as exc:  # noqa: BLE001
+        ok("refusal is parseable", False, exc)
+    ok("oversized request refused with -32600",
+       first.get("error", {}).get("code") == -32600, first)
+    second = {}
+    try:
+        second = strict(lines2[1])
+    except Exception:  # noqa: BLE001
+        pass
+    ok("stream resynced: the next request is answered",
+       bool((second.get("result") or {}).get("tools")), second)
+
+    # ------------------------------------------------ argument validation
+    # A wrong-typed argument used to reach the engine and surface as
+    # "origin_unavailable: TypeError", i.e. it blamed a missing Origin install.
+    import server as srv
+
+    def code_for(tool, args):
+        try:
+            srv._validate_args(tool, args, srv._BY_NAME[tool]["inputSchema"])
+        except srv.originlab.OriginError as exc:
+            return exc.code
+        return "no-raise"
+
+    ok("wrong-typed path is bad_arguments",
+       code_for("origin_import", {"path": 123}) == "bad_arguments")
+    ok("wrong-typed worksheet is bad_arguments",
+       code_for("origin_plot", {"worksheet": ["ws-1"]}) == "bad_arguments")
+    ok("boolean is not an integer",
+       code_for("origin_export", {"width": True}) == "bad_arguments")
+    ok("valid args pass", code_for("origin_import", {"path": "x.csv"}) == "no-raise")
+    ok("extra keys are tolerated",
+       code_for("origin_import", {"path": "x.csv", "bogus": 1}) == "no-raise")
+
     print("\n%d/%d json-safety checks passed" % (PASSED, PASSED + len(FAILED)))
     if FAILED:
         for f in FAILED:

package/test_labtalk_guard.py

@@ -0,0 +1,88 @@
+"""Checks for the LabTalk deny matcher (no Origin needed).
+
+The guard is advisory — a variable can still assemble a blocked command at runtime —
+but everything a model would plausibly type, including option variants and extra
+whitespace, has to be refused. Measured before the rewrite: 37 of 45 destructive
+statements went straight through.
+"""
+
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import originlab as ol  # noqa: E402
+
+PASSED = 0
+FAILED = []
+
+
+def ok(label, cond, detail=""):
+    global PASSED
+    if cond:
+        PASSED += 1
+    else:
+        FAILED.append("%s %s" % (label, detail))
+    print("%s %s%s" % ("PASS" if cond else "FAIL", label,
+                       (" | " + str(detail)[:100]) if detail else ""))
+
+
+BLOCKED = [
+    ("doc -s", "保存工程"),
+    ("doc -n", "新建工程会丢当前项目"),
+    ("doc -o C:\\x.opju", "打开工程绕过句柄重置"),
+    ("win -c Graph1", "关窗口"),
+    ("win -cd Graph1", "销毁窗口"),
+    ("del Book1", "删数据集"),
+    ("delete Book1", "删数据集"),
+    ("layer -d", "删图层"),
+    ("page -d", "删页面"),
+    ("rmdir C:\\temp\\x", "删目录"),
+    ("mkdir C:\\temp\\x", "建目录"),
+    ("run -p", "执行外部程序"),
+    ("run.file x", "执行外部脚本"),
+    ("type -a", "用外部程序打开文件"),
+    ("exit", "退出"),
+    ("quit", "退出"),
+    ("system dir", "系统命令"),
+    ("shell dir", "系统命令"),
+    ("close", "裸 close 以前漏过"),
+    ("DOC  -N", "大小写与多空格"),
+    ("win\t-cd", "制表符"),
+    ("xx = 1; win -cd Graph1;", "分号后的危险命令"),
+    ("if(1) del Book1;", "条件语句里的危险命令"),
+]
+
+ALLOWED = [
+    "xx = 1;",
+    "layer.x.title$ = \"Time (s)\";",
+    "win -a Graph1;",
+    "layer.x.type = 2;",
+    "doc.echo = 0;",
+    "doc -a;",
+    "layer.x.label$ = \"delivery time\";",
+    "label$ = \"exit\";",
+    "legend -r;",
+]
+
+
+def main():
+    for script, why in BLOCKED:
+        reasons = ol.labtalk_denied(script)
+        ok("blocked: %s（%s）" % (script, why), bool(reasons), reasons)
+    for script in ALLOWED:
+        reasons = ol.labtalk_denied(script)
+        ok("allowed: %s" % script, not reasons, reasons)
+    # the same matcher the tool calls
+    import inspect
+    src = inspect.getsource(ol.labtalk)
+    ok("tool uses the tested matcher", "labtalk_denied(script)" in src)
+    print("\n%d/%d deny-matcher checks passed" % (PASSED, PASSED + len(FAILED)))
+    if FAILED:
+        for f in FAILED:
+            print("  FAILED:", f)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/test_lifecycle.py

@@ -225,6 +225,20 @@ for tool in server.TOOLS:
         check("%s 有描述和 schema" % tool["name"],
               bool(tool.get("description")) and isinstance(tool.get("inputSchema"), dict))
 
+print()
+print("page-growth hint（不碰 COM）:")
+originlab._reset_growth()
+early = [originlab._growth_warning() for _ in range(49)]
+check("前 49 个页面不出提示", all(h is None for h in early))
+h50 = originlab._growth_warning()
+check("第 50 个页面给出提示", bool(h50) and "50" in h50, h50)
+check("提示带实测耗时", bool(h50) and "2.8" in h50, h50)
+originlab._reset_growth()
+check("清理后计数归零", originlab._page_growth[0] == 0, originlab._page_growth[0])
+check("非新建不计数", originlab._growth_warning(created=False) is None
+      and originlab._page_growth[0] == 0)
+originlab._reset_growth()
+
 print()
 if fails:
     print("%d 项失败: %s" % (len(fails), ", ".join(fails)))

package/test_paths.py

@@ -129,6 +129,17 @@ def main():
     ok("blank path silent", ol._rel_note("   ") is None)
     ok("no file written into the package dir by these checks",
        set(os.listdir(HERE)) == before, sorted(set(os.listdir(HERE)) - before))
+    print()
+    print("width guards (shared by export and view):")
+    ok("0 is refused", code_of(lambda: ol._image_width(0, 900, 2400)) == "bad_arguments")
+    ok("negative is refused", code_of(lambda: ol._image_width(-5, 900, 2400)) == "bad_arguments")
+    ok("absurd is refused", code_of(lambda: ol._image_width(100000, 900, 2400)) == "bad_arguments")
+    ok("the ceiling itself is allowed", ol._image_width(2400, 900, 2400) == 2400)
+    ok("a tiny value is lifted to the floor", ol._image_width(20, 900, 2400) == 100)
+    ok("garbage falls back to the default", ol._image_width("wide", 900, 2400) == 900)
+    ok("export ceiling is higher than view",
+       ol._image_width(12000, 1600, 12000) == 12000)
+
 
     print("\n%d/%d path checks passed" % (PASSED, PASSED + len(FAILED)))
     if FAILED:

package/test_readfile.py

@@ -0,0 +1,104 @@
+"""Offline checks for origin_read_file's shaping (no Origin needed).
+
+Two behaviours that cost a real debugging cycle:
+- a `.xlsx` used to be decoded as text and reported as "找不到数值数据行（只有表头？）",
+  which blames the user's file for our mistake;
+- the response used to carry no values at all, so a model could not tell a correctly
+  parsed column from one whose values slid into the neighbouring column.
+"""
+
+import os
+import shutil
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import originlab as ol  # noqa: E402
+
+PASSED = 0
+FAILED = []
+
+
+def ok(label, cond, detail=""):
+    global PASSED
+    if cond:
+        PASSED += 1
+    else:
+        FAILED.append("%s %s" % (label, detail))
+    print("%s %s%s" % ("PASS" if cond else "FAIL", label,
+                       (" | " + str(detail)[:110]) if detail else ""))
+
+
+def write(dirname, name, text, encoding="utf-8"):
+    path = os.path.join(dirname, name)
+    with open(path, "w", encoding=encoding, newline="") as fh:
+        fh.write(text)
+    return path
+
+
+def code_of(fn):
+    try:
+        fn()
+    except ol.OriginError as exc:
+        return exc.code
+    except Exception as exc:  # noqa: BLE001 — an unwrapped crash is the failure
+        return "UNWRAPPED:" + type(exc).__name__
+    return "no-raise"
+
+
+def main():
+    work = tempfile.mkdtemp(prefix="readfile_checks_")
+    try:
+        csv = write(work, "a.csv", "x,y\n1,2\n3,\n5,6\n")
+        res = ol.read_file(csv)
+        ok("csv parses", res.get("rows") == 3, res.get("rows"))
+        ok("every column carries a 3-value sample",
+           [c["sample"] for c in res["columns"]] == [[1.0, 3.0, 5.0], [2.0, None, 6.0]],
+           [c["sample"] for c in res["columns"]])
+        ok("sample keeps nulls so a gap is visible", None in res["columns"][1]["sample"])
+        ok("sample is explained", "原始值" in (res.get("sample_note") or ""),
+           res.get("sample_note"))
+        ok("full values still stay out of the payload",
+           all("values" not in c for c in res["columns"]))
+
+        # the binary-spreadsheet guard
+        for name, head in (("b.xlsx", b"PK\x03\x04"), ("c.xls", b"\xd0\xcf\x11\xe0"),
+                           ("d.wks", b"\x00\x00\x02\x00")):
+            path = os.path.join(work, name)
+            with open(path, "wb") as fh:
+                fh.write(head + b"\x00" * 64)
+            ok("%s is refused as a binary sheet" % name,
+               code_of(lambda p=path: ol.read_file(p)) == "unsupported_file_type",
+               code_of(lambda p=path: ol.read_file(p)))
+
+        # and the guard says what to do instead, with the file name in the message
+        path = os.path.join(work, "b.xlsx")
+        try:
+            ol.read_file(path)
+        except ol.OriginError as exc:
+            ok("message names the format", ".xlsx" in exc.message, exc.message)
+            ok("next action points at origin_import",
+               any("origin_import" in a for a in exc.next_actions), exc.next_actions)
+
+        # import_file must still accept Excel: only read_file refuses it
+        import inspect
+        src = inspect.getsource(ol.import_file)
+        ok("import_file still allows .xlsx", "二进制表格" not in src)
+
+        ok("a .bin is still routed to binio, not refused",
+           code_of(lambda: ol.read_file(os.path.join(
+               os.path.dirname(os.path.abspath(__file__)), "fixtures", "not_a_bin.bin")))
+           in ("parse_failed", "no-raise"), "binio path")
+
+        print("\n%d/%d read_file checks passed" % (PASSED, PASSED + len(FAILED)))
+        if FAILED:
+            for f in FAILED:
+                print("  FAILED:", f)
+            return 1
+        return 0
+    finally:
+        shutil.rmtree(work, ignore_errors=True)
+
+
+if __name__ == "__main__":
+    sys.exit(main())