pwn 0.5.682 → 0.5.683

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f46629cb3abad0974a4fe9bd5d2936bb42c90e304986261cf0106775ffb8de9
-  data.tar.gz: 56fc226ba599b541c47e66c38f7e3a6d142c019442a00707db8f9d8d12caee74
+  metadata.gz: 138deb9b9916fd71329a5898d6cb49ab53751e597f408177aee7682704f33500
+  data.tar.gz: 77f88100898efbff17bea33bbd2efa186afecf2776c02d3e577a71b26d1b2d3b
 SHA512:
-  metadata.gz: aadc0dad32c3ac362ee269637c0308a1f89e400c311dd5b69d9a7c2e944cc57698799c85b97c51ea3024207f18703b32735faacf394a7d2e3f91e6945efb724e
-  data.tar.gz: 748bedcea767a060882928c3697cc96a3ffa5f316cbca209d7e4dc870bcbaef6737ebb582d86b76dcd9c5f6624cd46c6d646b94dec8f0dbcd20af9a1cc0bbdf9
+  metadata.gz: 265a38e4abaead447360e549c98f88dc0a3d3220358d0e30c9e9419d6c1b53dd558dac87b2ce093e968b53bbab9051db7032b405d5835194c33934acd64ecb4d
+  data.tar.gz: 7c0e34b2be0c96ddef980ee81493f5b2d394680ca956f0b6208cc32758fda13f212670febca563092cd5b0331ac46464bdecd0f6c88d2f7a15744f4b1cd79d48

data/documentation/Agent-Tool-Registry.md

@@ -13,8 +13,8 @@ toolsets; the JSON-Schema for each tool is what the model actually sees.
 | `terminal` | `shell` | `Open3.capture3` on the host, after `PWN::AI::Agent::ToolGuard` |
 | `pwn` | `pwn_eval` | `TOPLEVEL_BINDING.eval` in the live REPL process, after `ToolGuard` |
 | `memory` | `memory_remember` · `memory_recall` · `memory_forget` · `memory_clear` · **`memory_lean`** | `PWN::Memory` → `~/.pwn/memory.json` |
