pwn 0.5.721 → 0.5.723

data/spec/lib/pwn/ai/agent/registry_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require 'tmpdir'
 
 describe PWN::AI::Agent::Registry do
   it 'should display information for authors' do
@@ -46,6 +47,67 @@ describe PWN::AI::Agent::Registry do
     expect(names.length).to eq(described_class::CORE_TOOLS.length)
   end
 
+  describe 'contextual policy routing' do
+    let(:policy) { PWN::AI::Agent::Policy }
+    let(:entries) do
+      %w[alpha beta].map do |name|
+        described_class::Entry.new(name: name, toolset: 'test', schema: { description: 'inspect' })
+      end
+    end
+
+    around do |example|
+      Dir.mktmpdir do |tmp|
+        @policy_dir = tmp
+        example.run
+      ensure
+        policy.attach_episode!(episode: nil)
+      end
+    end
+
+    before do
+      stub_const('PWN::AI::Agent::Policy::POLICY_FILE', File.join(@policy_dir, 'policy.json'))
+      stub_const('PWN::AI::Agent::Policy::TRAJECTORY_FILE', File.join(@policy_dir, 'policy_traj.jsonl'))
+      allow(policy).to receive(:enabled?).and_return(true)
+      allow(policy).to receive(:cold?).and_return(true)
+      allow(policy).to receive(:warm?).and_return(false)
+      allow(PWN::AI::Agent::Metrics).to receive_messages(advantage: 0.0, ucb: 0.0, prm_advantage: 0.0, prm_n: 0, proxy_trust: 1.0)
+    end
+
+    {
+      operations: [{ operation: 'read' }, { operation: 'search' }],
+      argument_features: [{ args: { path: '/not-stored' } }, { args: { query: 'not-stored' } }],
+      result_types: [{ result_type: :enoent, ok: false }, { result_type: :timeout, ok: false }]
+    }.each do |feature, contexts|
+      it "learns opposite next-tool rankings from sanitized previous #{feature}" do
+        3.times do
+          contexts.each_with_index do |context, index|
+            %w[alpha beta].each do |action|
+              policy.begin_episode(request: 'inspect')
+              policy.observe_step({ action: 'file', operation: 'read', ok: true }.merge(context))
+              policy.observe_step(action: action, ok: true)
+              score = index.zero? == (action == 'alpha') ? 1.0 : 0.0
+              policy.finish(score: score)
+            end
+          end
+        end
+
+        contexts.each_with_index do |context, index|
+          policy.begin_episode(request: 'inspect')
+          observation = { action: 'file', operation: 'read', ok: true }.merge(context)
+          observation[:args] = context[:args].transform_values { 'different-value' } if context[:args]
+          policy.observe_step(observation)
+          ranked = described_class.rank(query: 'inspect', entries: entries, preference: []).map(&:name)
+          expected = index.zero? ? %w[alpha beta] : %w[beta alpha]
+          expect(ranked).to eq(expected)
+          expect(policy.recommend(actions: %w[alpha beta], epsilon: 0.0)[:action]).to eq(expected.first)
+        end
+
+        lexical = described_class::Entry.new(name: 'lexical', toolset: 'test', schema: { description: 'inspect priority' })
+        expect(described_class.rank(query: 'inspect priority', entries: entries + [lexical], preference: []).first.name).to eq('lexical')
+      end
+    end
+  end
+
   it 'pins pentest and RE tools when the request is offensive-security work' do
     described_class.discover(force: true)
     defs = described_class.definitions(

data/spec/lib/pwn/ai/agent/reward_spec.rb

@@ -271,12 +271,14 @@ describe PWN::AI::Agent::Reward do
     expect(v[:rationale].to_s).not_to match(/heuristic overlap/)
   end
 
-  it 'sentinel window_means weights llm_orm above heuristic overlap' do
+  it 'sentinel window_means weights llm_orm above verified heuristic outcomes' do
     tmp = Dir.mktmpdir
     stub_const('PWN::AI::Agent::Reward::SENTINEL_FILE', File.join(tmp, 's.json'))
-    20.times { described_class.send(:record_sentinel, proxy: true, judge: 0.9, source: :heuristic) }
+    20.times { described_class.send(:record_sentinel, proxy: true, judge: 0.9, source: :heuristic, training_score: 0.9) }
     20.times { described_class.send(:record_sentinel, proxy: true, judge: 0.2, source: :llm_orm) }
-    means = described_class.send(:window_means, window: described_class.send(:load_sentinel)[:window])
+    window = described_class.send(:load_sentinel)[:window]
+    expect(window.length).to eq(40)
+    means = described_class.send(:window_means, window: window)
     # equal counts: unweighted mean would be 0.55; ORM-weighted mean is closer to 0.2
     expect(means[:judge]).to be < 0.45
     expect(means[:judge]).to be > 0.2
@@ -329,6 +331,146 @@ describe PWN::AI::Agent::Reward do
   end
 end
 
+describe 'PWN::AI::Agent::Reward request verification' do
+  include_context 'pwn tmp sandbox'
+
+  it 'invalidates verification when another tool runs after the checks' do
+    klass = PWN::AI::Agent::Reward
+    session = PWN::Sessions.create(title: 'changed artifact')[:id]
+    request = 'write the correct report'
+    PWN::Sessions.append(session_id: session, role: 'user', content: request)
+    klass.record_verification(request: request, session_id: session,
+                              checks: [{ criterion: request, passed: true, evidence: 'independent readback' }])
+    PWN::Sessions.append(session_id: session, role: 'tool', content: '{"success":true,"effect":"write"}')
+    allow(klass).to receive(:llm_judge).and_return(score: 0.2, source: :llm_orm, rationale: 'report changed')
+    allow(klass).to receive(:verify_as_reward).and_return(nil)
+    v = klass.judge(request: request, session_id: session, final: 'PASS', commit: false)
+    expect(v[:verification]).to be_nil
+    expect(v[:success]).to be false
+  end
+
+  it 'does not calibrate or persist a heuristic guess as a known outcome' do
+    klass = PWN::AI::Agent::Reward
+    allow(klass).to receive(:llm_judge).and_return(score: 0.9, source: :heuristic, rationale: 'overlap')
+    allow(klass).to receive(:verify_as_reward).and_return(nil)
+    expect(PWN::AI::Agent::Curriculum).not_to receive(:calibrate)
+    v = klass.judge(request: 'write a report', final: 'PASS report written',
+                    trace: ['{"success":true}'], persist_components: true)
+    row = PWN::AI::Agent::Learning.outcomes.first
+    expect(row[:verdict].to_s).to eq('unknown')
+    expect(row[:confidence]).to eq(v[:confidence])
+    expect(row[:training_score]).to be_nil
+  end
+
+  it 'keeps unknown live judgments out of sentinel calibration and routing distrust' do
+    klass = PWN::AI::Agent::Reward
+    allow(klass).to receive(:llm_judge).and_return(score: 0.1, source: :heuristic, rationale: 'overlap')
+    allow(klass).to receive(:verify_as_reward).and_return(nil)
+    allow(PWN::AI::Agent::Curriculum).to receive(:calibrate)
+
+    klass::SENTINEL_WINDOW.times do
+      v = klass.judge(request: 'write a report', final: 'unrelated', proxy_ok: true)
+      expect(v).to include(verdict: :unknown, training_score: nil)
+    end
+    snapshot = klass.sentinel
+
+    expect(snapshot).to include(samples: 0, status: :insufficient)
+    expect(PWN::AI::Agent::Curriculum).not_to have_received(:calibrate)
+    expect(klass.proxy_distrust).to eq(0.0)
+  end
+
+  it 'does not warm the sentinel from unknown canonical or legacy heuristic outcomes' do
+    klass = PWN::AI::Agent::Reward
+    unknowns = [
+      klass.resolve_outcome(outcome: { score: 0.1, source: :heuristic }),
+      klass.resolve_outcome(outcome: { score: 0.9, source: :llm_orm }, critic_pass: false),
+      klass.resolve_outcome(outcome: { source: :error }),
+      { score: 0.1, success: true, judge_source: 'heuristic' },
+      { score: 0.1, success: true, verdict: 'unknown' }
+    ]
+    File.write(PWN::AI::Agent::Learning::LEARNING_FILE, (unknowns * klass::SENTINEL_WINDOW).map(&:to_json).join("\n"))
+    allow(PWN::AI::Agent::Curriculum).to receive(:calibrate)
+
+    result = klass.warm_sentinel(limit: 200)
+
+    expect(result).to include(added: 0, samples: 0)
+    expect(klass.sentinel).to include(samples: 0, status: :insufficient)
+    expect(PWN::AI::Agent::Curriculum).not_to have_received(:calibrate)
+    expect(klass.proxy_distrust).to eq(0.0)
+  end
+
+  it 'warms known legacy engine scores and canonical verified failures' do
+    klass = PWN::AI::Agent::Reward
+    failed = klass.resolve_outcome(outcome: {
+                                     score: 0.0, source: :heuristic,
+                                     verification: { checks: [{ criterion: 'report', passed: false, evidence: 'report absent' }] }
+                                   })
+    rows = [{ score: 0.7, success: true, judge_source: 'llm_orm' }, failed]
+    File.write(PWN::AI::Agent::Learning::LEARNING_FILE, rows.map(&:to_json).join("\n"))
+
+    expect(klass.warm_sentinel).to include(added: 2, samples: 2)
+    expect(klass.send(:load_sentinel)[:window].map { |row| row[:judge] }).to contain_exactly(0.0, 0.7)
+  end
+
+  it 'removes unknown persisted sentinel rows and their stale routing distrust' do
+    klass = PWN::AI::Agent::Reward
+    window = [
+      { judge: 0.7, proxy: 1.0, source: 'llm_orm' },
+      { judge: 0.1, proxy: 1.0, source: 'heuristic' },
+      { judge: 0.9, proxy: 1.0, source: 'llm_orm', training_score: nil, decision_version: 1 },
+      { judge: 0.1, proxy: 1.0, verdict: 'unknown' }
+    ]
+    File.write(klass::SENTINEL_FILE, JSON.generate(window: window, proxy_distrust: 0.85, distrust_at: Time.now.utc.iso8601))
+
+    expect(klass.sentinel).to include(samples: 1, status: :insufficient)
+    expect(klass.send(:load_sentinel)[:window]).to eq([window.first])
+    expect(klass.proxy_distrust).to eq(0.0)
+  end
+
+  it 'keeps verified heuristic failures in the live sentinel and calibration' do
+    klass = PWN::AI::Agent::Reward
+    request = 'write the required report'
+    session = PWN::Sessions.create(title: request)[:id]
+    PWN::Sessions.append(session_id: session, role: 'user', content: request)
+    klass.record_verification(request: request, session_id: session,
+                              checks: [{ criterion: request, passed: false, evidence: 'required report is absent' }])
+    allow(klass).to receive(:llm_judge).and_return(score: 0.9, source: :heuristic, rationale: 'overlap')
+    allow(klass).to receive(:verify_as_reward).and_return(nil)
+    allow(PWN::AI::Agent::Curriculum).to receive(:calibrate)
+
+    v = klass.judge(request: request, session_id: session, final: 'report written', proxy_ok: true)
+
+    expect(v).to include(success: false, training_score: 0.2)
+    expect(klass.sentinel).to include(samples: 1, status: :insufficient)
+    expect(PWN::AI::Agent::Curriculum).to have_received(:calibrate).with(hash_including(actual: 0.2))
+  end
+
+  it 'uses only a verifier record bound to the current request and session' do
+    klass = PWN::AI::Agent::Reward
+    session = PWN::Sessions.create(title: 'verified request')[:id]
+    request = 'write the exact report content'
+    PWN::Sessions.append(session_id: session, role: 'user', content: request)
+    path = File.join(@tmp, 'report.txt')
+    File.write(path, 'checked content')
+    checks = [{ criterion: request, passed: File.read(path) == 'checked content', evidence: path }]
+    klass.record_verification(request: request, session_id: session, checks: checks)
+    allow(klass).to receive(:llm_judge).and_return(score: 0.0, source: :heuristic, rationale: 'weak overlap')
+    allow(klass).to receive(:verify_as_reward).and_return(nil)
+    v = klass.judge(request: request, session_id: session, final: 'Report written.', commit: false)
+    expect(v[:success]).to be true
+    expect(v[:verdict]).to eq(:solved)
+    expect(v[:judge_score]).to eq(0.0)
+    expect(v[:confidence]).to eq(1.0)
+    expect(v[:training_score]).to be >= 0.6
+    expect(v[:verification][:checks]).to eq(checks)
+
+    PWN::Sessions.append(session_id: session, role: 'user', content: 'another task')
+    stale = klass.judge(request: request, session_id: session, final: 'PASS', commit: false)
+    expect(stale[:success]).not_to be true
+    expect(stale[:verification]).to be_nil
+  end
+end
+
 describe 'PWN::AI::Agent::Reward vs TUI plan' do
   it 'does not let a TUI plan_cover_low haircut a high-evidence original-request answer' do
     stub_const('PWN::AI::Agent::Reward::SENTINEL_FILE', File.join(Dir.mktmpdir, 's.json'))
@@ -364,7 +506,8 @@ describe 'PWN::AI::Agent::Reward vs TUI plan' do
     )
     expect(v[:source].to_s).to eq 'heuristic'
     expect(v[:score]).to be >= 0.6
