pwn 0.5.686 → 0.5.688

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c85ad9f56d45556168111931b475458009ad82fd7dac279457824484dde1105
-  data.tar.gz: 8cc423564b1f6adc95674b7002ca2a33abcc3e337b0d9a4dbf493a108431d1af
+  metadata.gz: 57da0c5ba0b3110683a6cad1e71a400dc1d58ef63337016ff1d6b710bbc293e1
+  data.tar.gz: 125343370941538d882d38f8b3b2bec6a89d973db66dc5ad724e85ec073a2583
 SHA512:
-  metadata.gz: f1b42ef466382cbe8122910f5baee95d4c1af40090bf31e26961f31ee2d66a44be805c51bed475c4f96b57c9a0fac00cacd7a2a554f1035fabd354823f4a4652
-  data.tar.gz: a53ae1eeb0fdd70938672b357c55456699810679921abd9ecfa17a1f296a3fe9c4b10dfd663b0958e52b450d80a7197c601724120efc9ccf03b90c0cac1d55b2
+  metadata.gz: eb44627c68dd94bedf56449d7a5337b1042a69ecf080e17300dce2e907643a6c14e13cf32064dfbc384885b501e43b1c0e4f6bd203549dd805e335f6948eea5f
+  data.tar.gz: 5031073e597b8562dd5ff6718fb37faad67d0bdab0afce0750e518762c3398d16aba22e0486859ae56e8539455121ac7c2db457a9e6348e6ee366ba3b0534a15

data/.gitignore