-| `skills` | `skill_list` · `skill_view` · `skill_create` · `skill_add_reference` · `skill_delete` · `skill_migrate_legacy` | `~/.pwn/skills/<name>/SKILL.md` (**[agentskills.io](https://agentskills.io) spec**; legacy flat `*.md` auto-migrated) |
-| `sessions` | `sessions_list` · `sessions_view` · `sessions_current` · `sessions_delete` · `sessions_stats` · **`sessions_lean`** | `PWN::Sessions` → `~/.pwn/sessions/` |
+| `skills` | **`skills_recall`** · `skill_list` · `skill_view` · `skill_create` · `skill_add_reference` · `skill_delete` · `skill_migrate_legacy` | `~/.pwn/skills/<name>/SKILL.md` (**[agentskills.io](https://agentskills.io) spec**; legacy flat `*.md` auto-migrated) |
+| `sessions` | **`session_recall`** · `sessions_list` · `sessions_view` · `sessions_current` · `sessions_delete` · `sessions_stats` · **`sessions_lean`** | `PWN::Sessions` → `~/.pwn/sessions/` |
 | `learning` | `learning_note_outcome` · `learning_reflect` · `learning_distill_skill` · `learning_stats` · `learning_outcomes` · `learning_consolidate` · `learning_reset` · `learning_auto_introspect_toggle` · **`learning_gc_stores`** · **`learning_purge_noise`** · **`mistakes_list`** · **`mistakes_record`** · **`mistakes_resolve`** · **`mistakes_reset`** · **`mistakes_lean`** · **`reward_judge`** · **`reward_prm`** · **`reward_sentinel`** · **`reward_preferences`** · **`reward_export_dpo`** · **`reward_warm_sentinel`** · **`reward_scrub_preferences`** · **`reward_preference_balance`** · **`curriculum_practice`** · **`curriculum_train`** · **`curriculum_hindsight`** · **`curriculum_offline_judge`** · **`curriculum_preference_balance`** | `PWN::AI::Agent::Learning` + `Mistakes` + `Reward` + `Curriculum` → `~/.pwn/learning.jsonl` + `~/.pwn/mistakes.json` + `~/.pwn/preferences.jsonl` + `~/.pwn/curriculum/` + `~/.pwn/finetune/` |
 | `reward` | **`reward_generator_mix`** | `PWN::AI::Agent::Reward.generator_mix` → online preference source-mix controller (`preferences.jsonl`) |
 | `curriculum` | **`curriculum_practice_kpi`** | `PWN::AI::Agent::Curriculum.practice_kpi` → `~/.pwn/curriculum_kpi.jsonl` |
@@ -56,8 +56,9 @@ user request through as `relevance:`, `Registry.definitions` shrinks the
 pool to:
 
 ```text
-CORE_TOOLS  = shell · pwn_eval · memory_remember · memory_recall
-              mistakes_record · mistakes_resolve · learning_note_outcome
+CORE_TOOLS / DEFAULT_PREFERENCE (same list):
+memory_recall · session_recall · skills_recall · pwn_eval · shell
+mistakes_record · mistakes_resolve · learning_note_outcome · memory_remember
             + top-K keyword-ranked matches for THIS request
               (ties break on Metrics per-engine success_rate, then
                ai.agent.tool_preference)
@@ -80,7 +81,7 @@ When keyword fit and other rank scores tie, the registry prefers this
 default order:
 
 ```text
-memory_recall · pwn_eval · shell
+memory_recall · session_recall · skills_recall · pwn_eval · shell
 mistakes_record · mistakes_resolve · learning_note_outcome · memory_remember
 ```
 
@@ -88,9 +89,12 @@ Set `ai.agent.tool_preference` in `~/.pwn/pwn.yaml`, or pass `order:` /
 `preference:` into `Registry.definitions`, `.rank`, or `.apply_preference`.
 An explicit empty list turns preference off (no Env / default fallback).
 
+Learned facts and this session are injected (MEMORY / RECENT TURNS), not
+first tools. Preference then lists `pwn_eval` before `shell`. `sessions_view`
+is not a CORE tool. There is no separate ACT_PREFERENCE.
+
 Keyword fit stays the primary signal. Preference is a smaller bonus plus a
-stable sort after the router slims the pool, so `memory_recall` wins a
-tie against `shell` without hiding a better keyword match.
+stable sort after the router slims the pool.
 
 `Policy` uses the same list when it suggests a next action in the prompt.
 

data/documentation/Configuration.md

@@ -133,8 +133,10 @@ ai:
     shell_bash: false              # true -> run shell via bash -lc. Default is /bin/sh.
     plan_first: ~                  # Plan-then-act pre-pass. nil = auto (true when ai.active is ollama or openwebui).
     tool_router: ~                 # Dynamic tool-set slimming. nil = auto (true for ollama / openwebui).
-    tool_preference:               # Operator-tunable tool order. Rank bonus + Policy suggested-action list.
+    tool_preference:               # Same order as CORE_TOOLS. Current session is injected; then memory_recall, session_recall, skills_recall, pwn_eval, shell.
       - memory_recall
+      - session_recall
+      - skills_recall
       - pwn_eval
       - shell
       - mistakes_record
@@ -315,7 +317,7 @@ PWN::Config.refresh_env
 | `ai.agent.shell_bash` | Boolean | `false` | `PWN::AI::Agent::ToolGuard.shell_bash?` | When true, `shell` runs via `bash -lc` so bash-only syntax is allowed. Default is POSIX `/bin/sh` and bashisms are rejected with a rewrite hint. |
 | `ai.agent.plan_first` | Boolean \| `nil` | `nil` (auto: `true` when `ai.active` is `ollama` or `openwebui`) | `PWN::AI::Agent::Loop.plan_first` | Plan-then-act pre-pass: the model must emit a numbered tool plan (as an assistant message) *before* it may dispatch anything. Cheap chain-of-thought scaffolding for local models. |
 | `ai.agent.tool_router` | Boolean \| `nil` | `nil` (auto: `true` for `ollama` / `openwebui`) | `PWN::AI::Agent::Registry.definitions` | Dynamic tool-set slimming: expose only `Registry::CORE_TOOLS` + the top-K keyword-relevant schemas for *this* request. Ties break on historical `Metrics` success rate, then `ai.agent.tool_preference`. |
-| `ai.agent.tool_preference` | Array\<String\> | `memory_recall`, `pwn_eval`, `shell`, `mistakes_record`, `mistakes_resolve`, `learning_note_outcome`, `memory_remember` | `PWN::AI::Agent::Registry.preference_order` / `.rank` / `.apply_preference`, `Policy` | Operator-tunable tool order. Keyword fit stays primary; act/recon kinds lead with `shell`/`pwn_eval`. Explicit empty list disables preference. |
+| `ai.agent.tool_preference` | Array\<String\> | `memory_recall`, `session_recall`, `skills_recall`, `pwn_eval`, `shell`, `mistakes_record`, `mistakes_resolve`, `learning_note_outcome`, `memory_remember` | `PWN::AI::Agent::Registry.preference_order` / `.rank` / `.apply_preference`, `Policy` | Same order as `CORE_TOOLS`. Current session is injected; then `memory_recall`, `session_recall`, `skills_recall`, `pwn_eval`, `shell`. Explicit empty list disables preference. |
 | `ai.agent.defer_introspect` | Boolean | `true` | `PWN::AI::Agent::TurnFinalizer` | Run `Learning.auto_introspect` on a background thread after the user-visible reply. Specs and cron stay inline. |
 | `ai.agent.prompt_cache` | Boolean | `true` | `PWN::AI::Agent::PromptCache` | Engine-native prefix cache. Anthropic uses `cache_control`; OpenAI uses `prompt_cache_key`; Grok uses `x-grok-conv-id`; Gemini splits `systemInstruction`. Ollama and Open WebUI have no native prefix-cache field. |
 | `ai.agent.local_introspect` | Symbol | `failure_only` | `PWN::AI::Agent::Learning.auto_introspect` | End-of-turn introspect policy for local engines: `always` · `failure_only` · `every_n` (with `introspect_every_n`). |

data/documentation/How-PWN-Works.md

@@ -29,7 +29,7 @@ hardware).
 |---|---|
 | `Loop` | plan → **TaskSummarizer** briefs → dispatch tool_calls → observe → repeat until final answer; tightens runway when recent turns exhausted the budget |
 | **`TaskSummarizer`** | Executive UX: every request gets an English task compass (`emit_plan!` · `about_to` as `task k/n`) — no statement/question/goal type |
-| `Registry` | JSON-Schema function definitions grouped into 13 **toolsets** · **85 tools** · `CORE_TOOLS` default pool · kind-aware `tool_preference` |
+| `Registry` | JSON-Schema function definitions grouped into 13 **toolsets** · **87 tools** · `CORE_TOOLS` = `DEFAULT_PREFERENCE` (`memory_recall` · `session_recall` · `skills_recall` · `pwn_eval` · `shell`) |
 | `Dispatch` / `Result` | execute a tool, capture stdout/value/error/duration |
 | `PromptBuilder` | inject MEMORY / SKILLS / LEARNING / **KNOWN MISTAKES + FIXES** / METRICS / **POLICY** / EXTROSPECTION / RECENT TURNS |
 | `Metrics` · `Learning` · `Reflect` · **`Policy`** | **introspection** - how well am I doing? (Policy is live Q / REINFORCE, advisory rank only) |

data/documentation/Reinforcement-Learning.md

@@ -169,7 +169,7 @@ This table is the live control list. Track the outcomes, not source comments.
     :max_iters: 75           # hard cap; budget pressure may lower effective value
     :defer_introspect: true  # post-answer Learning after the user-visible reply
     :prompt_cache: true      # engine-native prefix cache (not ollama / openwebui)
-    :tool_preference: [memory_recall, pwn_eval, shell, mistakes_record, mistakes_resolve, learning_note_outcome, memory_remember]
+    :tool_preference: [memory_recall, session_recall, skills_recall, pwn_eval, shell, mistakes_record, mistakes_resolve, learning_note_outcome, memory_remember]
 ```
 
 ## Cron self-improvement

data/documentation/diagrams/agent-tool-registry.svg

@@ -29,7 +29,7 @@
 <text xml:space="preserve" text-anchor="middle" x="105.12" y="-521.82" font-family="sans-Serif" font-size="12.00" fill="#0f172a">JSON&#45;Schema function defs</text>
 <text xml:space="preserve" text-anchor="middle" x="105.12" y="-507.57" font-family="sans-Serif" font-size="12.00" fill="#0f172a">rank(query) · CORE_TOOLS</text>
 <text xml:space="preserve" text-anchor="middle" x="105.12" y="-493.32" font-family="sans-Serif" font-size="12.00" fill="#0f172a">tool_router → CORE + top&#45;K</text>
-<text xml:space="preserve" text-anchor="middle" x="105.12" y="-479.07" font-family="sans-Serif" font-size="12.00" fill="#0f172a">tool_preference (memory_recall first)</text>
+<text xml:space="preserve" text-anchor="middle" x="105.12" y="-479.07" font-family="sans-Serif" font-size="12.00" fill="#0f172a">tool_preference (pwn_eval then shell)</text>
 </g>
 <!-- terminal -->
 <g id="node2" class="node">

data/documentation/diagrams/dot/agent-tool-registry.dot

@@ -9,7 +9,7 @@ digraph "PWN_Agent_Tool_Registry" {
         shape=box, penwidth=1.3, color="#334155", fontcolor="#0f172a"];
   edge [color="#94a3b8", penwidth=1.1, arrowsize=0.7];
 
-  Registry [label="Registry\nJSON-Schema function defs\nrank(query) · CORE_TOOLS\ntool_router → CORE + top-K\ntool_preference (memory_recall first)", fillcolor="#c4b5fd", fontsize=12, penwidth=2];
+  Registry [label="Registry\nJSON-Schema function defs\nrank(query) · CORE_TOOLS\ntool_router → CORE + top-K\ntool_preference (pwn_eval then shell)", fillcolor="#c4b5fd", fontsize=12, penwidth=2];
 
   subgraph cluster_ts {
     label="Toolsets"; fontcolor="#a7f3d0"; style=rounded;

data/documentation/pwn-ai-Agent.md

@@ -197,7 +197,7 @@ max_iters: 75                   # budget pressure may lower the effective cap (s
 | `reward_llm_timeout` | `12` | seconds for the cheap ORM chat (clamped 2..30) |
 | `verify_as_reward` | `nil` (auto) | browser-grounded claim sample policy |
 | `local_introspect` | `:failure_only` | ollama / openwebui end-of-turn introspect policy |
-| `tool_preference` | CORE_TOOLS list (act leads with shell) | Rank bonus + Policy suggested-action order |
+| `tool_preference` | same list as CORE_TOOLS (`memory_recall`, `session_recall`, `skills_recall`, `pwn_eval`, `shell`) | Rank bonus + Policy suggested-action order |
 | `defer_introspect` | `true` | Post-answer Learning on a background thread |
 | `prompt_cache` | `true` | Engine-native prefix cache (not Ollama / Open WebUI) |
 

data/lib/pwn/ai/agent/loop.rb

@@ -321,9 +321,15 @@ module PWN
         LOOKUP_REQUEST_RX = /
           \b(what\s+is\s+my|hostname|uname|cwd|whoami|status|version|how\s+many)\b
         /ix
-        HOST_PATH_RX = %r{(?:/|\./)[\w./-]+\.\w+}
+        # Real filesystem paths only — not https://host.tld (that was matching //host.tld).
+        HOST_PATH_RX = %r{(?:(?<![.:/])/(?!/)|\./)[\w./-]+\.\w+}
+        BROWSER_REQUEST_RX = /
+          TransparentBrowser|browser_obj|\bdevtools\b|
+          \b(navigate|dump_links|headless_?chrome|watir)\b
+        /ix
+        BROWSER_EVIDENCE_RX = %r{https?://|dump_links|TransparentBrowser|\.close\b|browser_obj}i
 
-        # True only when the ask needs a live host/file effect. World-knowledge
+        # True only when the ask needs a live host/file/browser effect. World-knowledge
         # questions ("what color is a cherry") do not.
         public_class_method def self.needs_host_work?(opts = {})
           request = opts[:request].to_s
@@ -331,6 +337,7 @@ module PWN
           return true if request.match?(ACT_REQUEST_RX)
           return true if request.match?(LOOKUP_REQUEST_RX)
           return true if request.match?(HOST_PATH_RX)
+          return true if request.match?(BROWSER_REQUEST_RX)
 
           false
         rescue StandardError
@@ -377,10 +384,16 @@ module PWN
 
           return false if request.match?(LOOKUP_REQUEST_RX) && tools.any? && blob.length >= 20
           return true if tools.empty?
-          return false if blob.match?(MUTATION_EVIDENCE_RX)
-          return false if request_path_evidenced?(request: request, blob: blob)
 
-          true
+          if request.match?(ACT_REQUEST_RX) || request.match?(HOST_PATH_RX)
+            return false if blob.match?(MUTATION_EVIDENCE_RX)
+            return false if request_path_evidenced?(request: request, blob: blob)
+
+            return true
+          end
+          return false if request.match?(BROWSER_REQUEST_RX) && blob.match?(BROWSER_EVIDENCE_RX)
+
+          blob.length < 20
         rescue StandardError
           false
         end
@@ -1326,6 +1339,7 @@ module PWN
             last\s+thing\s+(?:i|you)\s+said
           )\b
         /ix
+        LAST_SESSION_RX = /\b(?:in|from|of)\s+(?:the\s+)?(?:last|previous|prior)\s+session\b|\blast\s+session\b/i
 
         # Pure greeting / light smalltalk — never full :act tool loop.
         # Anchored short forms only so "hi, please scan X" stays :act/:recon_act.
@@ -1393,6 +1407,14 @@ module PWN
             return :recall unless doing
           end
 
+          if req.match?(LAST_SESSION_RX) && !req.match?(HOWTO_RX) && !req.match?(LIVE_RECON_RX)
+            doing = req.match?(
+              /\b(implement|fix|patch|refactor|run|execute|scan|write|edit|
+                  change|deploy|install|build|compile|commit|push)\b/ix
+            )
+            return :recall unless doing
+          end
+
           # Live-action recon takes precedence over bare "how to" when both appear
           # only if the user clearly asks the agent to do the sweep here.
           live = req.match?(LIVE_RECON_RX) && req.match?(
@@ -1715,6 +1737,18 @@ module PWN
           session_id = opts[:session_id]
           system_role_content = opts[:system_role_content].to_s
           target = recall_target(request: request)
+          last_session = request.match?(LAST_SESSION_RX)
+          if last_session && defined?(PWN::Sessions) && PWN::Sessions.respond_to?(:previous_id)
+            prev = PWN::Sessions.previous_id(exclude_session_id: session_id)
+            if prev.to_s.empty?
+              txt = 'I do not have a previous session transcript yet.'
+              append_session(session_id: opts[:session_id], role: 'user', content: request)
+              append_session(session_id: opts[:session_id], role: 'assistant', content: txt)
+              return txt
+            end
+
+            session_id = prev
+          end
 
           prior_user = nil
           prior_asst = nil
@@ -1757,7 +1791,7 @@ module PWN
               # User-target / fallback: skip meta intermediate recall asks so
               # "what did I just say?" after a nested chain still surfaces the
               # original utterance when appropriate; default stays newest.
-              skip_meta = target == :assistant
+              skip_meta = target == :assistant || last_session
               prior_user = PWN::Memory.prior_user_message(
                 session_id: session_id,
                 max_chars: 4_000,

data/lib/pwn/ai/agent/policy.rb

@@ -580,10 +580,9 @@ module PWN
           end
 
           ev = evaluate(limit: opts[:limit] || 40)
-          fallback = %w[shell pwn_eval memory_recall mistakes_record mistakes_resolve learning_note_outcome memory_remember]
+          fallback = PWN::AI::Agent::Registry::DEFAULT_PREFERENCE
           pref = begin
-            intent = Thread.current[:pwn_request_intent]
-            PWN::AI::Agent::Registry.preference_order(intent: intent)
+            PWN::AI::Agent::Registry.preference_order
           rescue StandardError
             []
           end

data/lib/pwn/ai/agent/prompt_builder.rb

@@ -63,16 +63,14 @@ module PWN
 
           # Heredoc (not a "..." literal): an unescaped "..." inside a
           # double-quoted string is parsed as Range (begin..."...end).
-          # Skills sit in the STATIC prefix (Hermes index) so prompt-cache
-          # breakpoints can pin the persona + SKILLS list; MEMORY/LEARNING
-          # remain in the dynamic tail. Mid-turn lean: request + CORE_TOOLS +
-          # known-fix. Expand MEMORY/SKILLS/LEARNING/METRICS/POLICY/EXTRO
-          # only when the turn is stuck or the operator asked for the full harness.
+          # Mid-turn: current session + memory + skills + learning + known-fix,
+          # then tools (memory_recall / session_recall / skills_recall / pwn_eval / shell).
+          # Expand METRICS/POLICY/EXTRO when stuck or expand_harness.
           expand = opts[:expand_harness] == true || opts[:stuck] == true
           harness = if expand
-                      "#{skills_block}#{memory_block(limit: b[:memory], request: request)}#{recent_turns_block(session_id: session_id, request: request, limit: b[:recent_turns])}#{learning_block(limit: b[:learning])}#{mistakes_block(limit: b[:mistakes], request: request)}#{metrics_block(limit: b[:metrics], engine: engine)}#{policy_block if b[:policy].to_i.positive?}#{extrospection_block if b[:extro]}"
+                      "#{skills_block}#{recent_turns_block(session_id: session_id, request: request, limit: b[:recent_turns])}#{memory_block(limit: b[:memory], request: request)}#{learning_block(limit: b[:learning])}#{mistakes_block(limit: b[:mistakes], request: request)}#{metrics_block(limit: b[:metrics], engine: engine)}#{policy_block if b[:policy].to_i.positive?}#{extrospection_block if b[:extro]}"
                     else
-                      "#{recent_turns_block(session_id: session_id, request: request, limit: [b[:recent_turns].to_i, 1].max)}#{mistakes_block(limit: b[:mistakes], request: request)}"
+                      "#{recent_turns_block(session_id: session_id, request: request, limit: b[:recent_turns])}#{memory_block(limit: b[:memory], request: request)}#{skills_block}#{learning_block(limit: b[:learning])}#{mistakes_block(limit: b[:mistakes], request: request)}"
                     end
           <<~PROMPT
             #{base}
@@ -92,8 +90,11 @@ module PWN
             "I will run…", "one more thing…") — that is treated as an incomplete
             reply. Emit a real tool_call instead, or a complete final answer
             with evidence. A reply with no tool_calls is your FINAL answer to the user.
-              Prefer `pwn_eval` for anything in the PWN:: namespace and `shell`
-              for OS commands. Save durable facts with `memory_remember`.
+              Prefer this order: use RECENT TURNS (current session already in
+              context), then `memory_recall`, then `session_recall`, then
+              `skills_recall`, then `pwn_eval` for PWN:: work, then `shell` for OS
+              commands. Save durable facts with `memory_remember`.
+              TransparentBrowser: open once, reuse browser_obj, close once.
 
             AUTONOMY
               Multi-step goals must be finished in one Loop.run. Keep calling
@@ -140,13 +141,13 @@ module PWN
             metrics: (b[:metrics] || (local ? 3 : 8)).to_i,
             mistakes: (b[:mistakes] || (local ?  3 :  6)).to_i,
             learning: (b[:learning] || (local ?  2 :  5)).to_i,
-            # Always inject last user/assistant pair(s); local keeps it tiny.
-            recent_turns: (b[:recent_turns] || (local ? 1 : 2)).to_i,
+            # Always inject prior user/assistant pairs from this session.
+            recent_turns: (b[:recent_turns] || (local ? 3 : 6)).to_i,
             policy: (b[:policy] || 1).to_i,
             extro: b[:extro].nil? ? !local : b[:extro]
           }
         rescue StandardError
-          { memory: 25, metrics: 8, mistakes: 6, learning: 5, recent_turns: 2, policy: 1, extro: true }
+          { memory: 25, metrics: 8, mistakes: 6, learning: 5, recent_turns: 6, policy: 1, extro: true }
         end
 
         private_class_method def self.active_engine

data/lib/pwn/ai/agent/registry.rb

@@ -40,17 +40,14 @@ module PWN
           keyword_init: true
         )
 
-        CORE_TOOLS = %w[shell pwn_eval memory_remember memory_recall
-                        mistakes_record mistakes_resolve learning_note_outcome].freeze
+        CORE_TOOLS = %w[memory_recall session_recall skills_recall pwn_eval shell
+                        mistakes_record mistakes_resolve learning_note_outcome memory_remember].freeze
 
-        # Operator-tunable tool order. Prefer these names when keyword-fit
-        # (or other rank features) tie. Overridable via opts[:order],
+        # Schema order = CORE_TOOLS. Current session is injected (RECENT TURNS).
+        # Then memory / prior sessions / skills, then pwn_eval before shell.
         # opts[:preference], or PWN::Env[:ai][:agent][:tool_preference].
         # Explicit nil/empty order disables preference (no Env/DEFAULT fallback).
-        # Recall-first fallback; kind-aware preference_order leads act/recon
-        # with shell / pwn_eval. Names stay inside CORE_TOOLS.
-        DEFAULT_PREFERENCE = %w[memory_recall pwn_eval shell mistakes_record mistakes_resolve learning_note_outcome memory_remember].freeze
-        ACT_PREFERENCE = %w[shell pwn_eval memory_recall mistakes_record mistakes_resolve learning_note_outcome memory_remember].freeze
+        DEFAULT_PREFERENCE = CORE_TOOLS
 
         @entries = {}
         @discovered = false
@@ -156,7 +153,7 @@ module PWN
           raw = PWN::Env.dig(:ai, :agent, :tool_preference) if defined?(PWN::Env) && PWN::Env.is_a?(Hash)
           return Array(raw).map(&:to_s).reject(&:empty?) unless raw.nil? || (raw.respond_to?(:empty?) && raw.empty?)
 
-          ACT_PREFERENCE.dup
+          DEFAULT_PREFERENCE.dup
         rescue StandardError
           DEFAULT_PREFERENCE.dup
         end

data/lib/pwn/ai/agent/tools/sessions.rb

@@ -3,6 +3,38 @@
 require 'pwn/ai/agent/registry'
 require 'pwn/sessions'
 
+PWN::AI::Agent::Registry.register(
+  name: 'session_recall',
+  toolset: 'sessions',
+  schema: {
+    name: 'session_recall',
+    description: 'Search previous pwn-ai session transcripts (~/.pwn/sessions) ' \
+                 'for how a similar request was solved. Current session is ' \
+                 'already in RECENT TURNS — this is for older sessions. ' \
+                 'Call before pwn_eval / shell when prior method matters.',
+    parameters: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Keywords to match in prior user/assistant turns.' },
+        limit: { type: 'integer', default: 12, description: 'Max hits (newest / highest score first).' },
+        include_current: { type: 'boolean', default: false, description: 'Also search the active session.' }
+      },
+      required: []
+    }
+  },
+  check: -> { defined?(PWN::Sessions) },
+  handler: lambda { |args|
+    exclude = ''
+    exclude = PWN::Memory.current_session_id if defined?(PWN::Memory) && PWN::Memory.respond_to?(:current_session_id)
+    PWN::Sessions.recall(
+      query: args[:query],
+      limit: args[:limit] || 12,
+      exclude_session_id: exclude,
+      include_current: args[:include_current] == true
+    )
+  }
+)
+
 # Thin wrappers around PWN::Sessions so the model can DISCOVER and INSPECT
 # the JSONL transcripts that learning_reflect / learning_distill_skill
 # consume. Without these the model has to blindly `shell("ls ~/.pwn/sessions")`

data/lib/pwn/ai/agent/tools/skills.rb

@@ -22,6 +22,62 @@ require 'pwn/ai/agent/registry'
 # and/or a "## References" markdown section — mirroring the
 # PWN::SAST::*.security_references convention.
 
+PWN::AI::Agent::Registry.register(
+  name: 'skills_recall',
+  toolset: 'skills',
+  schema: {
+    name: 'skills_recall',
+    description: 'Search installed pwn-ai skills (name, description, body, ' \
+                 'references) for how to do similar work. Call before ' \
+                 'pwn_eval / shell when a reusable procedure may exist. ' \
+                 'The SKILLS index is already in the prompt — this loads ' \
+                 'matching full methods.',
+    parameters: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Keywords to match against skill name / description / body.' },
+        limit: { type: 'integer', default: 6, description: 'Max hits (highest score first).' }
+      },
+      required: []
+    }
+  },
+  check: -> { true },
+  handler: lambda { |args|
+    return [] unless defined?(PWN::Skills) && PWN::Skills.is_a?(Hash)
+
+    query = args[:query].to_s.downcase
+    tokens = query.split(/\W+/).reject { |t| t.length < 3 }
+    limit = (args[:limit] || 6).to_i
+    limit = 6 if limit <= 0
+    trunc = 400
+    hits = []
+    PWN::Skills.each do |name, meta|
+      next unless meta.is_a?(Hash)
+
+      blob = [
+        name.to_s,
+        meta[:description],
+        meta[:content],
+        Array(meta[:references]).join(' ')
+      ].join("\n").downcase
+      score = 0
+      score += 5 if !query.empty? && blob.include?(query)
+      tokens.each { |tok| score += 1 if blob.include?(tok) }
+      score = 1 if query.empty?
+      next if score <= 0
+
+      body = meta[:content].to_s
+      hits << {
+        name: name.to_s,
+        description: meta[:description].to_s,
+        score: score,
+        snippet: body.length > trunc ? "#{body[0, trunc]}…[truncated]" : body
+      }
+    end
+    hits.sort_by { |h| -h[:score].to_i }.first(limit)
+  }
+)
+
 PWN::AI::Agent::Registry.register(
   name: 'skill_list',
   toolset: 'skills',

data/lib/pwn/ai/anthropic.rb

@@ -418,7 +418,6 @@ module PWN
         rest_client = browser_obj[:browser]::Request
 
         spin = PWN::Plugins::TTYSpinner.start if spinner
-        spin.auto_spin if spinner
 
         retry_count = 0
         begin

data/lib/pwn/ai/gemini.rb

@@ -55,7 +55,6 @@ module PWN
         rest_client = browser_obj[:browser]::Request
 
         spin = PWN::Plugins::TTYSpinner.start if spinner
-        spin.auto_spin if spinner
 
         retry_count = 0
         begin

data/lib/pwn/ai/grok.rb

@@ -424,7 +424,6 @@ module PWN
         rest_client = browser_obj[:browser]::Request
 
         spin = PWN::Plugins::TTYSpinner.start if spinner
-        spin.auto_spin if spinner
 
         retry_count = 0
         begin

data/lib/pwn/ai/ollama.rb

@@ -75,7 +75,6 @@ module PWN
         rest_client = browser_obj[:browser]::Request
 
         spin = PWN::Plugins::TTYSpinner.start if spinner
-        spin.auto_spin if spinner
 
         retry_count = 0
         begin

data/lib/pwn/ai/open_ai.rb

@@ -460,7 +460,6 @@ module PWN
         rest_client = browser_obj[:browser]::Request
 
         spin = PWN::Plugins::TTYSpinner.start if spinner
-        spin.auto_spin if spinner
 
         retry_count = 0
         begin

data/lib/pwn/ai/open_web_ui.rb

@@ -87,7 +87,6 @@ module PWN
         rest_client = browser_obj[:browser]::Request
 
         spin = PWN::Plugins::TTYSpinner.start if spinner
-        spin.auto_spin if spinner
 
         retry_count = 0
         begin

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 pwn_eval shell mistakes_record mistakes_resolve learning_note_outcome memory_remember],
+            tool_preference: %w[memory_recall session_recall skills_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/plugins/repl.rb

@@ -3,6 +3,7 @@
 require 'curses'
 require 'pry'
 require 'reline'
+require 'tty-cursor'
 require 'tty-prompt'
 require 'unicode/display_width'
 require 'yaml'
@@ -240,6 +241,7 @@ module PWN
         end
 
         def readline(prompt)
+          PWN::Plugins::REPL.ready_tty!
           # Ask the terminal to encode Shift+Enter distinctly from Enter for
           # the duration of this read. Without this, most emulators send 0x0D
           # for both and SHIFT_ENTER_SEQS can never match. Reset in `ensure`.
@@ -280,6 +282,40 @@ module PWN
         end
       end
 
+      # Restore the TTY after a spinner / agent turn so Pry/Reline prints
+      # the next PS1 immediately. hide_cursor + a background worker leave
+      # the cursor hidden on $stdout (Reline's stream) even after
+      # TTY::Spinner#stop writes show-cursor to $stderr. Reline then
+      # waits for a key without redrawing the prompt.
+      public_class_method def self.ready_tty!(opts = {})
+        return nil if opts[:skip]
+
+        out = opts[:io] || $stdout
+        return nil unless out.respond_to?(:write)
+
+        out.write("\e[0m#{TTY::Cursor.show}") if defined?(TTY::Cursor)
+        out.write("\e[0m\e[?25h") unless defined?(TTY::Cursor)
+        out.flush if out.respond_to?(:flush)
+        reset_reline_editor
+        nil
+      rescue StandardError
+        nil
+      end
+
+      private_class_method def self.reset_reline_editor(opts = {})
+        return unless opts.is_a?(Hash)
+        return unless defined?(Reline)
+        return unless Reline.respond_to?(:core)
+
+        editor = Reline.core.instance_variable_get(:@line_editor)
+        return unless editor
+
+        editor.instance_variable_set(:@finished, false) if editor.instance_variable_defined?(:@finished)
+        nil
+      rescue StandardError
+        nil
+      end
+
       # Compact token-count formatter for the pwn.ai PS1 (e.g. 0, 843, 12K, 250K, 1M).
       public_class_method def self.compact_context_tokens(opts = {})
         n = opts[:tokens].to_i
@@ -1182,6 +1218,7 @@ module PWN
                 puts "\n\001\e[32m\002#{final}\001\e[0m\002\n\n"
                 pp PWN::Sessions.load(session_id: sess_id) if pi.config.pwn_ai_debug && sess_id && PWN.const_defined?(:Sessions)
                 request.replace('nil')
+                PWN::Plugins::REPL.ready_tty!
                 next
               rescue StandardError => e
                 warn "[pwn-ai] native agent loop failed (#{e.class}: #{e.message}\n#{e.backtrace}); " \

data/lib/pwn/plugins/tty_spinner.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'tty-spinner'
+require 'tty-cursor'
 
 module PWN
   module Plugins
@@ -10,10 +11,7 @@ module PWN
     # worker but does NOT join it. The worker is typically mid-sleep
     # on its interval, so it stays alive long enough to write another
     # frame (cursor col 1 + glyph) over the HTTP response that the
-    # caller is about to print. Creating the spinner with clear:false
-    # (the gem default) also reprints the last glyph + newline on
-    # stop, so the spinner appears to keep running whenever a
-    # response is provided.
+    # caller is about to print.
     #
     # #start uses clear:true + hide_cursor and owns the worker
     # (spin.start + Thread.new { spin.spin until spin.done? }).
@@ -37,7 +35,18 @@ module PWN
         }
         args[:output] = opts[:output] unless opts[:output].nil?
 