-    expect(v[:verdict].to_s).to eq 'solved'
+    expect(v[:verdict].to_s).to eq 'unknown'
+    expect(v[:training_score]).to be_nil
     args = {
       request: 'what live hosts can you find on this box and write /tmp/pwn-eval-hosts.json',
       final: final,
@@ -397,7 +540,8 @@ describe 'PWN::AI::Agent::Reward vs TUI plan' do
     expect(a[:score]).to eq(b[:score])
     expect(b[:score]).to eq(c[:score])
     expect(a[:score]).to be >= 0.6
-    expect(a[:verdict].to_s).to eq('solved')
+    expect(a[:verdict].to_s).to eq('unknown')
+    expect(a[:training_score]).to be_nil
   end
 
   it 'does not drag a long analytical PASS to partial on zero token overlap' do
@@ -409,10 +553,17 @@ describe 'PWN::AI::Agent::Reward vs TUI plan' do
     expect(v[:score]).to be > 0.35
   end
 
-  it 'floors verified PASS analytical answers at 0.6' do
-    src = File.read(PWN::AI::Agent::Reward.method(:judge).source_location.first)
-    expect(src).to include('[score, 0.6].max')
-    expect(src).to include('\bPASS\b')
+  it 'does not turn self-reported PASS or an unrelated successful command into verification' do
+    klass = PWN::AI::Agent::Reward
+    allow(klass).to receive(:llm_judge).and_return(
+      { score: 0.2, source: :llm_orm, verdict: :wrong, rationale: 'missing requested artifact' }
+    )
+    allow(klass).to receive(:verify_as_reward).and_return(nil)
+    v = klass.judge(request: 'write the requested report', final: 'PASS all done',
+                    trace: ['{"success":true,"result":{"exit":0}}'], commit: false)
+    expect(v[:score]).to eq(0.2)
+    expect(v[:success]).to be false
+    expect(v[:verifier_verdict]).to be_nil
   end
 
   it 'prefers model_routes.judge when selecting a judge model' do
@@ -423,7 +574,7 @@ describe 'PWN::AI::Agent::Reward vs TUI plan' do
     expect(m).to eq('local-judge')
   end
 
-  it 'records verifier PASS as success even when the judge scores 0.0' do
+  it 'does not accept an unbound verifier PASS option as completion evidence' do
     allow(PWN::AI::Agent::Reward).to receive(:llm_judge).and_return(
       { score: 0.0, source: 'heuristic', verdict: :wrong, rationale: 'overlap=0.01', confidence: 0.3 }
     )
@@ -434,8 +585,20 @@ describe 'PWN::AI::Agent::Reward vs TUI plan' do
       commit: false,
       verifier_verdict: :pass
     )
