pwn 0.5.680 → 0.5.682

data/lib/pwn/config.rb

@@ -160,7 +160,7 @@ module PWN
             # LLM tangible-task decomposition for autonomous goals (default on).
             task_summary_llm: nil,
             tool_router: nil, # nil = auto (true when :active is local :ollama/:openwebui) — cuts ~11k→~3k schema tokens
-            tool_preference: %w[memory_recall sessions_view pwn_eval shell mistakes_record mistakes_resolve learning_note_outcome memory_remember],
+            tool_preference: %w[memory_recall pwn_eval shell mistakes_record mistakes_resolve learning_note_outcome memory_remember],
             escalation_persona: 'escalator', # Swarm persona for frontier corrective hints when a local model is stuck
             # sample E3 verify_as_reward: true|false|nil(auto: ~10% local / always frontier when CLAIM_RX hits)
             verify_as_reward: nil,

data/lib/pwn/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PWN
-  VERSION = '0.5.680'
+  VERSION = '0.5.682'
 end

data/spec/integration/prompt_builder_spec.rb

@@ -29,14 +29,16 @@ RSpec.describe 'PWN::AI::Agent::PromptBuilder', :aggregate_failures do
     PWN::Env[:ai] = { active: :anthropic, module_reflection: false, agent: @agent_cfg }
   end
 
-  it 'contains every section header, session_id and PWN::VERSION' do
-    prompt = builder.build(session_id: 'sess_abc')
-    ['ENVIRONMENT', 'MEMORY', 'SKILLS', 'LEARNING', 'KNOWN MISTAKES', 'TOOL EFFECTIVENESS', 'EXTROSPECTION', 'TOOL USE'].each do |hdr|
+  it 'mid-turn autonomous prompt keeps request + CORE_TOOLS + known-fix, not the full harness' do
+    prompt = builder.build(session_id: 'sess_abc', request: 'Write hello into /tmp/x and verify it')
+    ['ENVIRONMENT', 'KNOWN MISTAKES', 'TOOL USE'].each do |hdr|
       expect(prompt).to include(hdr), "missing section: #{hdr}"
     end
     expect(prompt).to include('session_id : sess_abc')
     expect(prompt).to include(PWN::VERSION)
-    expect(prompt).to include('prompt builder marker')
+    ['MEMORY', 'SKILLS', 'LEARNING', 'TOOL EFFECTIVENESS', 'EXTROSPECTION', 'POLICY'].each do |hdr|
+      expect(prompt).not_to include(hdr), "mid-turn prompt still injects #{hdr}"
+    end
   end
 
   it 'never leaks a raw nil or an unrendered #{...} interpolation' do

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

@@ -54,6 +54,44 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
       expect(src.scan('inject_task_focus!').length).to be >= 3
     end
 
+    it 'does not keep injecting English focus after the plan is covered' do
+      src = File.read(described_class.method(:inject_task_focus!).source_location.first)
+      focus = src[/private_class_method def self\.inject_task_focus!.*?private_class_method def self\.\w+/m]
+      focus ||= src
+      expect(focus).to match(/plan_open\?/)
+    end
+
+    it 'does not tell an open English plan to stop after 3 tools just because budget is hot' do
+      src = File.read(described_class.method(:run).source_location.first)
+      expect(src).to match(/budget_exhaustion_hot\?/)
+      expect(src).to match(/plan_open\?/)
+      # local ≤3-tool abort is only for a closed/short plan, not mid-goal.
+      expect(src).to match(/english_open|plan_open\?/)
+    end
+
+    it 'parks stale extra budget scars even while the host is hot' do
+      tmp = Dir.mktmpdir
+      stub_const('PWN::AI::Agent::Mistakes::MISTAKES_FILE', File.join(tmp, 'mistakes.json'))
+      PWN::AI::Agent::Mistakes.reset if PWN::AI::Agent::Mistakes.respond_to?(:reset)
+      a = PWN::AI::Agent::Mistakes.record(
+        tool: 'agent_loop',
+        error: '[pwn-ai] iteration budget exhausted A',
+        shape: 'budget_exhausted'
+      )
+      b = PWN::AI::Agent::Mistakes.record(
+        tool: 'agent_loop',
+        error: '[pwn-ai] iteration budget exhausted B',
+        shape: 'budget_exhausted'
+      )
+      described_class.send(:maybe_park_budget_scars!)
+      parked_n = [a, b].count do |m|
+        PWN::AI::Agent::Mistakes.find(signature: m[:signature])[:parked]
+      end
+      expect(parked_n).to be >= 1
+    ensure
+      FileUtils.remove_entry(tmp) if tmp && Dir.exist?(tmp)
+    end
+
     it 're-ranks Registry tools from English tangible tasks after plan (sole driver)' do
       src = File.read(described_class.method(:run).source_location.first)
       expect(src).to match(/TaskSummarizer\.relevance_query/)
