expect-pty 0.5.0 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f3f00d375bb8a90ef67974bbd7649b031554e15f9d463cf28f1388d5d3e5dc1
-  data.tar.gz: 9c9a556719b8c79c43553bc344fa679737abb2330f8ecdec72beabfedb3842d7
+  metadata.gz: a2677ffa5b928375c26caefd595b51608a9e0e84eef0c923d683eb47229749a2
+  data.tar.gz: fe278b8bec5f635e71b0fd7ca9ca41978dbc3ca3eb0d3f82d6f0d6be2afd0282
 SHA512:
-  metadata.gz: 53fa1a25e62c9c16c2ecbafc3efa38ba4acd2c805afa6b1547e4b83cb95c98484bbd27f612a83397a9eb9a0715af857b7f9f4d698f52bdcaa4b7dcbd3a55a42e
-  data.tar.gz: 226b72621b685c9fce34097838e0c10a81f616b3ba26a62a90eb6f09c9e3a6e0a3cd5cac331ba79c9a81caf134707821622a3e1ebe85842aff01da79b1d1d554
+  metadata.gz: 50f8eef04336c2ad673dc0837b78176858c0f903555585f2ab99210b6e950e682af2a4ea64b3ca68b398bffbda07a08a44295097fb98c6b8299bf8db32cb3479
+  data.tar.gz: 6ba54b2d1c701272ce73f8b197c53655719868ff63c8aeb6479dccd0da8d2eedaef7e9e16a20adfc7bff7079feecc18efc8a4526cada4d015cd2b6fe6fdedbca

data/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## Unreleased
 
+## 0.5.2 - 2026-09-27
+
+- **文档排版**：整理贡献、发布、Kibitz 示例和 SSH 集成测试说明的换行与表格格式。
+
+## 0.5.1 - 2026-09-27
+
+- **终端清理**：`stty` 读取失败或中断后也会清理辅助管道和进程，保留原始异常，避免影响主会话。
+- **脱敏性能**：减少连续与重叠秘密匹配时的内存分配和处理耗时，保留跨块、规则更新和流尾部的脱敏行为。
+
 ## 0.5.0 - 2026-09-27
 
 - **独立脱敏**：新增无需创建会话的 `Expect::Redactor`，支持完整文本和分块字节流过滤，以及自定义替换标记。

data/CONTRIBUTING.md

@@ -1,6 +1,7 @@
 # 参与贡献
 
-欢迎中文或英文 issue 和 PR。库的公共 API 名称和错误信息使用英文；库内的责任划分、复杂生命周期和协议解释使用中文，RuboCop 等工具指令保持原格式。文档以现有文件的语言为准，示例中的可编辑命令保持直接清晰。
+欢迎中文或英文 issue 和 PR。库的公共 API 名称和错误信息使用英文；库内的责任划分、复杂生命周期和协议解释使用中文，RuboCop
+等工具指令保持原格式。文档以现有文件的语言为准，示例中的可编辑命令保持直接清晰。
 
 ## 本地检查
 
