expect-pty 0.3.2 → 0.4.0

data/lib/expect/relay_writer.rb

@@ -2,9 +2,11 @@
 
 class Expect
   # 向单个转接目标写入数据，维护发送进度与期限；恢复时不重放已成功写出的前缀。
+  # 只借用目标，不 dup 描述符，也不负责读取；所有就绪等待统一交给 Relay 调度。
   class RelayWriter
     attr_reader :target, :deadline
 
+    # data 在本游标存活期间由上层保持不变，offset 始终以实际交付的字节数计量。
     def initialize(target, data)
       @target = target
       @data = data
@@ -13,17 +15,21 @@ class Expect
       restart_timeout
     end
 
+    # 初次排队或重新进入 interconnect 时开始新的写入预算；普通短写不会刷新期限。
+    # 只有 Expect 目标提供 write_timeout，原生 IO 和自定义目标只受转接总期限约束。
     def restart_timeout
       period = target.write_timeout if target.is_a?(Expect)
       @deadline = period && (Expect.monotonic + period)
     end
 
+    # 真实 IO 可参与共同 select；自定义可写对象返回 nil，沿用其同步 write/flush 协议。
     def io
       return target.writer if target.is_a?(Expect)
 
       target if target.is_a?(IO)
     end
 
+    # 数据交付完但 flush 失败仍未完成；重试只补 flush，不重新发送已接受的数据。
     def done? = @offset == @data.bytesize && @flushed
 
     # 每轮每目标至多一次写入；真实 IO 永不在此等待，交给 Relay 的共同 select。
@@ -52,11 +58,14 @@ class Expect
       end
       true
     rescue Errno::EINTR
+      # 未获得写入计数就不移动游标；先检查原期限，再让共同循环轮询输入并重试。
       check_timeout! if check_timeout
       true
     end
+
     # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
+    # 保留本数据块已交付的进度，便于调用方区分未写入和部分写入；不清空恢复用的游标。
     def check_timeout!
       return unless deadline && Expect.monotonic >= deadline
 

data/lib/expect/result.rb

@@ -3,6 +3,8 @@
 class Expect
   # 保存一次等待的结果，保留 Struct 原生数组、Hash 转换和模式解构能力。
   # number 仅在文本匹配时存在；error 为 :timeout、:eof 或原始 IO 异常，文本字段均为字节串。
+  # before/match/after 是产生结果时的快照，后续读取不追加到旧结果；captures 保留未参与捕获的 nil。
+  # 结果对象仍采用普通可变 Struct 语义；session 只引用来源，不取得 IO 或子进程所有权。
   Result = Struct.new(:number, :error, :match, :before, :after, :session, :captures, keyword_init: true) do
     # 是否命中文本模式；事件不会返回模式序号。
     def matched? = !number.nil?

data/lib/expect/session_resources.rb

@@ -2,7 +2,9 @@
 
 class Expect
   # 独立保存句柄、PID 和日志所有权，让终结器无需直接捕获会话即可清理遗弃资源。
+  # IO 是否关闭与子进程是否退出分别记录；不能仅凭句柄状态清空 PID 或伪造退出状态。
   class SessionResources
+    # owned_log 只保存库打开的文件；借用的 IO/日志回调留在会话中，不能成为终结器的引用根。
     attr_accessor :pid, :status, :owned_log
     attr_reader :reader, :writer, :slave, :owner, :own
 
@@ -16,12 +18,13 @@ class Expect
     end
 
     # 只关闭由本库拥有的 IO；借用的 reader、writer 由调用方管理。
+    # 常规关闭错误延后到所有句柄尝试完再抛出，失败句柄仍留在账本内供下一次关闭重试。
     def close_handles
       return unless own
 
-      # PTY 的读写端可能是同一个对象，先去重，重复关闭也保持安全。
+      # 初始化校验失败时可能含无效参数，只关闭真实 IO；PTY 读写端也需要去重。
       failure = nil
-      [reader, writer, slave].compact.uniq.each do |io|
+      [reader, writer, slave].grep(IO).uniq.each do |io|
         io.close unless io.closed?
       rescue IOError, SystemCallError => error
         failure ||= error