@@ -64,3 +64,5 @@ packer/*.box
 third_party/burpsuite-pro.jar
 third_party/open_ai_pwn.jsonl
 ubuntu-*-cloudimg-console.log
+
+vendor/

data/.ruby-version

@@ -1 +1 @@
-4.0.5
+4.0.6

data/Gemfile

@@ -20,9 +20,9 @@ gem 'base32', '0.3.4'
 gem 'bitcoin-ruby', '0.0.20'
 gem 'brakeman', '8.0.6'
 gem 'bson', '5.2.0'
-gem 'bundler', '>=4.0.18'
+gem 'bundler', '>=4.0.19'
 gem 'bundler-audit', '>=0.9.3'
-gem 'bunny', '3.1.0'
+gem 'bunny', '3.2.0'
 gem 'colorize', '1.1.0'
 gem 'credit_card_validations', '9.0.0'
 gem 'curses', '1.6.0'
@@ -50,7 +50,7 @@ gem 'libusb', '0.8.0'
 gem 'luhn', '3.0.0'
 gem 'mail', '2.9.1'
 gem 'mcp', '1.2.0'
-gem 'meshtastic', '0.0.173'
+gem 'meshtastic', '0.0.174'
 gem 'metasm', '1.0.6'
 gem 'mongo', '2.25.0'
 gem 'msfrpc-client', '1.1.2'

data/README.md

@@ -121,10 +121,9 @@ message bus:
 Long-running turns also show **executive task briefs** (not raw commands) via
 `TaskSummarizer`. There is no request type. Every request gets an English
 task compass (`emit_plan!` on submit, `about_to` as `task k/n` before each
-tool batch). Duplicate briefs are suppressed. Budget-hot turns skip extra
-counterfactual forks and only strip tools on the last iteration when the
-original request is already satisfied. Yesterday's scars do not lower this
-request's `max_iters` (default 777).
+tool batch). Duplicate briefs are suppressed. Loop.run does not abort
+on a round cap — CORE_TOOLS stay until `may_finalize?`. Yesterday's
+scars do not end this request.
 
 Full pages: [How PWN Works](documentation/How-PWN-Works.md) ·
 [All data-flow diagrams](documentation/Diagrams.md)

data/documentation/Agent-Tool-Registry.md

@@ -56,7 +56,7 @@ pool to:
 ```text
 CORE_TOOLS / DEFAULT_PREFERENCE (same list):
 memory_recall · session_recall · skills_recall · pwn_eval · shell
-mistakes_record · mistakes_resolve · learning_note_outcome · memory_remember
+mistakes_record · mistakes_resolve · learning_note_outcome · memory_remember · skills_update
             + top-K keyword-ranked matches for THIS request
               (ties break on Metrics per-engine success_rate, then
                ai.agent.tool_preference)
@@ -80,7 +80,7 @@ default order:
 
 ```text
 memory_recall · session_recall · skills_recall · pwn_eval · shell
-mistakes_record · mistakes_resolve · learning_note_outcome · memory_remember
+mistakes_record · mistakes_resolve · learning_note_outcome · memory_remember · skills_update
 ```
 
 Set `ai.agent.tool_preference` in `~/.pwn/pwn.yaml`, or pass `order:` /

data/documentation/Configuration.md

@@ -118,7 +118,7 @@ ai:
 
   agent:
     native_tools: true             # Use provider-native tool_calls / function-calling. false → legacy text-parsed tool protocol.
-    max_iters: 777                 # Hard cap on tool-call rounds per user turn. Scars do not lower it.
+    max_iters: 777                 # Advisory / Swarm. Loop.run does not abort on this cap.
     task_summary: true             # Executive task briefs via TaskSummarizer (plan + about_to). false disables.
     task_summary_every: 5          # When task_summary_verbose: emit Progress every N completed tools.
     task_summary_interval_s: 8.0   # When verbose: also emit when this many seconds elapsed.
@@ -132,7 +132,7 @@ 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:               # Same order as CORE_TOOLS: memory_recall, session_recall, skills_recall, pwn_eval, shell, mistakes_record, mistakes_resolve, learning_note_outcome, memory_remember. Current session is injected separately.
+    tool_preference:               # Same order as CORE_TOOLS: memory_recall, session_recall, skills_recall, pwn_eval, shell, mistakes_record, mistakes_resolve, learning_note_outcome, memory_remember, skills_update. Current session is injected separately.
       - memory_recall
       - session_recall
       - skills_recall
@@ -142,6 +142,7 @@ ai:
       - mistakes_resolve
       - learning_note_outcome
       - memory_remember
+      - skills_update
     escalation_persona: escalator  # Swarm persona for a 3-line corrective hint after enough in-turn failures. nil = disabled.
     local_introspect: failure_only # End-of-turn auto_introspect policy for local engines: always | failure_only | every_n.
     policy: true                   # Live tabular Q / REINFORCE. Advisory only; never replaces TaskSummarizer / plan_first. false disables.
@@ -302,7 +303,7 @@ PWN::Config.refresh_env
 | Key path | Type | Default | Consumed by | Purpose |
 |---|---|---|---|---|
 | `ai.agent.native_tools` | Boolean | `true` | `PWN::Plugins::REPL` (`pwn-ai` cmd) | Use provider-native `tool_calls` / function-calling. `false` falls back to the legacy text-parsed tool protocol. |
-| `ai.agent.max_iters` | Integer | `777` | `PWN::AI::Agent::Loop.run`, `PWN::AI::Agent::Swarm` | Hard cap on tool-call rounds per user turn. Budget-hot scars and overconfidence do not lower this request's runway. |
+| `ai.agent.max_iters` | Integer | `777` | `PWN::AI::Agent::Swarm` | Advisory. `Loop.run` does not abort a live goal on this counter. |
 | `ai.agent.task_summary` | Boolean | `true` | `PWN::AI::Agent::TaskSummarizer`, `Loop` | Master switch for executive task briefs (`emit_plan!` / `about_to`). |
 | `ai.agent.task_summary_every` | Integer | `5` | `TaskSummarizer.every_n` | Verbose progress cadence (tools). |
 | `ai.agent.task_summary_interval_s` | Float | `8.0` | `TaskSummarizer.interval_s` | Verbose progress cadence (seconds). |
@@ -315,7 +316,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`, `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 as RECENT TURNS. 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`, `skills_update` | `PWN::AI::Agent::Registry.preference_order` / `.rank` / `.apply_preference`, `Policy` | Same order as `CORE_TOOLS`. Current session is injected as RECENT TURNS. 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/General-PWN-Usage.md

@@ -45,7 +45,7 @@ history                             # what you've typed → copy into a driver
 | `pwn-ai-sessions` | List / view / delete transcripts |
 | `pwn-ai-cron` | List / run scheduled jobs |
 | `pwn-ai-delegate` | Hand a task to a Swarm persona |
-| `toggle-pwn-ai-debug` | Stream pwn-ai module progress to the TUI and `/tmp/pwn-ai-DEBUG-TIMESTAMP.log` |
+| `toggle-debug` | Stage log per request to `/tmp/pwn-ai-DEBUG-<SESSION_ID>-RN.log` (`ai.agent.debug_trace` for TracePoint) |
 | `toggle-pwn-ai-speaks` | TTS every final answer on/off |
 | `welcome-banner` | Redraw a random `PWN::Banner` |
 | `toggle-pager` | Pry pager on/off |

data/documentation/Home.md

@@ -27,7 +27,7 @@
 | | |
 |---|---|
 | [The `pwn` REPL](pwn-REPL.md) | Pry shell with the whole `PWN::` namespace pre-loaded |
-| [`pwn-ai` Autonomous Agent](pwn-ai-Agent.md) | Natural-language TUI + `pwn --ai PROMPT` one-shot · **TaskSummarizer** briefs · iteration budget guard |
+| [`pwn-ai` Autonomous Agent](pwn-ai-Agent.md) | Natural-language TUI + `pwn --ai PROMPT` one-shot · **TaskSummarizer** briefs · CORE_TOOLS until `may_finalize?` |
 | [CLI Drivers `bin/pwn_*`](CLI-Drivers.md) | 54 headless executables (`pwn` + 53 `pwn_*`) for CI/CD |
 | [Drivers (build your own)](Drivers.md) | Turn a REPL session into a shipped binary |
 

data/documentation/How-PWN-Works.md

@@ -27,7 +27,7 @@ hardware).
 
 | Module | Role |
 |---|---|
-| `Loop` | plan → **TaskSummarizer** briefs → dispatch tool_calls → observe → repeat until final answer. Scars do not lower `max_iters` (default 777). Last-iter strips tools only when the original request is already satisfied |
+| `Loop` | plan → **TaskSummarizer** briefs → dispatch tool_calls → observe → repeat until `may_finalize?`. No iteration-budget abort |
 | **`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** · **87 tools** · `CORE_TOOLS` = `DEFAULT_PREFERENCE` (`memory_recall` · `session_recall` · `skills_recall` · `pwn_eval` · `shell` · `mistakes_record` · `mistakes_resolve` · `learning_note_outcome` · `memory_remember`) |
 | `Dispatch` / `Result` | execute a tool, capture stdout/value/error/duration |

data/documentation/Mistakes.md

@@ -50,7 +50,7 @@ Repeating shell failures with a known recipe (`command is required`, missing pat
 | Source | Trigger | What is recorded |
 |---|---|---|
 | `:tool` | any tool dispatch returns `success:false` / raises | *automatic* - `Loop.record_metrics` |
-| `:loop` | iteration budget exhausted with no final answer | *automatic* - `Loop.run` epilogue |
+| `:loop` | (legacy) iteration budget exhausted — Loop.run no longer emits this | *historical* |
 | `:user_correction` | next user message matches `CORRECTION_RX` (*"no that's wrong"*, *"still broken"*, *"try again"*, ...) | `check_user_correction` - also flips the previous `Learning` outcome to `success:false` |
 | `:model` | the model itself calls `mistakes_record` | wrong assumption, wrong file, hallucinated API - failures that are **not** dispatch errors |
 | **`:model` (proactive)** | **`extro_verify(claim:)` returns `:refuted`** | **`Mistakes.record(tool:'assumption', error:'REFUTED ...: <claim>')` - the browser caught the model being wrong about the world *before* a human did** |

data/documentation/Reinforcement-Learning.md

@@ -115,13 +115,11 @@ When unresolved `agent_loop` / `assistant_answer` budget-exhaustion fingerprints
 dominate, the loop marks the budget path hot and tightens *side work* only:
 
 - skip counterfactual / red-team forks that would spend more tool rounds
-- last-iter strips tools only when the original request is already satisfied
-- still flush TaskSummarizer state and Learning on the exhaust path
-- end-of-turn critic runs text-only under the same pressure
+- **do not abort** with `[pwn-ai] iteration budget exhausted`
 - **do not shrink `max_iters`** - yesterday's scars must not abort this request
 
 Practice prioritizes those scars with short-horizon "finish the task" prompts.
-Raising `ai.agent.max_iters` still sets the hard ceiling.
+`Loop.run` has no hard ceiling — CORE_TOOLS stay until `may_finalize?`.
 
 ## Design-priority STATUS
 
@@ -141,7 +139,7 @@ This is the live control list. Track the outcomes, not source comments.
 | ops | Nightly diet close | `offline_judge` then scrub + mix + KPI so raw resolve prose does not survive the night |
 | ops | Shape backfill (`Reward.infer_shape`) | Legacy shapeless rows become `winning_trace` / `revised_answer` when the content warrants |
 | ops | Mix in prompt | `Metrics.to_context` emits `MIX:` when preference sources are unhealthy |
-| must | Budget exhaust | Last-iter force-final only when the original request is already satisfied; skip extra forks when the budget path is hot; **do not shrink max_iters**; still flush the session + introspect |
+| must | Budget exhaust | Loop.run does **not** abort on a round cap or emit `[pwn-ai] iteration budget exhausted`. Keep CORE_TOOLS until `may_finalize?`. Skip extra CF forks when old budget scars are hot; **do not shrink max_iters** |
 
 ## Intro and extro join
 
@@ -171,7 +169,7 @@ This is the live control list. Track the outcomes, not source comments.
     :max_iters: 777          # hard cap for this request; scars do not lower it
     :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, session_recall, skills_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, skills_update]
 ```
 
 ## Cron self-improvement

data/documentation/Troubleshooting.md

@@ -149,6 +149,6 @@ If you still see doubles, confirm you are on a build with `lib/pwn/ai/agent/task
 
 ## Agent stops early / "iteration budget exhausted"
 
-When unresolved budget-exhaustion mistakes dominate, the Loop does **not** shrink `max_iters` (default 777). It only trims side work: skip extra counterfactual forks, and strip tools on the last iteration only if the original request is already satisfied. Check `mistakes_list`, resolve fixed signatures, or raise `ai.agent.max_iters` if a long task still hits the cap. Exhaust paths still run Learning and the task-summary flush.
+When unresolved budget-exhaustion mistakes dominate, the Loop does **not** abort the request. There is no `[pwn-ai] iteration budget exhausted` final. Loop keeps CORE_TOOLS until `may_finalize?`. Ctrl-C stops the turn. OpenGoal stays until a real final so `continue` reloads the same request. Old budget scars do not end this request.
 
 [← Home](Home.md)

data/documentation/pwn-REPL.md

@@ -27,7 +27,7 @@ commands.
 | `pwn-ai-cron` | `PWN::Cron` | List/run/toggle scheduled jobs |
 | `pwn-ai-delegate` | `Agent::Swarm` | Send one request to a persona |
 | `pwn-irc` | *(deprecated)* | Prints a pointer to `Agent::Swarm` - the IRC daemon transport is gone |
-| `toggle-pwn-ai-debug` | `Agent::Loop` / `Plugins::Log` | Stream every pwn-ai module step to the TUI and `/tmp/pwn-ai-DEBUG-TIMESTAMP.log` |
+| `toggle-debug` | `Agent::Loop` / `Plugins::Log` | Stage log per operator request to `/tmp/pwn-ai-DEBUG-<SESSION_ID>-RN.log`. Set `ai.agent.debug_trace` for per-call TracePoint |
 | `toggle-pwn-ai-speaks` | `Plugins::Voice` | TTS every final answer on/off |
 | `welcome-banner` | `PWN::Banner` | Redraw a random banner |
 | `toggle-pager` | Pry | Page long output on/off |

data/documentation/pwn-ai-Agent.md

@@ -143,7 +143,7 @@ There is no request type. Every request gets an English task compass.
 - Advancement needs a PRM +1 streak or a clear phase shift after tools on the active task (not a blind every-3-tools hop).
 - REPL contract: `on_tool.call('task', full_summary_text, '')` - result empty, no truncation.
 
-**Long-run pressure:** budget-hot turns skip extra counterfactual forks. The last iteration strips tools only when the original request is already satisfied. Scars and overconfidence do not lower this request's `max_iters` (default 777). Task state and Learning still flush on the exhaust path.
+**Long-run pressure:** Loop.run does not abort on a round cap. Keep CORE_TOOLS until `may_finalize?`. Budget-hot turns skip extra counterfactual forks. Ctrl-C stops the turn.
 
 ![TaskSummarizer](diagrams/task-summarizer.svg)
 
@@ -163,7 +163,6 @@ max_iters: 777                  # scars / overconf do not lower this request
 
 - SHIFT+ENTER = newline, ENTER = submit.
 - `back` / `exit` returns to the plain REPL.
-- Set `ai.agent.max_iters` in `~/.pwn/pwn.yaml` if long tasks get truncated.
 - Disable `auto_introspect` during noisy fuzz loops
   (`learning_auto_introspect_toggle(enabled: false)`), re-enable for the
   summary turn.
@@ -196,7 +195,7 @@ max_iters: 777                  # scars / overconf do not lower this request
 | `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` | same list as CORE_TOOLS (`memory_recall`, `session_recall`, `skills_recall`, `pwn_eval`, `shell`, `mistakes_record`, `mistakes_resolve`, `learning_note_outcome`, `memory_remember`) | Rank bonus + Policy suggested-action order |
+| `tool_preference` | same list as CORE_TOOLS (`memory_recall`, `session_recall`, `skills_recall`, `pwn_eval`, `shell`, `mistakes_record`, `mistakes_resolve`, `learning_note_outcome`, `memory_remember`, `skills_update`) | 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/curriculum.rb

@@ -527,7 +527,7 @@ module PWN
           ensure_persona(name: RED_TEAM_NAME, role: 'You are pwn-ai\'s adversarial plan reviewer. Given a numbered tool plan and telemetry from THIS host (tool success rates, known mistakes, environment drift), identify the ONE step most likely to fail and say why in ≤2 lines. Cite the metric/mistake/drift. If the plan is sound reply: SOUND.')
           telemetry = build_telemetry
           reply = with_curriculum_guard do
-            ask_persona(name: RED_TEAM_NAME, request: "GOAL: #{opts[:request].to_s[0, 300]}\n\nPLAN:\n#{opts[:plan].to_s[0, 1_200]}\n\nHOST TELEMETRY:\n#{telemetry}")
+            ask_persona(name: RED_TEAM_NAME, request: "GOAL: #{opts[:request].to_s[0, 300]}\n\nPLAN:\n#{opts[:plan].to_s[0, 1_200]}\n\nHOST TELEMETRY:\n#{telemetry}", text_only: true)
           end
           return nil if reply.to_s.strip.upcase.start_with?('SOUND') || reply.to_s.strip.empty?
 
@@ -1086,7 +1086,7 @@ module PWN
         private_class_method def self.ask_persona(opts = {})
           return nil unless defined?(Swarm)
 
-          r = Swarm.ask(name: opts[:name], request: opts[:request])
+          r = Swarm.ask(name: opts[:name], request: opts[:request], text_only: opts[:text_only])
           r.is_a?(Hash) ? r[:reply].to_s : r.to_s
         rescue StandardError
           nil

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

@@ -301,7 +301,7 @@ module PWN
         ].freeze
         STORE_TOOLS = %w[
           memory_remember mistakes_record mistakes_resolve
-          learning_note_outcome skill_create skill_add_reference
+          learning_note_outcome skill_create skill_add_reference skills_update
         ].freeze
 
         public_class_method def self.effect(opts = {})

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

@@ -408,6 +408,65 @@ module PWN
           out.merge(saved: true)
         end
 
+        # Fold RL artefacts (mistakes / structured_fix / an explicit lesson)
+        # into an existing skill. Does not create skills (use distill_skill /
+        # skill_create). Does not write loop-law. Dedupes by mistake signature.
+        public_class_method def self.update_skill(opts = {})
+          dry = opts[:dry_run] ? true : false
+          lesson = opts[:lesson].to_s.strip
+          notes = rl_skill_notes(
+            signature: opts[:signature],
+            request: opts[:request] || opts[:query],
+            lesson: lesson
+          )
+          return { updated: false, reason: 'no rl notes' } if notes.empty?
+
+          target = locate_skill_for_update(
+            name: opts[:name],
+            query: opts[:query] || opts[:request] || notes.map { |n| n[:text] }.join(' ')
+          )
+          return { updated: false, reason: 'no matching skill', notes: notes } unless target
+
+          body = skill_body_without_frontmatter(meta: target[:meta])
+          added = []
+          notes.each do |note|
+            next if body.include?(note[:id])
+
+            added << note
+          end
+          return { updated: false, name: target[:name], reason: 'already folded', notes: notes } if added.empty?
+
+          block = added.map { |n| "- [#{n[:id]}] #{n[:text]}" }.join("\n")
+          body = if body.match?(/^\#{1,3}\s*RL feedback\s*$/i)
+                   "#{body.rstrip}\n#{block}\n"
+                 else
+                   "#{body.rstrip}\n\n## RL feedback\n#{block}\n"
+                 end
+          return { updated: false, dry_run: true, name: target[:name], added: added.map { |n| n[:text] } } if dry
+
+          root = skills_dir
+          out = PWN::Config.write_skill(
+            name: target[:name],
+            description: target[:meta][:description],
+            content: body,
+            references: target[:meta][:references],
+            license: (target[:meta][:frontmatter] || {})['license'],
+            allowed_tools: target[:meta][:allowed_tools],
+            metadata: (target[:meta][:frontmatter] || {})['metadata'],
+            pwn_skills_path: root
+          )
+          PWN::Config.load_skills(pwn_skills_path: root) if PWN::Config.respond_to?(:load_skills)
+          note_outcome(
+            task: "skills_update:#{target[:name]}",
+            success: true,
+            details: "Folded #{added.length} RL note(s)",
+            tags: %w[skill rl]
+          )
+          out.merge(updated: true, added: added.map { |n| n[:id] })
+        rescue StandardError => e
+          { updated: false, error: "#{e.class}: #{e.message}" }
+        end
+
         # Supported Method Parameters::
         # report = PWN::AI::Agent::Learning.reflect(
         #   session_id: 'required - PWN::Sessions id to analyse',
@@ -490,28 +549,14 @@ module PWN
 
           proxy_ok = infer_success(session_id: session_id, final: opts[:final])
 
-          # S3 critic — BEFORE reward so verdict is evidence.
-          # P24/P0 — budget_hot or soft-cap → text_only or skip.
-          force_critic = begin
-            eng = (PWN::Env.dig(:ai, :active) if defined?(PWN::Env))
-            cal = defined?(Metrics) ? Metrics.calibration(engine: eng) : { n: 0 }
-            cal[:n].to_i >= 8 && (cal[:brier].to_f > 0.35 || cal[:overconfidence].to_f > 0.25)
-          rescue StandardError
-            false
-          end
-          # P0 — when W1 mix urgently needs :critic pairs, prefer running critic
-          need_critic_mix = begin
-            mix = defined?(Reward) && Reward.respond_to?(:generator_mix) ? Reward.generator_mix : {}
-            Array(mix[:urgent]).include?('critic')
-          rescue StandardError
-            false
-          end
-
           crit = { verdict: :pass, source: :skipped }
-          # Single skip path (Lint/DuplicateBranch): hard-budget OR no Curriculum.
-          if !defined?(Curriculum) || (over_hard.call && !need_critic_mix)
+          # Live-turn critic is always text-only. A tool-armed persona is
+          # another Loop.run of the same goal (opens more browsers, never
+          # returns the operator answer). Cron/practice still call
+          # Curriculum.critic without text_only.
+          if !defined?(Curriculum) || over_hard.call
             stages_skipped << :critic
-          elsif budget_hot || (over_soft.call && !force_critic && !need_critic_mix)
+          else
             stages_run << :critic_text_only
             crit = Curriculum.critic(
               request: opts[:request],
@@ -519,18 +564,6 @@ module PWN
               session_id: session_id,
               text_only: true
             )
-          elsif force_critic
-            stages_run << :critic_forced
-            prev = (PWN::Env[:ai][:agent][:critic] if defined?(PWN::Env) && PWN::Env[:ai].is_a?(Hash) && PWN::Env[:ai][:agent].is_a?(Hash))
-            begin
-              PWN::Env[:ai][:agent][:critic] = true if defined?(PWN::Env) && PWN::Env[:ai].is_a?(Hash) && PWN::Env[:ai][:agent].is_a?(Hash) && !PWN::Env[:ai][:agent].frozen?
-              crit = Curriculum.critic(request: opts[:request], final: opts[:final], session_id: session_id)
-            ensure
-              PWN::Env[:ai][:agent][:critic] = prev if defined?(PWN::Env) && PWN::Env[:ai].is_a?(Hash) && PWN::Env[:ai][:agent].is_a?(Hash) && !PWN::Env[:ai][:agent].frozen?
-            end
-          else
-            stages_run << :critic
-            crit = Curriculum.critic(request: opts[:request], final: opts[:final], session_id: session_id)
           end
 
           # R1 judge — always attempt (heuristic is cheap; LLM gated inside)
@@ -1097,6 +1130,91 @@ module PWN
           !final.strip.empty?
         end
 
+        private_class_method def self.rl_skill_notes(opts = {})
+          notes = []
+          day = Time.now.utc.strftime('%Y-%m-%d')
+          lesson = opts[:lesson].to_s.strip
+          notes << { id: "lesson:#{Digest::SHA256.hexdigest(lesson)[0, 8]}", text: "[#{day}] #{lesson[0, 400]}" } unless lesson.empty?
+          return notes unless defined?(Mistakes)
+
+          rows = []
+          if opts[:signature].to_s.strip.empty?
+            rows = Mistakes.top(limit: 8, unresolved_only: false)
+          else
+            hit = Mistakes.find(signature: opts[:signature].to_s)
+            rows = hit ? [hit] : []
+          end
+          req = opts[:request].to_s.downcase
+          rows.each do |mistake|
+            next unless mistake.is_a?(Hash)
+
+            err = mistake[:error].to_s.downcase
+            next if (err.include?('budget') || err.include?('iteration')) && !req.match?(/budget|iterat|exhaust/)
+
+            fix = mistake[:fix].to_s
+            sf = mistake[:structured_fix]
+            trace = sf.is_a?(Hash) ? sf[:winning_trace].to_s : ''
+            next if fix.empty? && trace.empty?
+
+            sig = mistake[:signature].to_s
+            next if sig.empty?
+
+            bit = "[#{day}] [#{sig}] #{mistake[:tool]}: #{mistake[:error].to_s[0, 120]}"
+            bit = "#{bit} — FIX: #{fix[0, 160]}" unless fix.empty?
+            bit = "#{bit} trace: #{trace[0, 160]}" unless trace.empty?
+            notes << { id: sig, text: bit }
+          end
+          notes.uniq { |n| n[:id] }.first(6)
+        rescue StandardError
+          notes
+        end
+
+        private_class_method def self.locate_skill_for_update(opts = {})
+          return nil unless defined?(PWN::Skills) && PWN::Skills.is_a?(Hash)
+
+          if opts[:name].to_s.strip.empty?
+            query = opts[:query].to_s.downcase
+            tokens = query.scan(/[a-z0-9_-]{3,}/).uniq
+            return nil if tokens.empty?
+
+            scored = PWN::Skills.map do |name, meta|
+              next unless meta.is_a?(Hash)
+
+              hay = "#{name} #{meta[:description]} #{meta[:content]}".downcase
+              score = tokens.count { |tok| hay.include?(tok) }
+              [name.to_s, meta, score]
+            end.compact
+            best = scored.max_by { |_, _, score| score }
+            return nil unless best && best[2] >= 2
+
+            return { name: best[0], meta: best[1] }
+          end
+
+          key = opts[:name].to_s
+          meta = PWN::Skills[key.to_sym] || PWN::Skills[key]
+          if meta.nil? && defined?(PWN::Config)
+            meta = PWN::Skills[PWN::Config.sanitize_skill_name(name: key).to_sym]
+            key = PWN::Config.sanitize_skill_name(name: key) if meta
+          end
+          return nil unless meta.is_a?(Hash)
+
+          { name: key.to_s, meta: meta }
+        rescue StandardError
+          nil
+        end
+
+        private_class_method def self.skill_body_without_frontmatter(opts = {})
+          meta = opts[:meta] || {}
+          raw = meta[:content].to_s
+          return raw unless defined?(PWN::Config) && PWN::Config.respond_to?(:parse_skill_frontmatter)
+
+          parsed = PWN::Config.parse_skill_frontmatter(content: raw)
+          body = parsed[:body].to_s
+          body.empty? ? raw : body
+        rescue StandardError
+          opts.dig(:meta, :content).to_s
+        end
+
         private_class_method def self.skills_dir
           if defined?(PWN::Config) && PWN::Config.respond_to?(:pwn_skills_path)
             PWN::Config.pwn_skills_path