-        TTY::Spinner.new(**args)
+        spin = TTY::Spinner.new(**args)
+        spin.start
+        interval = 1.0 / [spin.interval.to_f, 1.0].max
+        worker = Thread.new do
+          Thread.current.report_on_exception = false
+          until spin.done?
+            spin.spin
+            sleep(interval)
+          end
+        end
+        spin.define_singleton_method(:pwn_worker_thread) { worker }
+        spin
       end
 
       # Supported Method Parameters::
@@ -49,7 +58,47 @@ module PWN
         spin = opts.is_a?(Hash) ? opts[:spin] : opts
         return if spin.nil?
 
-        spin.stop if spin.respond_to?(:stop)
+        worker = spin.respond_to?(:pwn_worker_thread) ? spin.pwn_worker_thread : nil
+        begin
+          spin.stop if spin.respond_to?(:stop)
+        rescue StandardError
+          spin.kill if spin.respond_to?(:kill)
+        end
+        join_thread(thread: worker)
+        join_spinner(spin: spin)
+        begin
+          spin.clear_line if spin.respond_to?(:clear_line)
+          show = defined?(TTY::Cursor) ? TTY::Cursor.show : "\e[?25h"
+          out = spin.output if spin.respond_to?(:output)
+          out.print(show) if out.respond_to?(:print)
+          $stdout.write(show) if $stdout.respond_to?(:write)
+          $stdout.flush if $stdout.respond_to?(:flush)
+        rescue StandardError
+          nil
+        end
+        nil
+      end
+
+      private_class_method def self.join_thread(opts = {})
+        thread = opts[:thread]
+        return unless thread.is_a?(Thread)
+        return unless thread.alive?
+
+        unless thread.join(JOIN_SECS)
+          thread.kill
+          thread.join(JOIN_SECS)
+        end
+      rescue StandardError
+        thread.kill if thread.respond_to?(:kill)
+      end
+
+      private_class_method def self.join_spinner(opts = {})
+        spin = opts[:spin]
+        return unless spin.respond_to?(:join)
+
+        spin.join(JOIN_SECS)
+      rescue TTY::Spinner::NotSpinningError, StandardError
+        nil
       end
 
       # Author(s):: 0day Inc. <support@0dayinc.com>