-    expect(v[:success]).to eq(true)
-    expect(v[:verifier_verdict]).to eq(:pass)
+    expect(v[:success]).not_to eq(true)
+    expect(v[:verifier_verdict]).to be_nil
     expect(v[:judge_score]).to be < 0.6
   end
+
+  it 'tags tool-backed heuristics so they are not haircut' do
+    allow(PWN::AI::Agent::Reward).to receive(:llm_judge).and_return(nil)
+    v = PWN::AI::Agent::Reward.judge(
+      request: 'write /tmp/x and verify',
+      final: 'PASS file exists',
+      trace: ['{"success":true,"result":{"exit":0}}'],
+      commit: false
+    )
+    expect(v[:heuristic_class].to_s).to eq('toolbacked')
+    expect(v[:score]).to be >= 0.6
+  end
 end

data/spec/lib/pwn/ai/agent/swarm_spec.rb

@@ -15,7 +15,8 @@ describe PWN::AI::Agent::Swarm do
   end
 
   it 'exposes the core orchestration API' do
-    %i[personas spawn retire create list ask debate broadcast bus_append bus_tail].each do |m|
+    %i[personas spawn retire create list ask debate broadcast bus_append bus_tail
+       pack_specialist child_inbox child_honesty view_graph claim honesty_unmet].each do |m|
       expect(PWN::AI::Agent::Swarm).to respond_to m
     end
   end