@@ -40,6 +43,7 @@ class Expect
       status
     rescue Errno::ECHILD
       # 子进程可能已被调用方或其他线程回收，不再保留可能被系统复用的 PID。
+      # 无法获取别人已取走的 Process::Status，保留未知状态而不是推断成功或失败。
       @pid = nil
       status
     end

data/lib/expect/terminal.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "shellwords"
+
+# 会话终端的模式和窗口尺寸接口；人工接管期间的临时恢复由 interaction.rb 负责。
+class Expect
+  # 查询可恢复的终端模式字符串，或通过系统 stty 设置模式；参数按数组传递，不经 shell。
+  # 非终端返回空字符串；命令不存在或执行失败抛出 IOError，管道在所有退出路径关闭。
+  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)
+    sink.close
+    output = reader.read
+    _, status = Process.waitpid2(child)
+    raise IOError, "stty failed: #{output.strip}" unless status.success?
+
+    output.strip
+  rescue Errno::ENOENT
+    raise IOError, "stty executable not found in PATH; install the system terminal utilities"
+  ensure
+    reader&.close unless reader&.closed?
+    sink&.close unless sink&.closed?
+  end
+
+  # 读取终端的 [行数, 列数]；底层并非终端或句柄已关闭时保留原生 IO 异常。
+  def winsize = to_io.winsize
+
+  # 更新终端尺寸，由内核通知前台进程。
+  def winsize=(size)
+    to_io.winsize = size
+  end
+end

data/lib/expect/version.rb

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

data/lib/expect.rb

@@ -3,7 +3,6 @@
 require "pty"
 require "io/console"
 require "io/wait"
-require "shellwords"
 require "stringio"
 require "forwardable"
 require_relative "expect/version"
@@ -62,11 +61,19 @@ class Expect
     def spawn(*command, env: {}, chdir: nil, **)
       session = new(**)
       session.spawn(*command, env: env, chdir: chdir)
+      spawned = true
       return session unless block_given?
 
       yield session
+    rescue Exception # rubocop:disable Lint/RescueException -- 记录本次作用域的失败，清理后原样传播，包括非 StandardError 异常。
+      failed = true
+      raise
     ensure
-      session&.close if block_given? || (session && !session.pid)
+      if session && (block_given? || !spawned)
+        session.__send__(:cleanup_preserving_failure, failed) do
+          session.close(graceful: spawned && session.graceful_close?)
+        end
+      end
     end
 
     # 适配已有 IO；own: true 接管关闭责任，初始化失败也释放接管的读写端。
@@ -77,11 +84,14 @@ class Expect
       return session unless block_given?
 
       yield session
+    rescue Exception # rubocop:disable Lint/RescueException -- 初始化和块异常均须保留，清理失败不能替换原始原因。
+      failed = true
+      raise
     ensure
-      if initialized
-        session.close if block_given?
-      elsif own
-        [io, writer].uniq.each { |handle| handle.close if handle.is_a?(IO) && !handle.closed? }
+      if session && (block_given? || !initialized)
+        session.__send__(:cleanup_preserving_failure, failed) do
+          session.close(graceful: initialized && session.graceful_close?)
+        end
       end
     end
 
@@ -89,8 +99,8 @@ class Expect
     def expect(...) = expect_result(...).number
 
     # 多会话等待的完整结果入口；from: 提供默认来源，块内可分别指定每个模式的来源。
-    def expect_result(*patterns, from: [], timeout: configuration.timeout, &)
-      run_expect(from, patterns, timeout, &)
+    def expect_result(*patterns, from: [], timeout: configuration.timeout, deadline: nil, &)
+      run_expect(from, patterns, timeout, deadline: deadline, &)
     end
 
     # 返回继续等待的控制符，reset_timeout 决定是否重新计算匹配期限。
@@ -139,15 +149,17 @@ class Expect
     private
 
     # 先完成模式声明再启动引擎；无参数块支持简洁 DSL，有参数块保留调用方 self。
-    def run_expect(sessions, patterns, timeout, &block)
+    def run_expect(sessions, patterns, timeout, deadline: nil, &block)
       timeout = duration(timeout)