@@ -12,12 +13,17 @@ bundle exec rake           # RuboCop 和默认测试
 script/ci                  # 另含示例、Gem 构建及隔离安装验证
 ```
 
-修改转接或匹配时，先运行对应的 `test/*_test.rb`，再运行 `bundle exec rake`。默认测试不需要 SSH；真实 SSH 集成测试的环境要求见 [测试说明](test/integration/README.md)。发布操作和历史验证分别见 [发布说明](docs/RELEASING.md) 与 [验证记录](docs/VERIFICATION.md)。
+修改转接或匹配时，先运行对应的 `test/*_test.rb`，再运行 `bundle exec rake`。默认测试不需要 SSH；真实 SSH
+集成测试的环境要求见 [测试说明](test/integration/README.md)。发布操作和历史验证分别见 [发布说明](docs/RELEASING.md)
+与 [验证记录](docs/VERIFICATION.md)。
 
-RuboCop 对生产代码保留有限的长度、ABC、嵌套、参数数量和分支复杂度门槛。测试及基准的场景编排豁免方法长度与 ABC 计数；协议状态机的分支豁免只放在对应方法，并注明原因。阈值用于提示复核，职责拆分仍应保持状态归属和异常恢复逻辑完整。
+RuboCop 对生产代码保留有限的长度、ABC、嵌套、参数数量和分支复杂度门槛。测试及基准的场景编排豁免方法长度与 ABC
+计数；协议状态机的分支豁免只放在对应方法，并注明原因。阈值用于提示复核，职责拆分仍应保持状态归属和异常恢复逻辑完整。
 
 ## 提交问题或改动
 
-问题报告请附 Ruby 版本、操作系统、最小复现代码、预期与实际结果，以及必要的异常信息；日志中请删去凭据和会话敏感内容。修复行为缺陷时，先加入能在旧实现复现问题的回归测试。涉及缓冲、转义、背压或进程清理的改动，请对照 [内部状态与数据归属](docs/INTERNAL_CONTRACTS.md)，说明超时、EOF 和失败后的恢复行为。
+问题报告请附 Ruby
+版本、操作系统、最小复现代码、预期与实际结果，以及必要的异常信息；日志中请删去凭据和会话敏感内容。修复行为缺陷时，先加入能在旧实现复现问题的回归测试。涉及缓冲、转义、背压或进程清理的改动，请对照 [内部状态与数据归属](docs/INTERNAL_CONTRACTS.md)
+，说明超时、EOF 和失败后的恢复行为。
 
 PR 请说明行为变化、运行过的命令及结果。不要把本机生成的 `tmp/`、日志或凭据加入提交。

data/README.md

@@ -16,7 +16,7 @@ RubyGems/Bundler 解析。推荐入口 **`require "expect/pty"`**；本项目提
 项目和仓库名为 `expect-ruby`，Gem 名为 `expect-pty`。在应用的 Gemfile 中添加以下内容，然后运行 `bundle install`：
 
 ```ruby
-gem "expect-pty", "~> 0.5.0", require: "expect/pty"
+gem "expect-pty", "~> 0.5.2", require: "expect/pty"
 ```
 
 也可直接执行 `gem install expect-pty`。需要跟随开发分支时，可从 GitHub 安装：
@@ -29,8 +29,8 @@ gem "expect-pty", git: "https://github.com/gatework/expect-ruby.git", branch: "m
 
 ```sh
 mkdir -p tmp
-gem build expect-pty.gemspec --output tmp/expect-pty-0.5.0.gem
-gem install ./tmp/expect-pty-0.5.0.gem
+gem build expect-pty.gemspec --output tmp/expect-pty-0.5.2.gem
+gem install ./tmp/expect-pty-0.5.2.gem
 ```
 
 ```ruby

data/benchmark/redactor.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "support"
+
+# 同一驱动可加载基线或候选库；每轮创建独立过滤器，不能跨样本继承流状态。
+module RedactorBenchmark
+  def self.measure(runner, name, input, patterns, expected, chunk_size: nil, partial: false)
+    chunks = if chunk_size
+               (0...input.bytesize).step(chunk_size).map { |offset| input.byteslice(offset, chunk_size) }
+             else
+               [input]
+             end
+    runner.measure(name, bytes: input.bytesize,
+                         inputs: { bytes: input.bytesize, secret_lengths: patterns.map(&:bytesize),
+                                   chunk_size: chunk_size, partial: partial, repeated_finish: true },
+                         verify: ->(output) { ExpectBenchmark.check(output == expected, "incorrect #{name} output") },
+                         iterations: 5) do
+      filter = Expect::Redactor.new(patterns)
+      output = +"".b
+      chunks.each { |chunk| output << filter.append(chunk) }
+      output << filter.finish(partial: partial) << filter.finish(partial: partial)
+    end
+  end
+end
+
+runner = ExpectBenchmark::Runner.new("redactor")
+size = runner.smoke ? 512 : 65_536
+plain = "x" * size
+RedactorBenchmark.measure(runner, "empty_rules", plain, [], plain)
+RedactorBenchmark.measure(runner, "no_match", plain, ["secret"], plain)
+RedactorBenchmark.measure(runner, "no_match_many", plain, %w[secret password token credential], plain)
+RedactorBenchmark.measure(runner, "sparse", "#{plain}secret!", ["secret"], "#{plain}[FILTERED]!")
+RedactorBenchmark.measure(runner, "contiguous_short", "token" * (size / 5), ["token"], "[FILTERED]")
+
+(runner.smoke ? [1, 32, 128] : [1, 32, 1024, 4096]).each do |length|
+  RedactorBenchmark.measure(runner, "overlap_#{length}", "a" * size, ["a" * length], "[FILTERED]")
+end
+count = runner.smoke ? 8 : 256
+RedactorBenchmark.measure(runner, "contained_patterns", "abcde!" * count,
+                          %w[abc bc ab bcd], "[FILTERED]e!" * count)
+RedactorBenchmark.measure(runner, "binary_overlap", "\0\xffABC\x80!".b * count,
+                          ["\xffABC".b, "ABC\x80".b], "\0[FILTERED]!".b * count, chunk_size: 3)
+RedactorBenchmark.measure(runner, "marker_in_input", "[FILTERED] secret!" * count,
+                          %w[secret FILTERED], "[[FILTERED]] [FILTERED]!" * count)
+
+[1, 7, 4096].each do |chunk_size|
+  RedactorBenchmark.measure(runner, "stream_#{chunk_size}", "prefix secret!\n" * count,
+                            ["secret"], "prefix [FILTERED]!\n" * count, chunk_size: chunk_size)
+end
+[true, false].each do |partial|
+  RedactorBenchmark.measure(runner, "partial_#{partial}", "prefix pass", ["password"],
+                            partial ? "prefix [FILTERED]" : "prefix pass", chunk_size: 1, partial: partial)
+end
+
+runner.measure("update_pending", bytes: 10, inputs: { update: "keep old mask and match new secret" },
+                                 verify: lambda { |output|
+                                   ExpectBenchmark.check(output == "[FILTERED]!")
+                                 }, iterations: 100) do
+  filter = Expect::Redactor.new(%w[abc long-pattern])
+  output = filter.append("abcsec")
+  filter.patterns = ["secret"]
+  output << filter.append("ret!") << filter.finish << filter.finish
+end
+runner.finish

data/docs/INTERNAL_CONTRACTS.md

@@ -61,6 +61,16 @@ exec 成功后诊断输出失败，也要立即回收未交付给调用方的子
 是否保留原始异常由当前构造、块或关闭作用域显式记录，不能直接读取调用者 rescue 中的 `$!`。`Interrupt` 和 `SystemExit`
 同样先清理再传播；`break` / `throw` 不是异常，此时清理失败仍应抛出。
 
+`stty` 为辅助管道和 PID 创建独立的 SessionResources，不写入主会话的 PID/status，不关闭主会话。
+账本构造被中断时仍关闭局部变量中已经创建的管道；fork 后的副本只关闭本地管道，不向父进程的辅助 PID 发信号或 detach，等待途中也重新核对归属。
+正常路径读取输出并阻塞回收，EINTR 只重试 wait，不再次启动命令，也不增加固定等待。
+异常路径先尝试关闭两个管道，再依次等待自然退出、发送 TERM、发送 KILL；每阶段使用固定的 50ms 单调时钟预算，
+非阻塞 wait 或 signal 的 EINTR 不延长期限。ECHILD 立即释放该 PID 的归属，不向可能复用的 PID 发信号；
+ESRCH 后仍尝试回收。三个阶段结束或系统调用失败后仍有 PID 时交给 `Process.detach` 异步回收，不保证返回前退出，
+也不伪造退出状态。预算约束进程轮询，不是任意同步 IO 或系统调度的硬实时保证。
+本次主异常（包括 Interrupt/SystemExit）保持对象身份；没有主异常时传播首个 IOError/SystemCallError 清理失败。
+永久失败的 close 只保证被尝试，不能报告成句柄已关闭；缺失 stty 仍为 IOError 并保留 ENOENT cause。
+
 ## 缓冲裁剪与字面扫描
 
 `buffer_discarded_bytes` 随会话累计，只在匹配窗口执行 `trim_buffer` 时增加。读取、`buffer=`、降低上限和下一次匹配应用上限都可能触发裁剪；匹配消费、清空、EOF 和 Relay 交接不计入，关闭后仍保留计数。它是可观察的丢弃量，不是缓冲满事件，也不提供全文归档。
@@ -80,6 +90,8 @@ exec 成功后诊断输出失败，也要立即回收未交付给调用方的子
 `redactor.rb` 是无 IO 的公共字节过滤器。会话复制并追加注册秘密，每个接收日志流以及发送、接收诊断方向各自持有过滤器。暂存最长秘密长度减一的尾部，重叠秘密合并为隐藏区间，过滤发生在 `inspect` 转义之前。缓冲快照可能只剩秘密中间字节，启用脱敏时整体隐藏，不重复展示其内容。
 
 公共构造器及 `patterns=` 会校验并复制秘密；空模式列表直接交付字节，更新规则不清除已经建立的掩码。
+同一模式的命中按字节偏移递增枚举，相交或相邻区间合并后才写入掩码；不能通过跳过整个秘密长度省略重叠命中。
+合并仍与现有掩码取并集，保留其他模式和旧规则已标记的隐藏字节，不改变跨块连续区间只输出一个替换标记的规则。
 默认替换标记为 `[FILTERED]`，上层库可显式指定自己的标记。类方法 `redact` 使用独立流并以 `finish(partial: false)` 结束完整文本；
 `append`/`finish` 的默认流策略仍隐藏末尾疑似秘密前缀。作用域所有权、终端渲染和异常字段选择由调用方负责。
 
@@ -99,11 +111,12 @@ EOF 结束接收流，日志或诊断目标替换先冲刷旧流，显式关闭
 
 | 不变量 | 测试 |
 | --- | --- |
+| stty 主错误优先、辅助进程回收、EINTR 预算、ECHILD/ESRCH、detach 和主会话隔离 | terminal_cleanup_test |
 | 裁剪计数、正常消费、转接交接与日志错误 | buffer_accounting_test |
 | 外部回收、借用 IO、关闭失败重试、原生错误分类 | lifecycle_contract_test |
 | 绝对期限、接收和回调重置、过期文本、EOF、EINTR、零轮询 | deadline_test |
 | Logger/IO/回调、分片与重叠秘密、二进制、流尾部、关闭失败、覆盖与重入 | diagnostics_test |
-| 公共过滤器独立加载、完整文本与分块、空规则、规则更新、输入复制和安全摘要 | redactor_test |
+| 公共过滤器独立加载、完整文本与分块、空规则、规则更新、输入复制、安全摘要及固定种子字节区间差分 | redactor_test |
 | 字面跨读取命中、声明优先级、缓存失效、操作序列与全量扫描对照 | literal_scan_test |
 
 ## 既有回归入口

data/docs/PERFORMANCE.md

@@ -7,9 +7,10 @@ bundle exec ruby benchmark/matching.rb
 bundle exec ruby benchmark/relay.rb
 bundle exec ruby benchmark/send_slow.rb
 bundle exec ruby benchmark/scaling.rb
+bundle exec ruby benchmark/redactor.rb
 ```
 
-默认预热一次、采样五次。结果分别写入 `tmp/benchmark/matching.json`、`relay.json`、`send_slow.json`
+默认预热一次、采样五次。结果分别写入 `tmp/benchmark/matching.json`、`relay.json`、`send_slow.json`、`scaling.json`、`redactor.json`
 ，该目录不提交。每个场景先核对非空输入的预期结果，再计时；每轮计时后再次核对最后一次执行的结果。输出包括
 Ruby、平台、源码提交、工作区是否修改、库源码 SHA-256、输入规模、迭代次数、处理字节数、墙钟耗时、分配对象数和 GC 次数。
 
@@ -20,6 +21,7 @@ Ruby、平台、源码提交、工作区是否修改、库源码 SHA-256、输
 | matching  | 4 KiB、64 KiB、1 MiB；1、8、32 个正则；首个命中、末个命中、全未命中；UTF-8 前缀和可选捕获；1、8、32 个会话、多组重复来源和同时就绪的真实管道 |
 | relay     | 无转义、字面转义、16 个正则转义；正常目标与每次只接受 17 字节的目标共同接收相同数据                                                          |
 | send_slow | 真实本地 socket；无回显、持续回显；零延迟和每字符 1ms 延迟                                                                                   |
+| redactor | 空规则、无命中/稀疏/连续/高重叠；包含关系、多秘密、二进制、原文替换标记、1/7/4096 字节分块、partial finish、重复 finish 及 pending 中更新规则 |
 
 `matching` 的扫描用内部 `find_match` 单独度量缓冲扫描，排除 PTY 启动和回调开销；就绪场景包含管道写入、选择和读取。`relay`
 的前三项单独度量转义扫描，混合目标项运行完整转接循环。短写模拟目标吞吐受限，不等同于真实慢网络。`send_slow` 包含
@@ -34,6 +36,10 @@ socket、接收线程和完整回显校验的成本；无回显时计时止于
 
 每个样本记录计时区间前后的 RSS 和打开描述符数，以及进程的描述符上限；采样自身不进入计时或分配计数。RSS 是端点快照，受 Ruby 堆和分配器保留影响，不代表峰值或存活对象大小。平台不支持某项采样时记录 `null`。描述符快照也不是长期泄漏证明，应同时检查重复样本和关闭流程。
 
+`redactor` 每次操作创建独立过滤器，分块数据在计时前准备，计时包含过滤器构造、append 和两次 finish。
+主要输入规模为 64 KiB，高重叠秘密长度为 1/32/1024/4096 字节；smoke 缩小为 512 字节及 1/32/128 字节秘密。
+公共 Runner 会加载完整 Expect（含 PTY）；基准本身不启动 PTY 会话，独立 `require "expect/redactor"` 的无 PTY 契约由测试验证。
+
 ## 同环境对照
 
 对照目录必须包含已知提交的完整源码。两个版本使用同一套基准脚本、同一 Ruby 和依赖，在机器空闲时交替运行，比较原始样本的中位数与分配量：
@@ -72,6 +78,7 @@ bundle exec ruby benchmark/matching.rb --smoke
 bundle exec ruby benchmark/relay.rb --smoke
 bundle exec ruby benchmark/send_slow.rb --smoke
 bundle exec ruby benchmark/scaling.rb --smoke
+bundle exec ruby benchmark/redactor.rb --smoke
 ```
 
 `script/ci` 运行这些小规模正确性检查，不设置墙钟性能阈值。热点优化必须有实际收益证据；减少对象分配不代表所有输入都会变快，也不能替代完整测试和安装验证。
@@ -104,3 +111,55 @@ bundle exec ruby benchmark/scaling.rb --samples 3 --iterations 10
 同一工作树的三次容量样本中，1、16、64 来源各执行十轮的耗时中位数分别为 0.179、1.372、8.285 ms；1,000 来源执行三轮为 401.878 ms。1,000 来源样本的描述符数均为 2,007 → 2,007，RSS 端点从约 35.8 MB 增至 37.9 MB，不能解释为稳定内存上限。阻塞目标场景十轮共 0.186 ms，其他来源仍可推进，描述符数均为 13 → 13。
 
 原始记录为 `tmp/core-improvements/scaling-final.json` 和 `scaling-1000-final.json`，库源码摘要与上述工作树匹配记录一致。当前证据支持保留既有 select 调度，先量化真实负载，再决定是否需要替换后端。
+
+## Redactor 重叠区间合并验证（2026-09-27）
+
+基线为 `v0.5.0` / `b7cd25e736acbfcb43e412ec4d233f9b2602cb03` 的源码归档。使用同一份
+`benchmark/redactor.rb`、macOS arm64、Ruby 4.0.6、Bundler 4.0.17 和相同依赖，按“基线 → 候选”交替运行两轮，
+每轮 `--samples 5 --iterations 20`。下表是最后一轮五个样本的中位数，耗时和分配均为 **20 次操作总量**。
+每项输出在预热及各样本结束后校验，性能采样期间没有并行运行项目测试。
+
+| 工作负载 | 基线 ms | 候选 ms | 基线分配对象 | 候选分配对象 |
+| --- | ---: | ---: | ---: | ---: |
+| 空规则 | 0.438 | 0.416 | 541 | 541 |
+| 单秘密无命中 | 0.774 | 0.973 | 561 | 561 |
+| 多秘密无命中 | 2.305 | 1.447 | 641 | 641 |
+| 稀疏命中 | 1.145 | 1.175 | 581 | 581 |
+| 连续短秘密 | 26.159 | 9.345 | 262,661 | 541 |
+| 重叠 / 1 字节秘密 | 113.787 | 42.799 | 1,311,241 | 541 |
+| 重叠 / 32 字节秘密 | 189.706 | 97.756 | 1,310,661 | 581 |
+| 重叠 / 1024 字节秘密 | 642.376 | 429.316 | 1,290,821 | 581 |
+| 重叠 / 4096 字节秘密 | 1698.130 | 1361.663 | 1,229,381 | 581 |
+| 包含关系 | 2.881 | 2.915 | 26,201 | 26,201 |
+| 二进制跨块重叠 | 7.967 | 8.299 | 101,221 | 101,221 |
+| 原文包含替换标记 | 2.758 | 2.837 | 21,081 | 21,081 |
+| 1 字节分块 | 34.612 | 34.151 | 589,161 | 589,161 |
+| 7 字节分块 | 6.746 | 6.716 | 93,361 | 93,361 |
+| 4096 字节分块 | 1.434 | 1.456 | 10,781 | 10,781 |
+| partial finish | 0.128 | 0.129 | 2,141 | 2,141 |
+| exact finish | 0.117 | 0.113 | 2,021 | 2,021 |
+| pending 中更新规则 | 0.075 | 0.076 | 961 | 961 |
+
+两轮中连续短秘密耗时减少 63.6%–64.3%；重叠秘密按长度分别减少 62.4%–62.8%、48.5%–48.9%、
+33.1%–33.2%、19.7%–19.8%。重叠查找仍逐字节进行，只减少重复掩码分配/覆盖，没有跳过重叠命中或改变脱敏范围。
+
+短样本中的无命中结果波动明显，因此又通过本地 `tmp/guide-review/redactor-common.rb` 筛选同一驱动的常见负载，
+每轮改为 `--samples 5 --iterations 500`，再交替运行两轮。该包装器只跳过上述五项密集命中，不改变任何输入、过滤或校验逻辑。
+第二轮中单秘密无命中为 23.883 → 24.009 ms，多秘密为 56.148 → 56.081 ms，1 字节分块为 873.397 → 870.462 ms。
+存在小幅代价：稀疏命中两轮慢 2.3%/4.5%，4096 字节分块慢 2.2%/2.5%，规则更新慢 1.0%/6.0%；
+后者第二轮 500 次操作为 1.562 → 1.655 ms。其余常见负载约在 -2.8% 至 +3.6% 之间，分配量不变。
+保留此优化的取舍是以少量区间记录计算换取密集/重叠场景的显著分配下降，不声称所有负载都更快，也不设置 CI 墙钟阈值。
+
+复现全负载：
+
+```sh
+bundle exec ruby benchmark/redactor.rb --library /path/to/v0.5.0/lib --samples 5 --iterations 20 --output tmp/benchmark/redactor-before.json
+bundle exec ruby benchmark/redactor.rb --samples 5 --iterations 20 --output tmp/benchmark/redactor-after.json
+```
+
+原始样本：`tmp/guide-review/redactor-before-{4,5}.json`、`redactor-after-{4,5}.json`；
+延长采样：`redactor-common-before-{1,2}.json`、`redactor-common-after-{1,2}.json`。均在忽略目录，不随 Gem 分发。
+基线库 SHA-256 为 `d2a55eb1aa1d00658195f21f32adf37cf3ab8a24bb6a5bcf9564f6e9a6047b28`，
+性能采样时的候选库（版本号仍为 `0.5.0`）为 `753d403cf4801900cb53be5c34b04da0ffa313f25b4d2fb23a6d25ffce36e75a`，
+驱动文件为 `f99f6c8f1ec21d4d97c984dbfd51fd3e17b64fa7968095323e16d68d4a0d4cc0`。
+这些是合成字节过滤负载，不代表完整设备会话吞吐；RSS 端点不用于声称峰值内存降低。

data/docs/RELEASING.md

@@ -1,6 +1,7 @@
 # 发布版本
 
-项目名为 `expect-ruby`，RubyGems 名为 `expect-pty`。使用 `script/release.rb --rubygems-only` 可仅发布 RubyGems；不加该选项时还会创建 GitHub Release，附带同一个 Gem 和 `SHA256SUMS`。生成文件统一放在已被 Git 忽略的 `tmp/` 下。
+项目名为 `expect-ruby`，RubyGems 名为 `expect-pty`。使用 `script/release.rb --rubygems-only` 可仅发布 RubyGems；不加该选项时还会创建
+GitHub Release，附带同一个 Gem 和 `SHA256SUMS`。生成文件统一放在已被 Git 忽略的 `tmp/` 下。
 
 ## 准备版本
 
@@ -12,7 +13,8 @@
 
 ## 仅发布 RubyGems
 
-本地已登录 `gem` 时，脚本直接使用已有凭据。如果 RubyGems 要求一次性验证码，`gem push` 会提示输入。此模式不调用 `gh`，不要求推送到 GitHub，也不创建标签或 GitHub Release。
+本地已登录 `gem` 时，脚本直接使用已有凭据。如果 RubyGems 要求一次性验证码，`gem push` 会提示输入。此模式不调用 `gh`，不要求推送到
+GitHub，也不创建标签或 GitHub Release。
 
 ```sh
 bundle install
@@ -20,9 +22,13 @@ ruby script/release.rb --rubygems-only --dry-run
 ruby script/release.rb --rubygems-only
 ```
 
-默认执行 `script/ci` 的检查、完整测试、构建和隔离安装验证，构建包保存在 `tmp/ci/expect-pty-版本号.gem`。随后复制到 `tmp/release/版本号/candidate-*/` 的独占目录，核对包内文件并生成发布说明和校验文件。该副本贯穿后续发布，目录会保留供失败重试。正式发布前再次确认源码未变，上传 RubyGems 后下载远端包核对 SHA256。
+默认执行 `script/ci` 的检查、完整测试、构建和隔离安装验证，构建包保存在 `tmp/ci/expect-pty-版本号.gem`。随后复制到
+`tmp/release/版本号/candidate-*/` 的独占目录，核对包内文件并生成发布说明和校验文件。该副本贯穿后续发布，目录会保留供失败重试。正式发布前再次确认源码未变，上传
+RubyGems 后下载远端包核对 SHA256。
 
-正式发布逐个核对包内普通文件在目标 Git 提交中的存在性、原始字节和执行权限，同时核对 gemspec 的安装元数据及主页。`git status` 为空不能替代这一检查：忽略规则可能隐藏被 glob 收入包的本地文件，`assume-unchanged` 和 `core.filemode` 也可能隐藏差异。候选包必须与已提交源码一致。
+正式发布逐个核对包内普通文件在目标 Git 提交中的存在性、原始字节和执行权限，同时核对 gemspec 的安装元数据及主页。
+`git status` 为空不能替代这一检查：忽略规则可能隐藏被 glob 收入包的本地文件，`assume-unchanged` 和 `core.filemode`
+也可能隐藏差异。候选包必须与已提交源码一致。
 
 `--dry-run` 只做本地验证，可在提交前使用。它仍要求版本号和发布说明完整。
 
@@ -35,11 +41,13 @@ ruby script/release.rb --dry-run
 ruby script/release.rb
 ```
 