data/lib/pwn/sessions.rb

@@ -119,6 +119,86 @@ module PWN
       File.readlines(path).map { |l| JSON.parse(l, symbolize_names: true) }
     end
 
+    # Newest session that is not exclude_session_id (the prior pwn-ai run).
+    #
+    # Supported Method Parameters::
+    #   id = PWN::Sessions.previous_id(
+    #     exclude_session_id: 'optional - current session to skip'
+    #   )
+    public_class_method def self.previous_id(opts = {})
+      exclude = opts[:exclude_session_id].to_s
+      rows = list.sort_by { |s| [s[:mtime].to_s, s[:id].to_s] }.reverse
+      hit = rows.find { |s| s[:id].to_s != exclude }
+      hit && hit[:id].to_s
+    rescue StandardError
+      nil
+    end
+
+    # Search prior session transcripts for query terms. Current session is
+    # excluded by default — that tail is already in RECENT TURNS.
+    #
+    # Supported Method Parameters::
+    #   hits = PWN::Sessions.recall(
+    #     query: 'optional - substring / tokens to match',
+    #     exclude_session_id: 'optional - skip this id (current session)',
+    #     include_current: 'optional - Boolean include excluded id (default false)',
+    #     limit: 'optional - max hits (default 12)',
+    #     max_files: 'optional - newest files to scan (default 40)',
+    #     truncate: 'optional - chars per hit (default 280)'
+    #   )
+    public_class_method def self.recall(opts = {})
+      query = opts[:query].to_s.downcase
+      tokens = query.split(/\W+/).reject { |t| t.length < 3 }
+      limit = (opts[:limit] || 12).to_i
+      limit = 12 if limit <= 0
+      max_files = (opts[:max_files] || 40).to_i
+      max_files = 40 if max_files <= 0
+      trunc = (opts[:truncate] || 280).to_i
+      trunc = 280 if trunc <= 0
+      exclude = opts[:exclude_session_id].to_s
+      include_current = opts[:include_current] == true
+
+      hits = []
+      list.sort_by { |s| s[:mtime].to_s }.reverse.first(max_files).each do |sess|
+        sid = sess[:id].to_s
+        next if !include_current && !exclude.empty? && sid == exclude
+
+        load(session_id: sid).each do |row|
+          next unless row.is_a?(Hash)
+          next unless %w[user assistant].include?(row[:role].to_s)
+
+          body = row[:content].to_s
+          next if body.strip.empty?
+
+          score = recall_score(body: body.downcase, query: query, tokens: tokens)
+          next if score <= 0
+
+          hits << {
+            session_id: sid,
+            role: row[:role].to_s,
+            timestamp: row[:timestamp],
+            content: body.length > trunc ? "#{body[0, trunc]}…[truncated]" : body,
+            score: score
+          }
+        end
+      end
+      hits.sort_by { |h| [-h[:score].to_f, h[:timestamp].to_s] }.first(limit)
+    rescue StandardError
+      []
+    end
+
+    private_class_method def self.recall_score(opts = {})
+      body = opts[:body].to_s
+      query = opts[:query].to_s
+      tokens = Array(opts[:tokens])
+      return 1 if query.empty?
+
+      score = 0
+      score += 5 if !query.empty? && body.include?(query)
+      tokens.each { |tok| score += 1 if body.include?(tok) }
+      score
+    end
+
     # Supported Method Parameters::
     #   history_for_ai = PWN::Sessions.to_response_history(session_id:)
     #   (converts transcript to the response_history format used by PWN::AI::* .chat)