+      deadline = Float(deadline) unless deadline.nil?
+      raise ArgumentError, "deadline must be finite" if deadline && !deadline.finite?
       raise ArgumentError, "provide patterns or a pattern block, not both" if block_given? && !patterns.empty?
 
       pattern_list = PatternList.new(sessions, patterns)
       if block
         block.parameters.empty? ? pattern_list.instance_exec(&block) : block.call(pattern_list)
       end
-      Matcher.new(pattern_list.validate!, timeout).run
+      Matcher.new(pattern_list.validate!, timeout, deadline: deadline).run
     end
   end
 
@@ -157,7 +169,7 @@ class Expect
   def_delegators :@configuration, *Configuration::ATTRIBUTES, *Configuration::PREDICATES
   def_delegators :@configuration, *(Configuration::ATTRIBUTES - [:buffer_limit]).map { |name| :"#{name}=" }
 
-  attr_reader :command, :last_result, :slave, :tty_name
+  attr_reader :command, :last_result, :slave, :tty_name, :buffer_discarded_bytes
 
   # 校验并更新缓冲上限后，立即裁剪已接收的内容；校验失败不改变旧缓冲。
   def buffer_limit=(value)
@@ -173,11 +185,11 @@ class Expect
     @tty_name = slave.path
     spawn(*command, env: env, chdir: chdir) unless command.empty?
     initialized = true
+  rescue Exception # rubocop:disable Lint/RescueException -- 构造异常时也要关闭已创建的资源并回收已启动的子进程。
+    failed = true
+    raise
   ensure
-    unless initialized
-      master&.close unless master&.closed?
-      slave&.close unless slave&.closed?
-    end
+    cleanup_preserving_failure(failed) { close(graceful: false) } if @resources && !initialized
   end
 
   # 在新控制终端中执行命令并同步确认 exec 结果；同一会话只能启动一次。
@@ -226,20 +238,21 @@ class Expect
       hard_close
       raise SpawnError, failure
     end
-    trace("spawned pid=#{child}")
+    trace("spawned pid=#{child}", event: :spawned)
     self
   ensure
     from_child&.close unless from_child&.closed?
     to_parent&.close unless to_parent&.closed?
   end
+
   # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
   # 在当前会话等待文本或事件，返回模式序号或 nil。
   def expect(...) = expect_result(...).number
 
   # 使用会话默认超时构造一次等待，返回含匹配内容、来源和错误的 Result。
-  def expect_result(*patterns, timeout: self.timeout, &)
-    self.class.__send__(:run_expect, [self], patterns, timeout, &)
+  def expect_result(*patterns, timeout: self.timeout, deadline: nil, &)
+    self.class.__send__(:run_expect, [self], patterns, timeout, deadline: deadline, &)
   end
 
   # 供实例回调返回继续控制符，语义与 Expect.continue 相同。
@@ -296,6 +309,7 @@ class Expect
     raise ArgumentError, "buffer must be a String" unless value.is_a?(String)
 
     @buffer = value.b
+    @buffer_generation += 1
     trim_buffer
   end
 
@@ -303,6 +317,7 @@ class Expect
   def clear_buffer
     previous = @buffer
     @buffer = "".b
+    @buffer_generation += 1
     previous
   end
 
@@ -312,7 +327,7 @@ class Expect
     raise IOError, "closed Expect session" if closed? || writer.closed?
 
     data = objects.map { |object| object.to_s.b }.join
-    trace("sending #{data.inspect}", level: 2) if debug_level >= 2
+    trace_data(:sending, data, level: 2) if debug_level >= 2
     deadline = write_timeout && (Expect.monotonic + write_timeout)
     offset = 0
     while offset < data.bytesize
@@ -350,6 +365,7 @@ class Expect
     end
     data.bytesize
   end
+
   # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
   # 链式写入单个对象，返回当前会话。
@@ -382,82 +398,6 @@ class Expect
     count
   end
 