-正式发布先创建 GitHub Release，再上传 RubyGems，最后下载 RubyGems 上的包核对 SHA256。GitHub 上还没有标签时，会为当前提交创建 `v版本号` 标签。
+正式发布先创建 GitHub Release，再上传 RubyGems，最后下载 RubyGems 上的包核对 SHA256。GitHub 上还没有标签时，会为当前提交创建
+`v版本号` 标签。
 
 ## GitHub Actions 发布
 
-GitHub Runner 不会继承本机的 Gem 登录状态。要在 Actions 发布 RubyGems，需在仓库的 Settings → Secrets and variables → Actions 中配置 `RUBYGEMS_API_KEY`，使用具有 `Push rubygem` 权限的发布 Key。
+GitHub Runner 不会继承本机的 Gem 登录状态。要在 Actions 发布 RubyGems，需在仓库的 Settings → Secrets and variables →
+Actions 中配置 `RUBYGEMS_API_KEY`，使用具有 `Push rubygem` 权限的发布 Key。
 
 ```sh
 git tag -a v0.3.3 -m 'Release v0.3.3'
@@ -49,22 +57,28 @@ gh workflow run release.yml --ref v0.3.3 --repo gatework/expect-ruby
 
 也可以在 Actions → Release → Run workflow 选择对应版本标签。工作流仅支持手动触发，避免本地发布时出现第二次并发上传。
 
-发布作业先验证标签与版本号一致，再复用 CI 的 Linux/macOS、Ruby 3.2/3.3/3.4/4.0 共 8 个环境。全部通过后，下载 Ubuntu / Ruby 4.0 作业验证过的 Gem，交给同一个发布脚本；发布阶段不重新构建。
+发布作业先验证标签与版本号一致，再复用 CI 的 Linux/macOS、Ruby 3.2/3.3/3.4/4.0 共 8 个环境。全部通过后，下载 Ubuntu / Ruby
+4.0 作业验证过的 Gem，交给同一个发布脚本；发布阶段不重新构建。
 
 未配置 `RUBYGEMS_API_KEY` 时，GitHub Release 仍会创建，RubyGems 步骤会明确失败；此时可以下载 Release 中的原包，在本地使用已有登录状态完成上传。
 
 ## 失败后继续
 
-保留脚本输出的 `Artifact` 路径，用该候选 Gem 重试发布；更换 RubyGems 工具版本或重新构建可能得到不同字节，同一个版本不得覆盖已有内容。也可以直接指定从 CI 或 Release 下载的原包：
+保留脚本输出的 `Artifact` 路径，用该候选 Gem 重试发布；更换 RubyGems 工具版本或重新构建可能得到不同字节，同一个版本不得覆盖已有内容。也可以直接指定从
+CI 或 Release 下载的原包：
 
 ```sh
 ruby script/release.rb --rubygems-only --artifact tmp/ci/expect-pty-0.3.3.gem
 ```
 
-将示例路径替换为实际输出的 `Artifact` 路径。`--artifact` 会跳过构建和测试，但仍核对包与当前源码是否一致；需要同时恢复 GitHub Release 时去掉 `--rubygems-only`。
+将示例路径替换为实际输出的 `Artifact` 路径。`--artifact` 会跳过构建和测试，但仍核对包与当前源码是否一致；需要同时恢复
+GitHub Release 时去掉 `--rubygems-only`。
 
-工作流失败时优先使用 Re-run failed jobs，继续使用本次 CI 保存的产物。需要在本地恢复时，检出发布标签对应的干净源码，下载该 Release 的 Gem，再通过 `--artifact` 指定它。
+工作流失败时优先使用 Re-run failed jobs，继续使用本次 CI 保存的产物。需要在本地恢复时，检出发布标签对应的干净源码，下载该
+Release 的 Gem，再通过 `--artifact` 指定它。
 
-脚本会校验现有 RubyGems 版本和 GitHub Release 附件的 SHA256；一致时复用，不一致时中止。已有 GitHub Release 缺少附件时会补传，已有版本和附件不会被覆盖。
+脚本会校验现有 RubyGems 版本和 GitHub Release 附件的 SHA256；一致时复用，不一致时中止。已有 GitHub Release
+缺少附件时会补传，已有版本和附件不会被覆盖。
 
-上传中断若留下 `starter` 状态的空附件，脚本会明确指出附件名称。先确认没有其他发布或上传在运行，再在 GitHub Release 中删除该失败附件，使用原包重试；脚本不会自动删除可能仍在上传的附件。
+上传中断若留下 `starter` 状态的空附件，脚本会明确指出附件名称。先确认没有其他发布或上传在运行，再在 GitHub Release
+中删除该失败附件，使用原包重试；脚本不会自动删除可能仍在上传的附件。

data/examples/kibitz/README.md

@@ -1,6 +1,8 @@
 # 本地 Kibitz 示例与测试
 
-参考 [Expect.pm 的 kibitz](https://github.com/jacoby/expect.pm/tree/master/examples/kibitz)，使用本项目的 `Expect.open` 块、`listeners=`、`on_sequence` 和 `Expect.interconnect` 连接两端输入与同一个交互进程。参考源码为上游提交 `2ea0e4ce20a896c95cb4c94e781f1b1f3145150d`。
+参考 [Expect.pm 的 kibitz](https://github.com/jacoby/expect.pm/tree/master/examples/kibitz)，使用本项目的 `Expect.open`
+块、`listeners=`、`on_sequence` 和 `Expect.interconnect` 连接两端输入与同一个交互进程。参考源码为上游提交
+`2ea0e4ce20a896c95cb4c94e781f1b1f3145150d`。
 
 需要 Ruby 3.2+ 和 macOS/Linux。示例和自动脚本只依赖标准库，不需要 SSH 服务或密码。
 
@@ -12,7 +14,8 @@
 ruby examples/kibitz/kibitz.rb -- /bin/sh -i
 ```
 