@@ -417,6 +497,8 @@ module PWN
           PWN::Sessions.append(session_id: sess[:id], role: 'user', content: 'Run NmapIt...')
           transcript = PWN::Sessions.load(session_id: sess[:id])
           hist = PWN::Sessions.to_response_history(session_id: sess[:id])
+          PWN::Sessions.recall(query: 'hping3', exclude_session_id: sess[:id])
+          PWN::Sessions.previous_id(exclude_session_id: sess[:id])
           PWN::Sessions.list
           PWN::Sessions.stats
           PWN::Sessions.delete(session_id: sess[:id], force: true)

data/lib/pwn/version.rb

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

data/spec/integration/prompt_builder_spec.rb

@@ -29,14 +29,14 @@ RSpec.describe 'PWN::AI::Agent::PromptBuilder', :aggregate_failures do
     PWN::Env[:ai] = { active: :anthropic, module_reflection: false, agent: @agent_cfg }
   end
 
-  it 'mid-turn autonomous prompt keeps request + CORE_TOOLS + known-fix, not the full harness' do
+  it 'mid-turn prompt injects MEMORY + RECENT TURNS + known-fix, not the parked 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|
+    ['ENVIRONMENT', 'MEMORY', 'SKILLS', 'LEARNING', '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)
-    ['MEMORY', 'SKILLS', 'LEARNING', 'TOOL EFFECTIVENESS', 'EXTROSPECTION', 'POLICY'].each do |hdr|
+    ['TOOL EFFECTIVENESS', 'EXTROSPECTION', 'POLICY'].each do |hdr|
       expect(prompt).not_to include(hdr), "mid-turn prompt still injects #{hdr}"
     end
   end

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

@@ -15,7 +15,7 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
     expect(help_response).to respond_to :help
   end
 
-  describe 'RL-adjacent loop contracts' do
+  describe 'RL-adjacent loop contracts' do # rubocop:disable Metrics/BlockLength
     it 'exhaust path still calls task_summary_flush! and auto_introspect' do
       src = File.read(described_class.method(:run).source_location.first)
       # budget exhausted terminal path
@@ -316,6 +316,44 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
       expect(described_class.needs_host_work?(request: 'Write hello into /tmp/x.txt')).to eq true
     end
 
+    it 'does not treat https URLs as file paths; browser collect asks complete on URL evidence' do
+      req = <<~REQ.gsub(/\s+/, ' ').strip
+        Navigate to https://0dayinc.com using TransparentBrowser.open(browser_type: :chrome, devtools: true)
+        find all the blog posts ever made, and return a list of URLs.
+        Once complete close the browser via TransparentBrowser.close
+      REQ
+      expect(req.scan(described_class::HOST_PATH_RX)).to eq([])
+      expect(described_class.needs_host_work?(request: req)).to eq true
+      expect(described_class.world_knowledge?(request: req)).to eq false
+      expect(
+        described_class.send(
+          :request_unsatisfied?,
+          request: req,
+          messages: [{ role: 'assistant', content: 'opening chrome', tool_calls: [] }],
+          last_iter: false
+        )
+      ).to eq true
+      collected = [
+        {
+          role: 'assistant',
+          tool_calls: [{ function: { name: 'pwn_eval', arguments: '{"code":"browser.goto"}' } }]
+        },
+        {
+          role: 'tool',
+          name: 'pwn_eval',
+          content: '{"success":true,"result":["https://0dayinc.com/blog/one","https://0dayinc.com/blog/two"]}'
+        }
+      ]
+      expect(
+        described_class.send(
+          :request_unsatisfied?,
+          request: req,
+          messages: collected,
+          last_iter: false
+        )
+      ).to eq false
+    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/)
@@ -507,6 +545,30 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
       FileUtils.rm_rf(sess_tmp) if sess_tmp
     end
 