-  # 读取当前日志目标，可能为库打开的文件、借用的 IO、回调或 nil。
-  attr_reader :log_output
-
-  # 替换借用的日志目标或停止日志；先校验新目标，失败时保留旧目标。
-  def log_output=(target)
-    unless target.nil? || target.respond_to?(:write) || target.respond_to?(:call)
-      raise ArgumentError, "log output must support write or call, or be nil"
-    end
-
-    replace_log(target)
-  end
-
-  # 打开追加/覆盖日志文件，或注册接收字节的日志块；同一次只能指定一种目标。
-  def log_to(target = nil, mode: "a", &block)
-    raise ArgumentError, "provide a log target or a block, not both" if block && target
-
-    target = block if block
-    if target.respond_to?(:to_path) || target.is_a?(String)
-      raise ArgumentError, "log mode must be a or w" unless %w[a w].include?(mode)
-
-      # 库打开的文件由 SessionResources 持有，替换日志或关闭会话时释放；外部 IO 只借用。
-      replace_log(File.open(target, "#{mode}b", 0o600), owned: true)
-    else
-      raise ArgumentError, "provide a log target or a block" unless target
-
-      self.log_output = target
-    end
-  end
-
-  # 向当前日志目标补写内容，支持 IO 和回调，不发送给子进程或监听器。
-  def write_log(*objects)
-    target = log_output
-    return unless target
-
-    data = objects.map { |object| object.to_s.b }.join
-    target.respond_to?(:call) ? target.call(data) : emit(target, data)
-  end
-
-  # 返回监听器列表副本，避免外部原地修改转发关系。
-  def listeners = @listeners.dup
-
-  # 校验所有监听器均可写后一次性替换列表，外部数组后续修改不会影响会话。
-  def listeners=(outputs)
-    outputs = Array(outputs)
-    raise ArgumentError, "listeners must support write" unless outputs.all? { |output| output.respond_to?(:write) }
-
-    @listeners = outputs.dup
-  end
-
-  # 查询可恢复的终端模式字符串，或通过系统 stty 设置模式；参数按数组传递，不经 shell。
-  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)
-    sink.close
-    output = reader.read
-    _, status = Process.waitpid2(child)
-    raise IOError, "stty failed: #{output.strip}" unless status.success?
-
-    output.strip
-  ensure
-    reader&.close unless reader&.closed?
-    sink&.close unless sink&.closed?
-  end
-
-  # 读取终端的 [行数, 列数]。
-  def winsize = to_io.winsize
-
-  # 更新终端尺寸，由内核通知前台进程。
-  def winsize=(size)
-    to_io.winsize = size
-  end
-
   # 轮询回收状态直到进程退出或期限到达；返回 Process::Status 或 nil，超时不丢弃 PID。
   def wait(timeout: nil)
     period = Expect.duration(timeout)
@@ -501,12 +441,22 @@ class Expect
   def close(graceful: graceful_close?)
     soft_close if graceful
     nil
+  rescue Exception # rubocop:disable Lint/RescueException -- 软关闭的原始异常在硬关闭兜底后继续传播。
+    failed = true
+    raise
   ensure
-    hard_close
+    cleanup_preserving_failure(failed) { hard_close }
   end
 
   private
 
+  # 仅在本次生命周期已有异常时抑制常规清理错误；调用者 rescue 中的旧异常不算本次失败。
+  def cleanup_preserving_failure(failed)
+    yield
+  rescue IOError, SystemCallError
+    raise unless failed
+  end
+
   # 共用的进程关闭流程；force 控制是否允许 KILL，只有资源创建者能够操作直属子进程。
   def finish_close(timeout:, term_timeout:, force:)
     failure = nil
@@ -534,7 +484,11 @@ class Expect
     completed = true
     status
   ensure
-    cleanup.call { self.log_output = nil }
+    begin
+      cleanup.call { flush_diagnostics }
+    ensure
+      cleanup.call { self.log_output = nil }
+    end
     # 用本次流程的完成状态判断异常传播，不能误把调用者 rescue 中的异常当成当前错误。
     raise failure if failure && completed
   end
@@ -554,19 +508,23 @@ class Expect
   end
 
   # 统一初始化 PTY 与已有 IO 会话，复制配置并注册不直接捕获会话的资源终结器。
-  def initialize_session(reader, writer:, slave: nil, own: false, **)
+  def initialize_session(reader, writer:, slave: nil, own: false, diagnostic_output: nil, **)
+    # 先登记所有权，后续校验失败也使用同一个资源对象逐个清理所属 IO。
+    @resources = SessionResources.new(reader, writer: writer, slave: slave, own: own)
     raise ArgumentError, "reader must be a real IO" unless reader.is_a?(IO) && !reader.closed?
     raise ArgumentError, "writer must be a real IO" unless writer.is_a?(IO) && !writer.closed?
 