-程序打印一条完整的 `--join /tmp/expect-kibitz-.../peer.sock` 命令。在本机、同一账户的第二个终端执行这条命令，两端即可操作同一个 shell。输入和输出在两端都可见，例如：
+程序打印一条完整的 `--join /tmp/expect-kibitz-.../peer.sock` 命令。在本机、同一账户的第二个终端执行这条命令，两端即可操作同一个
+shell。输入和输出在两端都可见，例如：
 
 ```sh
 # 第一个终端设置 shell 变量
@@ -21,7 +24,8 @@ shared_value=42
 printf '%s\n' "$shared_value"
 ```
 
-任一端输入 `exit` 结束共享 shell；Ctrl-C 发给共享进程的前台任务。任一端按 Ctrl-] 结束自己的转接并断开连接，另一端随 EOF 结束。终端配置在退出时恢复。可以通过 `-- program args...` 运行其他交互程序；不传程序时使用 `$SHELL`，缺省 `/bin/sh`。
+任一端输入 `exit` 结束共享 shell；Ctrl-C 发给共享进程的前台任务。任一端按 Ctrl-] 结束自己的转接并断开连接，另一端随 EOF
+结束。终端配置在退出时恢复。可以通过 `-- program args...` 运行其他交互程序；不传程序时使用 `$SHELL`，缺省 `/bin/sh`。
 
 ## 无子进程互传和可选参数
 
@@ -39,9 +43,11 @@ ruby examples/kibitz/kibitz.rb --noescape -- /bin/sh -i
 ruby examples/kibitz/kibitz.rb --timeout 30 --log /tmp/my-kibitz-session.log -- /bin/sh -i
 ```
 
-共享进程模式的日志记录该进程实际返回的字节，包括终端回显；无子进程模式记录对端返回的字节。日志使用 0600 权限。进程正常结束时，发起端返回该进程的退出码；转义或对端 EOF 返回 0，超时或连接失败返回非零。加入端只能观察连接结束，不取得共享进程的退出码。
+共享进程模式的日志记录该进程实际返回的字节，包括终端回显；无子进程模式记录对端返回的字节。日志使用 0600
+权限。进程正常结束时，发起端返回该进程的退出码；转义或对端 EOF 返回 0，超时或连接失败返回非零。加入端只能观察连接结束，不取得共享进程的退出码。
 
-这是同账户本地示例：连接使用 0700 临时目录内的 0600 Unix socket，接受一位加入者后移除 socket，退出时清理目录。原例的用户邀请、跨主机 rlogin、FIFO 以及转义菜单没有移植；双方终端初始尺寸由发起端决定，未实现运行期间的窗口尺寸同步。
+这是同账户本地示例：连接使用 0700 临时目录内的 0600 Unix socket，接受一位加入者后移除 socket，退出时清理目录。原例的用户邀请、跨主机
+rlogin、FIFO 以及转义菜单没有移植；双方终端初始尺寸由发起端决定，未实现运行期间的窗口尺寸同步。
 
 ## 自动运行同样的两个终端流程
 
@@ -51,21 +57,23 @@ ruby examples/kibitz/test_kibitz.rb
 bundle exec rake test:kibitz
 ```
 