@@ -82,7 +120,7 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
 
       last_plan = { plan: %w[identify implement verify], plan_idx: 2 }
       msgs_mut = msgs + [
-        { role: 'tool', content: '{"success":true,"result":{"stdout":"0 offenses detected"}}' }
+        { role: 'tool', content: '{"success":true,"result":{"stdout":"patched loop.rb\n0 offenses detected"}}' }
       ]
       r_mut = loop_mod.send(
         :evidence_enough_to_finalize?,
@@ -98,10 +136,199 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
       )
       expect(r_bare).to be false
 
+      # plan_idx on last item is not enough if mutate/verify English tasks lack evidence
+      r_idx_only = loop_mod.send(
+        :evidence_enough_to_finalize?,
+        messages: msgs, turn_fails: {}, i: 5, max_iters: 40,
+        request: 'fix p17', plan_steps: 3, ts_state: last_plan
+      )
+      expect(r_idx_only).to be false
+
       # call site must pass ts_state
       src = File.read(loop_mod.method(:run).source_location.first)
       expect(src).to match(/evidence_enough_to_finalize\?\([\s\S]*?ts_state: ts_state/)
-      expect(src).to match(/English-task gate/)
+      expect(src).to match(/original request|request is the completion/i)
+    end
+
+    it 'P17 does not inject finalize while implement/verify English tasks remain open' do
+      loop_mod = described_class
+      ls_find = [
+        { role: 'user', content: 'map then implement then verify' },
+        { role: 'tool', name: 'shell', content: '{"success":true,"result":{"stdout":"ls: loop.rb","exit":0}}' },
+        { role: 'tool', name: 'shell', content: '{"success":true,"result":{"stdout":"find: task_summarizer.rb","exit":0}}' },
+        { role: 'tool', name: 'shell', content: '{"success":true,"result":{"stdout":"resolved file listing","exit":0}}' }
+      ]
+      mid = {
+        plan: [
+          'Map how tasks complete',
+          'Implement the completion fix',
+          'Verify full task completion end-to-end'
+        ],
+        plan_idx: 0
+      }
+
+      r_active = loop_mod.send(
+        :evidence_enough_to_finalize?,
+        messages: ls_find, turn_fails: {}, i: 4, max_iters: 40,
+        request: 'map then implement then verify', plan_steps: 3, ts_state: mid
+      )
+      expect(r_active).to be false
+
+      jumped = mid.merge(plan_idx: 2)
+      r_jumped = loop_mod.send(
+        :evidence_enough_to_finalize?,
+        messages: ls_find, turn_fails: {}, i: 4, max_iters: 40,
+        request: 'map then implement then verify', plan_steps: 3, ts_state: jumped
+      )
+      expect(r_jumped).to be false
+      expect(
+        PWN::AI::Agent::TaskSummarizer.plan_open?(state: jumped, messages: ls_find)
+      ).to eq true
+      left = PWN::AI::Agent::TaskSummarizer.unfinished_tasks(state: jumped, messages: ls_find)
+      expect(left.map { |t| t[:item] }.join(' ')).to match(/Implement|Verify/i)
+
+      src = File.read(loop_mod.method(:run).source_location.first)
+      expect(src).to match(/Write the complete final answer now/)
+      expect(src).to match(/evidence_enough_to_finalize\?/)
+      expect(src).to match(/Do NOT call more tools/)
+    end
+
+    it 'P17 can early-final when English tasks are covered even if plan_idx is still 0' do
+      loop_mod = described_class
+      done = {
+        plan: [
+          'Determine the local hostname',
+          'Present the result and report completion'
+        ],
+        plan_idx: 0
+      }
+      msgs = [
+        { role: 'user', content: 'what is my hostname?' },
+        { role: 'tool', name: 'shell', content: '{"success":true,"result":{"stdout":"kali-box","exit":0}}' },
+        { role: 'tool', name: 'shell', content: '{"success":true,"result":{"stdout":"kali-box","exit":0}}' }
+      ]
+      expect(
+        PWN::AI::Agent::TaskSummarizer.plan_open?(state: done, messages: msgs)
+      ).to eq false
+      r = loop_mod.send(
+        :evidence_enough_to_finalize?,
+        messages: msgs, turn_fails: {}, i: 4, max_iters: 40,
+        request: 'what is my hostname?', plan_steps: 2, ts_state: done
+      )
+      expect(r).to be true
+    end
+
+    it 'P17 can early-final a finished request even while advisory English tasks remain' do
+      loop_mod = described_class
+      leftover_plan = {
+        plan: [
+          'Determine the local hostname',
+          'run rspec to verify'
+        ],
+        plan_idx: 0
+      }
+      msgs = [
+        { role: 'user', content: 'what is my hostname?' },
+        { role: 'tool', name: 'shell', content: '{"success":true,"result":{"stdout":"kali-box","exit":0}}' },
+        { role: 'tool', name: 'shell', content: '{"success":true,"result":{"stdout":"kali-box","exit":0}}' }
+      ]
+      expect(
+        PWN::AI::Agent::TaskSummarizer.plan_open?(state: leftover_plan, messages: msgs)
+      ).to eq true
+      r = loop_mod.send(
+        :evidence_enough_to_finalize?,
+        messages: msgs, turn_fails: {}, i: 4, max_iters: 40,
+        request: 'what is my hostname?', plan_steps: 2, ts_state: leftover_plan
+      )
+      expect(r).to be true
+    end
+
+    it 'open_plan_blocks_final? does not govern completion — the original request does' do
+      src = File.read(described_class.method(:run).source_location.first)
+      expect(src).to match(/original request is the completion signal/i)
+      expect(src).not_to match(/if open_plan_blocks_final\?/)
+    end
+
+    it 'request_unsatisfied? uses request-shaped evidence, not just mutation regex' do
+      ls_only = [
+        { role: 'user', content: 'write complete into /tmp/x.txt and verify it' },
+        {
+          role: 'assistant',
+          tool_calls: [
+            { function: { name: 'shell', arguments: '{"command":"ls /tmp"}' } }
+          ]
+        },
+        { role: 'tool', name: 'shell', content: '{"success":true,"result":{"stdout":"x","exit":0}}' }
+      ]
+      expect(
+        described_class.send(
+          :request_unsatisfied?,
+          request: 'Write complete into /tmp/x.txt and verify it reads complete',
+          messages: ls_only,
+          last_iter: false
+        )
+      ).to eq true
+      # Path-shaped write without the old printf/sed regex still satisfies the request.
+      written = ls_only + [
+        {
+          role: 'assistant',
+          tool_calls: [
+            { function: { name: 'shell', arguments: '{"command":"python3 -c \\"open(\'/tmp/x.txt\',\'w\').write(\'complete\')\\""}' } }
+          ]
+        },
+        {
+          role: 'tool',
+          name: 'shell',
+          content: '{"success":true,"result":{"stdout":"","stderr":"","exit":0}}'
+        }
+      ]
+      expect(
+        described_class.send(
+          :request_unsatisfied?,
+          request: 'Write complete into /tmp/x.txt and verify it reads complete',
+          messages: written,
+          last_iter: false
+        )
+      ).to eq false
+      expect(
+        described_class.send(
+          :request_unsatisfied?,
+          request: 'what is my hostname?',
+          messages: [
+            { role: 'tool', name: 'shell', content: '{"success":true,"result":{"stdout":"kali","exit":0}}' }
+          ],
+          last_iter: false
+        )
+      ).to eq false
+    end
+
+    it 'does not bounce world-knowledge asks that need no host work' do
+      expect(described_class.needs_host_work?(request: 'what color is a cherry')).to eq false
+      expect(described_class.world_knowledge?(request: 'what color is a cherry')).to eq true
+      expect(
+        described_class.send(
+          :request_unsatisfied?,
+          request: 'what color is a cherry',
+          messages: [{ role: 'assistant', content: 'Red.', tool_calls: [] }],
+          last_iter: false
+        )
+      ).to eq false
+      expect(described_class.needs_host_work?(request: 'Write hello into /tmp/x.txt')).to eq true
+    end
+
+    it 'last-iter strips tools only on the true last slot; leftover English tasks do not force required' do
+      src = File.read(described_class.method(:run).source_location.first)
+      expect(src).to match(/text_only_iters = 1/)
+      expect(src).not_to match(/english_open && hot/)
+      expect(src).to match(/has_tool_result \|\| !need_tools \? 'auto' : 'required'/)
+      expect(src).not_to match(/still_acting/)
+    end
+
+    it 'Loop.run default tool pool is CORE_TOOLS, not the full registry' do
+      src = File.read(described_class.method(:run).source_location.first)
+      expect(src).to match(/fetch\(:core_only,\s*true\)/)
+      expect(src).to match(/core_only:/)
+      expect(src).to match(/CORE_TOOLS/)
     end
 
     it 'does not put TaskSummarizer into Reward credit paths' do
@@ -120,9 +347,8 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
       expect(src).to match(/tool_calls_from_text/)
       expect(src).to match(/_text_tool_coerced/)
       expect(src).to match(/tool_choice/)
-      # stay required while monologue / unfinished; only auto when settled
-      expect(src).to match(/still_acting/)
-      expect(src).to match(/has_tool_result && !still_acting/)
+      # After the first tool result, auto. English leftovers do not keep required.
+      expect(src).to match(/has_tool_result \|\| !need_tools \? 'auto' : 'required'/)
       # normalize_llm must promote text tool forms
       expect(src).to match(/normalize_llm[\s\S]*tool_calls_from_text/m)
       expect(src).to match(/MONOLOGUE_TOOL_INTENT_RX/)
@@ -154,26 +380,16 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
       expect(described_class.request_intent(request: 'refactor Loop.run and run rubocop')).to eq(:act)
     end
 
-    it 'request_kind maps statement | question | autonomous_goal' do
-      expect(described_class).to respond_to :request_kind
-      expect(described_class.request_kind(request: 'FYI the build is green.')).to eq(:statement)
-      expect(described_class.request_kind(request: 'how to do a ping sweep with hping3?')).to eq(:question)
-      expect(described_class.request_kind(request: 'what did I just say?')).to eq(:question)
-      expect(described_class.request_kind(request: 'hi')).to eq(:statement)
-      expect(described_class.request_kind(request: 'refactor Loop.run and run rubocop')).to eq(:autonomous_goal)
-      expect(described_class.request_kind(request: 'using hping3 what live hosts can you find in this subnet?')).to eq(:autonomous_goal)
-      # Live host-fact Qs need tools — not text-only question path.
-      expect(described_class.request_kind(request: 'what is my hostname?')).to eq(:autonomous_goal)
-      expect(described_class.request_kind(request: 'excellent - what is my hostname?')).to eq(:autonomous_goal)
+    it 'does not classify request types — Loop has no request_kind' do
+      expect(described_class).not_to respond_to :request_kind
     end
 
-    it 'run short-circuits statement/question but not host-evidence goals' do
+    it 'run does not short-circuit statement/question — they take the full tool loop' do
       src = File.read(described_class.method(:run).source_location.first)
-      expect(src).to match(/kind\.to_sym == :statement/)
-      expect(src).to match(/kind\.to_sym == :question/)
-      expect(src).to match(/needs_breakdown/)
-      expect(src).to match(/answer_statement/)
-      expect(src).to match(/answer_question/)
+      expect(src).not_to match(/kind\.to_sym == :statement/)
+      expect(src).not_to match(/kind\.to_sym == :question/)
+      expect(src).not_to match(/Request type/)
+      expect(src).to match(/Every request gets a task compass/)
     end
 
     it 'classifies pure prior-turn recall and vague memory cues as :recall' do
@@ -214,13 +430,10 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
     it 'run short-circuits how-to without plan_first or tools' do
       src = File.read(described_class.method(:run).source_location.first)
       expect(src).to match(/request_intent/)
-      expect(src).to match(/request_kind/)
+      expect(src).not_to match(/request_kind/)
       expect(src).to match(/answer_howto/)
-      expect(src).to match(/answer_statement/)
-      expect(src).to match(/answer_question/)
       expect(src).to match(/intent == :howto/)
       expect(src).to match(/skip_plan/)
-      expect(src).to match(/needs_breakdown/)
     end
 
     it 'answer_howto does not register shell tool use in source path' do
@@ -235,8 +448,7 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
       expect(src).to match(/answer_recall/)
       expect(src).to match(/intent == :recall.*?return answer_recall/m)
       expect(src).to match(/skip_plan/)
-      expect(src).to match(/request_kind/)
-      expect(src).to match(/needs_breakdown|autonomous_goal|statement|question/)
+      expect(src).not_to match(/request_kind/)
     end
 
     it 'run short-circuits greetings via answer_greeting before plan_first' do
@@ -245,8 +457,7 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
       expect(src).to match(/answer_greeting/)
       expect(src).to match(/intent == :greeting.*?return answer_greeting/m)
       expect(src).to match(/skip_plan/)
-      expect(src).to match(/request_kind/)
-      expect(src).to match(/needs_breakdown|autonomous_goal|statement|question/)
+      expect(src).not_to match(/request_kind/)
     end
 
     it 'answer_greeting returns fixed ack without weather echo or tools' do
@@ -474,16 +685,23 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
     end
   end
 
+  it 'Loop.run finishes the original request; English tasks are advisory only' do
+    src = File.read(described_class.method(:run).source_location.first)
+    expect(src).to match(/original request is the completion signal/i)
+    expect(src).not_to match(/do NOT finalize/i)
+    expect(src).not_to match(/if open_plan_blocks_final\?/)
+  end
+
   it 'Loop.run marks the Hermes user-path so TurnFinalizer can defer' do
     src = File.read(described_class.method(:run).source_location.first)
     expect(src).to match(/TurnFinalizer\.enter_user_path!/)
     expect(src).to match(/TurnFinalizer\.leave_user_path!/)
   end
 
-  it 'should_auto_introspect skips cheap greeting/question/statement answers' do
+  it 'should_auto_introspect skips cheap greeting/howto/recall answers' do
     src = File.read(described_class.method(:run).source_location.first)
     expect(src).to include('return false if %i[greeting howto recall].include?(intent)')
-    expect(src).to include('return false if kind == :statement')
-    expect(src).to include('return false if kind == :question && fails.zero?')
+    expect(src).not_to include('return false if kind == :statement')
+    expect(src).not_to include('return false if kind == :question && fails.zero?')
   end
 end # rubocop:enable Metrics/BlockLength

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

@@ -170,4 +170,18 @@ describe PWN::AI::Agent::Mistakes do
     expect(out[:extinguished]).to be >= 1
     expect(described_class.find(signature: m[:signature])[:resolved]).to be true
   end
+
+  it 'to_context downranks budget-exhaustion scars on unrelated requests' do
+    stub_const('PWN::AI::Agent::Mistakes::MISTAKES_FILE', File.join(Dir.mktmpdir, 'mistakes.json'))
+    described_class.reset if described_class.respond_to?(:reset)
+    described_class.record(
+      tool: 'agent_loop',
+      error: '[pwn-ai] iteration budget exhausted',
+      shape: 'budget_exhausted'
+    )
+    described_class.record(tool: 'shell', error: 'nmpa: command not found unique-host')
+    ctx = described_class.to_context(request: 'what is my hostname?', limit: 2)
+    expect(ctx).to include('shell')
+    expect(ctx).not_to match(/iteration budget exhausted/)
+  end
 end

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

@@ -80,7 +80,11 @@ describe PWN::AI::Agent::Policy do
       kind: :autonomous_goal,
       request: 'fix the reward judge',
       engine: :grok,
-      ts_state: { plan: %w[inspect tighten verify], plan_idx: 2 },
+      ts_state: {
+        plan: %w[inspect tighten verify],
+        plan_idx: 2,
+        evidence_blob: 'inspected reward.rb patched judge 12 examples, 0 failures'
+      },
       final: 'The cheap ORM now grades the last tools and usable result.',
       score: 0.82
     )
