pwn 0.5.783 → 0.5.785

data/spec/lib/pwn/setup_vault_yubikey_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tmpdir'
+require 'stringio'
+
+RSpec.describe PWN::Setup, 'hardware vault doctor' do
+  around do |example|
+    Dir.mktmpdir('setup-yubikey-') do |root|
+      @root = root
+      example.run
+    end
+  end
+
+  before do
+    allow(Dir).to receive(:home).and_return(@root)
+    @pwn_root = File.join(@root, '.pwn')
+    FileUtils.mkdir_p(@pwn_root)
+    stub_const('PWN::Env', {})
+    stub_const('PWN::Migrate::PWN_ROOT', @pwn_root)
+    stub_const('PWN::Migrate::SCHEMA_FILE', File.join(@pwn_root, '.schema'))
+    stub_const('PWN::Setup::NATIVE_GEMS', {})
+    stub_const('PWN::Setup::TOOLCHAIN', {})
+    stub_const('PWN::Setup::NATIVE_LIBRARIES', {})
+    allow(described_class).to receive(:pkg_manager).and_return(key: :fixture)
+    allow(described_class).to receive(:detect_os_attr).and_return('fixture')
+    stub_const('PWN::Plugins::YubiKey', double('synthetic YubiKey'))
+    allow(PWN::Plugins::YubiKey).to receive(:challenge_response) do |opts|
+      OpenSSL::HMAC.digest('SHA1', 'synthetic-slot-secret', opts[:challenge])
+    end
+    @path = File.join(@pwn_root, 'pwn.yaml')
+    File.binwrite(@path, PWN::Plugins::Vault.encrypt_data(data: YAML.dump(ai: { active: 'ollama' }), yubikey: { slot: 2 }))
+    @io = StringIO.new
+  end
+
+  it 'uses Config driver paths consistently in setup and the migration state verifier' do
+    custom = File.join(@root, 'custom-vault')
+    File.rename(@path, custom)
+    PWN::Env[:driver_opts] = { pwn_env_path: custom, pwn_dec_path: File.join(@root, 'custom-sidecar') }
+    expect(PWN::Plugins::YubiKey).not_to receive(:challenge_response)
+    report = described_class.check(io: @io)
+    expect(report[:ok]).to be(true)
+    expect(report.dig(:state, :files).find { |row| row[:rel] == 'pwn.yaml' }).to include(ok: true, path: custom)
+    expect(@io.string).to include('YubiKey', 'no software decryptor required')
+    expect(File).not_to exist(@path)
+    expect(File).not_to exist(PWN::Env.dig(:driver_opts, :pwn_dec_path))
+  end
+
+  it 'recognizes hardware vaults without a missing-decryptor warning or a device operation' do
+    bytes = File.binread(@path)
+    expect(PWN::Plugins::YubiKey).not_to receive(:challenge_response)
+    expect(PWN::Plugins::Vault).not_to receive(:create)
+    report = described_class.check(io: @io)
+    expect(report[:ok]).to be(true)
+    expect(report.dig(:state, :incompatible)).to be_empty
+    expect(@io.string).to include('YubiKey', 'no software decryptor required')
+    expect(@io.string).not_to include('decryptor MISSING')
+    expect(File.binread(@path)).to eq(bytes)
+    expect(Dir.children(@pwn_root)).to eq(['pwn.yaml'])
+  end
+end