@@ -54,4 +55,123 @@ describe PWN::AI::Agent::Swarm do
       expect(b[:ok]).to eq(false)
     end
   end
+
+  it 'packs specialists to at most three skills and strips swarm unless orchestrator' do
+    packed = described_class.pack_specialist(name: 'xss', skills: %w[xss sqli ssrf auth], toolsets: %w[pwn swarm terminal])
+    expect(packed[:skills].length).to eq(3)
+    expect(packed[:toolsets]).not_to include('swarm')
+    orch = described_class.pack_specialist(name: 'lead', skills: %w[recon], toolsets: %w[swarm pwn], orchestrator: true)
+    expect(orch[:toolsets]).to include('swarm')
+  end
+
+  it 'spills long bus rows to the artifact store and keeps a short content plus ref' do
+    Dir.mktmpdir do |dir|
+      allow(Dir).to receive(:home).and_return(dir)
+      stub_const('PWN::AI::Agent::Swarm::SWARM_ROOT', File.join(dir, 'swarm'))
+      stub_const('PWN::Plugins::ArtifactRegistry::ROOT', File.join(dir, 'art'))
+      s = described_class.create(topic: 'bus')
+      body = 'P' * 800
+      row = described_class.bus_append(swarm_id: s[:swarm_id], from: :red, content: body)
+      expect(row[:content].bytesize).to be <= 400
+      expect(row[:sha256]).to match(/\A[0-9a-f]{64}\z/)
+      expect(row[:ref].to_s).not_to be_empty
+    end
+  end
+
+  it 'refuses ask when the work unit is already claimed' do
+    Dir.mktmpdir do |dir|
+      allow(Dir).to receive(:home).and_return(dir)
+      stub_const('PWN::AI::Agent::Swarm::SWARM_ROOT', File.join(dir, 'swarm'))
+      stub_const('PWN::AI::Agent::Swarm::AGENTS_FILE', File.join(dir, 'agents.yml'))
+      described_class.spawn(name: 'red', role: 'recon')
+      described_class.claim(unit: '10.0.0.5:recon', agent_id: 'other', ttl: 600, engagement_id: 'lab')
+      out = described_class.ask(name: 'red', request: 'recon 10.0.0.5', unit: '10.0.0.5:recon', engagement_id: 'lab')
+      expect(out[:ok]).to eq(false)
+      expect(out[:error]).to eq('claim_held')
+    end
+  end
+
+  it 'child inbox lists finding ids from Findings, not reply prose' do
+    allow(PWN::Plugins::Findings).to receive(:report).and_return(
+      [{ id: 'deadbeef', session_id: 'sess-1', title: 'xss' }]
+    )
+    allow(PWN::Plugins::ArtifactRegistry).to receive(:list).and_return([])
+    box = described_class.child_inbox(session_id: 'sess-1', name: 'red')
+    expect(box[:finding_ids]).to eq(['deadbeef'])
+  end
+
+  it 'flags child honesty gap when pwn toolset filed nothing' do
+    allow(described_class).to receive(:child_inbox).and_return(finding_ids: [], artifact_shas: [], coverage: [])
+    h = described_class.child_honesty(name: 'xss', toolsets: %w[pwn], session_id: 's')
+    expect(h[:gap]).to eq('child_filed_nothing')
+  end
+
+  it 'view_graph lists personas and live claims' do
+    Dir.mktmpdir do |dir|
+      allow(Dir).to receive(:home).and_return(dir)
+      stub_const('PWN::AI::Agent::Swarm::SWARM_ROOT', File.join(dir, 'swarm'))
+      s = described_class.create(topic: 'g')
+      File.write(File.join(dir, 'swarm', s[:swarm_id], 'personas.json'), JSON.generate('red' => 'sess'))
+      described_class.claim(unit: 'h1:recon', agent_id: 'red', ttl: 60, engagement_id: s[:swarm_id])
+      g = described_class.view_graph(swarm_id: s[:swarm_id])
+      expect(g[:agents].map { |a| a[:name] }).to include('red')
+      expect(g[:claims].any? { |c| c[:unit] == 'h1:recon' }).to eq(true)
+    end
+  end
+
+  it 'stores ephemeral personas under the swarm dir, not the host agents.yml' do
+    Dir.mktmpdir do |dir|
+      allow(Dir).to receive(:home).and_return(dir)
+      stub_const('PWN::AI::Agent::Swarm::SWARM_ROOT', File.join(dir, 'swarm'))
+      stub_const('PWN::AI::Agent::Swarm::AGENTS_FILE', File.join(dir, 'agents.yml'))
+      s = described_class.create(topic: 'eph')
+      described_class.spawn(name: 'xss', role: 'xss only', swarm_id: s[:swarm_id], ephemeral: true)
+      expect(File).not_to exist(File.join(dir, 'agents.yml'))
+      expect(described_class.personas(swarm_id: s[:swarm_id]).keys.map(&:to_s)).to include('xss')
+    end
+  end
+
+  it 'broadcast fans out with threads' do
+    src = File.read(described_class.method(:broadcast).source_location.first)
+    expect(src).to match(/Thread\.new/)
+  end
+
+  it 'ask passes nested: true so nested Loop.run does not write the RN footer' do
+    src = File.read(described_class.method(:ask).source_location.first)
+    expect(src).to match(/nested:\s*true/)
+  end
+
+  it 'migrate_personas empties stock escalator tools and adds pwn to scribe' do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, 'agents.yml')
+      File.write(path, <<~YML)
+        ---
+        red:
+          role: keep
+          engine: grok
+          toolsets: [terminal, pwn]
+          max_iters: 25
+        scribe:
+          role: report
+          engine: grok
+          toolsets: [memory, skills, learning, sessions]
+          max_iters: 10
+        escalator:
+          role: hint
+          engine: grok
+          toolsets: [terminal, pwn, memory]
+          max_iters: 8
+      YML
+      out = described_class.migrate_personas(path: path)
+      expect(out[:changed]).to eq(true)
+      expect(out[:patched]).to include('escalator', 'scribe')
+      again = described_class.migrate_personas(path: path)
+      expect(again[:changed]).to eq(false)
+      loaded = described_class.send(:load_personas_file, path: path)
+      expect(loaded[:escalator][:toolsets]).to eq([])
+      expect(loaded[:scribe][:toolsets]).to include('pwn')
+      expect(loaded[:red][:engine]).to eq(:grok)
+      expect(loaded[:red][:toolsets]).to eq(%w[terminal pwn])
+    end
+  end
 end