-脚本真正启动两份 `kibitz.rb`，通过两个独立 PTY 模拟两位用户，并执行打印出的 Unix socket 加入流程。共享模式运行真实 `/bin/sh -i`，没有 mock 转发逻辑。
-
-| 场景 | 检查 |
-| --- | --- |
-| 共享 shell | 输入回显、双方命令、共享变量、两端输出、中文、stderr、失败后继续执行 |
-| Ctrl-C 与进程 EOF | 第二端中断第一端启动的前台任务，最终输出到达两端，进程退出 |
-| `--noproc` | 双向字节互传，发送端无本地回显 |
-| 自定义转义 | `STOP` 分两次发送，前缀不泄漏，转义和尾部不进入对端 |
-| 加入端转义 | Ctrl-] 关闭加入端，发起端响应 EOF |
-| `--noescape` | Ctrl-] 字节被完整转发 |
-| 非零退出 | 共享 shell 返回 7，发起程序也返回 7 |
-| 超时 | 转接到期返回失败，另一端结束 |
-| 每个场景 | 就绪时已关闭本地回显，退出后两端终端配置恢复，socket 清理、日志权限正确 |
-
-每轮结果写入 `tmp/kibitz/` 的独立目录，可用 `EXPECT_LOG_DIR` 指定其他目录。`report.json` 包含各场景检查项与整体 `passed`，各场景子目录保留 `session.log`。只有全部检查通过才返回 0。默认测试集还覆盖没有第二端加入时的超时清理：
+脚本真正启动两份 `kibitz.rb`，通过两个独立 PTY 模拟两位用户，并执行打印出的 Unix socket 加入流程。共享模式运行真实
+`/bin/sh -i`，没有 mock 转发逻辑。
+
+| 场景              | 检查                                                                    |
+|-------------------|-------------------------------------------------------------------------|
+| 共享 shell        | 输入回显、双方命令、共享变量、两端输出、中文、stderr、失败后继续执行    |
+| Ctrl-C 与进程 EOF | 第二端中断第一端启动的前台任务，最终输出到达两端，进程退出              |
+| `--noproc`        | 双向字节互传，发送端无本地回显                                          |
+| 自定义转义        | `STOP` 分两次发送，前缀不泄漏，转义和尾部不进入对端                     |
+| 加入端转义        | Ctrl-] 关闭加入端，发起端响应 EOF                                       |
+| `--noescape`      | Ctrl-] 字节被完整转发                                                   |
+| 非零退出          | 共享 shell 返回 7，发起程序也返回 7                                     |
+| 超时              | 转接到期返回失败，另一端结束                                            |
+| 每个场景          | 就绪时已关闭本地回显，退出后两端终端配置恢复，socket 清理、日志权限正确 |
+
+每轮结果写入 `tmp/kibitz/` 的独立目录，可用 `EXPECT_LOG_DIR` 指定其他目录。`report.json` 包含各场景检查项与整体 `passed`
+，各场景子目录保留 `session.log`。只有全部检查通过才返回 0。默认测试集还覆盖没有第二端加入时的超时清理：
 
 ```sh
 bundle exec ruby -Itest test/kibitz_test.rb

data/examples/kibitz/kibitz.rb

@@ -135,6 +135,7 @@ module Kibitz
     File.unlink(socket_path) if socket_path && File.socket?(socket_path)
     Dir.rmdir(directory) if directory && Dir.exist?(directory)
   end
+
   # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 end
 

data/lib/expect/redactor.rb

@@ -72,13 +72,24 @@ class Expect
       end
     end
 
-    # 每次只将命中区域标为隐藏，不清除旧掩码；偏移逐字节推进以识别相互重叠的秘密。
+    # 仍逐字节推进重叠命中，但同一模式的相交/相邻区间只写一次掩码。
+    # 只向旧掩码取并集，不能清除其他模式或旧规则已经隐藏的 pending 字节。
     def mark_secrets
       @patterns.each do |pattern|
-        offset = -1
+        starting = @pending.index(pattern)
+        next unless starting
+
+        length = pattern.bytesize
+        ending = starting + length
+        offset = starting
         while (offset = @pending.index(pattern, offset + 1))
-          @hidden[offset, pattern.bytesize] = "\1" * pattern.bytesize
+          if offset > ending
+            @hidden[starting, ending - starting] = "\1" * (ending - starting)
+            starting = offset
+          end
+          ending = offset + length
         end
+        @hidden[starting, ending - starting] = "\1" * (ending - starting)
       end
     end
 

data/lib/expect/terminal.rb

@@ -5,25 +5,30 @@ require "shellwords"
 # 会话终端的模式和窗口尺寸接口；人工接管期间的临时恢复由 interaction.rb 负责。
 class Expect
   # 查询可恢复的终端模式字符串，或通过系统 stty 设置模式；参数按数组传递，不经 shell。
-  # 非终端返回空字符串；命令不存在或执行失败抛出 IOError，管道在所有退出路径关闭。
+  # 辅助进程与管道独立记账，不能覆盖主会话 PID；失败时保留原异常并有界回收。
   def stty(*modes)
     return "" unless tty?
 
     modes = modes.flat_map { |mode| Shellwords.split(mode.to_s) }
     modes = ["-g"] if modes.empty?
     reader, sink = IO.pipe
-    child = Process.spawn("stty", *modes, in: to_io, out: sink, err: sink)
+    resources = SessionResources.new(reader, writer: sink, own: true)
+    resources.pid = Process.spawn("stty", *modes, in: to_io, out: sink, err: sink)
     sink.close
     output = reader.read
-    _, status = Process.waitpid2(child)
+    status = wait_stty(resources.pid)
+    resources.pid = nil
     raise IOError, "stty failed: #{output.strip}" unless status.success?
 
     output.strip
   rescue Errno::ENOENT
+    failed = true
     raise IOError, "stty executable not found in PATH; install the system terminal utilities"
+  rescue Exception # rubocop:disable Lint/RescueException -- 中断同样先回收辅助进程，再原样传播；不读取调用者的旧 $!。
+    failed = true
+    raise
   ensure
-    reader&.close unless reader&.closed?
-    sink&.close unless sink&.closed?
+    cleanup_preserving_failure(failed) { cleanup_stty(resources, reader, sink) }
   end
 
   # 读取终端的 [行数, 列数]；底层并非终端或句柄已关闭时保留原生 IO 异常。
@@ -33,4 +38,65 @@ class Expect
   def winsize=(size)
     to_io.winsize = size
   end
+
+  private
+
+  # 正常路径阻塞取得真实状态，不额外轮询或固定等待；EINTR 不重新执行 stty。
+  def wait_stty(pid)
+    Process.waitpid2(pid).last
+  rescue Errno::EINTR
+    retry
+  end
+
+  # 即使账本初始化被中断，局部变量中的管道仍须关闭；单端失败不跳过其他清理。
+  # 无主异常时由调用方传播首个常规清理错误。
+  def cleanup_stty(resources, reader, sink)
+    failure = nil
+    [reader, sink].compact.each do |io|
+      io.close unless io.closed?
+    rescue IOError, SystemCallError => error
+      failure ||= error
+    end
+    begin
+      reap_stty(resources) if resources
+    rescue IOError, SystemCallError => error
+      failure ||= error
+    end
+    raise failure if failure
+  end
+
+  # 每阶段共享固定的 50ms 单调时钟预算：自然退出、TERM、KILL；中断不续期。
+  # 仍无法同步回收或系统调用失败时交给 detach 的后台 wait，不伪造退出状态。
+  def reap_stty(resources)
+    return unless resources.owner == Process.pid
+
+    [nil, "TERM", "KILL"].each do |signal|
+      deadline = Expect.monotonic + 0.05
+      loop do
+        begin
+          resources.reap
+          return resources.status unless resources.pid && resources.owner == Process.pid
+
+          if signal
+            begin
+              Process.kill(signal, resources.pid)
+            rescue Errno::ESRCH
+              # 退出可发生在非阻塞 wait 与信号之间，仍需继续 wait。
+              nil
+            end
+            signal = nil
+          end
+        rescue Errno::EINTR
+          # 重试沿用本阶段期限，连续 EINTR 也必须交还控制权。
+          nil
+        end
+        remaining = deadline - Expect.monotonic
+        break unless remaining.positive?
+
+        sleep [remaining, 0.005].min
+      end
+    end
+  ensure
+    Process.detach(resources.pid) if resources.pid && resources.owner == Process.pid
+  end
 end

data/lib/expect/version.rb

@@ -2,5 +2,5 @@
 
 class Expect
   # Gem 与库共用的版本号；独立文件使 gemspec 无需加载完整会话实现。
-  VERSION = "0.5.0"
+  VERSION = "0.5.2"
 end

data/script/ci

@@ -7,7 +7,7 @@ bundle exec rake
 bundle exec ruby examples/dialogue.rb
 
 # 只检查小规模工作负载的正确性，不为共享 CI 机器设置性能阈值。
-for benchmark in matching relay send_slow scaling; do
+for benchmark in matching relay send_slow scaling redactor; do
   bundle exec ruby "benchmark/${benchmark}.rb" --smoke
 done
 
@@ -60,7 +60,11 @@ child = 'STDOUT.sync = true; puts "ready"; puts "reply:#{$stdin.gets&.strip}"'
 Expect.spawn(RbConfig.ruby, "--disable-gems", "-e", child, raw_pty: true, log_stdout: false) do |session|
   session.winsize = [30, 100]
   abort "io-console terminal size failed" unless session.winsize == [30, 100]
+  # BSD stty 设置模式会清空待读输出，先收取提示，使子进程停在等待输入的位置。
   abort "installed gem did not receive the PTY prompt" unless session.expect("ready", timeout: 5)
+  mode = session.stty
+  abort "installed stty query failed" if mode.empty?
+  session.stty(mode)
 
   session.puts("expect-ruby")
   abort "installed gem PTY dialogue failed" unless session.expect("reply:expect-ruby", timeout: 5)

data/test/integration/README.md

@@ -8,9 +8,11 @@ SSH_HOST=127.0.0.1 SSH_USER=crate ruby test/integration/ssh_scripts.rb
 SSH_HOST=127.0.0.1 SSH_USER=crate bundle exec rake test:ssh
 ```
 
-脚本隐藏读取密码；也支持由运行环境提供 `EXPECT_PASSWORD`。密码不会作为 SSH 命令行参数传递，日志在认证完成后才开启。默认自动测试不连接 SSH、不读取密码。
+脚本隐藏读取密码；也支持由运行环境提供 `EXPECT_PASSWORD`。密码不会作为 SSH 命令行参数传递，日志在认证完成后才开启。默认自动测试不连接
+SSH、不读取密码。
 
-支持 `SSH_PORT`（默认 22）、`EXPECT_LOG_DIR`（日志根目录）、`SSH_KNOWN_HOSTS`。连接非本机主机时，必须提供已有的受信任 known_hosts，例如：
+支持 `SSH_PORT`（默认 22）、`EXPECT_LOG_DIR`（日志根目录）、`SSH_KNOWN_HOSTS`。连接非本机主机时，必须提供已有的受信任
+known_hosts，例如：
 
 ```sh
 SSH_HOST=192.0.2.10 SSH_USER=operator SSH_PORT=22 \
@@ -18,23 +20,27 @@ SSH_HOST=192.0.2.10 SSH_USER=operator SSH_PORT=22 \
   EXPECT_LOG_DIR=tmp/device-check ruby test/integration/ssh_scripts.rb
 ```
 