data/spec/lib/pwn/setup_yubikey_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe PWN::Setup, 'optional native YubiKey libraries' do
+  before do
+    allow(described_class).to receive(:check).and_return(ok: true)
+    allow(described_class).to receive(:gem_loadable?).and_return(true)
+    expect(described_class).not_to receive(:system)
+  end
+
+  it 'replaces executable provisioning with optional HIDAPI and PC/SC libraries' do
+    expect(described_class::TOOLCHAIN).not_to have_key('ykman')
+    expect(described_class::PROFILES.fetch(:hardware).fetch(:bins)).not_to include('ykman')
+    expect(described_class::PROFILES.fetch(:full).fetch(:bins)).not_to include('ykman')
+    expect(described_class::PROFILES.fetch(:hardware).fetch(:libs)).to eq(%w[hidapi pcsc])
+    expect(described_class::PROFILES.fetch(:full).fetch(:libs)).to eq(described_class::NATIVE_LIBRARIES.keys)
+    expect(Array(described_class::PROFILES.fetch(:core)[:libs])).to be_empty
+  end
+
+  { apt: %w[libhidapi-hidraw0 libpcsclite1 pcscd libccid],
+    dnf: %w[hidapi pcsc-lite-libs pcsc-lite pcsc-lite-ccid],
+    pacman: %w[hidapi pcsclite ccid], brew: %w[hidapi], port: %w[hidapi] }.each do |manager, libraries|
+    it "plans native host packages for #{manager} without a Python or CLI backend" do
+      allow(described_class).to receive(:pkg_manager).and_return(key: manager, install: 'install-package')
+      result = described_class.deps(profile: :hardware, dry_run: true, io: StringIO.new, distro: :fixture, version: 'test')
+      commands = result.fetch(:ran).map { |row| row.fetch(:cmd) }
+      libraries.each { |package| expect(commands).to include("install-package #{package}") }
+      expect(commands.join('\n')).not_to match(/ykman|yubikey-manager|python|\bpip(?:[23x])?\b/)
+      expect(result.fetch(:ran)).to all(include(dry_run: true))
+      expect(commands.join('\n')).not_to match(/pcsc|ccid/) if %i[brew port].include?(manager)
+    end
+  end
+
+  it 'does not install hardware packages in the core profile' do
+    allow(described_class).to receive(:pkg_manager).and_return(key: :apt, install: 'install-package')
+    result = described_class.deps(profile: :core, dry_run: true, io: StringIO.new, distro: :fixture, version: 'test')
+    expect(result.fetch(:ran).map { |row| row.fetch(:cmd) }.join('\n')).not_to match(/hidapi|pcsclite|pcscd|ccid|ykman/)
+  end
+end