data/spec/lib/pwn/ai/agent/tool_guard_spec.rb

@@ -67,6 +67,12 @@ describe PWN::AI::Agent::ToolGuard do
       expect(out[:exit]).to eq(2)
       expect(out[:error]).to eq('invalid_payload')
       expect(out[:stderr]).to include('missing required command')
+      expect(out[:max_payload_bytes]).to eq(described_class::MAX_PAYLOAD_BYTES)
+    end
+
+    it 'names the byte range of a placeholder token' do
+      out = described_class.invalid_payload(hint: 'ellipsis', offending_token: '...', text: 'foo ... bar')
+      expect(out[:byte_range]).to eq([4, 7])
     end
   end
 

data/spec/lib/pwn/ai/agent/tools/capabilities_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'PWN::AI::Agent::Tools capabilities' do
+  before(:all) do
+    PWN::AI::Agent::Registry.discover(force: true)
+    load '/opt/pwn/lib/pwn/ai/agent/tools/capabilities.rb'
+  end
+
+  it 'registers the capabilities tool' do
+    expect(PWN::AI::Agent::Registry.lookup(name: 'capabilities')).not_to be_nil
+  end
+end

data/spec/lib/pwn/ai/agent/tools/context_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'PWN::AI::Agent::Tools context' do
+  before(:all) do
+    PWN::AI::Agent::Registry.discover(force: true)
+    load '/opt/pwn/lib/pwn/ai/agent/tools/context.rb'
+  end
+
+  it 'registers the context_attach tool' do
+    expect(PWN::AI::Agent::Registry.lookup(name: 'context_attach')).not_to be_nil
+  end
+end