+    it 'answer_recall looks up the previous session file for last-session asks' do
+      sess_tmp = Dir.mktmpdir('pwn-sess-last')
+      stub_const('PWN::Sessions::SESSIONS_DIR', sess_tmp)
+      old = PWN::Sessions.create(id: '20200101_000000_oldone', title: 'old')
+      PWN::Sessions.append(session_id: old[:id], role: 'user', content: 'SHIP MARKER LAST SESSION')
+      PWN::Sessions.append(session_id: old[:id], role: 'assistant', content: 'ack old')
+      cur = PWN::Sessions.create(id: '20260101_000000_curone', title: 'current')
+      PWN::Sessions.append(session_id: cur[:id], role: 'user', content: 'what did I just say?')
+      PWN::Sessions.append(session_id: cur[:id], role: 'assistant', content: "You just said:\n\nwhat did I just say?")
+      allow(described_class).to receive(:should_auto_introspect?).and_return(false)
+      req = 'what did I just say in the last session?'
+      expect(described_class.request_intent(request: req)).to eq(:recall)
+      out = described_class.send(
+        :answer_recall,
+        request: req,
+        session_id: cur[:id],
+        system_role_content: 'test'
+      )
+      expect(out).to include('SHIP MARKER LAST SESSION')
+      expect(out).not_to match(/You just said:\s*\n\s*what did I just say\?/i)
+    ensure
+      FileUtils.rm_rf(sess_tmp) if sess_tmp
+    end
+
     it 'answer_recall returns prior assistant text for how-did-you-respond without tools' do
       sess_tmp = Dir.mktmpdir('pwn-sess-recall-asst')
       stub_const('PWN::Sessions::SESSIONS_DIR', sess_tmp)

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

@@ -64,11 +64,15 @@ describe PWN::AI::Agent::PromptBuilder do
     end
   end
 
-  describe 'mid-turn lean prompt' do
-    it 'does not inject MEMORY/SKILLS/LEARNING/POLICY/EXTRO on a live goal' do
+  describe 'mid-turn prompt' do
+    it 'injects current session + MEMORY + SKILLS + LEARNING + known-fix before tools' do
       src = File.read(described_class.method(:build).source_location.first)
+      expect(src).to match(/recent_turns_block/)
+      expect(src).to match(/memory_block/)
+      expect(src).to match(/skills_block/)
+      expect(src).to match(/learning_block/)
       expect(src).to match(/KNOWN MISTAKES|mistakes_block/)
-      expect(src).to match(/stuck|expand_harness|lean/)
+      expect(src).to match(/skills_recall/)
     end
   end
 end

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

@@ -13,17 +13,24 @@ describe PWN::AI::Agent::Registry do
     expect(help_response).to respond_to :help
   end
 
-  it 'DEFAULT_PREFERENCE names only CORE_TOOLS in a recall-first fallback' do
-    expect(described_class::DEFAULT_PREFERENCE).to eq(
-      %w[memory_recall pwn_eval shell mistakes_record mistakes_resolve learning_note_outcome memory_remember]
+  it 'CORE_TOOLS is recall-then-act including skills_recall before pwn_eval' do
+    expect(described_class.const_defined?(:ACT_PREFERENCE)).to eq false
+    expect(described_class::CORE_TOOLS).to eq(
+      %w[memory_recall session_recall skills_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).to eq(described_class::CORE_TOOLS)
     expect(described_class::DEFAULT_PREFERENCE).not_to include('sessions_view')
+    expect(described_class::CORE_TOOLS.index('memory_recall')).to be < described_class::CORE_TOOLS.index('session_recall')
+    expect(described_class::CORE_TOOLS.index('session_recall')).to be < described_class::CORE_TOOLS.index('skills_recall')
+    expect(described_class::CORE_TOOLS.index('skills_recall')).to be < described_class::CORE_TOOLS.index('pwn_eval')
+    expect(described_class::CORE_TOOLS.index('pwn_eval')).to be < described_class::CORE_TOOLS.index('shell')
   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])