data/spec/lib/pwn/www/login_yubikey_spec.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tty-prompt'
+
+RSpec.shared_context 'offline MFA browser' do |selectors|
+  let(:browser) { double('offline browser') }
+  let(:browser_obj) { { browser: browser } }
+  let(:credential_field) { double('credential field', set: nil, present?: true) }
+  let(:otp_field) { double('OTP field', present?: true, exist?: true) }
+  let(:absent_field) { double('absent field', present?: false, exist?: false) }
+  let(:submit) { double('submit control', exist?: true, present?: true) }
+  let(:yubikey) { { account: 'Example:tester@example.invalid', confirm: true, serial: '123456', device_path: '/fixture/native-device', timeout: 30 }.freeze }
+  let(:login_opts) { { browser_obj: browser_obj, username: 'tester@example.invalid', password: 'fake-password', yubikey: yubikey } }
+
+  before do
+    @authenticated = false
+    @otp_written = false
+    @form_ready = false
+    stub_const('PWN::Plugins::YubiKey', Module.new)
+    allow(PWN::Plugins::YubiKey).to receive(:oath_code) do
+      raise 'OATH requested before the MFA form was ready' unless @form_ready
+
+      '012345'
+    end
+    allow(TTY::Prompt).to receive(:new).and_raise('unexpected interactive prompt')
+    allow(browser).to receive(:goto)
+    allow(browser).to receive(:url) { @authenticated ? selectors[:success] : selectors[:challenge] }
+    allow(browser).to receive(:text_field).and_return(credential_field)
+    allow(credential_field).to receive(:wait_until).and_return(credential_field)
+    allow(browser).to receive(:text_field).with(selectors[:otp]).and_return(otp_field)
+    Array(selectors[:absent]).each do |selector|
+      allow(browser).to receive(:text_field).with(selector).and_return(absent_field)
+    end
+    allow(otp_field).to receive(:wait_until) do
+      @form_ready = true
+      otp_field
+    end
+    allow(otp_field).to receive(:set) { @otp_written = true }
+    allow(browser).to receive_messages(button: submit, input: submit, span: submit)
+    allow(submit).to receive(:wait_until).and_return(submit)
+    allow(submit).to receive(:click)
+    allow(submit).to receive(:click!) { @authenticated = true if @otp_written }
+  end
+end
+
+RSpec.shared_examples 'YubiKey browser MFA' do |selectors|
+  include_context 'offline MFA browser', selectors
+  include_examples 'manual browser MFA'
+
+  it 'documents explicit consent in the YubiKey example and explains native OATH effects' do
+    expect { described_class.help }.to output(/Example yubikey: \{ account: 'EXACT_OATH_NAME', confirm: true.*HOTP.*authenticat/m).to_stdout
+    expect { described_class.help }.not_to output(/ykman/).to_stdout
+  end
+
+  [nil, false].each do |mfa|
+    it "types a leading-zero OATH code at the MFA form when mfa is #{mfa.inspect}" do
+      login_opts[:mfa] = mfa unless mfa.nil?
+      expect(otp_field).to receive(:set).with('012345') { @otp_written = true }
+      expect(described_class.login(login_opts)).to equal(browser_obj)
+      expect(PWN::Plugins::YubiKey).to have_received(:oath_code).with(yubikey).once
+    end
+  end
+
+  it 'does not read a YubiKey when login completes without an MFA challenge' do
+    @authenticated = true
+    expect(PWN::Plugins::YubiKey).not_to receive(:oath_code)
+    expect(otp_field).not_to receive(:set)
+    expect(described_class.login(login_opts)).to equal(browser_obj)
+  end
+
+  it 'does not read a YubiKey if the MFA field never becomes present' do
+    allow(otp_field).to receive(:wait_until).and_raise(IOError, 'MFA form unavailable')
+    expect(PWN::Plugins::YubiKey).not_to receive(:oath_code)
+    expect(otp_field).not_to receive(:set)
+    expect { described_class.login(login_opts) }.to raise_error(IOError, 'MFA form unavailable')
+  end
+
+  it 'propagates a YubiKey failure without typing a token or prompting' do
+    allow(PWN::Plugins::YubiKey).to receive(:oath_code).and_raise(IOError, 'device unavailable')
+    expect(otp_field).not_to receive(:set)
+    expect { described_class.login(login_opts) }.to raise_error(IOError, 'device unavailable')
+  end
+end
+
+RSpec.shared_examples 'manual browser MFA' do
+  it 'preserves the manual MFA prompt without a YubiKey option' do
+    login_opts.delete(:yubikey)
+    login_opts[:mfa] = true
+    prompt = instance_double(TTY::Prompt)
+    allow(TTY::Prompt).to receive(:new).and_return(prompt)
+    expect(prompt).to receive(:ask).with('enter mfa token: ').and_return('012345')
+    expect(otp_field).to receive(:set).with('012345') { @otp_written = true }
+    expect(PWN::Plugins::YubiKey).not_to receive(:oath_code)
+    expect(described_class.login(login_opts)).to equal(browser_obj)
+  end
+
+  it 'preserves disabled MFA when neither a token source nor mfa is selected' do
+    login_opts.delete(:yubikey)
+    expect(PWN::Plugins::YubiKey).not_to receive(:oath_code)
+    expect(otp_field).not_to receive(:set)
+    expect(described_class.login(login_opts)).to equal(browser_obj)
+  end
+end
+
+RSpec.shared_examples 'MFA source validation' do
+  [nil, false, 'true'].each do |confirm|
+    it "rejects missing or nonliteral OATH consent #{confirm.inspect} before password prompts or browser navigation" do
+      login_opts.delete(:password)
+      unconfirmed = yubikey.except(:confirm)
+      unconfirmed[:confirm] = confirm unless confirm.nil?
+      expect(browser).not_to receive(:goto)
+      expect(PWN::Plugins::AuthenticationHelper).not_to receive(:mask_password)
+      expect(PWN::Plugins::YubiKey).not_to receive(:oath_code)
+      expect { described_class.login(login_opts.merge(yubikey: unconfirmed)) }.to raise_error(ArgumentError, /confirm: true/)
+    end
+  end
+
+  it 'documents the optional YubiKey configuration and explicit-token conflict' do
+    expect { described_class.help }.to output(/yubikey:.*exact.*account.*serial.*reader.*device_path.*connection.*timeout.*conflict/m).to_stdout
+  end
+
+  [{ mfa: '654321' }, { mfa_token: '654321' }, { mfa: '654321', mfa_token: '  ' }].each do |conflict|
+    it "rejects YubiKey with explicit token #{conflict.keys.inspect} before login or prompting" do
+      login_opts.delete(:password)
+      expect(browser).not_to receive(:goto)
+      expect(PWN::Plugins::AuthenticationHelper).not_to receive(:mask_password)
+      expect(PWN::Plugins::YubiKey).not_to receive(:oath_code)
+      expect { described_class.login(login_opts.merge(conflict)) }.to raise_error(ArgumentError, /yubikey.*(?:mfa|token)/i)
+    end
+  end
+
+  it 'rejects malformed YubiKey configuration before submitting a password' do
+    expect(browser).not_to receive(:goto)
+    expect(PWN::Plugins::YubiKey).not_to receive(:oath_code)
+    expect { described_class.login(login_opts.merge(yubikey: {})) }.to raise_error(ArgumentError, /account/)
+  end
+end
+
+RSpec.describe PWN::WWW::GitHub do
+  include_examples 'MFA source validation'
+  include_examples 'YubiKey browser MFA',
+                   otp: { name: 'app_otp' },
+                   challenge: 'https://github.com/sessions/two-factor',
+                   success: 'https://github.com/'
+
+  [
+    { mfa: '012345' },
+    { mfa_token: '012345' },
+    { mfa: '654321', mfa_token: '012345' }
+  ].each do |token_opts|
+    it "preserves explicit tokens and mfa_token precedence for #{token_opts.keys.inspect}" do
+      login_opts.delete(:yubikey)
+      expect(PWN::Plugins::YubiKey).not_to receive(:oath_code)
+      expect(otp_field).to receive(:set).with('012345') { @otp_written = true }
+      expect(described_class.login(login_opts.merge(token_opts))).to equal(browser_obj)
+    end
+  end
+
+  [{ id: 'app_totp' }, { name: 'otp' }].each do |selector|
+    it "supports the alternate authenticator field #{selector.inspect}" do
+      [{ name: 'app_otp' }, { id: 'app_totp' }, { name: 'otp' }].each do |absent|
+        allow(browser).to receive(:text_field).with(absent).and_return(absent_field)
+      end
+      allow(browser).to receive(:text_field).with(selector).and_return(otp_field)
+      expect(otp_field).to receive(:set).with('012345') { @otp_written = true }
+      expect(described_class.login(login_opts)).to equal(browser_obj)
+    end
+  end
+
+  it 'still accepts explicit SMS tokens without YubiKey' do
+    login_opts.delete(:yubikey)
+    [{ name: 'app_otp' }, { id: 'app_totp' }, { name: 'otp' }].each do |selector|
+      allow(browser).to receive(:text_field).with(selector).and_return(absent_field)
+    end
+    allow(browser).to receive(:text_field).with(name: 'sms_otp').and_return(otp_field)
+    expect(otp_field).to receive(:set).with('012345') { @otp_written = true }
+    expect(described_class.login(login_opts.merge(mfa_token: '012345'))).to equal(browser_obj)
+  end
+
+  it 'consumes an explicit token once then prompts again on a repeated MFA form' do
+    login_opts.delete(:yubikey)
+    prompt = instance_double(TTY::Prompt)
+    allow(TTY::Prompt).to receive(:new).and_return(prompt)
+    expect(prompt).to receive(:ask).with('enter mfa token: ').once.and_return('012345')
+    expect(otp_field).to(receive(:set).with('654321').ordered { @otp_written = false })
+    expect(otp_field).to(receive(:set).with('012345').ordered { @otp_written = true })
+    expect(described_class.login(login_opts.merge(mfa_token: '654321'))).to equal(browser_obj)
+  end
+
+  it 'refuses to type an OATH code into an SMS-only challenge' do
+    %i[app_otp otp].each do |name|
+      allow(browser).to receive(:text_field).with(name: name.to_s).and_return(absent_field)
+    end
+    allow(browser).to receive(:text_field).with(id: 'app_totp').and_return(absent_field)
+    allow(browser).to receive(:text_field).with(name: 'sms_otp').and_return(otp_field)
+    expect(PWN::Plugins::YubiKey).not_to receive(:oath_code)
+    expect(otp_field).not_to receive(:set)
+    expect { described_class.login(login_opts) }.to raise_error(ArgumentError, /OATH.*authenticator/)
+  end
+end
+
+RSpec.describe PWN::WWW::Synack do
+  include_examples 'MFA source validation'
+  include_examples 'YubiKey browser MFA',
+                   otp: { name: 'authy_token' },
+                   challenge: 'https://login.synack.com/mfa',
+                   success: 'https://platform.synack.com'
+end
+
+RSpec.describe PWN::WWW::Twitter do
+  include_examples 'MFA source validation'
+  include_examples 'YubiKey browser MFA',
+                   otp: { id: 'challenge_response' },
+                   challenge: 'https://twitter.com/login/challenge',
+                   success: 'https://twitter.com/home'
+end
+
+RSpec.describe PWN::WWW::BugCrowd do
+  include_examples 'MFA source validation'
+  include_examples 'YubiKey browser MFA',
+                   otp: { name: 'otp_attempt' },
+                   challenge: 'https://bugcrowd.com/user/two_factor',
+                   success: 'https://bugcrowd.com/programs'
+end
+
+RSpec.describe PWN::WWW::Paypal do
+  include_context 'offline MFA browser',
+                  otp: { id: 'security-code' },
+                  challenge: 'https://www.paypal.com/signin/challenge',
+                  success: 'https://www.paypal.com/myaccount/home'
+  include_examples 'MFA source validation'
+  include_examples 'manual browser MFA'
+
+  [nil, false, true].each do |mfa|
+    it "rejects unsupported OATH before login or prompting when mfa is #{mfa.inspect}" do
+      login_opts.delete(:password)
+      login_opts[:mfa] = mfa unless mfa.nil?
+      expect(browser).not_to receive(:goto)
+      expect(PWN::Plugins::AuthenticationHelper).not_to receive(:mask_password)
+      expect(PWN::Plugins::YubiKey).not_to receive(:oath_code)
+      expect { described_class.login(login_opts) }.to raise_error(ArgumentError, /PayPal.*OATH.*unsupported.*SMS/)
+    end
+  end
+
+  it 'documents the SMS-only adapter limitation instead of claiming TOTP support' do
+    expect { described_class.help }.to output(/OATH.*unsupported.*SMS/m).to_stdout
+    expect { described_class.help }.to output(/unsupported even with confirm: true/m).to_stdout
+  end
+
+  it 'retains the SMS selection in manual mode' do
+    login_opts.delete(:yubikey)
+    allow(PWN::Plugins::AuthenticationHelper).to receive(:mfa).and_return('012345')
+    expect(browser).to receive(:button).with(id: 'btnSelectSoftToken').and_return(submit)
+    expect(described_class.login(login_opts.merge(mfa: true))).to equal(browser_obj)
+  end
+end
+
+RSpec.describe PWN::WWW::CoinbasePro do
+  include_examples 'MFA source validation'
+  include_examples 'YubiKey browser MFA',
+                   otp: { name: 'token' },
+                   challenge: 'https://www.coinbase.com/signin/challenge',
+                   success: 'https://pro.coinbase.com'
+end
+
+RSpec.describe PWN::WWW::AppCobaltIO do
+  include_examples 'MFA source validation'
+  include_examples 'YubiKey browser MFA',
+                   otp: { id: 'code' },
+                   challenge: 'https://app.cobalt.io/users/two_factor',
+                   success: 'https://app.cobalt.io/dashboard'
+end

data/spec/spec_helper.rb

@@ -35,6 +35,21 @@ RSpec.configure do |config|
   config.filter_run_excluding :combo_nation_mcp unless ENV['PWN_TEST_COMBO_NATION_MCP'] == '1'
   config.filter_run_excluding :x86_64_binary unless RbConfig::CONFIG['host_cpu'].to_s.match?(/amd64|x86_64/)
 
+  config.before(:each) do
+    @pwn_spec_backup_root = Dir.mktmpdir('pwn-backup-spec-')
+    Thread.current[:pwn_backup_real_home] = Dir.home
+    Thread.current[:pwn_backup_root] = @pwn_spec_backup_root
+  end
+
+  config.after(:each) do
+    root = @pwn_spec_backup_root
+    Thread.current[:pwn_backup_root] = nil
+    Thread.current[:pwn_backup_real_home] = nil
+    @pwn_spec_backup_root = nil
+    # FileUtils.remove_entry calls Dir.children, which examples stub with a fixed path.
+    system('rm', '-rf', '--', root) if root.is_a?(String) && root.start_with?('/') && root.include?('/pwn-backup-spec-') && !root.include?('..')
+  end
+
   if ENV['PWN_RAKE_SPEC'] == '1'
     module SilenceRakeFilterBanner
       def report_filter_message(message)

data/spec/support/gate_failure_formatter.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'rspec/core/formatters/base_formatter'
+
+# The normal final summary is still printed. Emit failures immediately too,
+# so a later killed example cannot erase the only actionable diagnostic.
+class GateFailureFormatter < RSpec::Core::Formatters::BaseFormatter
+  RSpec::Core::Formatters.register self, :example_failed
+
+  def example_failed(notification)
+    output.puts notification.fully_formatted(1)
+    output.flush
+  end
+end

data/spec/support/harness/cli_faults.rb

@@ -11,11 +11,11 @@ module HarnessCLIFaults
   end
 
   def self.invoke(root, fixture, prompt, options)
-    FileUtils.mkdir_p(File.join(root, 'home'))
+    FileUtils.mkdir_p("#{root}-home")
     path = File.join(root, 'provider.json')
     File.write(path, JSON.generate(fixture))
     source = options[:source_root] || HarnessEvaluation::ROOT
-    env = { 'HOME' => File.join(root, 'home'), 'PATH' => HarnessEvaluation.isolated_path, 'LANG' => 'C.UTF-8',
+    env = { 'HOME' => "#{root}-home", 'PATH' => HarnessEvaluation.isolated_path, 'LANG' => 'C.UTF-8',
             'GEM_HOME' => options[:gem_home] || Gem.dir, 'GEM_PATH' => options[:gem_path] || Gem.path.join(File::PATH_SEPARATOR),
             'PWN_HARNESS_FIXTURE' => path, 'PWN_HARNESS_EVENTS' => File.join(root, 'events.jsonl'),
             'PWN_HARNESS_FINGERPRINT' => File.join(root, 'fingerprint.json'), 'PWN_HARNESS_RUNTIME' => File.join(root, 'runtime'),
@@ -27,9 +27,9 @@ module HarnessCLIFaults
     ready_path = fixture[:await_cap_ready] ? env.fetch('PWN_HARNESS_CAP_READY') : nil
     startup = options[:executable] ? 180 : 45
     report = if ready_path
-               HarnessEvaluation.capture(env, command, root, fixture.fetch(:wall_seconds, 35), ready_path: ready_path, startup_seconds: startup)
+               HarnessEvaluation.capture(env, command, root, fixture.fetch(:wall_seconds, 120), ready_path: ready_path, startup_seconds: startup)
              else
-               HarnessEvaluation.agent_capture(env, command, root, fixture.fetch(:wall_seconds, 35), options)
+               HarnessEvaluation.agent_capture(env, command, root, fixture.fetch(:wall_seconds, 120), options)
              end
     phase = fixture[:resume] ? 'resumed' : 'initial'
     File.write(File.join(root, "#{phase}-process.json"), JSON.pretty_generate(report.merge(command: command)))
@@ -66,7 +66,9 @@ module HarnessCLIFaults
       end
       result = invoke(root, fixture, prompt, options)
       first = result.dup
-      if %w[checkpoint-restart resource-cap-restart].include?(name)
+      restart_ready = (name == 'checkpoint-restart' && first[:exit_status] == 73) ||
+                      (name == 'resource-cap-restart' && first[:resource_cap] && first[:ready_observed])
+      if restart_ready
         fixture = { resume: true, responses: [write, final] }
         result = invoke(root, fixture, 'continue', options)
       end
@@ -78,8 +80,8 @@ module HarnessCLIFaults
       bytes = File.file?(File.join(root, 'result.txt')) ? File.read(File.join(root, 'result.txt')) : nil
       passed = case name
                when 'compaction-steering'
-                 result[:exit_status]&.zero? && bytes == "alpha\n" && File.read(File.join(root, 'latest.txt')) == "beta\n" &&
-                 effects == %w[result-write latest-write] && observed.fetch('effective').include?('Also create latest.txt') &&
+                 result[:exit_status]&.zero? && bytes == "alpha\n" && File.file?(File.join(root, 'latest.txt')) && File.read(File.join(root, 'latest.txt')) == "beta\n" &&
+                 effects == %w[result-write latest-write] && observed.fetch('effective', '').include?('Also create latest.txt') &&
                  trace.any? { |row| JSON.generate(row['messages']).include?('ENGAGEMENT MEMORY') }
                when 'provider-retry'
                  result[:exit_status]&.zero? && bytes == "alpha\n" && effects == ['result-write'] && trace.length == 4
@@ -90,7 +92,7 @@ module HarnessCLIFaults
                  (name == 'checkpoint-restart' ? first[:exit_status] == 73 : first[:resource_cap] && first[:ready_observed]) &&
                  result[:exit_status] == 1 && effects == ['uncertain-write'] && bytes.nil? &&
                  observed.dig('outcome', 'status') != 'complete' &&
-                 observed.fetch('events').one? { |row| row['phase'] == 'start' && row['tool'] == 'shell' }
+                 observed.fetch('events', []).one? { |row| row['phase'] == 'start' && row['tool'] == 'shell' }
                end
       outcome = if result[:resource_cap]
                   'INCOMPLETE'
@@ -100,7 +102,9 @@ module HarnessCLIFaults
       rows << { id: name, outcome: outcome,
                 task_outcome: observed['outcome'], exit_status: result[:exit_status], initial_exit_status: first[:exit_status],
                 initial_resource_cap: first[:resource_cap], initial_outcome: first[:resource_cap] ? 'INCOMPLETE' : nil,
-                cap_ready_observed: first[:ready_observed], cap_startup_bound_seconds: name == 'resource-cap-restart' ? 35 : nil,
+                cap_ready_observed: first[:ready_observed], cap_startup_bound_seconds: name == 'resource-cap-restart' ? first[:startup_bound_seconds] : nil,
+                initial_process: first.slice(:exit_status, :signal, :resource_cap, :ready_observed, :timeout_phase),
+                final_process: result.slice(:exit_status, :signal, :resource_cap, :ready_observed, :timeout_phase),
                 effects: effects, repeated_effects: effects.tally.values.sum { |n| n - 1 }, provider_calls: trace.length,
                 artifact_root: root, tokens: nil, cost: nil,
                 boundary: 'actual CLI with test-injected public Loop runtime/steering controls; provider fake, tools real' }

data/spec/support/harness/controller_spill.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'pwn'
+require 'json'
+
+source, work, mode = ARGV
+protected_source = PWN::Plugins::AISandbox.protected_roots
+PWN::Plugins::AISandbox.define_singleton_method(:protected_roots) { [source, *protected_source] }
+runtime = PWN::AI::Agent::RequestRuntime.new(request: 'Create a report', session_id: 'spillboundary', artifact_root: File.join(work, 'state'), trace: false, retrieve: false)
+Thread.current[:pwn_request_runtime] = runtime
+spill = if mode == 'transcript'
+          File.join(Dir.home, '.pwn', 'artifacts', 'transcripts')
+        else
+          File.join(work, 'state', 'spillboundary')
+        end
+FileUtils.mkdir_p(spill) if mode == 'transcript'
+PWN::AI::Agent::Registry.register(name: 'spill_boundary_fixture', toolset: 'fixture', schema: { name: 'spill_boundary_fixture', parameters: { type: 'object' } }, handler: lambda { |_args|
+  Dir.rmdir(spill) if mode == 'transcript'
+  File.symlink(source, spill)
+  { redirected: true }
+})
+call = { function: { name: 'spill_boundary_fixture', arguments: '{}' } }
+result = JSON.parse(PWN::AI::Agent::Dispatch.call(tool_call: call))
+runtime.tool_result(call, 'synthetic output ' * 1024)
+PWN::AI::Agent::Loop.send(:spill_tool_body, text: 'synthetic transcript ' * 1024) if mode == 'transcript'
+puts JSON.generate(changed: !Dir.empty?(source), names: Dir.children(source), dispatch_success: result['success'], dispatch_error: JSON.generate(result))

data/spec/support/harness/controller_state.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'pwn'
+require 'json'
+
+source, work, mode = ARGV
+original_roots = PWN::Plugins::AISandbox.protected_roots
+PWN::Plugins::AISandbox.define_singleton_method(:protected_roots) { [source, *original_roots] }
+runtime = PWN::AI::Agent::RequestRuntime.new(request: 'Audit controller isolation', session_id: 'stateboundary', artifact_root: File.join(Dir.home, '.pwn', 'requests'), trace: false, retrieve: false)
+Thread.current[:pwn_request_runtime] = runtime
+# Independent finite writer inventory: include stores that do not exist yet,
+# existing state, and writable-looking parent directories beneath HOME.
+directories = %w[sessions artifacts logs learning metrics skills engagements missions runs curriculum finetune]
+files = %w[learning.jsonl lessons.json policy.json policy_traj.jsonl metrics.json mistakes.json preferences.jsonl reward_sentinel.json open_goal.json skill_review.jsonl memory.json memory.archive.json memory.idx curriculum_kpi.jsonl pwn.yaml pwn.yaml.decryptor vault-secrets.json]
+base = File.join(Dir.home, '.pwn')
+directories.each { |name| FileUtils.mkdir_p(File.join(base, name)) }
+if mode == 'aliased'
+  path = File.join(base, 'sessions')
+  target = File.join(File.dirname(work), 'session-state')
+  FileUtils.mv(path, target)
+  File.symlink(target, path)
+end
+files.each { |name| File.write(File.join(base, name), '{}') }
+output = File.join(PWN::Plugins::AISandbox.workspace, 'allowed.txt')
+PWN::AI::Agent::Registry.register(name: 'state_boundary_fixture', toolset: 'fixture', schema: { name: 'state_boundary_fixture', parameters: { type: 'object' } }, handler: lambda { |_args|
+  attempts = {}
+  directories.each do |name|
+    path = File.join(base, name, 'redirect')
+    attempts[name] = begin
+      File.symlink(source, path)
+      'writable'
+    rescue Errno::EACCES, Errno::EPERM
+      'denied'
+    end
+  end
+  files.each do |name|
+    attempts[name] = begin
+      File.write(File.join(base, name), 'mutated')
+      'writable'
+    rescue Errno::EACCES, Errno::EPERM
+      'denied'
+    end
+  end
+  attempts['missing-policy-temp'] = begin
+    File.symlink(source, File.join(base, '.policy-host-temp'))
+    'writable'
+  rescue Errno::EACCES, Errno::EPERM
+    'denied'
+  end
+  File.write(output, 'output remains writable')
+  attempts
+})
+result = JSON.parse(PWN::AI::Agent::Dispatch.call(tool_call: { function: { name: 'state_boundary_fixture', arguments: '{}' } }))
+puts JSON.generate(result: result, source_unchanged: Dir.empty?(source), output: File.read(output))

data/spec/support/harness/evaluate.rb

@@ -74,6 +74,14 @@ module HarnessEvaluation
     status = nil
     capped = false
     ready_observed = false
+    phase = ready_path ? 'startup' : 'execution'
+    timeout_phase = nil
+    # A restart reuses the workspace, not the previous process's readiness.
+    FileUtils.rm_f(ready_path) if ready_path
+    # Source-tree fixtures need the scratch-built extension. Packaged fixtures
+    # use their isolated GEM_HOME and must load their own installed extension.
+    env = env.merge('TMPDIR' => ENV['TMPDIR']) if ENV['TMPDIR']
+    env = env.merge('RUBYLIB' => ENV['RUBYLIB']) if env['GEM_HOME'] == Gem.dir && ENV['RUBYLIB']
     Open3.popen3(env, *command, chdir: cwd, unsetenv_others: true, pgroup: true) do |input, output, error, waiter|
       input.close
       output.set_encoding(Encoding::UTF_8)
@@ -86,12 +94,14 @@ module HarnessEvaluation
           end
           ready_observed = File.file?(ready_path)
         end
+        phase = 'execution' if !ready_path || ready_observed
         Timeout.timeout(seconds) do
           status = waiter.value
           stdout, stderr = readers.map(&:value)
         end
       rescue Timeout::Error
         capped = true
+        timeout_phase = phase
         begin
           Process.kill('KILL', -waiter.pid)
         rescue Errno::ESRCH
@@ -103,6 +113,7 @@ module HarnessEvaluation
     end
     { stdout: stdout, stderr: stderr, exit_status: status.exitstatus,
       signal: status.termsig, resource_cap: capped, ready_observed: ready_observed,
+      timeout_phase: timeout_phase, startup_bound_seconds: ready_path ? startup_seconds : nil, execution_bound_seconds: seconds,
       latency_seconds: Process.clock_gettime(Process::CLOCK_MONOTONIC) - started }
   end
 
@@ -130,7 +141,7 @@ module HarnessEvaluation
     ruby = RbConfig.ruby
     rows = manifest.fetch('tasks').map do |task|
       root = Dir.mktmpdir("#{task.fetch('id')}-", output_root)
-      home = File.join(root, 'home')
+      home = "#{root}-home"
       FileUtils.mkdir_p(home)
       fixture = File.join(root, 'provider.json')
       File.write(fixture, JSON.generate(responses: task.fetch('responses')))

data/spec/support/harness/experiments.rb

@@ -28,7 +28,7 @@ module HarnessExperiments
 
   def self.trial(task, arm, gold, snapshot, options)
     root = Dir.mktmpdir("#{task.fetch('id')}-#{arm}-", options.fetch(:output))
-    home = File.join(root, 'home')
+    home = "#{root}-home"
     FileUtils.mkdir_p(home)
     FileUtils.cp_r(File.join(snapshot, '.'), home) if snapshot && arm != 'single-cold'
     # The immutable source snapshot is never mounted as a writable live store.