pwn 0.5.647 → 0.5.650

data/spec/integration/reinforced_feedback_loop_spec.rb

@@ -44,6 +44,7 @@ RSpec.describe 'PWN::AI::Agent reinforced feedback loop', :aggregate_failures do
     stub_const('PWN::AI::Agent::Reward::DPO_DIR',            File.join(@tmp, 'finetune'))
     stub_const('PWN::AI::Agent::Curriculum::CURRICULUM_DIR', File.join(@tmp, 'curriculum'))
     stub_const('PWN::AI::Agent::Curriculum::MODELS_FILE',    File.join(@tmp, 'curriculum', 'models.json'))
+    stub_const('PWN::AI::Agent::Curriculum::KPI_FILE',       File.join(@tmp, 'curriculum_kpi.jsonl'))
     stub_const('PWN::Sessions::SESSIONS_DIR',                File.join(@tmp, 'sessions'))
     stub_const('PWN::Memory::MEMORY_FILE',                   File.join(@tmp, 'memory.json'))
     stub_const('PWN::MemoryIndex::INDEX_FILE',               File.join(@tmp, 'memory.idx')) if defined?(PWN::MemoryIndex)
@@ -1201,5 +1202,303 @@ RSpec.describe 'PWN::AI::Agent reinforced feedback loop', :aggregate_failures do
       expect(r[:verdict]).to eq :pass
     end
   end