-    @resources = SessionResources.new(reader, writer: writer, slave: slave, own: own)
     @pty = reader.tty?
     @slave = slave
     @configuration = Configuration.new(**self.class.configuration.to_h, **)
     @buffer = "".b
+    @buffer_generation = 0
+    @buffer_discarded_bytes = 0
     @listeners = []
     @sequences = {}
     @relay_outputs = []
     @closed = @eof = false
+    self.diagnostic_output = diagnostic_output
     ObjectSpace.define_finalizer(self, SessionResources.finalizer(@resources))
   end
 
@@ -582,9 +540,14 @@ class Expect
     @last_result = Result.new(number: pattern.number, before: @buffer.byteslice(0, offset),
                               match: @buffer.byteslice(offset, length), after: @buffer.byteslice((offset + length)..),
                               session: self, captures: captures)
-    @buffer = @last_result.after.dup unless preserve_buffer?
+    unless preserve_buffer?
+      @buffer = @last_result.after.dup
+      @buffer_generation += 1
+    end
+    # 诊断回调可能嵌套等待；恢复本次结果后再交给正式模式回调，不能返回内层等待的结果。
+    result = @last_result
     trace("matched pattern #{pattern.number}")
-    @last_result
+    @last_result = result
   end
 
   # 记录超时、EOF 或原始 IO 异常，保留当前缓冲快照并清除旧匹配及捕获组。
@@ -617,74 +580,41 @@ class Expect
       # 某些系统用 PTY 的 EIO 表示对端关闭；普通 IO 的同类错误仍按异常处理。
       raise unless @pty
 
-      @eof = true
-      return nil
+      return finish_read
     rescue EOFError
-      @eof = true
-      return nil
+      return finish_read
     end
     return nil if data == :wait_readable
 
-    if data.nil?
-      @eof = true
-      return nil
-    end
+    return finish_read if data.nil?
+
     data = data.b
     buffer << data
     trim_buffer if trim
-    trace("received #{data.inspect}", level: 2) if debug_level >= 2
-    trace("buffer #{@buffer.inspect}", level: 3) if debug_level >= 3
+    trace_data(:received, data, level: 2) if debug_level >= 2
+    trace_data(:buffer, @buffer, level: 3) if debug_level >= 3
     # 仅在真实读取时记录日志，后续匹配或人工转接重用缓冲时不会重复记录。
     write_log(data)
     propagate(data) if propagate
     data
   end
 
+  def finish_read
+    @eof = true
+    flush_log
+    flush_diagnostics(:received)
+    nil
+  end
+
   # 缓冲超过上限时只保留最新尾部字节，不对编码做隐式修改。
   def trim_buffer
     limit = buffer_limit
-    @buffer = @buffer.byteslice(-limit, limit) if limit&.positive? && @buffer.bytesize > limit
-  end
-
-  # 按各自开关将接收字节转发到 stdout 和监听器，不重复写日志。
-  def propagate(data)
-    emit($stdout, data) if log_stdout?
-    @listeners.each { |listener| emit(listener, data) } if log_listeners?
-  end
+    return unless limit && @buffer.bytesize > limit
 
-  # 向目标写入并在支持时立即 flush，使日志和终端输出及时可见。
-  def emit(target, data)
-    offset = 0
-    while offset < data.bytesize
-      count = target.write(data.byteslice(offset..))
-      unless count.is_a?(Integer) && count.positive? && count <= data.bytesize - offset
-        raise IOError, "write must return the number of accepted bytes"
-      end
-
-      offset += count
-    end
-    target.flush if target.respond_to?(:flush)
-  end
-
-  # 按诊断级别向 stderr 输出会话标识和消息。
-  def trace(message, level: 1)
-    warn("#{inspect}: #{message}") if debug_level >= level
-  end
-
-  # 交接日志目标和所有权，只关闭库拥有的旧文件；失败时释放新打开的文件。
-  def replace_log(target, owned: false)
-    previous = log_output
-    # 重复赋值同一目标时保留原所有权，防止将库打开的文件误变成借用资源。
-    return target if previous.equal?(target)
-
-    previous.close if @resources.owned_log && previous && !previous.closed?
-    # 终结器只持有所属文件；借用回调可能捕获会话，不能让它经资源对象成为 GC 根。
-    @resources.owned_log = owned ? target : nil
-    @log_output = target
-    target
-  rescue Exception # rubocop:disable Lint/RescueException -- 替换失败时仍释放刚打开的文件。
-    target.close if owned && target && !target.closed?
-    raise
+    # 只累计匹配窗口裁剪，消费、清空及转接交接不算丢弃；关闭后仍可读取累计值。
+    @buffer_discarded_bytes += @buffer.bytesize - limit
+    @buffer = @buffer.byteslice(-limit, limit)
+    @buffer_generation += 1
   end
 
   # 仅由资源创建者向仍未回收的子进程发送信号；若进程刚好退出，则尝试回收。