+  it 'preference_order is DEFAULT_PREFERENCE — kind/intent do not change it' do
+    expect(described_class.preference_order).to eq(described_class::DEFAULT_PREFERENCE)
+    expect(described_class.preference_order.first(5)).to eq(%w[memory_recall session_recall skills_recall pwn_eval shell])
+    expect(described_class.preference_order(kind: :question)).to eq(described_class::DEFAULT_PREFERENCE)
+    expect(described_class.preference_order(intent: :recall)).to eq(described_class::DEFAULT_PREFERENCE)
   end
 
   it 'preference_order still honors explicit empty list and Env override' do
@@ -34,8 +41,8 @@ describe PWN::AI::Agent::Registry do
   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).to eq(described_class::CORE_TOOLS)
     expect(names).not_to include('sessions_view')
-    expect(names.length).to be <= described_class::CORE_TOOLS.length
+    expect(names.length).to eq(described_class::CORE_TOOLS.length)
   end
 end

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

@@ -28,6 +28,11 @@ describe 'PWN::AI::Agent::Tools sessions' do
     expect(PWN::AI::Agent::Registry.lookup(name: 'sessions_current')).not_to be_nil
   end
 
+  it 'registers the session_recall tool' do
+    PWN::AI::Agent::Registry.discover(force: true)
+    expect(PWN::AI::Agent::Registry.lookup(name: 'session_recall')).not_to be_nil
+  end
+
   it 'exposes the sessions toolset in the registry' do
     PWN::AI::Agent::Registry.discover(force: true)
     expect(PWN::AI::Agent::Registry.toolsets).to include('sessions')

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

@@ -10,6 +10,10 @@ describe 'PWN::AI::Agent::Tools skills' do
     expect(PWN::AI::Agent::Registry.lookup(name: 'skill_list')).not_to be_nil
   end
 
+  it 'registers the skills_recall tool' do
+    expect(PWN::AI::Agent::Registry.lookup(name: 'skills_recall')).not_to be_nil
+  end
+
   it 'registers the skill_migrate_legacy tool' do
     expect(PWN::AI::Agent::Registry.lookup(name: 'skill_migrate_legacy')).not_to be_nil
   end
@@ -32,6 +36,18 @@ describe 'PWN::AI::Agent::Tools skills' do
     let(:delete) { PWN::AI::Agent::Registry.lookup(name: 'skill_delete')[:handler] }
     let(:list)   { PWN::AI::Agent::Registry.lookup(name: 'skill_list')[:handler] }
     let(:view)   { PWN::AI::Agent::Registry.lookup(name: 'skill_view')[:handler] }
+    let(:recall) { PWN::AI::Agent::Registry.lookup(name: 'skills_recall')[:handler] }
+
+    it 'skills_recall ranks matching skills by query and skips non-matches' do
+      create.call(name: 'browser-dump', description: 'Dump links via TransparentBrowser.', content: "open once, dump_links, close once\n")
+      create.call(name: 'unrelated', description: 'Something else entirely.', content: "no overlap here\n")
+      hits = recall.call(query: 'TransparentBrowser dump_links', limit: 8)
+      expect(hits).to be_an(Array)
+      expect(hits).not_to be_empty
+      names = hits.map { |h| h[:name].to_s }
+      expect(names).to include('browser-dump')
+      expect(names).not_to include('unrelated')
+    end
 
     it 'skill_create writes <name>/SKILL.md with required name+description frontmatter' do
       out = create.call(name: 'Recon Quick_Scan', description: 'Fast host triage.', content: "# Recon\nnmap -T4 -F {t}\n", references: ['T1046'])

data/spec/lib/pwn/ai/red_team/test_case_engine_spec.rb

@@ -59,8 +59,13 @@ describe PWN::AI::RedTeam::TestCaseEngine do
       described_class.define_singleton_method(:judge) { |_opts| 'EPSS 5%' }
     end
 
+    before do
+      described_class.class_variable_set(:@@logger, Logger.new(File::NULL))
+    end
+
     after do
       load File.expand_path('../../../../../lib/pwn/ai/red_team/test_case_engine.rb', __dir__)
+      described_class.class_variable_set(:@@logger, Logger.new(File::NULL))
     end
 
     it 'generates payload_count LLM payloads from strategies' do
@@ -85,6 +90,21 @@ describe PWN::AI::RedTeam::TestCaseEngine do
       )
     end
 
+    it 'does not print [INFO] completion banners to $stdout' do
+      apply_env_stub
+      apply_engine_stub({})
+      expect do
+        described_class.execute(
+          strategies: strategies,
+          payload_count: 1,
+          security_references: refs,
+          target_engine: :grok,
+          attacker_engine: :grok,
+          max_adaptive_rounds: 0
+        )
+      end.to output('').to_stdout
+    end
+
     it 'defaults to ten generated payloads when payload_count is omitted' do
       tracker = {}
       apply_env_stub

data/spec/lib/pwn/plugins/repl_spec.rb

@@ -24,4 +24,13 @@ describe PWN::Plugins::REPL do
     expect(described_class.compact_context_tokens(tokens: 26_000)).to eq('26K')
     expect(described_class.compact_context_tokens(tokens: 500_000)).to eq('500K')
   end
+
+  it 'ready_tty! exists and the pwn-ai path resets the TTY before the next PS1' do
+    expect(described_class).to respond_to :ready_tty!
+    hook = File.read(described_class.method(:add_hooks).source_location.first)
+    expect(hook).to match(/ready_tty!/)
+    expect(hook).to match(/request\.replace\('nil'\)/)
+    reader = File.read(described_class.const_get(:PWNMultiLineInput).instance_method(:readline).source_location.first)
+    expect(reader).to match(/ready_tty!/)
+  end
 end

data/spec/lib/pwn/plugins/tty_spinner_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require 'stringio'
 
 describe PWN::Plugins::TTYSpinner do
   it 'should display information for authors' do
@@ -10,4 +11,33 @@ describe PWN::Plugins::TTYSpinner do
   it 'should display information for existing help method' do
     expect(described_class).to respond_to :help
   end
+
+  it 'stop joins the auto_spin worker so no frames are written after the response' do
+    io = StringIO.new
+    spin = described_class.start(output: io, format: :dots)
+    spin.auto_spin
+    worker = spin.instance_variable_get(:@thread)
+    expect(worker).to be_a(Thread)
+    sleep 0.12
+    described_class.stop(spin: spin)
+    expect(worker.alive?).to eq false
+    after_stop = io.string.dup
+    sleep 0.2
+    expect(io.string).to eq(after_stop)
+    expect(spin.done?).to eq true
+  end
+
+  it 'stop is a no-op for nil and is idempotent' do
+    expect { described_class.stop(spin: nil) }.not_to raise_error
+    io = StringIO.new
+    spin = described_class.start(output: io)
+    described_class.stop(spin: spin)
+    expect { described_class.stop(spin: spin) }.not_to raise_error
+  end
+
+  it 'stop shows the cursor on $stdout so the next PS1 is visible' do
+    src = File.read(described_class.method(:stop).source_location.first)
+    expect(src).to match(/Cursor\.show/)
+    expect(src).to match(/\$stdout/)
+  end
 end

data/spec/lib/pwn/sessions_spec.rb

@@ -61,4 +61,33 @@ describe PWN::Sessions do
   ensure
     FileUtils.rm_rf(tmp) if tmp
   end