@@ -91,6 +95,53 @@ describe PWN::AI::Agent::Policy do
     expect(open_s).not_to eq(done_s)
   end
 
+  it 'quality bin is not high while English tasks remain even if plan_idx is last' do
+    last_but_open = described_class.state(
+      kind: :autonomous_goal,
+      request: 'fix the reward judge',
+      engine: :grok,
+      ts_state: { plan: %w[inspect tighten verify], plan_idx: 2 }
+    )
+    expect(last_but_open).to include('|p')
+    expect(last_but_open).not_to include('|ph')
+  end
+
+  it 'observe_step credits English-task progress above bare tool-ok hygiene' do
+    tmp = Dir.mktmpdir
+    stub_const('PWN::AI::Agent::Policy::POLICY_FILE', File.join(tmp, 'policy.json'))
+    stub_const('PWN::AI::Agent::Policy::TRAJECTORY_FILE', File.join(tmp, 'policy_traj.jsonl'))
+    described_class.reset
+    allow(described_class).to receive(:enabled?).and_return(true)
+    PWN::Env[:ai] ||= {}
+    PWN::Env[:ai][:agent] ||= {}
+    PWN::Env[:ai][:agent][:policy] = true
+
+    ts = {
+      plan: ['locate the source', 'fix the truncation bug', 'run rspec to verify'],
+      plan_idx: 0,
+      evidence_blob: ''
+    }
+    described_class.begin_episode(
+      session_id: 'en_credit',
+      request: 'locate then fix',
+      kind: :autonomous_goal,
+      engine: :grok,
+      ts_state: ts
+    )
+    grind = described_class.observe_step(
+      action: 'shell', ok: true, session_id: 'en_credit', ts_state: ts
+    )
+    ts[:plan_idx] = 1
+    ts[:evidence_blob] = 'rg hit locate the source lib/task_summarizer.rb patched later'
+    advance = described_class.observe_step(
+      action: 'shell', ok: true, session_id: 'en_credit', ts_state: ts
+    )
+    expect(advance[:reward].to_f).to be > grind[:reward].to_f
+  ensure
+    described_class.reset
+    FileUtils.remove_entry(tmp) if tmp && Dir.exist?(tmp)
+  end
+
   it 'warmup! meets the episode budget so greedy suggestions appear' do
     tmp = Dir.mktmpdir
     stub_const('PWN::AI::Agent::Policy::POLICY_FILE', File.join(tmp, 'policy.json'))

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