+
+  # ═══════════════════════════════════════════════════════════════════════
+  # Design-priority STATUS (post P14–P25) — P0 / P1 / P2
+  # documentation/Reinforcement-Learning.md § Design-priority STATUS
+  # ═══════════════════════════════════════════════════════════════════════
+
+  describe 'P0 · W1 generator diversity (TARGET_SOURCE_MIX + generator_mix)' do
+    it 'exposes TARGET_SOURCE_MIX soft targets that sum to 1.0' do
+      mix = reward::TARGET_SOURCE_MIX
+      expect(mix.keys).to include('mistakes_resolve', 'curriculum', 'counterfactual', 'critic', 'user_correction')
+      expect(mix.values.sum).to be_within(0.001).of(1.0)
+      expect(mix['mistakes_resolve']).to be <= 0.40
+    end
+
+    it 'generator_mix flags underfilled sources and returns recommendation' do
+      # seed a few usable traj pairs skewed toward curriculum/critic
+      6.times do |i|
+        reward.record_preference(
+          prompt: "p#{i}",
+          rejected: "bad answer #{i} " + ('x' * 40),
+          chosen: "STRATEGY: use shell\nWINNING_TRACE: shell(uname)\nFINAL: linux #{i}",
+          source: i.even? ? :curriculum : :critic,
+          shape: :winning_trace
+        )
+      end
+      m = reward.generator_mix
+      expect(m[:n]).to be >= 5
+      expect(m[:shares]).to be_a(Hash)
+      expect(m[:targets]).to eq(reward::TARGET_SOURCE_MIX)
+      expect(m[:urgent]).to include('counterfactual') # 0 share << 0.20 target
+      expect(m[:healthy]).to eq(false)
+      expect(m[:recommendation]).to match(/boost:|need_/)
+    end
+
+    it 'write_source_quota reports underfilled against TARGET_SOURCE_MIX' do
+      12.times do |i|
+        reward.record_preference(
+          prompt: "q#{i}",
+          rejected: "nope #{'y' * 40}",
+          chosen: "STRATEGY: a\nWINNING_TRACE: t\nFINAL: ok #{i}",
+          source: :curriculum,
+          shape: :winning_trace
+        )
+      end
+      q = reward.write_source_quota(source: 'counterfactual')
+      expect(q[:underfilled]).to eq(true)
+      expect(q[:target]).to eq(0.20)
+    end
+
+    it 'counterfactual and critic force-run when generator_mix marks them urgent' do
+      allow(reward).to receive(:generator_mix).and_return(
+        urgent: %w[counterfactual critic], suppress: [], healthy: false, n: 20,
+        recommendation: 'boost:counterfactual,critic'
+      )
+      # env flags OFF — mix_need should still open the gate
+      @agent_cfg[:counterfactual] = false
+      @agent_cfg[:critic] = false
+      allow(curriculum).to receive(:in_curriculum?).and_return(false)
+      allow(curriculum).to receive(:reflect_available?).and_return(false)
+
+      # counterfactual: stubs the expensive branch; we only assert it does not
+      # short-circuit on disabled when mix_need is true. If still nil for other
+      # reasons, at least enabled? gate is not the cause.
+      allow(curriculum).to receive(:enabled?).and_call_original
+      # critic text_only always works once gate opens
+      r = curriculum.critic(request: 'q', final: 'a solid factual answer', text_only: true)
+      expect(r[:source].to_s).not_to eq('disabled')
+    end
+  end
+
+  describe 'P0 · Introspect budget (soft/hard ms + stages_skipped)' do
+    it 'defines INTROSPECT_SOFT_MS < INTROSPECT_HARD_MS' do
+      expect(learning::INTROSPECT_SOFT_MS).to be < learning::INTROSPECT_HARD_MS
+      expect(learning::INTROSPECT_SOFT_MS).to be_between(500, 10_000)
+    end
+
+    it 'auto_introspect returns stages_skipped and respects hard budget' do
+      @agent_cfg[:auto_introspect] = true
+      # Force over_hard by collapsing thresholds
+      stub_const('PWN::AI::Agent::Learning::INTROSPECT_SOFT_MS', 0)
+      stub_const('PWN::AI::Agent::Learning::INTROSPECT_HARD_MS', 0)
+      allow(loop_mod).to receive(:budget_exhaustion_hot?).and_return(false)
+
+      sid = 'spec_budget_introspect'
+      dir = File.join(@tmp, 'sessions')
+      FileUtils.mkdir_p(dir)
+      payload = [
+        { role: 'user', content: 'uname -a', timestamp: Time.now.utc.iso8601 },
+        { role: 'assistant', content: 'Linux kali', timestamp: Time.now.utc.iso8601 }
+      ].map { |h| JSON.generate(h) }.join("\n")
+      File.write(File.join(dir, "#{sid}.jsonl"), "#{payload}\n")
+
+      r = learning.auto_introspect(session_id: sid, request: 'uname -a', final: 'Linux kali')
+      expect(r).to be_a(Hash)
+      expect(r).to have_key(:stages_run)
+      expect(r).to have_key(:stages_skipped)
+      expect(r[:stages_skipped]).to include(:prm) # hard skip
+      expect(r[:elapsed_ms]).to be_a(Numeric)
+    end
+  end
+
+  describe 'P1 · Local judge calibration (shrinkage + confidence)' do
+    it 'heuristic judge returns confidence and shrinks extreme local scores' do
+      v = reward.judge(
+        request: 'what is the kernel',
+        final: 'The Linux kernel is a monolithic unix-like kernel used by kali.',
+        trace: [],
+        proxy_ok: true,
+        commit: false
+      )
+      expect(v[:source].to_s).to eq('heuristic')
+      expect(v[:confidence]).to be <= 0.5
+      expect(v).to have_key(:score_raw)
+      # local + no-trace cap pulls highs down
+      expect(v[:score]).to be <= 0.45 if v[:score_raw].to_f >= 0.6
+      expect(v[:rationale].to_s).to match(/P1:local_no_trace_cap|heuristic/)
+    end
+
+    it 'Metrics.effective_rate scales distrust by judge_confidence' do
+      # establish proxy success
+      10.times { metrics.record(name: 'shell', success: true, duration: 0.01) }
+      # high judge scores but low confidence (heuristic)
+      8.times { metrics.record_judge(name: 'shell', score: 0.2, confidence: 0.35) }
+      allow(metrics).to receive(:proxy_trust).and_return(0.3) # distrust 0.7
+      rate = metrics.effective_rate(name: 'shell')
+      conf = metrics.judge_confidence(name: 'shell')
+      expect(conf).to be_within(0.05).of(0.35)
+      # With conf=0.35, eff_d = 0.7*0.35 = 0.245 — still blended, not pure judge
+      # pure judge would be ~0.2; pure proxy ~1.0; blend must sit between
+      expect(rate).to be > 0.2
+      expect(rate).to be < 1.0
+    end
+  end
+
+  describe 'P1 · Practice outer KPI (practice_kpi + repeating_trend)' do
+    it 'practice_kpi snapshots repeating counts and writes KPI_FILE' do
+      mistakes.record(tool: 'agent_loop', error: 'iteration budget exhausted without a final answer')
+      3.times { mistakes.record(tool: 'agent_loop', error: 'iteration budget exhausted without a final answer') }
+      r = curriculum.practice_kpi(results: [{ resolved: true, mean_score: 0.8 }])
+      expect(r[:repeating_n]).to be >= 1
+      expect(r[:budget_repeating_n]).to be >= 1
+      expect(r[:practiced]).to eq 1 # len(results) recorded tonight
+      expect(r[:resolved_tonight]).to eq 1
+      expect(File.exist?(curriculum::KPI_FILE)).to eq(true)
+      expect(r[:trend]).to be_a(Hash)
+    end
+
+    it 'repeating_trend reports baseline then delta across snapshots' do
+      curriculum.practice_kpi(results: [])
+      # bump repeating by recording more
+      4.times { mistakes.record(tool: 'assistant_answer', error: 'critic: [pwn-ai] iteration budget exhausted') }
+      curriculum.practice_kpi(results: [])
+      t = curriculum.repeating_trend
+      expect(t[:samples]).to be >= 2
+      expect(t).to have_key(:delta_repeating)
+      expect(%i[improving flat regressing baseline]).to include(t[:status])
+    end
+  end
+
+  describe 'P2 · PRM sample efficiency (PRM_MIN_N / fleet coverage)' do
+    it 'prm_advantage is 0 until n >= PRM_MIN_N then applies shrinkage' do
+      expect(metrics::PRM_MIN_N).to eq 5
+      expect(metrics::PRM_FULL_N).to eq 20
+      4.times { metrics.record_step_reward(name: 'shell', reward: 1.0) }
+      expect(metrics.prm_n(name: 'shell')).to eq 4
+      expect(metrics.prm_advantage(name: 'shell')).to eq 0.0
+      metrics.record_step_reward(name: 'shell', reward: 1.0)
+      expect(metrics.prm_n(name: 'shell')).to eq 5
+      # single-tool zero-variance → damp*shrink keeps |adv| small but defined
+      adv = metrics.prm_advantage(name: 'shell')
+      expect(adv).to be_a(Numeric)
+    end
+
+    it 'Registry.rank drops PRM delta until ≥3 tools are PRM-ready' do
+      # only 1 tool ready → delta 0; rank still returns by keyword
+      10.times { metrics.record_step_reward(name: 'shell', reward: 1.0) }
+      expect(metrics.prm_n(name: 'shell')).to be >= metrics::PRM_MIN_N
+      ranked = registry.rank(query: 'run a shell command on the host')
+      expect(ranked.map(&:name)).to include('shell')
+      # spin up 3 ready tools — rank path must not raise
+      %w[shell memory_recall sessions_list].each do |n|
+        10.times { metrics.record_step_reward(name: n, reward: 0.5) }
+      end
+      expect do
+        registry.rank(query: 'run a shell command on the host')
+      end.not_to raise_error
+    end
+  end
+
+  describe 'P2 · STATUS table is the flag authority (no archaeology)' do
+    it 'Reinforcement-Learning.md ships a Design-priority STATUS section' do
+      doc_path = File.expand_path('../../documentation/Reinforcement-Learning.md', __dir__)
+      expect(File.exist?(doc_path)).to eq(true), "missing #{doc_path}"
+      doc = File.read(doc_path)
+      expect(doc).to match(/Design-priority STATUS/)
+      expect(doc).to match(/generator_mix/)
+      expect(doc).to match(/INTROSPECT_SOFT_MS/)
+      expect(doc).to match(/practice_kpi/)
+      expect(doc).to match(/PRM_MIN_N/)
+    end
+  end
+
+  # Design-priority ops closure — make STATUS success criteria reachable on-host
+  describe 'P0 ops · nightly diet close + shape backfill + mix in prompt' do
+    it 'infer_shape tags legacy winning_trace-like chosen sides' do
+      row = {
+        source: 'mistakes_resolve',
+        chosen: "shell → {\"success\":true}\npwn_eval → ok\n#{'x' * 80}",
+        rejected: "failed earlier #{'y' * 80}",
+        shape: ''
+      }
+      s = reward.infer_shape(row: row)
+      expect(s).to eq('winning_trace')
+    end
+
+    it 'infer_shape tags long critic revisions as revised_answer' do
+      row = {
+        source: 'critic',
+        chosen: 'A' * 250,
+        rejected: 'B' * 100,
+        shape: nil
+      }
+      expect(reward.infer_shape(row: row)).to eq('revised_answer')
+    end
+
+    it 'scrub_preferences backfills shape on kept rows when dry_run:false path runs over tmp' do
+      # exercise infer_shape + usable path without rewriting the live ledger
+      raw = {
+        source: 'curriculum',
+        prompt: 'finish under 5 tools',
+        rejected: "iteration budget exhausted #{'z' * 80}",
+        chosen: "shell → ok\nmemory_recall → hit\n#{'w' * 100}",
+        shape: ''
+      }
+      expect(reward.usable_preference?(row: raw.merge(shape: 'winning_trace'))).to eq(true)
+      inferred = reward.infer_shape(row: raw)
+      expect(reward::TRAJECTORY_SHAPES).to include(inferred)
+    end
+
+    it 'offline_judge return hash reserves scrub/generator_mix/practice_kpi keys' do
+      # dry structural contract: method source must call scrub + mix + kpi
+      src = begin
+        File.read(curriculum.instance_method(:offline_judge).source_location.first)
+      rescue StandardError
+        File.read('lib/pwn/ai/agent/curriculum.rb')
+      end
+      expect(src).to match(/scrub_preferences/)
+      expect(src).to match(/generator_mix/)
+      expect(src).to match(/practice_kpi/)
+    end
+
+    it 'Metrics.to_context surfaces W1 MIX when generator_mix is unhealthy' do
+      allow(reward).to receive(:generator_mix).and_return(
+        n: 20, healthy: false, trajectory_fraction: 0.1,
+        urgent: %w[critic counterfactual], suppress: %w[mistakes_resolve],
+        recommendation: 'boost:critic,counterfactual'
+      )
+      # ensure at least one metrics row so to_context is non-empty
+      metrics.record(name: 'shell', success: true, duration: 0.01) if metrics.respond_to?(:record)
+      ctx = metrics.to_context(limit: 3)
+      expect(ctx).to match(/W1 MIX:/)
+      expect(ctx).to match(/boost:critic/)
+    end
+  end
+
+  describe 'P0 · Budget exhaust deepen (last-iter / no-CF-hot / exhaust Learning)' do
+    it 'tightens budget-hot max_iters caps to 8 local / 12 remote' do
+      src = File.read(loop_mod.method(:run).source_location.first)
+      # max_iters is private_class_method — read surrounding source
+      expect(src).to match(/ollama \? 8 : 12/)
+      expect(src).to match(/budget_exhaustion_hot\?/)
+    end
+
+    it 'forces tools=nil on last iter and skips counterfactual when budget-hot' do
+      src = File.read(loop_mod.method(:run).source_location.first)
+      expect(src).to match(/FINAL ITERATION/)
+      expect(src).to match(/last_iter \? nil : tools/)
+      # CF gate requires !budget_exhaustion_hot?
+      expect(src).to match(/!budget_exhaustion_hot\?/)
+      expect(src).to match(/Curriculum\.counterfactual/)
+    end
+
+    it 'exhaust path appends session + auto_introspect (not bare string only)' do
+      src = File.read(loop_mod.method(:run).source_location.first)
+      idx = src.index('shape: :budget_exhausted')
+      expect(idx).not_to be_nil
+      tail = src[idx, 800]
+      expect(tail).to match(/append_session/)
+      expect(tail).to match(/auto_introspect/)
+      expect(tail).to match(/final_msg/)
+    end
+
+    it 'STATUS table lists Budget exhaust deepen' do
+      doc = File.read(File.expand_path('../../documentation/Reinforcement-Learning.md', __dir__))
+      expect(doc).to match(/Budget exhaust deepen/)
+      expect(doc).to match(/Last-iter force-final/)
+    end
+  end
 end
 # rubocop:enable Metrics/BlockLength

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