data/spec/lib/pwn/ai/agent/tools/job_run_spec.rb

@@ -12,5 +12,7 @@ describe 'PWN::AI::Agent::Tools job_run' do
     expect(PWN::AI::Agent::Registry.lookup(name: 'job_run')).not_to be_nil
     expect(PWN::AI::Agent::Registry.lookup(name: 'job_status')).not_to be_nil
     expect(PWN::AI::Agent::Registry.lookup(name: 'job_result')).not_to be_nil
+    expect(PWN::AI::Agent::Registry.lookup(name: 'job_tail')).not_to be_nil
+    expect(PWN::AI::Agent::Registry.lookup(name: 'job_kill')).not_to be_nil
   end
 end

data/spec/lib/pwn/ai/agent/tools/learning_spec.rb

@@ -8,6 +8,31 @@ describe 'PWN::AI::Agent::Tools learning' do
     expect(PWN::AI::Agent::Registry.lookup(name: 'learning_note_outcome')).not_to be_nil
   end
 
+  [true, false].each do |reported_success|
+    it "stores a model claim of success=#{reported_success} as an unverified note" do
+      Dir.mktmpdir do |dir|
+        stub_const('PWN::AI::Agent::Learning::LEARNING_FILE', File.join(dir, 'learning.jsonl'))
+        PWN::AI::Agent::Registry.discover(force: true)
+        tool = PWN::AI::Agent::Registry.lookup(name: 'learning_note_outcome')
+        expect(PWN::AI::Agent::Learning).not_to receive(:promote_process_lesson)
+        expect(PWN::AI::Agent::Curriculum).not_to receive(:calibrate)
+
+        entry = tool[:handler].call(task: 'Run the regression suite', success: reported_success,
+                                    details: 'Claimed test result without an independent verifier.', tags: ['tests'])
+
+        expect(entry).to include(success: nil, status: 'unverified', verdict: :unknown,
+                                 score: nil, training_score: nil, judge_source: 'self_report')
+        expect(entry[:details]).to include("reported_success=#{reported_success}", 'Claimed test result without an independent verifier.')
+        expect(entry[:tags]).to include('tests', 'unknown')
+        saved = PWN::AI::Agent::Learning.outcomes
+        expect(saved.length).to eq(1)
+        expect(saved.first[:details]).to eq(entry[:details])
+        expect(PWN::AI::Agent::Learning.outcomes(success: true)).to be_empty
+        expect(PWN::AI::Agent::Learning.outcomes(success: false)).to be_empty
+      end
+    end
+  end
+
   it 'registers the learning_reflect tool' do
     PWN::AI::Agent::Registry.discover(force: true)
     expect(PWN::AI::Agent::Registry.lookup(name: 'learning_reflect')).not_to be_nil