-这是 POSIX shell 脚本测试；厂商专用 CLI（如交换机的 `show` 命令、分页提示符）需要对应设备的命令和预期输出，不能直接使用这些 shell fixtures。
+这是 POSIX shell 脚本测试；厂商专用 CLI（如交换机的 `show` 命令、分页提示符）需要对应设备的命令和预期输出，不能直接使用这些
+shell fixtures。
 
 ## 同一个登录会话执行的脚本
 
-| 脚本 | 验证内容 | 预期退出码 |
-| --- | --- | --- |
-| `01_identity.sh` | 当前用户、远端 PTY、完成标记 | 0 |
-| `02_output.sh` | stdout、stderr、中文和输出顺序 | 0 |
-| `03_delayed.sh` | 分三次延迟输出，确保日志完整 | 0 |
-| `04_failure.sh` | 明确输出错误并退出 | 7（预期失败） |
-| `05_recovery.sh` | 上个脚本失败后继续执行，计算结果为 42 | 0 |
+| 脚本             | 验证内容                              | 预期退出码    |
+|------------------|---------------------------------------|---------------|
+| `01_identity.sh` | 当前用户、远端 PTY、完成标记          | 0             |
+| `02_output.sh`   | stdout、stderr、中文和输出顺序        | 0             |
+| `03_delayed.sh`  | 分三次延迟输出，确保日志完整          | 0             |
+| `04_failure.sh`  | 明确输出错误并退出                    | 7（预期失败） |
+| `05_recovery.sh` | 上个脚本失败后继续执行，计算结果为 42 | 0             |
 
-fixtures 位于 `test/fixtures/ssh_scripts/`，都不修改目标文件或设备配置。文件内容通过 SSH 的交互 shell 传给独立 `/bin/sh -c` 执行，不需要上传文件。每个脚本都有随机开始/结束标记，结束标记携带真实 `$?`；脚本输出和退出码都必须符合预期才算通过。
+fixtures 位于 `test/fixtures/ssh_scripts/`，都不修改目标文件或设备配置。文件内容通过 SSH 的交互 shell 传给独立
+`/bin/sh -c` 执行，不需要上传文件。每个脚本都有随机开始/结束标记，结束标记携带真实 `$?`；脚本输出和退出码都必须符合预期才算通过。
 
-测试关闭终端回显和 shell 行编辑，使用单引号传输完整脚本，保留中文 UTF-8 和引号，避免 C locale 的交互式 readline 把高位字节当快捷键执行。末尾仍等待 shell 提示符，确认可以继续执行下一项。
+测试关闭终端回显和 shell 行编辑，使用单引号传输完整脚本，保留中文 UTF-8 和引号，避免 C locale 的交互式 readline
+把高位字节当快捷键执行。末尾仍等待 shell 提示符，确认可以继续执行下一项。
 
-另外执行两条日志控制命令：关闭日志后输出 `UNLOGGED_OUTPUT`，再以默认追加模式开启日志并输出 `APPEND_OK`。最后发送延迟输出及退出命令，只调用 `soft_close`，确认 `SESSION_FINAL_TAIL` 确实在关闭过程中写入日志。
+另外执行两条日志控制命令：关闭日志后输出 `UNLOGGED_OUTPUT`，再以默认追加模式开启日志并输出 `APPEND_OK`。最后发送延迟输出及退出命令，只调用
+`soft_close`，确认 `SESSION_FINAL_TAIL` 确实在关闭过程中写入日志。
 
 ## 检查和输出文件
 
@@ -43,11 +49,14 @@ fixtures 位于 `test/fixtures/ssh_scripts/`，都不修改目标文件或设备
 - `session.log`：收到的原始数据，以及手工添加的 `[SEND] 脚本名 sha256=...` 和 `[EXIT] 脚本名 status=...`。
 - `report.json`：主机、用户、远端 TTY、每项脚本输出和退出码、校验结果、SSH 退出码、日志字节数及 SHA-256。
 
-只有认证后的输出进入日志。Expect 自动记录接收字节，发送的脚本名称和摘要由 `write_log` 明确写入，便于审核执行了哪个 fixture；fixture 文件中的原文可以用报告内的 SHA-256 核对。
+只有认证后的输出进入日志。Expect 自动记录接收字节，发送的脚本名称和摘要由 `write_log` 明确写入，便于审核执行了哪个
+fixture；fixture 文件中的原文可以用报告内的 SHA-256 核对。
 
-共 11 项日志/流程检查：完整输出、执行顺序、即时 flush、stdout/stderr、UTF-8、非零退出后恢复、覆盖模式、暂停记录、追加模式、关闭前尾部输出、密码不出现在日志中。另校验日志条目没有重复，日志句柄在停止记录和关闭会话后正确关闭。
+共 11 项日志/流程检查：完整输出、执行顺序、即时
+flush、stdout/stderr、UTF-8、非零退出后恢复、覆盖模式、暂停记录、追加模式、关闭前尾部输出、密码不出现在日志中。另校验日志条目没有重复，日志句柄在停止记录和关闭会话后正确关闭。
 
-成功返回进程退出码 0。认证失败、超时、脚本输出错误、意外退出码或日志校验失败均返回非零，并在有报告目录时留下 `passed: false` 的报告。不用仅看到终端输出就判断成功；请查看最终 PASS 和 `report.json` 的 `passed`。
+成功返回进程退出码 0。认证失败、超时、脚本输出错误、意外退出码或日志校验失败均返回非零，并在有报告目录时留下 `passed: false`
+的报告。不用仅看到终端输出就判断成功；请查看最终 PASS 和 `report.json` 的 `passed`。
 
 ## 无需 SSH 的回归测试
 
@@ -56,7 +65,8 @@ bundle exec ruby -Itest test/script_logging_test.rb
 bundle exec rake test
 ```
 
-`test/script_logging_test.rb` 使用真实本地 PTY 执行相同 fixtures，另外验证回调日志、借用 File 日志、错误退出/错误输出的反例、引号和 shell 元字符、日志错误上抛，以及超时后继续收集日志。它和 SSH 脚本共享测试 helper，不依赖远端账户。
+`test/script_logging_test.rb` 使用真实本地 PTY 执行相同 fixtures，另外验证回调日志、借用 File 日志、错误退出/错误输出的反例、引号和
+shell 元字符、日志错误上抛，以及超时后继续收集日志。它和 SSH 脚本共享测试 helper，不依赖远端账户。
 
 ## SSH interact 人工和自动验证
 
@@ -67,13 +77,18 @@ ruby examples/ssh_interact.rb --auto
 bundle exec rake test:ssh_interact
 ```
 
-使用上述同一套 SSH 环境变量和隐藏密码输入。人工模式显示 `EXPECT_SCRIPT_PROMPT>`；输入命令有回显，Ctrl-C 传给远端前台任务。在命令结束、回到 shell 提示符后按 Ctrl-]，会关闭远端回显，执行 `MANUAL_AUTOMATION_RESUMED` 检查，再正常退出 SSH。也支持直接输入 `exit`：成功退出记为 `completion: remote_exit`，此路径不执行返回 expect 的检查。非零 SSH 退出仍判为失败。
+使用上述同一套 SSH 环境变量和隐藏密码输入。人工模式显示 `EXPECT_SCRIPT_PROMPT>`；输入命令有回显，Ctrl-C 传给远端前台任务。在命令结束、回到
+shell 提示符后按 Ctrl-]，会关闭远端回显，执行 `MANUAL_AUTOMATION_RESUMED` 检查，再正常退出 SSH。也支持直接输入 `exit`：成功退出记为
+`completion: remote_exit`，此路径不执行返回 expect 的检查。非零 SSH 退出仍判为失败。
 
-`--auto` 创建真实本地 PTY，验证两次 `interact` 接管、当前用户和远端 TTY、stdout/stderr/中文、Ctrl-C、Ctrl-]、转义后的本地尾部不进入 SSH、恢复 `expect` 及终端与监听设置。4 项命令输出和 13 项交互/日志检查全部通过后才返回 0。
+`--auto` 创建真实本地 PTY，验证两次 `interact` 接管、当前用户和远端 TTY、stdout/stderr/中文、Ctrl-C、Ctrl-]、转义后的本地尾部不进入
+SSH、恢复 `expect` 及终端与监听设置。4 项命令输出和 13 项交互/日志检查全部通过后才返回 0。
 
-日志在认证之后开启；每次在 `tmp/ssh-interact/` 新建 0700 目录，保存 0600 的 `session.log` 和 `report.json`。报告包含检查项、命令输出、SSH 退出码及日志摘要。自动模式也校验日志无重复、退出尾部不丢失、密码不出现在日志中。
+日志在认证之后开启；每次在 `tmp/ssh-interact/` 新建 0700 目录，保存 0600 的 `session.log` 和 `report.json`
+。报告包含检查项、命令输出、SSH 退出码及日志摘要。自动模式也校验日志无重复、退出尾部不丢失、密码不出现在日志中。
 
-无需 SSH 的回归位于 `test/interact_test.rb`，覆盖可见输入、Ctrl-C、两次接管、返回自动命令、超时、两端 EOF、回调异常和输出 IO 故障时的终端恢复。`test/script_logging_test.rb` 另验证 CRLF 输出边界，包括空输出、末尾有/无换行和多个换行。
+无需 SSH 的回归位于 `test/interact_test.rb`，覆盖可见输入、Ctrl-C、两次接管、返回自动命令、超时、两端 EOF、回调异常和输出 IO
+故障时的终端恢复。`test/script_logging_test.rb` 另验证 CRLF 输出边界，包括空输出、末尾有/无换行和多个换行。
 
 ## `ssh_auto.rb` 环境检查
 