@@ -64,16 +64,11 @@ describe PWN::AI::Agent::PromptBuilder do
     end
   end
 
-  describe 'Hermes skill-index prefix' do
-    it 'emits SKILLS before MEMORY so prompt-cache can pin the index' do
+  describe 'mid-turn lean prompt' do
+    it 'does not inject MEMORY/SKILLS/LEARNING/POLICY/EXTRO on a live goal' do
       src = File.read(described_class.method(:build).source_location.first)
-      skills_needle = ['#', '{skills_block}'].join
-      memory_needle = ['#', '{memory_block'].join
-      skills_at = src.index(skills_needle)
-      memory_at = src.index(memory_needle)
-      expect(skills_at).not_to be_nil
-      expect(memory_at).not_to be_nil
-      expect(skills_at).to be < memory_at
+      expect(src).to match(/KNOWN MISTAKES|mistakes_block/)
+      expect(src).to match(/stuck|expand_harness|lean/)
     end
   end
 end

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

@@ -13,9 +13,29 @@ describe PWN::AI::Agent::Registry do
     expect(help_response).to respond_to :help
   end
 
-  it 'DEFAULT_PREFERENCE is memory_recall, sessions_view, pwn_eval, shell, mistakes_record, mistakes_resolve, learning_note_outcome, memory_remember' do
+  it 'DEFAULT_PREFERENCE names only CORE_TOOLS in a recall-first fallback' do
     expect(described_class::DEFAULT_PREFERENCE).to eq(
-      %w[memory_recall sessions_view pwn_eval shell mistakes_record mistakes_resolve learning_note_outcome memory_remember]
+      %w[memory_recall pwn_eval shell mistakes_record mistakes_resolve learning_note_outcome memory_remember]
     )