data/spec/lib/pwn/ai/context_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tmpdir'
+
+describe PWN::AI::Context do
+  it 'should display information for authors' do
+    expect(described_class).to respond_to :authors
+  end
+
+  it 'should display information for existing help method' do
+    expect(described_class).to respond_to :help
+  end
+
+  it 'attaches a file with sha256 and chunks' do
+    Dir.mktmpdir do |dir|
+      allow(Dir).to receive(:home).and_return(dir)
+      stub_const('PWN::Plugins::ArtifactRegistry::ROOT', File.join(dir, 'artifacts'))
+      path = File.join(dir, 'note.md')
+      File.write(path, 'hello world ' * 20)
+      row = described_class.attach_file(path: path, session_id: 's1')
+      expect(row[:sha256]).to match(/\A[0-9a-f]{64}\z/)
+      expect(row[:chunks]).not_to be_empty
+      expect(File.file?(row[:path])).to be true
+    end
+  end
+
+  it 'attaches a hexdump slice' do
+    Dir.mktmpdir do |dir|
+      allow(Dir).to receive(:home).and_return(dir)
+      stub_const('PWN::Plugins::ArtifactRegistry::ROOT', File.join(dir, 'artifacts'))
+      path = File.join(dir, 'blob.bin')
+      File.binwrite(path, "\x7fELF#{0.chr * 64}")
+      row = described_class.attach_hexdump(path: path, offset: 0, length: 16)
+      expect(row[:kind]).to eq('hexdump')
+      expect(row[:sha256]).not_to be_empty
+    end
+  end
+
+  it 'attaches an HTTP transcript string' do
+    Dir.mktmpdir do |dir|
+      allow(Dir).to receive(:home).and_return(dir)
+      stub_const('PWN::Plugins::ArtifactRegistry::ROOT', File.join(dir, 'artifacts'))
+      row = described_class.attach_http_transcript(har_or_raw: '{"log":{"entries":[]}}')
+      expect(row[:kind]).to eq('http_transcript')
+    end
+  end
+end