@@ -85,6 +100,10 @@ ruby examples/ssh_auto.rb --no-interact
 bundle exec rake test:ssh_auto
 ```
 
-该示例自动登录 `SSH_HOST`（默认 `127.0.0.1`），用本库的 `write` / `expect` 顺序执行文件顶部的 `COMMANDS`，显示真实输出并检查退出码。默认命令为 `id`、`uname -srm`、`sw_vers`、`df -h /` 和 `uptime`，不修改系统设置；可直接修改数组来下发其他 macOS/POSIX shell 命令。它不依赖 `test/support`，`ScriptProbe.check` 只供测试脚本使用。
+该示例自动登录 `SSH_HOST`（默认 `127.0.0.1`），用本库的 `write` / `expect` 顺序执行文件顶部的 `COMMANDS`，显示真实输出并检查退出码。默认命令为
+`id`、`uname -srm`、`sw_vers`、`df -h /` 和 `uptime`，不修改系统设置；可直接修改数组来下发其他 macOS/POSIX shell 命令。它不依赖
+`test/support`，`ScriptProbe.check` 只供测试脚本使用。
 
-执行成功后默认进入 `interact`，输入有回显，Ctrl-C 发给远端前台任务；`exit` 或 Ctrl-] 结束连接。使用 `--no-interact` 则执行完退出。`EXPECT_LOG_DIR` 可指定日志目录，默认 `tmp/ssh-auto/`；每次创建独立 0600 日志，记录命令和远端输出，认证前关闭日志。此使用示例不生成 JSON 测试报告，详细日志断言仍由 `ssh_scripts.rb` 和 `ssh_interact.rb --auto` 验证。
+执行成功后默认进入 `interact`，输入有回显，Ctrl-C 发给远端前台任务；`exit` 或 Ctrl-] 结束连接。使用 `--no-interact` 则执行完退出。
+`EXPECT_LOG_DIR` 可指定日志目录，默认 `tmp/ssh-auto/`；每次创建独立 0600 日志，记录命令和远端输出，认证前关闭日志。此使用示例不生成
+JSON 测试报告，详细日志断言仍由 `ssh_scripts.rb` 和 `ssh_interact.rb --auto` 验证。

data/test/redactor_test.rb

@@ -103,4 +103,81 @@ class RedactorTest < Minitest::Test
     filter.append("raw-pending")
     assert_equal "#<Expect::Redactor>", filter.inspect
   end
+
+  def test_seeded_binary_chunks_match_a_naive_union_of_full_and_partial_spans
+    random = Random.new(5000)
+    250.times do |index|
+      alphabet = index.even? ? [97, 98] : [0, 97, 98, 99, 128, 255]
+      input = Array.new(random.rand(0..120)) { alphabet.sample(random: random) }.pack("C*")
+      patterns = Array.new(random.rand(0..6)) do
+        Array.new(random.rand(1..8)) { alphabet.sample(random: random) }.pack("C*")
+      end
+      chunks = []
+      offset = 0
+      while offset < input.bytesize
+        chunks << input.byteslice(offset, random.rand(1..15))
+        offset += chunks.last.bytesize
+      end
+      [false, true].each do |partial|
+        expected = reference_redact(input, patterns, partial: partial)
+        [[input], input.bytes.map(&:chr), chunks].each_with_index do |partition, kind|
+          filter = Expect::Redactor.new(patterns)
+          actual = partition.map { |chunk| filter.append(chunk) }.join.b + filter.finish(partial: partial)
+          assert_equal expected, actual, "seed=5000 case=#{index} partition=#{kind} partial=#{partial}"
+          assert_empty filter.finish(partial: partial)
+        end
+      end
+    end
+  end
+
+  def test_long_overlaps_merge_across_chunks_without_repeating_markers
+    filter = Expect::Redactor.new(["a" * 1024, "a" * 32, "ab"])
+    output = +""
+    256.times { output << filter.append("a" * 17) }
+    output << filter.append("b!") << filter.finish
+    assert_equal "[FILTERED]!", output
+  end
+
+  def test_rule_removal_keeps_hidden_pending_bytes_and_partial_finish_is_separate
+    filter = Expect::Redactor.new(%w[aaaa long-pattern])
+    assert_empty filter.append("aaaaa")
+    filter.patterns = ["abc"]
+    assert_equal "[FILTERED]", filter.append("ab")
+    assert_empty filter.finish # 新的疑似前缀紧邻已隐藏区域，不能重复输出替换标记。
+
+    filter = Expect::Redactor.new(%w[aaaa long-pattern])
+    assert_empty filter.append("aaaaa")
+    filter.patterns = []
+    assert_equal "[FILTERED]!", filter.append("!") + filter.finish
+  end
+
+  private
+
+  # 独立参考模型：逐偏移比较完整秘密，再合并布尔掩码；不复用生产代码的扫描/输出实现。
+  def reference_redact(input, patterns, partial:)
+    hidden = Array.new(input.bytesize, false)
+    patterns.each do |pattern|
+      input.bytesize.times do |offset|
+        next unless input.byteslice(offset, pattern.bytesize) == pattern
+
+        pattern.bytesize.times { |length| hidden[offset + length] = true }
+      end
+      next unless partial
+
+      (1...pattern.bytesize).each do |length|
+        next unless input.end_with?(pattern.byteslice(0, length))
+
+        ((input.bytesize - length)...input.bytesize).each { |offset| hidden[offset] = true }
+      end
+    end
+    output = +"".b
+    input.bytes.each_with_index do |byte, offset|
+      if hidden[offset]
+        output << "[FILTERED]" if offset.zero? || !hidden[offset - 1]
+      else
+        output << byte
+      end
+    end
+    output
+  end
 end

data/test/terminal_cleanup_test.rb

@@ -0,0 +1,349 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class TerminalCleanupTest < ExpectTest
+  def test_read_failures_preserve_identity_reap_helper_and_leave_main_session_usable
+    [IOError.new("read failed"), Interrupt.new("interrupted"), SystemExit.new(17)].each do |failure|
+      session = terminal_session
+      main_pid = session.pid
+      with_stty_pipe do |reader, sink, spawned|
+        reader.stub(:read, -> { raise failure }) do
+          assert_same failure, assert_raises(failure.class) { bounded { session.stty } }
+        end
+        assert reader.closed?
+        assert sink.closed?
+        assert_reaped spawned.fetch(:pid)
+      end
+      assert_main_session_usable session, main_pid
+    end
+  end
+
+  def test_read_error_wins_over_close_error_and_helper_is_still_reaped
+    session = terminal_session
+    failure = IOError.new("read failed")
+    attempts = 0
+    with_stty_pipe do |reader, sink, spawned|
+      reader.stub(:read, -> { raise failure }) do
+        reader.stub(:close, lambda {
+          attempts += 1
+          raise IOError, "close failed"
+        }) do
+          assert_same failure, assert_raises(IOError) { bounded { session.stty } }
+          refute reader.closed?, "permanently failing close must not be reported as closed"
+          assert sink.closed?
+          assert_reaped spawned.fetch(:pid)
+        end
+      end
+    end
+    assert_equal 1, attempts
+  end
+
+  def test_cleanup_error_after_success_is_visible_even_inside_caller_rescue
+    session = terminal_session
+    failure = IOError.new("close failed")
+    begin
+      raise ArgumentError, "already handled"
+    rescue ArgumentError
+      with_stty_pipe do |reader, sink, spawned|
+        reader.stub(:close, -> { raise failure }) do
+          assert_same failure, assert_raises(IOError) { bounded { session.stty } }
+          assert sink.closed?
+          assert_reaped spawned.fetch(:pid)
+        end
+      end
+    end
+  end
+
+  def test_spawn_failure_attempts_both_closes_and_keeps_missing_command_cause
+    session = terminal_session
+    reader, sink = IO.pipe
+    @ios.push(reader, sink)
+    failure = Errno::ENOENT.new("missing stty")
+    IO.stub(:pipe, [reader, sink]) do
+      Process.stub(:spawn, ->(*) { raise failure }) do
+        Process.stub(:kill, ->(*) { flunk "no helper was spawned" }) do
+          reader.stub(:close, -> { raise IOError, "reader close failed" }) do
+            error = assert_raises(IOError) { session.stty }
+            assert_match "stty executable not found", error.message
+            assert_same failure, error.cause
+            assert sink.closed?
+          end
+        end
+      end
+    end
+  end
+
+  def test_externally_reaped_helper_is_not_signalled_and_does_not_change_main_status
+    session = terminal_session
+    main_pid = session.pid
+    failure = IOError.new("read failed after external wait")
+    with_stty_pipe do |reader, _sink, spawned|
+      reader.stub(:read, lambda {
+        bounded { Process.waitpid2(spawned.fetch(:pid)) }
+        raise failure
+      }) do
+        Process.stub(:kill, ->(*) { flunk "must not signal an externally reaped PID" }) do
+          assert_same failure, assert_raises(IOError) { bounded { session.stty } }
+        end
+      end
+      assert_reaped spawned.fetch(:pid)
+    end
+    assert_main_session_usable session, main_pid
+  end
+
+  def test_uncooperative_helper_is_killed_and_reaped_after_read_failure
+    session = terminal_session
+    failure = IOError.new("read failed")
+    command = [RbConfig.ruby, "--disable-gems", "-e",
+               'Signal.trap("TERM", "IGNORE"); STDOUT.sync = true; puts "ready"; sleep 60']
+    signals = []
+    kill = Process.method(:kill)
+    with_stty_pipe(command: command) do |reader, _sink, spawned|
+      read = reader.method(:gets)
+      reader.stub(:read, lambda {
+        assert_equal("ready\n", bounded { read.call })
+        raise failure
+      }) do
+        Process.stub(:kill, lambda { |signal, pid|
+          signals << [signal, pid]
+          kill.call(signal, pid)
+        }) do
+          assert_same failure, assert_raises(IOError) { bounded(2) { session.stty } }
+        end
+      end
+      assert_equal [["TERM", spawned.fetch(:pid)], ["KILL", spawned.fetch(:pid)]], signals
+      assert_reaped spawned.fetch(:pid)
+    end
+  end
+
+  def test_normal_wait_retries_eintr_without_signalling_or_sleeping
+    session = terminal_session
+    wait = Process.method(:waitpid2)
+    attempts = 0
+    with_stty_pipe do |_reader, _sink, spawned|
+      Process.stub(:waitpid2, lambda { |pid, *flags|
+        assert_equal spawned.fetch(:pid), pid
+        attempts += 1
+        raise Errno::EINTR if attempts == 1
+
+        wait.call(pid, *flags)
+      }) do
+        session.stub(:sleep, ->(*) { flunk "successful stty must not add a fixed delay" }) do
+          Process.stub(:kill, ->(*) { flunk "successful helper must not be signalled" }) do
+            refute_empty session.stty
+          end
+        end
+      end
+      assert_equal 2, attempts
+      assert_reaped spawned.fetch(:pid)
+    end
+  end
+
+  def test_continuous_cleanup_eintr_has_a_fixed_budget_and_detaches_real_helper
+    session = terminal_session
+    failure = IOError.new("read failed")
+    clock = 0.0
+    waiter = nil
+    detach = Process.method(:detach)
+    attempts = 0
+    with_stty_pipe do |reader, _sink, spawned|
+      reader.stub(:read, -> { raise failure }) do
+        Expect.stub(:monotonic, -> { clock }) do
+          session.stub(:sleep, ->(duration) { clock += duration }) do
+            Process.stub(:waitpid2, lambda { |pid, flags|
+              assert_equal spawned.fetch(:pid), pid
+              assert_equal Process::WNOHANG, flags
+              attempts += 1
+              raise Errno::EINTR
+            }) do
+              Process.stub(:kill, ->(*) { flunk "ownership has not been checked successfully" }) do
+                Process.stub(:detach, lambda { |pid|
+                  assert_equal spawned.fetch(:pid), pid
+                  waiter = detach.call(pid)
+                }) do
+                  assert_same failure, assert_raises(IOError) { bounded { session.stty } }
+                end
+              end
+            end
+          end
+        end
+      end
+      assert_operator attempts, :>, 3
+      assert_in_delta 0.15, clock, 0.000001
+      refute_nil waiter
+      assert_instance_of(Process::Status, bounded { waiter.value })
+      assert_reaped spawned.fetch(:pid)
+    end
+  end
+
+  def test_esrch_between_poll_and_signal_still_reaps_without_fabricating_status
+    session = terminal_session
+    main_pid = session.pid
+    failure = IOError.new("read failed")
+    clock = 0.0
+    signalled = false
+    wait = Process.method(:waitpid2)
+    with_stty_pipe do |reader, _sink, spawned|
+      reader.stub(:read, -> { raise failure }) do
+        Expect.stub(:monotonic, -> { clock }) do
+          session.stub(:sleep, ->(duration) { clock += duration }) do
+            Process.stub(:waitpid2, lambda { |pid, flags|
+              assert_equal Process::WNOHANG, flags
+              signalled ? wait.call(pid, flags) : nil
+            }) do
+              Process.stub(:kill, lambda { |signal, pid|
+                assert_equal "TERM", signal
+                assert_equal spawned.fetch(:pid), pid
+                bounded { wait.call(pid) }
+                signalled = true
+                raise Errno::ESRCH
+              }) do
+                Process.stub(:detach, ->(*) { flunk "ECHILD already released ownership" }) do
+                  assert_same failure, assert_raises(IOError) { bounded { session.stty } }
+                end
+              end
+            end
+          end
+        end
+      end
+      assert signalled
+      assert_reaped spawned.fetch(:pid)
+    end
+    assert_main_session_usable session, main_pid
+  end
+
+  def test_sink_close_failure_still_attempts_reader_close_and_reaps_helper
+    session = terminal_session
+    failure = IOError.new("sink close failed")
+    attempts = 0
+    with_stty_pipe do |reader, sink, spawned|
+      sink.stub(:close, lambda {
+        attempts += 1
+        raise failure
+      }) do
+        assert_same failure, assert_raises(IOError) { bounded { session.stty } }
+        assert reader.closed?
+        refute sink.closed?
+        assert_reaped spawned.fetch(:pid)
+      end
+    end
+    assert_equal 2, attempts
+  end
+
+  def test_forked_copy_closes_local_pipes_without_reaping_or_signalling_parent_helper
+    session = terminal_session
+    current_pid = Process.pid
+    failure = IOError.new("unwind in forked copy")
+    with_stty_pipe do |reader, sink, _spawned|
+      Process.stub(:pid, -> { current_pid }) do
+        reader.stub(:read, lambda {
+          current_pid = -1 # 在资源登记后模拟 fork 子进程的身份，父进程仍拥有辅助 PID。
+          raise failure
+        }) do
+          Process.stub(:waitpid2, ->(*) { flunk "non-owner must not wait for the parent's helper" }) do
+            Process.stub(:kill, ->(*) { flunk "non-owner must not signal the parent's helper" }) do
+              Process.stub(:detach, ->(*) { flunk "non-owner must not detach the parent's helper" }) do
+                assert_same failure, assert_raises(IOError) { session.stty }
+                assert reader.closed?
+                assert sink.closed?
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def test_ledger_initialization_failure_still_closes_both_pipes
+    session = terminal_session
+    [IOError.new("ledger failed"), Interrupt.new("interrupted registration")].each do |failure|
+      with_stty_pipe do |reader, sink, spawned|
+        Expect::SessionResources.stub(:new, ->(*) { raise failure }) do
+          assert_same failure, assert_raises(failure.class) { session.stty }
+          assert reader.closed?
+          assert sink.closed?
+          assert_empty spawned
+        end
+      end
+    end
+  end
+
+  def test_fork_during_cleanup_wait_stops_process_cleanup
+    session = terminal_session
+    current_pid = Process.pid
+    failure = IOError.new("read failed")
+    with_stty_pipe do |reader, sink, _spawned|
+      Process.stub(:pid, -> { current_pid }) do
+        reader.stub(:read, -> { raise failure }) do
+          session.stub(:sleep, ->(*) { current_pid = -1 }) do
+            Process.stub(:waitpid2, ->(*) {}) do
+              Process.stub(:kill, ->(*) { flunk "fork during wait must release inherited process ownership" }) do
+                Process.stub(:detach, ->(*) { flunk "non-owner must not detach" }) do
+                  assert_same failure, assert_raises(IOError) { bounded { session.stty } }
+                  assert reader.closed?
+                  assert sink.closed?
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  private
+
+  def terminal_session
+    session = child(<<~'RUBY', raw_pty: true)
+      puts "ready"
+      while (line = STDIN.gets)
+        puts "reply:#{line.strip}"
+      end
+    RUBY
+    assert_equal 1, session.expect("ready", timeout: 2)
+    session
+  end
+
+  def assert_main_session_usable(session, main_pid)
+    assert_equal main_pid, session.pid
+    assert_nil session.process_status
+    refute session.closed?
+    session.puts "still usable"
+    assert_equal 1, session.expect("reply:still usable", timeout: 2)
+  end
+
+  def assert_reaped(pid)
+    assert_raises(Errno::ECHILD) { Process.waitpid(pid, Process::WNOHANG) }
+  end
+
+  # 只替换本次 stty 的管道；即使断言失败，恢复全局 stub 后仍由探针回收自己的真实子进程。
+  def with_stty_pipe(command: nil)
+    reader, sink = IO.pipe
+    @ios.push(reader, sink)
+    spawned = {}
+    spawn = Process.method(:spawn)
+    IO.stub(:pipe, [reader, sink]) do
+      Process.stub(:spawn, lambda { |*arguments, **options|
+        spawned[:pid] = spawn.call(*(command || arguments), **options)
+      }) do
+        yield reader, sink, spawned
+      end
+    end
+  ensure
+    reap_probe_child(spawned[:pid]) if spawned && spawned[:pid]
+  end
+
+  def reap_probe_child(pid)
+    return if Process.waitpid(pid, Process::WNOHANG)
+
+    begin
+      Process.kill("KILL", pid)
+    rescue Errno::ESRCH
+      nil
+    end
+    bounded { Process.waitpid(pid) }
+  rescue Errno::ECHILD
+    nil
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: expect-pty
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.2
 platform: ruby
 authors:
 - expect-pty contributors
@@ -111,6 +111,7 @@ files:
 - README.md
 - Rakefile
 - benchmark/matching.rb
+- benchmark/redactor.rb
 - benchmark/relay.rb
 - benchmark/scaling.rb
 - benchmark/send_slow.rb
@@ -178,6 +179,7 @@ files:
 - test/support/interact_probe.rb
 - test/support/kibitz_probe.rb
 - test/support/script_probe.rb
+- test/terminal_cleanup_test.rb
 - test/test_helper.rb
 - test/timeout_test.rb
 homepage: https://github.com/gatework/expect-ruby