+
+  it 'recall searches prior session transcripts and skips the current session' do
+    tmp = Dir.mktmpdir
+    stub_const('PWN::Sessions::SESSIONS_DIR', tmp)
+    old = PWN::Sessions.create(id: '20200101_000000_oldone', title: 'old')
+    PWN::Sessions.append(session_id: old[:id], role: 'user', content: 'use hping3 for a ping sweep')
+    PWN::Sessions.append(session_id: old[:id], role: 'assistant', content: 'Prefer pwn_eval then shell for that')
+    cur = PWN::Sessions.create(id: '20260101_000000_curone', title: 'current')
+    PWN::Sessions.append(session_id: cur[:id], role: 'user', content: 'unrelated current chatter')
+    hits = PWN::Sessions.recall(query: 'hping3', exclude_session_id: cur[:id], limit: 8)
+    expect(hits).to be_an(Array)
+    expect(hits).not_to be_empty
+    expect(hits.all? { |h| h[:session_id] != cur[:id] }).to eq true
+    expect(hits.any? { |h| h[:content].to_s.include?('hping3') }).to eq true
+  ensure
+    FileUtils.rm_rf(tmp) if tmp
+  end
+
+  it 'previous_id returns the newest session that is not the current one' do
+    tmp = Dir.mktmpdir
+    stub_const('PWN::Sessions::SESSIONS_DIR', tmp)
+    old = PWN::Sessions.create(id: '20200101_000000_oldses', title: 'old')
+    PWN::Sessions.append(session_id: old[:id], role: 'user', content: 'SHIP MARKER LAST SESSION')
+    cur = PWN::Sessions.create(id: '20260101_000000_curses', title: 'current')
+    PWN::Sessions.append(session_id: cur[:id], role: 'user', content: 'what did I just say?')
+    expect(PWN::Sessions.previous_id(exclude_session_id: cur[:id])).to eq(old[:id])
+  ensure
+    FileUtils.rm_rf(tmp) if tmp
+  end
 end

data/spec/spec_helper.rb

@@ -38,3 +38,9 @@ RSpec.configure do |config|
     $stderr = original_stderr
   end
 end
+
+# Logger.new($stdout) captures the IO at class load — the same stream RSpec
+# uses for progress dots. Reassigning $stdout in before(:each) does not
+# retarget that logger. Point the red-team engine at /dev/null so execute
+# banners cannot leak into rake.
+PWN::AI::RedTeam::TestCaseEngine.class_variable_set(:@@logger, Logger.new(File::NULL)) if defined?(PWN::AI::RedTeam::TestCaseEngine)

data/third_party/pwn_rdoc.jsonl

@@ -2043,7 +2043,9 @@
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL.compact_context_tokens Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.compact_context_tokens`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL.enable_autocomplete Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.enable_autocomplete`: Supported Method Parameters\n\nPWN::Plugins::REPL.enable_autocomplete(\n\nenabled: 'optional - Boolean (default true). false reverts to single-line cycling.'\n\n)\n\nIRB-style suggest-as-you-type for the pwn REPL.\n\nReplaces Pry’s default input (rb-readline — single-candidate TAB cycling) with Reline and turns on Reline.autocompletion, which renders a live dropdown of candidates below the cursor as you type (the same widget IRB uses).  Pry already wires Reline.completion_proc → @pry.complete (Pry::InputCompleter) when input == Reline, so the menu is fed by the full Ruby/PWN object graph: constants (PWN::Plugins::Nm<TAB>), instance methods, local/global variables, and Pry slash-commands.\n\nNavigate with ↑/↓ or TAB, accept with → or ENTER, dismiss with ESC.\n\nScope: this drives the MAIN pwn REPL (Ruby).  pwn-ai / pwn-asm swap to PWNMultiLineInput, which bypasses Pry’s Reline path on purpose (natural-language / opcode input — Ruby completion isn’t useful there); SHIFT+ENTER multi-line continues to work in those modes.\n"}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL.help Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.help`: "}]}
+{"messages":[{"role":"user","content":"PWN::Plugins::REPL.ready_tty! Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.ready_tty!`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL.refresh_ps1_proc Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.refresh_ps1_proc`: "}]}
+{"messages":[{"role":"user","content":"PWN::Plugins::REPL.reset_reline_editor Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.reset_reline_editor`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL.start Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.start`: Supported Method Parameters\n\nPWN::Plugins::REPL.start\n"}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL.process Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.process`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL::PWNMultiLineInput.new Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL::PWNMultiLineInput.new`: "}]}
@@ -2115,6 +2117,8 @@
 {"messages":[{"role":"user","content":"PWN::Plugins::Spider.help Usage"},{"role":"assistant","content":"`PWN::Plugins::Spider.help`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::TTYSpinner.authors Usage"},{"role":"assistant","content":"`PWN::Plugins::TTYSpinner.authors`: Author(s)\n\n0day Inc. <support@0dayinc.com>\n"}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::TTYSpinner.help Usage"},{"role":"assistant","content":"`PWN::Plugins::TTYSpinner.help`: "}]}
+{"messages":[{"role":"user","content":"PWN::Plugins::TTYSpinner.join_spinner Usage"},{"role":"assistant","content":"`PWN::Plugins::TTYSpinner.join_spinner`: "}]}
+{"messages":[{"role":"user","content":"PWN::Plugins::TTYSpinner.join_thread Usage"},{"role":"assistant","content":"`PWN::Plugins::TTYSpinner.join_thread`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::TTYSpinner.start Usage"},{"role":"assistant","content":"`PWN::Plugins::TTYSpinner.start`: Supported Method Parameters\n\nspin = PWN::Plugins::TTYSpinner.start(\n\nformat: 'optional - TTY::Spinner format (defaults to :dots)',\noutput: 'optional - IO to draw on (defaults to $stderr)'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::TTYSpinner.stop Usage"},{"role":"assistant","content":"`PWN::Plugins::TTYSpinner.stop`: Supported Method Parameters\n\nPWN::Plugins::TTYSpinner.stop(\n\nspin: 'optional - TTY::Spinner from #start (no-op if nil)'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::ThreadPool.authors Usage"},{"role":"assistant","content":"`PWN::Plugins::ThreadPool.authors`: Author(s)\n\n0day Inc. <support@0dayinc.com>\n"}]}
@@ -2700,6 +2704,8 @@
 {"messages":[{"role":"user","content":"PWN::Sessions.list Usage"},{"role":"assistant","content":"`PWN::Sessions.list`: Supported Method Parameters\n\nsessions = PWN::Sessions.list\n"}]}
 {"messages":[{"role":"user","content":"PWN::Sessions.load Usage"},{"role":"assistant","content":"`PWN::Sessions.load`: Supported Method Parameters\n\ntranscript = PWN::Sessions.load(session_id: ‘required’)\n"}]}
 {"messages":[{"role":"user","content":"PWN::Sessions.protected_session_ids Usage"},{"role":"assistant","content":"`PWN::Sessions.protected_session_ids`: "}]}
+{"messages":[{"role":"user","content":"PWN::Sessions.recall Usage"},{"role":"assistant","content":"`PWN::Sessions.recall`: Supported Method Parameters\n\nhits = PWN::Sessions.recall(\n\nquery: 'optional - substring / tokens to match',\nexclude_session_id: 'optional - skip this id (current session)',\ninclude_current: 'optional - Boolean include excluded id (default false)',\nlimit: 'optional - max hits (default 12)',\nmax_files: 'optional - newest files to scan (default 40)',\ntruncate: 'optional - chars per hit (default 280)'\n\n)\n"}]}
+{"messages":[{"role":"user","content":"PWN::Sessions.recall_score Usage"},{"role":"assistant","content":"`PWN::Sessions.recall_score`: "}]}
 {"messages":[{"role":"user","content":"PWN::Sessions.sessions_dir Usage"},{"role":"assistant","content":"`PWN::Sessions.sessions_dir`: Supported Method Parameters\n\ndir = PWN::Sessions.sessions_dir\n"}]}
 {"messages":[{"role":"user","content":"PWN::Sessions.stats Usage"},{"role":"assistant","content":"`PWN::Sessions.stats`: Supported Method Parameters\n\nstats = PWN::Sessions.stats\n"}]}
 {"messages":[{"role":"user","content":"PWN::Sessions.stub_session? Usage"},{"role":"assistant","content":"`PWN::Sessions.stub_session?`: "}]}

metadata

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