data/spec/lib/pwn/ai/http_retry_spec.rb

@@ -43,6 +43,33 @@ describe PWN::AI::HttpRetry do
     PWN::Plugins::Log.stop_debug if defined?(PWN::Plugins::Log)
   end
 
+  it 'honors Retry-After seconds and does not use sub-second fallback' do
+    resp = instance_double('RestClient::Response', headers: { retry_after: '45' })
+    expect(described_class.retry_after_s(response: resp, retry_count: 1)).to eq(45.0)
+    expect(described_class.retry_after_s(retry_count: 1)).to be >= 2.0
+    expect(described_class.retry_after_s(retry_count: 4)).to be >= 8.0
+  end
+
+  it 'treats insufficient_quota 429 bodies as non-retryable' do
+    resp = instance_double('RestClient::Response', body: '{"error":{"code":"insufficient_quota","message":"You exceeded your current quota"}}')
+    err = instance_double('RestClient::TooManyRequests', message: '429 Too Many Requests', response: resp)
+    expect(described_class.quota_exhausted?(error: err)).to eq(true)
+    expect(described_class.quota_exhausted?(error: '429 rate_limit_exceeded')).to eq(false)
+  end
+
+  it 'builds an operator billing line from credit_balance_exhausted 429 bodies' do
+    resp = instance_double(
+      'RestClient::Response',
+      body: '{"error":{"message":"You have no credits remaining. Add credits to continue using the API at https://platform.openai.com/settings/organization/billing/.","type":"insufficient_quota","code":"credit_balance_exhausted"}}'
+    )
+    err = instance_double('RestClient::TooManyRequests', message: '429 Too Many Requests', response: resp)
+    expect(described_class.quota_exhausted?(error: err)).to eq(true)
+    msg = described_class.quota_message(error: err)
+    expect(msg).to include('no credits')
+    expect(msg).to include('platform.openai.com/settings/organization/billing')
+    expect(msg).to include('ChatGPT')
+  end
+
   {
     'PWN::AI::Grok' => '/opt/pwn/lib/pwn/ai/grok.rb',
     'PWN::AI::OpenAI' => '/opt/pwn/lib/pwn/ai/open_ai.rb',