+    expect(described_class::DEFAULT_PREFERENCE - described_class::CORE_TOOLS).to be_empty
+    expect(described_class::DEFAULT_PREFERENCE).not_to include('sessions_view')
+  end
+
+  it 'preference_order defaults to shell / pwn_eval — there is no request type' do
+    expect(described_class.preference_order.first(2)).to eq(%w[shell pwn_eval])
+    expect(described_class.preference_order(kind: :question).first(2)).to eq(%w[shell pwn_eval])
+  end
+
+  it 'preference_order still honors explicit empty list and Env override' do
+    expect(described_class.preference_order(order: [])).to eq([])
+    expect(described_class.preference_order(preference: %w[shell])).to eq(%w[shell])
+  end
+
+  it 'definitions(core_only: true) ships CORE_TOOLS, not the full ~85 schema set' do
+    described_class.discover
+    names = described_class.definitions(core_only: true).map { |t| t.dig(:function, :name) }
+    expect(names).to match_array(described_class::CORE_TOOLS)
+    expect(names).not_to include('sessions_view')
+    expect(names.length).to be <= described_class::CORE_TOOLS.length
   end
 end

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

@@ -107,12 +107,11 @@ describe 'P0 signal hygiene (handler + inbox + policy-cold + calibrate)' do
     expect(one[:n]).to eq(1)
   end
 
-  it 'classifies review/opinion asks as questions' do
+  it 'treats review/opinion asks as goals with no request type' do
     allow(PWN::Env).to receive(:dig).and_call_original
-    allow(PWN::Env).to receive(:dig).with(:ai, :agent, :request_kind_llm).and_return(false)
     allow(PWN::Env).to receive(:dig).with(:ai, :agent, :task_summary_llm).and_return(false)
-    expect(PWN::AI::Agent::TaskSummarizer.request_kind(request: 'suggest areas for improvement')).to eq(:question)
-    expect(PWN::AI::Agent::TaskSummarizer.needs_task_breakdown?(request: 'suggest areas for improvement')).to eq(false)
-    expect(PWN::AI::Agent::TaskSummarizer.request_kind(request: 'fix all the issues you just described')).to eq(:autonomous_goal)
+    expect(PWN::AI::Agent::TaskSummarizer).not_to respond_to(:request_kind)
+    expect(PWN::AI::Agent::TaskSummarizer.needs_task_breakdown?(request: 'suggest areas for improvement')).to eq(true)
+    expect(PWN::AI::Agent::TaskSummarizer.needs_task_breakdown?(request: 'fix all the issues you just described')).to eq(true)
   end
 end