@@ -1,10 +1,48 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require 'json'
 
 describe 'PWN::AI::Agent::Tools ruby_eval' do
-  it 'registers the pwn_eval tool' do
+  before(:all) do
     PWN::AI::Agent::Registry.discover
+  end
+
+  it 'registers the pwn_eval tool' do
     expect(PWN::AI::Agent::Registry.lookup(name: 'pwn_eval')).not_to be_nil
   end
+
+  it 'returns structured error for SyntaxError payloads (constant block param)' do
+    entry = PWN::AI::Agent::Registry.lookup(name: 'pwn_eval')
+    result = entry.handler.call(code: 'results = probes.map do |R|')
+    expect(result).to be_a(Hash)
+    expect(result[:error]).to match(/SyntaxError/)
+    expect(result[:error]).to match(/\(pwn_eval\)/)
+    expect(result[:error]).not_to match(/ruby_eval\.rb:49/)
+    expect(result[:hint]).to match(/\|r\| not \|R\|/)
+  end
+
+  it 'evaluates valid code and returns stdout + value' do
+    entry = PWN::AI::Agent::Registry.lookup(name: 'pwn_eval')
+    result = entry.handler.call(code: '1 + 1')
+    expect(result[:error]).to be_nil
+    expect(result[:value]).to eq('2')
+  end
+
+  it 'Dispatch.call JSON-wraps syntax errors instead of raising' do
+    out = PWN::AI::Agent::Dispatch.call(
+      tool_call: {
+        id: 't1',
+        type: 'function',
+        function: {
+          name: 'pwn_eval',
+          arguments: JSON.generate(code: 'results = probes.map do |R|')
+        }
+      }
+    )
+    parsed = JSON.parse(out, symbolize_names: true)
+    # handler now rescues → success:true with error key in result
+    expect(parsed[:success]).to eq(true)
+    expect(parsed[:result][:error]).to match(/SyntaxError/)
+  end
 end