@@ -697,4 +627,6 @@ class Expect
   end
 end
 
+require_relative "expect/logging"
+require_relative "expect/terminal"
 require_relative "expect/interaction"

data/script/ci

@@ -7,7 +7,7 @@ bundle exec rake
 bundle exec ruby examples/dialogue.rb
 
 # 只检查小规模工作负载的正确性，不为共享 CI 机器设置性能阈值。
-for benchmark in matching relay send_slow; do
+for benchmark in matching relay send_slow scaling; do
   bundle exec ruby "benchmark/${benchmark}.rb" --smoke
 done
 
@@ -45,7 +45,7 @@ spec = Gem.loaded_specs.fetch("expect-pty")
 install_root = File.realpath(ENV.fetch("GEM_HOME"))
 abort "gem was loaded outside the isolated install" unless File.realpath(spec.full_gem_path).start_with?("#{install_root}/")
 abort "Bundler leaked into the plain gem smoke" if ARGV.first == "plain" && defined?(Bundler)
-unexpected = %w[minitest rake rubocop parallel].select { |name| Gem.loaded_specs.key?(name) }
+unexpected = %w[minitest rake rubocop parallel logger].select { |name| Gem.loaded_specs.key?(name) }
 abort "development dependencies leaked into the application: #{unexpected.join(', ')}" unless unexpected.empty?
 spec.runtime_dependencies.each do |dependency|
   loaded = Gem.loaded_specs.fetch(dependency.name)
@@ -68,7 +68,34 @@ Expect.spawn(RbConfig.ruby, "--disable-gems", "-e", child, raw_pty: true, log_st
   abort "installed gem child did not exit successfully" unless status&.success?
 end
 
-puts "Installed #{spec.full_name}: #{ARGV.fetch(0)} PTY and runtime dependencies passed"
+# 使用已安装包验证内部过滤器随包分发，且结构化诊断无需加载可选的 Logger。
+reader, producer = IO.pipe
+events = []
+transcript = StringIO.new
+begin
+  Expect.open(reader, own: true, buffer_limit: 5, debug_level: 2,
+              diagnostic_output: ->(event) { events << event }) do |session|
+    session.redact("secret")
+    session.log_to(transcript)
+    session.buffer = "ready"
+    expired = session.expect_result("ready", deadline: Expect.monotonic)
+    abort "expired deadline consumed buffered text" unless expired.timeout? && session.buffer == "ready"
+    abort "zero timeout lost buffered text" unless session.expect("ready", timeout: 0) == 1
+    producer.write("secret!")
+    producer.close
+    result = session.expect_result(:eof, deadline: Expect.monotonic + 5)
+    abort "installed gem did not preserve capped input" unless result.eof? && result.before == "cret!"
+    abort "incorrect installed buffer accounting" unless session.buffer_discarded_bytes == 2
+    abort "installed redaction failed" unless transcript.string == "[FILTERED]!"
+    abort "diagnostics leaked secret" if events.any? { |event| event[:message].include?("secret") }
+    abort "filtered diagnostic missing" unless events.any? { |event| event[:message].include?("[FILTERED]") }
+  end
+ensure
+  reader.close unless reader.closed?
+  producer.close unless producer.closed?
+end
+
+puts "Installed #{spec.full_name}: #{ARGV.fetch(0)} PTY, core contracts and runtime dependencies passed"
 RUBY
   ruby smoke.rb plain