data/third_party/pwn_rdoc.jsonl

@@ -20,7 +20,7 @@
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Curriculum.build_eval_set Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Curriculum.build_eval_set`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Curriculum.build_telemetry Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Curriculum.build_telemetry`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Curriculum.bump_cooldown! Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Curriculum.bump_cooldown!`: "}]}
-{"messages":[{"role":"user","content":"PWN::AI::Agent::Curriculum.calibrate Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Curriculum.calibrate`: Supported Method Parameters\n\nPWN::AI::Agent::Curriculum.calibrate(predicted:, actual:, engine:)\n"}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Curriculum.calibrate Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Curriculum.calibrate`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Curriculum.counterfactual Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Curriculum.counterfactual`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Curriculum.critic Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Curriculum.critic`: Supported Method Parameters\n\nv = PWN::AI::Agent::Curriculum.critic(\n\nrequest: 'required - user request',\nfinal: 'required - candidate final answer',\nsession_id: 'optional - for evidence lookup'\n\n)\n\nReturns { verdict: :pass|:flaw, flaw:, confidence: }. On :flaw the (final, flaw) pair is recorded as a preference so a future self-correction becomes DPO signal.\n"}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Curriculum.critic_text_only Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Curriculum.critic_text_only`: "}]}
@@ -39,12 +39,14 @@
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Curriculum.offline_judge Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Curriculum.offline_judge`: Supported Method Parameters\n\nr = PWN::AI::Agent::Curriculum.offline_judge(\n\nsince_hours: 'optional - lookback window (default 24)',\nlimit: 'optional - max sessions to score (default 40)',\nprm: 'optional - also run Process Reward Model (default true)',\ncommit: 'optional - write scores into learning/sentinel (default true)'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Curriculum.ollama_create Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Curriculum.ollama_create`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Curriculum.practice Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Curriculum.practice`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Curriculum.practice_kpi Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Curriculum.practice_kpi`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Curriculum.practice_skip? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Curriculum.practice_skip?`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Curriculum.preference_balance Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Curriculum.preference_balance`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Curriculum.preference_diet_gate Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Curriculum.preference_diet_gate`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Curriculum.python_site_package_roots Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Curriculum.python_site_package_roots`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Curriculum.red_team_plan Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Curriculum.red_team_plan`: Supported Method Parameters\n\nhint = PWN::AI::Agent::Curriculum.red_team_plan(\n\nrequest: 'required - user goal',\nplan: 'required - numbered plan text from plan_first'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Curriculum.reflect_available? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Curriculum.reflect_available?`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Curriculum.repeating_trend Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Curriculum.repeating_trend`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Curriculum.replay_on Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Curriculum.replay_on`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Curriculum.replay_on_detailed Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Curriculum.replay_on_detailed`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Curriculum.revise_after_flaw Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Curriculum.revise_after_flaw`: "}]}
@@ -258,6 +260,7 @@
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Learning.auto_introspect Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Learning.auto_introspect`: Supported Method Parameters\n\nPWN::AI::Agent::Learning.auto_introspect(\n\nsession_id: 'required - id of the just-completed session',\nrequest: 'optional - original user request (for outcome logging)',\nfinal: 'optional - final assistant answer (for outcome logging)'\n\n)\n\nCalled by Loop.run when PWN::Env[:agent] is truthy. Never raises — learning must not break the primary loop.\n"}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Learning.auto_introspect_enabled? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Learning.auto_introspect_enabled?`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Learning.build_skill_from_session Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Learning.build_skill_from_session`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Learning.checkable_claim? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Learning.checkable_claim?`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Learning.compress_exemplar Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Learning.compress_exemplar`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Learning.compress_finetune_trace Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Learning.compress_finetune_trace`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Learning.consolidate Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Learning.consolidate`: Supported Method Parameters\n\nremoved = PWN::AI::Agent::Learning.consolidate(\n\nmax_entries: 'optional - hard cap on PWN::Memory size (default MAX_MEMORY_ENTRIES)'\n\n)\n\nDeduplicates near-identical lesson values and prunes the oldest entries once the cap is exceeded so the injected MEMORY block stays high-signal.\n"}]}
@@ -265,7 +268,7 @@
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Learning.exemplars_for Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Learning.exemplars_for`: Supported Method Parameters\n\nmsgs = PWN::AI::Agent::Learning.exemplars_for(\n\nrequest: 'required - current user request',\nlimit: 'optional - max exemplar traces to return (default 1)',\nmax_msgs: 'optional - cap on messages per exemplar (default 6)'\n\n)\n\nRetrieval-augmented BEHAVIOUR: keyword-matches request against prior successful outcomes in learning.jsonl, loads the matching session, and compresses its (user, tool, assistant) trace into a short few-shot exemplar Loop.run splices between system and user. Local models are dramatically better with 1 concrete example than with 25 abstract lessons.\n"}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Learning.export_finetune Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Learning.export_finetune`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Learning.fact_check_local_final Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Learning.fact_check_local_final`: "}]}
-{"messages":[{"role":"user","content":"PWN::AI::Agent::Learning.flip_last_outcome Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Learning.flip_last_outcome`: Supported Method Parameters\n\nPWN::AI::Agent::Learning.flip_last_outcome(\n\nsession_id: 'optional - only flip if the newest outcome belongs to this session',\nreason: 'optional - why it is being flipped (usually the user correction text)'\n\n)\n\nRewrites the most-recently-appended learning.jsonl entry from success:true to success:false. Called by Mistakes.check_user_correction when the user’s next message rejects the previous answer, so the 100 %-success illusion is broken and the failure enters the corpus.\n"}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Learning.flip_last_outcome Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Learning.flip_last_outcome`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Learning.fold_judge_into_metrics Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Learning.fold_judge_into_metrics`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Learning.help Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Learning.help`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Learning.heuristic_lessons Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Learning.heuristic_lessons`: "}]}
@@ -316,9 +319,11 @@
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Metrics.effective_rate Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Metrics.effective_rate`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Metrics.gamma_sample Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Metrics.gamma_sample`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Metrics.help Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Metrics.help`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Metrics.judge_confidence Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Metrics.judge_confidence`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Metrics.judge_rate Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Metrics.judge_rate`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Metrics.load Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Metrics.load`: Supported Method Parameters\n\nmetrics = PWN::AI::Agent::Metrics.load\n"}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Metrics.prm_advantage Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Metrics.prm_advantage`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Metrics.prm_n Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Metrics.prm_n`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Metrics.proxy_trust Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Metrics.proxy_trust`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Metrics.record Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Metrics.record`: Supported Method Parameters\n\nPWN::AI::Agent::Metrics.record(\n\nname: 'required - tool name that was dispatched',\nsuccess: 'required - Boolean, did the handler complete without error',\nduration: 'optional - Float seconds the dispatch took',\nerror: 'optional - String error message when success is false',\nengine: 'optional - Symbol/String AI engine that chose this tool (segments telemetry)'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Metrics.record_calibration Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Metrics.record_calibration`: Supported Method Parameters\n\nPWN::AI::Agent::Metrics.record_calibration(predicted:, actual:, brier:, engine:)\n\nW3 — plan_first emits p(success); Loop.run calls this with the realised outcome. Tracked per-engine so calibration of the local LoRA vs frontier is comparable.\n"}]}
@@ -399,9 +404,11 @@
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Reward.export_dpo Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Reward.export_dpo`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Reward.extract_cmd Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Reward.extract_cmd`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Reward.fold_step_reward_to_metrics Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Reward.fold_step_reward_to_metrics`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Reward.generator_mix Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Reward.generator_mix`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Reward.help Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Reward.help`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Reward.heuristic_judge Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Reward.heuristic_judge`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Reward.heuristic_prm Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Reward.heuristic_prm`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Reward.infer_shape Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Reward.infer_shape`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Reward.judge Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Reward.judge`: Supported Method Parameters\n\nv = PWN::AI::Agent::Reward.judge(\n\nrequest: 'required - original user request',\nfinal: 'required - assistant final answer',\nsession_id: 'optional - PWN::Sessions id (adds tool trace)',\ntrace: 'optional - Array of tool-result strings (overrides session_id)',\ncommit: 'optional - write score into learning.jsonl / sentinel (default true)'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Reward.llm_judge Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Reward.llm_judge`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Reward.llm_prm Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Reward.llm_prm`: "}]}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pwn
 version: !ruby/object:Gem::Version
-  version: 0.5.647
+  version: 0.5.650
 platform: ruby
 authors:
 - 0day Inc.