pwn 0.5.744 → 0.5.745

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df80036cfdf54ca32a6a7a568d17d167f16f4983c5f6c106f7577f2ca183814f
-  data.tar.gz: c423990479c34d4a21c5b549e283e81b44dec52670fbb9f19e7bf53f8ac692ba
+  metadata.gz: f3d60fd604a668b531459517b97dfee6448f9485679bd4c25bfe3ec12090cee9
+  data.tar.gz: 64a4dd65248017933e877c03db222ce61741e60044a03a1c9c9a1297ca7a4fde
 SHA512:
-  metadata.gz: c300723020b4e2da6e292ec06298fad5dc3a3c0f7e108eea2f91e2f746c18da3d705ea0ea4127185df3c82c3eaad4204307756c40b0b4ac0e8c8db1575e485b3
-  data.tar.gz: 4738cce8fb8eb570df5b0e48de365894f261b6ad3c011e875cc88a5f87f0397b849143910520b2aadb4dd628dcb242fe7d8865be2ed101d0e7829ba27127b9b5
+  metadata.gz: 1792ff5aea6a7c406248ab0fd6647732c490e56450afdf768840f340b4d7b4847a2d2cd996ff1349b3ca1a1bbfc05be40310225345e675937cc16022aaad5ec3
+  data.tar.gz: 7155e5d3cfca02bda195d0b0f926b85d6cd95b306b570d5956484ae237d360b36628a979e2d98a2c5ce3008343c7cecc1d14f12d0a986dbc577923a9f7905930

data/documentation/CLI-Drivers.md

@@ -59,6 +59,16 @@ pwn_setup --migrate --fix        # ~/.pwn state doctor + autofix (PWN::Migrate)
 See [Installation](Installation.md) for the full profile table, the
 `PWN::Setup` API and the `PWN::Migrate` state-file registry.
 
+## Offline policy evaluation with `pwn-ai`
+
+`pwn-ai --policy evaluate --baseline PATH --candidate PATH` prints two frozen
+held-out reports without opening a vault or starting an AI session. The separate
+`--policy promote` and `--policy rollback` actions require an explicit target and
+both `--approve-policy-change` and `--policy-writers-stopped`. They never start
+network tasks or automatically promote on success. See
+[Policy-Benchmark](Policy-Benchmark.md#offline-operator-cli) for runnable local
+commands, receipt preservation, fresh replay gates, and limitations.
+
 ## Typical CI usage
 
 ```yaml

data/documentation/Installation.md

@@ -187,6 +187,7 @@ What `--migrate` does:
    directory layout) → **deep-merge** any keys the current
    `PWN::Config.env_template` added into your encrypted `~/.pwn/pwn.yaml`
    **without overwriting your values** (re-encrypted with the same key/IV).
+   Schema 5 adds `ai.agent.skill_review` (`recommend` when the key is absent).
 
 Everything is idempotent and dry-run capable. The plain `pwn` launcher also
 prints a one-line drift warning on startup whenever `~/.pwn/.schema`

data/documentation/Policy-Benchmark.md

@@ -220,6 +220,82 @@ fields except `elapsed_seconds`. They contain no wall-clock timestamps, random
 IDs or temporary paths. The original training report still contains the timing
 and metadata variability described above.
 
+## Offline operator CLI
+
+`pwn-ai --policy evaluate|promote|rollback` reuses `PolicyEvaluation`; it never
+starts a session, loads the encrypted configuration, runs `Learning.rsi_tick`,
+or invokes the agent loop. It cannot be combined with `--ai`, replay, mission,
+or other session options. Evaluation accepts existing explicit frozen snapshots,
+runs suites 0 and 1, and prints a JSON **array** suitable for `--reports`. It does
+not train or write the live policy. The Ruby API supports other indices 0..7.
+
+From a source checkout, this disposable demonstration stays entirely under a
+new `/tmp` directory (use `pwn-ai` instead of `ruby -Ilib bin/pwn-ai` for an
+installed executable):
+
+```sh
+umask 077
+work=$(mktemp -d /tmp/pwn-offline-policy.XXXXXX)
+ruby scripts/benchmark_policy.rb --heldout \
+  --snapshot-dir "$work/snapshots" --output "$work/benchmark.json"
+ruby -Ilib bin/pwn-ai --policy evaluate \
+  --baseline "$work/snapshots/off.json" --candidate "$work/snapshots/on.json" \
+  > "$work/reports.json"
+cp "$work/snapshots/off.json" "$work/demo-live.json"
+```
+
+Review `reports.json` before deciding whether to proceed. For a real target,
+first stop **all** agent processes and other policy writers, take the baseline
+copy only after stopping them, and keep writers stopped through promotion and
+readback. The acknowledgement does not stop processes or acquire a writer lock.
+Concurrent promotions are also unsupported. Do not replace a real policy with
+these demonstration snapshots or infer live gains from this fixture experiment.
+
+Only if approving the change to the **disposable demo target**, run:
+
+```sh
+ruby -Ilib bin/pwn-ai --policy promote \
+  --baseline "$work/snapshots/off.json" --candidate "$work/snapshots/on.json" \
+  --reports "$work/reports.json" --live-policy "$work/demo-live.json" \
+  --approve-policy-change --policy-writers-stopped > "$work/promotion.json"
+cmp "$work/demo-live.json" "$work/snapshots/on.json"
+```
+
+The command re-executes both reports before considering replacement. It returns
+nonzero on refusal or malformed input; check the exit status and JSON, not just
+whether a redirected file exists. Keep the successful `promotion.json` receipt
+and digest-named backup. Use distinct, new output paths: shell redirection opens
+files before the CLI starts, so never redirect onto snapshots, the live target,
+or an existing receipt. A failed retry must not overwrite the successful receipt.
+
+Rollback is a separate explicit operator decision with the same stopped-writer
+requirement; it refuses intervening changes to the target:
+
+```sh
+ruby -Ilib bin/pwn-ai --policy rollback \
+  --receipt "$work/promotion.json" --live-policy "$work/demo-live.json" \
+  --approve-policy-change --policy-writers-stopped > "$work/rollback.json"
+cmp "$work/demo-live.json" "$work/snapshots/off.json"
+```
+
+Neither approval flag alone is sufficient. There is no default live path,
+automatic promotion, target discovery, network task, or model training in this
+CLI path. Reports and receipts are operator-owned local JSON, not executable
+configuration; neither can supply approval flags. Existing `Learning.rsi_tick`
+only snapshots measured rates and records a regression lesson. It does not call
+this gate, generate candidates, schedule practice, or approve changes. The
+broader online learning and curriculum paths remain unchanged and separate.
+
+Focused verification commands (no hardware, providers, or live models):
+
+```sh
+bundle exec rspec spec/lib/pwn/ai/cli_spec.rb \
+  spec/lib/pwn/ai/agent/policy_evaluation_spec.rb \
+  spec/lib/pwn/ai/agent/learning_spec.rb spec/lib/pwn/ai/agent/rsi_metrics_spec.rb
+bundle exec rubocop lib/pwn/ai/cli.rb spec/lib/pwn/ai/cli_spec.rb \
+  spec/lib/pwn/ai/agent/rsi_metrics_spec.rb
+```
+
 ## Explicit promotion and rollback
 
 This is an **operator-invoked local eligibility gate**, not automatic online

data/documentation/Reinforcement-Learning.md

@@ -12,6 +12,13 @@ one. Without a trainer it still **exports** the datasets and a manual CLI. Live
 
 ESR and ASR are the rates RSI actually compares. ESR is `verified_exploit_tools / vulnerable_tools`. ASR is `successful_attacks / total_attack_attempts`. `Learning.rsi_tick` stores the pair and writes an `rsi` lesson when ESR falls. Tool telemetry and the judge score are separate. A passing suite is not either rate.
 
+RSI's rate tick does not generate or promote policy candidates. For the separate
+**offline operator evaluation** path, use `pwn-ai --policy evaluate` and review
+the fixed local held-out reports. Promotion and rollback each require explicit
+`--approve-policy-change --policy-writers-stopped` plus a named live policy path;
+neither runs automatically from RSI. See the executable commands, stopped-writer
+requirements, and benchmark limits in [Policy-Benchmark](Policy-Benchmark.md#offline-operator-cli).
+
 ![Reinforcement-learning loop](diagrams/reinforcement-learning.svg)
 
 ```

data/documentation/Skills-Memory-Learning.md

@@ -132,6 +132,8 @@ bundled skills into `~/.pwn/skills/` when the name is missing:
 | `att&ck` | Exhaustive test procedure per ATT&CK technique (`references/T1059.001.md`) |
 | `humanizer` | Strip AI writing patterns from prose. Keep meaning and identifiers. |
 
+`PWN::AI::Agent::SkillReview` runs after introspection. A routine success does not create a skill. A tested procedure, a resolved recurring mistake, or an explicit correction can recommend an update to the closest skill under `~/.pwn/skills`. The default mode is `recommend`. `auto-safe` writes only a small addition that an execution fixture passed in three sessions, and it keeps a backup. It does not create skills, rewrite generated `pwn/` module skills, or save secrets and raw tool output. Set `ai.agent.skill_review` to `off`, `recommend`, or `auto-safe`.
+
 Source: `etc/default_skills/` in the gem. SOP edits in `~/.pwn/skills/<name>/SKILL.md`
 are never overwritten. Generated `~/.pwn/skills/pwn/**/SKILL.md` module skills
 are updated on migrate when `lib/pwn` changes.

data/etc/default_skills/pwn/ai/agent/skill_review/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: pwn-ai-agent-skillreview
+description: Drive PWN::AI::Agent::SkillReview from pwn_eval.
+license: MIT
+allowed-tools: [pwn, pwn_eval]
+metadata:
+  bundled: true
+  generated: true
+  module: PWN::AI::Agent::SkillReview
+  source: pwn/ai/agent/skill_review.rb
+---
+
+# PWN::AI::Agent::SkillReview
+
+Decide whether a completed task should update or create a skill. recommend is the default. auto-safe writes only a small verified addition.
+
+## When to use
+
+Call `PWN::AI::Agent::SkillReview` from `pwn_eval` when the task needs this module.
+Do not reimplement it in shell.
+
+## Methodologies
+
+Generated from `pwn/ai/agent/skill_review.rb`. Prefer the public class methods below.
+Class methods take `(opts = {})` and read `opts`.
+
+## How to call
+
+```ruby
+PWN::AI::Agent::SkillReview.help
+PWN::AI::Agent::SkillReview.review(opts)
+```
+
+## Public methods
+
+- `review`
+- `review_turn`
+- `note_reuse`
+- `authors`
+- `help`
+
+## Source
+
+`pwn/ai/agent/skill_review.rb`
+
+## Verification
+
+`PWN::AI::Agent::SkillReview.respond_to?(:review)` after the
+module is loaded. Read the source for parameter names.

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

@@ -822,13 +822,20 @@ module PWN
             rsi_tick(request: opts[:request])
           end
 
+          skill_review = nil
+          if defined?(SkillReview)
+            stages_run << :skill_review
+            skill_review = SkillReview.review_turn(request: opts[:request], final: opts[:final], success: opts[:success], session_id: opts[:session_id])
+          end
+
           {
             ok: ok,
             score: v[:score],
             elapsed_ms: elapsed_ms.call,
             budget_hot: budget_hot,
             stages_run: stages_run,
-            stages_skipped: stages_skipped
+            stages_skipped: stages_skipped,
+            skill_review: skill_review
           }
         rescue StandardError => e
           warn "[pwn-ai/learning] auto_introspect swallowed: #{e.class}: #{e.message}"

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

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'fileutils'
+require 'json'
+
+module PWN
+  module AI
+    module Agent
+      # Decide whether a completed task should update or create a skill.
+      # recommend is the default. auto-safe writes only a small verified addition.
+      module SkillReview
+        LEDGER = File.join(Dir.home, '.pwn', 'skill_review.jsonl').freeze
+        MODES = %w[off recommend auto-safe].freeze
+
+        public_class_method def self.review(opts = {})
+          mode = mode_from(mode: opts[:mode])
+          request = opts[:request].to_s
+          return finish(action: 'skipped', reason: 'mode off', mode: mode, request: request) if mode == 'off'
+          return finish(action: 'skipped', reason: 'routine success is not a skill', mode: mode, request: request) unless useful?(opts)
+
+          procedure = procedure_from(procedure: opts[:procedure], evidence: opts[:evidence])
+          unless procedure[:ok]
+            return finish(action: 'refused', reason: procedure[:reason], mode: mode, request: request) if opts[:procedure]
+
+            return finish(action: 'recommend', reason: 'a structured procedure is required before saving', mode: mode, request: request, verified: false)
+          end
+
+          target = locate(name: opts[:name], query: request, procedure: procedure[:text])
+          kind = target ? 'update' : 'create'
+          verified = verified_execution?(evidence: opts[:evidence])
+          proposal = {
+            action: 'recommend',
+            kind: kind,
+            name: target ? target[:name] : opts[:name].to_s,
+            mode: mode,
+            request: request,
+            verified: verified,
+            reason: target ? 'closest skill matches the procedure' : 'no existing skill matches',
+            path: target && target[:path]
+          }
+          return finish(proposal.merge(action: 'refused', reason: 'generated module skills are not rewritten')) if generated?(name: proposal[:name], path: proposal[:path])
+          return finish(proposal) unless mode == 'auto-safe' && auto_safe?(proposal: proposal, procedure: procedure)
+
+          apply_update(proposal: proposal, procedure: procedure, evidence: opts[:evidence], skills_root: opts[:skills_root])
+        end
+
+        public_class_method def self.review_turn(opts = {})
+          request = opts[:request].to_s
+          correction = defined?(Mistakes) && request.match?(Mistakes::CORRECTION_RX)
+          mistake = opts[:mistake]
+          if mistake.nil? && defined?(Mistakes) && Mistakes.respond_to?(:top)
+            rows = Array(Mistakes.top(limit: 8, unresolved_only: false))
+            mistake = rows.find { |row| row.is_a?(Hash) && row[:resolved] == true && row[:count].to_i >= 2 }
+            mistake = mistake.merge(source: 'mistakes') if mistake
+          end
+          review(opts.merge(user_correction: correction == true, mistake: mistake, session_id: opts[:session_id], final: opts[:final]))
+        end
+
+        public_class_method def self.note_reuse(opts = {})
+          row = {
+            name: opts[:name].to_s,
+            retrieved: opts[:retrieved] == true,
+            reused: opts[:reused] == true,
+            regressed: opts[:regressed] == true,
+            at: Time.now.utc.iso8601
+          }
+          append_ledger(row: row)
+          row
+        end
+
+        public_class_method def self.authors
+          "AUTHOR(S):\n  0day Inc. <support@0dayinc.com>\n"
+        end
+
+        public_class_method def self.help
+          puts "USAGE:
+            # Review a completed task and recommend or apply a skill change.
+            #{self}.review(
+              request: 'required - the completed task text',
+              mode: 'optional - off, recommend, or auto-safe; default recommend',
+              procedure: 'optional - Hash with when, prerequisites, steps, verification, and failures',
+              evidence: 'optional - execution proof with source, fixture_passed, and sessions',
+              name: 'optional - skill name to prefer',
+              success: 'optional - true alone is a routine success and is skipped',
+              user_correction: 'optional - true reviews an explicit operator correction',
+              skills_root: 'optional - skills directory for the write'
+            )
+
+            # Build a review from the completed turn, including an operator correction or a resolved mistake.
+            #{self}.review_turn(
+              request: 'required - the completed task text',
+              final: 'optional - final answer, not saved as a procedure',
+              success: 'optional - true alone does not create a skill',
+              session_id: 'optional - session id for the turn',
+              mistake: 'optional - resolved mistake Hash with count and source from the mistakes store'
+            )
+
+            # Record whether a later task retrieved or reused a reviewed skill.
+            #{self}.note_reuse(
+              name: 'required - skill name',
+              retrieved: 'optional - true when the catalog returned the skill',
+              reused: 'optional - true when the procedure was followed',
+              regressed: 'optional - true when reuse made the task worse'
+            )
+
+            # Print the module authors.
+            #{self}.authors
+          "
+        end
+
+        private_class_method def self.mode_from(opts = {})
+          raw = opts[:mode]
+          raw = PWN::Env.dig(:ai, :agent, :skill_review) if raw.nil? && defined?(PWN::Env) && PWN::Env.respond_to?(:dig)
+          mode = raw.to_s
+          mode = 'recommend' if mode.empty? || !MODES.include?(mode)
+          mode
+        end
+
+        private_class_method def self.useful?(opts = {})
+          return true if opts[:user_correction] == true
+
+          return true if opts[:procedure].is_a?(Hash) && opts[:evidence].is_a?(Hash)
+
+          mistake = opts[:mistake]
+          mistake.is_a?(Hash) && mistake[:resolved] == true && mistake[:count].to_i >= 2 && mistake[:source].to_s == 'mistakes'
+        end
+
+        private_class_method def self.procedure_from(opts = {})
+          raw = opts[:procedure]
+          return { ok: false, reason: 'procedure is required' } unless raw.is_a?(Hash)
+
+          fields = %i[when prerequisites steps verification failures]
+          missing = fields.reject { |key| raw[key].to_s.strip.length >= 8 }
+          return { ok: false, reason: "procedure missing #{missing.join(', ')}" } unless missing.empty?
+
+          text = fields.map { |key| "#{key}: #{raw[key].to_s.strip}" }.join("\n")
+          return { ok: false, reason: 'secret or target-specific text is not saved' } if sensitive?(text: text)
+          return { ok: false, reason: 'raw tool output is not a procedure' } if text.match?(/STDOUT|STDERR/) || text.length > 1200
+
+          { ok: true, text: text }
+        end
+
+        private_class_method def self.sensitive?(opts = {})
+          opts[:text].to_s.match?(/bearer |password|api_key|BEGIN |token|sk-[A-Za-z0-9]/i) || opts[:text].to_s.match?(/\b\d{1,3}(?:\.\d{1,3}){3}\b/)
+        end
+
+        private_class_method def self.verified_execution?(opts = {})
+          evidence = opts[:evidence].is_a?(Hash) ? opts[:evidence] : {}
+          evidence[:source].to_s == 'execution' && evidence[:fixture_passed] == true && Array(evidence[:sessions]).map(&:to_s).uniq.length >= 3 && evidence[:model_claimed] != true
+        end
+
+        private_class_method def self.locate(opts = {})
+          return nil unless defined?(PWN::Skills) && PWN::Skills.is_a?(Hash)
+
+          name = opts[:name].to_s
+          unless name.empty?
+            meta = PWN::Skills[name.to_sym] || PWN::Skills[name]
+            return { name: name, path: meta[:path], meta: meta } if meta.is_a?(Hash)
+          end
+
+          tokens = "#{opts[:query]} #{opts[:procedure]}".downcase.scan(/[a-z0-9]{4,}/).uniq
+          scored = PWN::Skills.map do |key, meta|
+            next unless meta.is_a?(Hash)
+
+            hay = "#{key} #{meta[:description]}".downcase
+            [key.to_s, meta, tokens.count { |tok| hay.include?(tok) }]
+          end.compact
+          best = scored.max_by { |_, _, score| score }
+          return nil unless best && best[2] >= 2
+
+          { name: best[0], path: best[1][:path], meta: best[1] }
+        end
+
+        private_class_method def self.generated?(opts = {})
+          opts[:name].to_s.start_with?('pwn/') || opts[:path].to_s.include?('/skills/pwn/')
+        end
+
+        private_class_method def self.auto_safe?(opts = {})
+          proposal = opts[:proposal] || {}
+          procedure = opts[:procedure] || {}
+          proposal[:kind] == 'update' && proposal[:verified] == true && procedure[:text].to_s.length <= 400
+        end
+
+        private_class_method def self.apply_update(opts = {})
+          proposal = opts[:proposal]
+          path = proposal[:path].to_s
+          return finish(proposal.merge(action: 'refused', reason: 'skill path missing')) unless File.file?(path) && !File.symlink?(path)
+
+          original = File.read(path)
+          digest = Digest::SHA256.hexdigest(original)
+          backup = "#{path}.#{digest}.bak"
+          File.open(backup, File::WRONLY | File::CREAT | File::EXCL, 0o600) { |file| file.write(original) } unless File.exist?(backup)
+          signature = (opts[:evidence] || {})[:signature].to_s
+          lesson = "#{signature}\n#{opts[:procedure][:text]}"
+          written = Learning.update_skill(name: proposal[:name], lesson: lesson, query: proposal[:request], pwn_skills_path: opts[:skills_root])
+          current = File.read(path)
+          unless current.include?(signature) && !signature.empty?
+            File.write(path, original)
+            return finish(proposal.merge(action: 'refused', reason: 'readback failed', written: written))
+          end
+
+          PWN::Config.load_skills(pwn_skills_path: opts[:skills_root]) if defined?(PWN::Config) && PWN::Config.respond_to?(:load_skills)
+          finish(proposal.merge(action: 'applied', backup: backup))
+        end
+
+        private_class_method def self.finish(opts = {})
+          row = opts.transform_keys(&:to_sym)
+          append_ledger(row: row)
+          row
+        end
+
+        private_class_method def self.append_ledger(opts = {})
+          path = LEDGER
+          FileUtils.mkdir_p(File.dirname(path))
+          File.open(path, 'a') { |file| file.puts(JSON.generate(opts[:row])) }
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/pwn/ai/agent.rb

@@ -15,6 +15,7 @@ module PWN
       autoload :GQRX, 'pwn/ai/agent/gqrx'
       autoload :SAST, 'pwn/ai/agent/sast'
       autoload :SkillConsolidation, 'pwn/ai/agent/skill_consolidation'
+      autoload :SkillReview, 'pwn/ai/agent/skill_review'
       autoload :TransparentBrowser, 'pwn/ai/agent/transparent_browser'
       autoload :VulnGen, 'pwn/ai/agent/vuln_gen'
 

data/lib/pwn/ai/cli.rb

@@ -20,6 +20,14 @@ module PWN
           options.on('--execute PATH', 'Run an approved YAML task DAG') { |v| result[:execute] = v }
           options.on('--resume RUN_ID', 'Resume a checkpointed DAG run, skipping completed steps') { |v| result[:resume] = v }
           options.on('--mission ID', 'Bind this plan or run to a durable mission') { |v| result[:mission] = v }
+          options.on('--policy ACTION', %w[evaluate promote rollback], 'Offline policy: evaluate, promote, rollback (no AI session)') { |v| result[:policy] = v }
+          options.on('--baseline PATH', 'Frozen baseline policy JSON') { |v| result[:baseline] = v }
+          options.on('--candidate PATH', 'Frozen candidate policy JSON') { |v| result[:candidate] = v }
+          options.on('--reports PATH', 'JSON array from --policy evaluate; replayed before promotion') { |v| result[:reports] = v }
+          options.on('--receipt PATH', 'Saved successful promotion JSON for rollback') { |v| result[:receipt] = v }
+          options.on('--live-policy PATH', 'Explicit existing policy target; no default') { |v| result[:live_path] = v }
+          options.on('--approve-policy-change', 'Operator explicitly approves promotion or rollback') { result[:enabled] = true }
+          options.on('--policy-writers-stopped', 'Operator attests ALL policy writers are stopped') { result[:quiescent] = true }
           options.on('--ai PROMPT', 'One-shot request; - reads standard input') { |v| result[:ai] = v }
           options.on('--pwn-env PATH', 'Use the specified encrypted configuration') { |v| result[:pwn_env_path] = v }
           options.on('--pwn-dec PATH', 'Use the specified decryptor') { |v| result[:pwn_dec_path] = v }
@@ -31,6 +39,8 @@ module PWN
         raise OptionParser::InvalidArgument, '--ai cannot accompany --replay or --rerun' if result[:ai] && (result[:replay] || result[:rerun])
         raise OptionParser::InvalidArgument, '--plan-only requires --ai' if result[:plan_only] && !result[:ai]
 
+        validate_policy_options(parsed: result)
+
         result[:help_text] = parser.to_s
         result
       end
@@ -44,6 +54,8 @@ module PWN
         end
 
         require 'pwn'
+        return run_policy(parsed: parsed, output: output) if parsed[:policy]
+
         if parsed[:plan_only]
           prompt = parsed[:ai] == '-' ? (opts[:input] || $stdin).read : parsed[:ai]
           raise ArgumentError, '--ai requires a non-empty prompt' if prompt.to_s.strip.empty?
@@ -97,6 +109,48 @@ module PWN
         0
       end
 
+      private_class_method def self.validate_policy_options(opts = {})
+        parsed = opts[:parsed]
+        fields = %i[baseline candidate reports receipt live_path enabled quiescent]
+        unless parsed[:policy]
+          raise OptionParser::InvalidArgument, 'policy options require --policy' if fields.any? { |key| parsed.key?(key) }
+
+          return
+        end
+
+        allowed = {
+          'evaluate' => %i[baseline candidate],
+          'promote' => %i[baseline candidate reports live_path enabled quiescent],
+          'rollback' => %i[receipt live_path enabled quiescent]
+        }.fetch(parsed[:policy])
+        unexpected = parsed.keys - allowed - %i[policy help]
+        raise OptionParser::InvalidArgument, "options not allowed with --policy #{parsed[:policy]}: #{unexpected.join(', ')}" unless unexpected.empty?
+
+        missing = (allowed - %i[enabled quiescent]) - parsed.keys
+        raise OptionParser::InvalidArgument, "missing policy options: #{missing.join(', ')}" unless missing.empty? || parsed[:help]
+      end
+
+      private_class_method def self.run_policy(opts = {})
+        parsed = opts[:parsed]
+        evaluator = PWN::AI::Agent::PolicyEvaluation
+        args = parsed.slice(:baseline, :candidate, :live_path, :enabled, :quiescent)
+        report = case parsed[:policy]
+                 when 'evaluate'
+                   [0, 1].map { |seed| evaluator.evaluate(args.merge(seed: seed)) }
+                 when 'promote', 'rollback'
+                   raise ArgumentError, 'requires --approve-policy-change and --policy-writers-stopped; stop all policy writers first' unless parsed[:enabled] && parsed[:quiescent]
+
+                   key = parsed[:policy] == 'promote' ? :reports : :receipt
+                   args[key] = JSON.parse(File.read(parsed.fetch(key)), symbolize_names: true)
+                   parsed[:policy] == 'promote' ? evaluator.promote(args) : evaluator.rollback(args)
+                 end
+        opts[:output].puts(JSON.generate(report))
+        report.is_a?(Hash) && (report[:promoted] == false || report[:rolled_back] == false) ? 1 : 0
+      rescue StandardError => e
+        opts[:output].puts(JSON.generate(error: e.message))
+        1
+      end
+
       private_class_method def self.bind_mission!(opts = {})
         report = opts[:report] || {}
         return report unless report[:run_id]

data/lib/pwn/config.rb

@@ -161,6 +161,8 @@ module PWN
             max_depth: 3,
             # run PWN::AI::Agent::Learning.auto_introspect after every final answer
             auto_introspect: true,
+            # off, recommend, or auto-safe. A missing key means recommend.
+            skill_review: 'recommend',
             # also run PWN::AI::Agent::Extrospection.auto_extrospect from auto_introspect
             # (host/repo/env probes only — no toolchain/GUI/net side-effects)
             auto_extrospect: true,

data/lib/pwn/migrate.rb

@@ -49,7 +49,7 @@ module PWN
     # Bump this whenever the shape of any file under ~/.pwn changes in a
     # way that requires a one-time transform.  Add the transform as an
     # entry in MIGRATIONS keyed by the NEW schema number.
-    SCHEMA_VERSION = 4
+    SCHEMA_VERSION = 5
 
     OK   = "\e[32mok\e[0m"
     BAD  = "\e[31mFAIL\e[0m"
@@ -245,6 +245,10 @@ module PWN
       4 => lambda { |_root, io|
         io.puts '    · pwn.yaml ai_sandbox, ai_router, model_routes task classes'
         PWN::Migrate.backfill_vault(io: io)
+      },
+      5 => lambda { |_root, io|
+        io.puts '    · pwn.yaml ai.agent.skill_review'
+        PWN::Migrate.backfill_vault(io: io)
       }
     }.freeze
 

data/lib/pwn/plugins/repl/mesh.rb

@@ -1654,7 +1654,7 @@ module PWN
             if PWN.const_defined?(:MeshMutex) && PWN.const_defined?(:MeshRxBodyWin)
               mutex = PWN.const_get(:MeshMutex)
               state = PWN.const_defined?(:MeshRxState) ? PWN.const_get(:MeshRxState) : {}
-              ts = Time.now.strftime('%H:%M:%S')
+              ts = Time.now.strftime('%Y-%m-%d %H:%M:%S%z')
               color = opts[:local] ? 23 : 21
               secure = packet[:pki_encrypted] == true || mesh_channel_securely_encrypted?(env: env, channel: channel_name)
               security_icon = secure ? '🔒' : '🔍'

data/lib/pwn/version.rb

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

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

@@ -34,6 +34,11 @@ describe 'RSI exploit and attack rates' do
   end
 
   it 'writes an RSI lesson when the measured exploit rate falls' do
+    expect(PWN::AI::Agent::PolicyEvaluation).not_to receive(:evaluate)
+    expect(PWN::AI::Agent::PolicyEvaluation).not_to receive(:promote)
+    expect(PWN::AI::Agent::PolicyEvaluation).not_to receive(:rollback)
+    expect(PWN::AI::Agent::Loop).not_to receive(:run)
+    expect(PWN::AI::Agent::Dispatch).not_to receive(:call)
     PWN::AI::Agent::Metrics.record_attempt(kind: 'exploit', tool: 'ret2libc', vulnerable_tool: 'libc', vulnerable: true, success: true)
     PWN::AI::Agent::Learning.rsi_tick(request: 'measure exploit rate')
     PWN::AI::Agent::Metrics.record_attempt(kind: 'exploit', tool: 'rop', vulnerable_tool: 'nginx', vulnerable: true, success: false)

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tmpdir'
+require 'json'
+
+describe PWN::AI::Agent::SkillReview do
+  let(:dir) { Dir.mktmpdir('pwn-skill-review-') }
+  let(:skill_path) { File.join(dir, 'osint', 'SKILL.md') }
+
+  before do
+    FileUtils.mkdir_p(File.dirname(skill_path))
+    File.write(skill_path, "---\nname: osint\ndescription: Public source checks.\n---\n\n# OSINT\n\nUse public sources.\n")
+    stub_const('PWN::Skills', {
+                 osint: {
+                   description: 'Public source checks for domains and hosts.',
+                   content: File.read(skill_path),
+                   path: skill_path
+                 }
+               })
+    stub_const('PWN::AI::Agent::SkillReview::LEDGER', File.join(dir, 'skill_review.jsonl'))
+    allow(PWN::Config).to receive(:load_skills)
+    allow(PWN::AI::Agent::Learning).to receive(:update_skill).and_call_original
+  end
+
+  after { FileUtils.remove_entry(dir) if dir && Dir.exist?(dir) }
+
+  def procedure
+    {
+      when: 'a public domain check needs a saved query order',
+      prerequisites: 'the domain is already in scope',
+      steps: 'query the public feed, then record the response code',
+      verification: 'the fixture command exits 0',
+      failures: 'an empty domain skips the feed'
+    }
+  end
+
+  def evidence
+    {
+      source: 'execution',
+      fixture_passed: true,
+      sessions: %w[s1 s2 s3],
+      signature: 'osint-order'
+    }
+  end
+
+  it 'does not create a skill from a routine success' do
+    result = described_class.review(request: 'check the lab host', success: true, mode: 'recommend')
+    expect(result[:action]).to eq('skipped')
+    expect(result[:reason]).to include('routine')
+    expect(File).not_to exist(File.join(dir, 'new-skill', 'SKILL.md'))
+  end
+
+  it 'recommends an update to the closest skill and does not write in recommend mode' do
+    result = described_class.review(
+      request: 'domain public source check',
+      mode: 'recommend',
+      procedure: procedure,
+      evidence: evidence
+    )
+    expect(result[:action]).to eq('recommend')
+    expect(result[:kind]).to eq('update')
+    expect(result[:name]).to eq('osint')
+    expect(File.read(skill_path)).not_to include('osint-order')
+  end
+
+  it 'auto-safe appends a small verified procedure and keeps a backup' do
+    allow(PWN::Config).to receive(:write_skill) do |opts|
+      body = opts[:content]
+      File.write(skill_path, body.include?('---') ? body : "---\nname: osint\ndescription: Public source checks.\n---\n\n#{body}")
+      { name: 'osint', path: skill_path }
+    end
+    result = described_class.review(
+      request: 'domain public source check',
+      mode: 'auto-safe',
+      procedure: procedure,
+      evidence: evidence,
+      skills_root: dir
+    )
+    expect(result[:action]).to eq('applied')
+    expect(File.read(skill_path)).to include('osint-order')
+    expect(Dir.glob("#{skill_path}.*.bak")).not_to be_empty
+    expect(PWN::Config).to have_received(:load_skills).at_least(:once)
+  end
+
+  it 'refuses auto-safe creation, secrets, generated module skills, and model-only proof' do
+    stub_const('PWN::Skills', {})
+    created = described_class.review(request: 'new procedure', mode: 'auto-safe', procedure: procedure, evidence: evidence, name: 'fresh-check')
+    expect(created[:action]).to eq('recommend')
+    expect(created[:kind]).to eq('create')
+
+    secret = described_class.review(
+      request: 'domain public source check',
+      mode: 'auto-safe',
+      procedure: procedure.merge(steps: 'send Authorization bearer secret-token'),
+      evidence: evidence
+    )
+    expect(secret[:action]).to eq('refused')
+
+    generated = described_class.review(
+      request: 'nmap scan diff',
+      mode: 'auto-safe',
+      name: 'pwn/plugins/nmap_it',
+      procedure: procedure,
+      evidence: evidence
+    )
+    expect(generated[:action]).to eq('refused')
+
+    claimed = described_class.review(
+      request: 'domain public source check',
+      mode: 'auto-safe',
+      procedure: procedure,
+      evidence: { source: 'model', model_claimed: true, fixture_passed: true, sessions: %w[s1 s2 s3] }
+    )
+    expect(claimed[:action]).to eq('recommend')
+    expect(claimed[:verified]).to eq(false)
+  end
+
+  it 'recommends a correction without writing a transcript' do
+    stub_const('PWN::AI::Agent::Mistakes', Class.new)
+    allow(PWN::AI::Agent::Mistakes).to receive(:top).and_return([])
+    stub_const('PWN::AI::Agent::Mistakes::CORRECTION_RX', /wrong/i)
+    result = described_class.review_turn(request: 'no, that is wrong, save the public query order', success: false, mode: 'auto-safe')
+    expect(result[:action]).to eq('recommend')
+    expect(File.read(skill_path)).not_to include('wrong')
+  end
+end

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

@@ -14,6 +14,114 @@ RSpec.describe 'PWN::AI::CLI' do
     expect(PWN::AI::CLI.parse(argv: ['--rerun', 'session-1'])).to include(rerun: 'session-1')
   end
 
+  it 'evaluates two frozen offline suites without loading configuration or running the loop' do
+    Dir.mktmpdir('pwn-cli-policy-', '/tmp') do |root|
+      snapshot = File.join(root, 'snapshot.json')
+      File.write(snapshot, JSON.generate(q: {}, h: {}, visits: {}, returns: [], n_updates: 0, td_abs_sum: 0.0))
+      expect(PWN::Config).not_to receive(:refresh_env)
+      expect(PWN::AI::Agent::Loop).not_to receive(:run)
+      out = StringIO.new
+      expect(PWN::AI::CLI.run(argv: ['--policy', 'evaluate', '--baseline', snapshot, '--candidate', snapshot], output: out)).to eq(0)
+      reports = JSON.parse(out.string)
+      expect(reports.map { |report| report['seed'] }).to eq([0, 1])
+      expect(reports).to all(include('protocol' => 'pwn-policy-heldout-v2'))
+      stdout, stderr, status = Open3.capture3(
+        { 'HOME' => root, 'LANG' => 'C.UTF-8' }, RbConfig.ruby, '-Ilib', 'bin/pwn-ai',
+        '--policy', 'evaluate', '--baseline', snapshot, '--candidate', snapshot,
+        unsetenv_others: true
+      )
+      expect(status.success?).to be(true), stderr
+      expect(JSON.parse(stdout).map { |report| report['seed'] }).to eq([0, 1])
+      expect(Dir.children(root)).to eq(['snapshot.json'])
+    end
+  end
+
+  it 'promotes only with both operator acknowledgements and rolls back using the saved receipt' do
+    Dir.mktmpdir('pwn-cli-policy-', '/tmp') do |root|
+      output, error, status = Open3.capture3(
+        { 'HOME' => root, 'LANG' => 'C.UTF-8' }, RbConfig.ruby,
+        File.expand_path('../../../../scripts/benchmark_policy.rb', __dir__),
+        '--heldout', '--snapshot-dir', File.join(root, 'snapshots'), unsetenv_others: true
+      )
+      expect(status.success?).to be(true), error
+      baseline = File.join(root, 'snapshots', 'off.json')
+      candidate = File.join(root, 'snapshots', 'on.json')
+      reports = File.join(root, 'reports.json')
+      File.write(reports, JSON.generate(JSON.parse(output).fetch('heldout')))
+      live = File.join(root, 'live.json')
+      FileUtils.cp(baseline, live)
+      argv = ['--policy', 'promote', '--baseline', baseline, '--candidate', candidate, '--reports', reports, '--live-policy', live]
+      expect(PWN::Config).not_to receive(:refresh_env)
+      expect(PWN::AI::Agent::Loop).not_to receive(:run)
+      [[], ['--approve-policy-change'], ['--policy-writers-stopped']].each do |flags|
+        expect(PWN::AI::CLI.run(argv: argv + flags, output: StringIO.new)).to eq(1)
+        expect(File.binread(live)).to eq(File.binread(baseline))
+      end
+      approval = %w[--approve-policy-change --policy-writers-stopped]
+      original_reports = File.read(reports)
+      tampered = JSON.parse(original_reports)
+      tampered.first['passed'] = true
+      File.write(reports, JSON.generate(tampered))
+      rejected = StringIO.new
+      expect(PWN::AI::CLI.run(argv: argv + approval, output: rejected)).to eq(1)
+      expect(JSON.parse(rejected.string)).to include('promoted' => false, 'reason' => 'provenance/artifact replay mismatch')
+      expect(File.binread(live)).to eq(File.binread(baseline))
+      File.write(reports, original_reports)
+      out = StringIO.new
+      expect(PWN::AI::CLI.run(argv: argv + approval, output: out)).to eq(0)
+      expect(JSON.parse(out.string)).to include('promoted' => true, 'replayed_seeds' => [0, 1])
+      expect(File.binread(live)).to eq(File.binread(candidate))
+      receipt = File.join(root, 'receipt.json')
+      File.write(receipt, out.string)
+      rollback = ['--policy', 'rollback', '--receipt', receipt, '--live-policy', live]
+      expect(PWN::AI::CLI.run(argv: rollback, output: StringIO.new)).to eq(1)
+      expect(File.binread(live)).to eq(File.binread(candidate))
+      File.write(live, File.read(baseline))
+      expect(PWN::AI::CLI.run(argv: rollback + approval, output: StringIO.new)).to eq(1)
+      File.write(live, File.read(candidate))
+      expect(PWN::AI::CLI.run(argv: rollback + approval, output: StringIO.new)).to eq(0)
+      expect(File.binread(live)).to eq(File.binread(baseline))
+    end
+  end
+
+  it 'rejects policy flags outside their action and never combines offline evaluation with a live session' do
+    [
+      %w[--baseline baseline.json],
+      %w[--approve-policy-change],
+      %w[--policy evaluate --baseline b --candidate c --ai prompt],
+      %w[--policy evaluate --baseline b --candidate c --replay session],
+      %w[--policy evaluate --baseline b --candidate c --mission mission],
+      %w[--policy evaluate --baseline b --candidate c --pwn-env vault],
+      %w[--policy evaluate --baseline b --candidate c --live-policy live],
+      %w[--policy evaluate --baseline b --candidate c --approve-policy-change],
+      %w[--policy evaluate --baseline b],
+      %w[--policy rollback --receipt r],
+      %w[--policy promote --baseline b --candidate c --reports r],
+      %w[--policy rollback --receipt r --live-policy l --candidate c]
+    ].each do |argv|
+      expect { PWN::AI::CLI.parse(argv: argv) }.to raise_error(OptionParser::ParseError), argv.inspect
+    end
+  end
+
+  it 'returns nonzero JSON diagnostics for malformed offline inputs without starting a session' do
+    Dir.mktmpdir('pwn-cli-policy-', '/tmp') do |root|
+      path = File.join(root, 'invalid.json')
+      File.write(path, 'not json')
+      expect(PWN::Config).not_to receive(:refresh_env)
+      expect(PWN::Sessions).not_to receive(:create)
+      expect(PWN::AI::Agent::Loop).not_to receive(:run)
+      [
+        ['--policy', 'evaluate', '--baseline', path, '--candidate', path],
+        ['--policy', 'rollback', '--receipt', path, '--live-policy', path, '--approve-policy-change', '--policy-writers-stopped']
+      ].each do |argv|
+        out = StringIO.new
+        expect(PWN::AI::CLI.run(argv: argv, output: out)).to eq(1)
+        expect(JSON.parse(out.string)).to have_key('error')
+        expect(File.read(path)).to eq('not json')
+      end
+    end
+  end
+
   it 'rejects ambiguous actions and stray positional arguments' do
     [%w[--replay one --rerun two], %w[--analyze file --replay one], %w[--replay one --ai prompt], ['stray']].each do |argv|
       expect { PWN::AI::CLI.parse(argv: argv) }.to raise_error(OptionParser::ParseError)

data/spec/lib/pwn/migrate_spec.rb

@@ -80,7 +80,7 @@ describe PWN::Migrate do
       File.write(File.join(@tmp, '.schema'), JSON.generate(schema: 2))
       expect(described_class.needed?).to be(true)
       result = described_class.run(fix: false, backup: false, io: io)
-      expect(result[:applied_migrations]).to eq([3, 4])
+      expect(result[:applied_migrations]).to eq([3, 4, 5])
       expected = Marshal.load(Marshal.dump(original))
       expected['custom']['model'] = nil
       expect(YAML.safe_load_file(path)).to eq(expected)
@@ -189,7 +189,7 @@ describe PWN::Migrate do
       File.write(File.join(@tmp, '.schema'), JSON.generate(schema: 3))
       expect(described_class.needed?).to be(true)
       result = described_class.run(fix: true, backup: false, io: io)
-      expect(result[:applied_migrations]).to eq([4])
+      expect(result[:applied_migrations]).to eq([4, 5])
       creds = YAML.safe_load_file(dec, symbolize_names: true)
       user = PWN::Plugins::Vault.dump(file: yaml, key: creds[:key], iv: creds[:iv])
       expect(user[:ai][:active]).to eq('grok')
@@ -206,6 +206,33 @@ describe PWN::Migrate do
       expect(described_class.needed?).to be(false)
     end
 
+    it 'upgrades a schema-4 vault with skill_review without changing a user setting' do
+      yaml = File.join(@tmp, 'pwn.yaml')
+      dec = File.join(@tmp, 'pwn.yaml.decryptor')
+      stale = { ai: { active: 'grok', grok: { key: 'sk-KEEP' }, agent: { skill_review: 'off', max_iters: 3 } } }
+      missing = { ai: { active: 'openai', openai: { key: 'sk-OTHER' }, agent: { max_iters: 9 } } }
+      File.write(yaml, YAML.dump(stale).gsub(/^(\s*):/, '\1'))
+      PWN::Plugins::Vault.create(file: yaml, decryptor_file: dec)
+      File.write(File.join(@tmp, '.schema'), JSON.generate(schema: 4))
+      result = described_class.run(fix: true, backup: false, io: io)
+      expect(result[:applied_migrations]).to eq([5])
+      creds = YAML.safe_load_file(dec, symbolize_names: true)
+      user = PWN::Plugins::Vault.dump(file: yaml, key: creds[:key], iv: creds[:iv])
+      expect(user.dig(:ai, :agent, :skill_review)).to eq('off')
+      expect(user.dig(:ai, :agent, :max_iters)).to eq(3)
+      expect(user.dig(:ai, :grok, :key)).to eq('sk-KEEP')
+
+      File.write(yaml, YAML.dump(missing).gsub(/^(\s*):/, '\1'))
+      PWN::Plugins::Vault.encrypt(file: yaml, key: creds[:key], iv: creds[:iv])
+      File.write(File.join(@tmp, '.schema'), JSON.generate(schema: 4))
+      described_class.run(fix: true, backup: false, io: io)
+      filled = PWN::Plugins::Vault.dump(file: yaml, key: creds[:key], iv: creds[:iv])
+      expect(filled.dig(:ai, :agent, :skill_review)).to eq('recommend')
+      expect(filled.dig(:ai, :agent, :max_iters)).to eq(9)
+      expect(filled.dig(:ai, :openai, :key)).to eq('sk-OTHER')
+      expect(described_class.run(fix: true, backup: false, io: io)[:applied_migrations]).to eq([])
+    end
+
     it 'dry_run writes nothing' do
       r = PWN::Migrate.run(fix: true, backup: true, dry_run: true, io: io)
       expect(r[:dry_run]).to be true

data/third_party/pwn_rdoc.jsonl

@@ -826,6 +826,22 @@
 {"messages":[{"role":"user","content":"PWN::AI::Agent::SkillConsolidation.consolidate Usage"},{"role":"assistant","content":"`PWN::AI::Agent::SkillConsolidation.consolidate`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::SkillConsolidation.consolidate_file Usage"},{"role":"assistant","content":"`PWN::AI::Agent::SkillConsolidation.consolidate_file`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::SkillConsolidation.help Usage"},{"role":"assistant","content":"`PWN::AI::Agent::SkillConsolidation.help`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::SkillReview.append_ledger Usage"},{"role":"assistant","content":"`PWN::AI::Agent::SkillReview.append_ledger`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::SkillReview.apply_update Usage"},{"role":"assistant","content":"`PWN::AI::Agent::SkillReview.apply_update`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::SkillReview.authors Usage"},{"role":"assistant","content":"`PWN::AI::Agent::SkillReview.authors`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::SkillReview.auto_safe? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::SkillReview.auto_safe?`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::SkillReview.finish Usage"},{"role":"assistant","content":"`PWN::AI::Agent::SkillReview.finish`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::SkillReview.generated? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::SkillReview.generated?`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::SkillReview.help Usage"},{"role":"assistant","content":"`PWN::AI::Agent::SkillReview.help`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::SkillReview.locate Usage"},{"role":"assistant","content":"`PWN::AI::Agent::SkillReview.locate`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::SkillReview.mode_from Usage"},{"role":"assistant","content":"`PWN::AI::Agent::SkillReview.mode_from`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::SkillReview.note_reuse Usage"},{"role":"assistant","content":"`PWN::AI::Agent::SkillReview.note_reuse`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::SkillReview.procedure_from Usage"},{"role":"assistant","content":"`PWN::AI::Agent::SkillReview.procedure_from`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::SkillReview.review Usage"},{"role":"assistant","content":"`PWN::AI::Agent::SkillReview.review`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::SkillReview.review_turn Usage"},{"role":"assistant","content":"`PWN::AI::Agent::SkillReview.review_turn`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::SkillReview.sensitive? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::SkillReview.sensitive?`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::SkillReview.useful? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::SkillReview.useful?`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::SkillReview.verified_execution? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::SkillReview.verified_execution?`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Swarm.ask Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Swarm.ask`: Supported Method Parameters\n\nreply = PWN::AI::Agent::Swarm.ask(\n\nname: 'required - persona name from ~/.pwn/agents.yml',\nrequest: 'required - what to ask/instruct the persona',\nswarm_id: 'optional - join an existing swarm (created if omitted)',\nto: 'optional - addressee recorded on the bus (default :all)',\non_tool: 'optional - ->(name, args, result) live-UI callback'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Swarm.authors Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Swarm.authors`: Author(s)\n\n0day Inc. <support@0dayinc.com>\n"}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Swarm.broadcast Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Swarm.broadcast`: Supported Method Parameters\n\nresult = PWN::AI::Agent::Swarm.broadcast(\n\nrequest: 'required', names: 'optional - default all personas',\nswarm_id: 'optional'\n\n)\n"}]}
@@ -1052,6 +1068,8 @@
 {"messages":[{"role":"user","content":"PWN::AI::CLI.help Usage"},{"role":"assistant","content":"`PWN::AI::CLI.help`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::CLI.parse Usage"},{"role":"assistant","content":"`PWN::AI::CLI.parse`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::CLI.run Usage"},{"role":"assistant","content":"`PWN::AI::CLI.run`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::CLI.run_policy Usage"},{"role":"assistant","content":"`PWN::AI::CLI.run_policy`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::CLI.validate_policy_options Usage"},{"role":"assistant","content":"`PWN::AI::CLI.validate_policy_options`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Context.attach_disasm Usage"},{"role":"assistant","content":"`PWN::AI::Context.attach_disasm`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Context.attach_file Usage"},{"role":"assistant","content":"`PWN::AI::Context.attach_file`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Context.attach_hexdump Usage"},{"role":"assistant","content":"`PWN::AI::Context.attach_hexdump`: "}]}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pwn
 version: !ruby/object:Gem::Version
-  version: 0.5.744
+  version: 0.5.745
 platform: ruby
 authors:
 - 0day Inc.
@@ -4958,6 +4958,7 @@ files:
 - etc/default_skills/pwn/ai/agent/reward/SKILL.md
 - etc/default_skills/pwn/ai/agent/sast/SKILL.md
 - etc/default_skills/pwn/ai/agent/skill_consolidation/SKILL.md
+- etc/default_skills/pwn/ai/agent/skill_review/SKILL.md
 - etc/default_skills/pwn/ai/agent/swarm/SKILL.md
 - etc/default_skills/pwn/ai/agent/task_dag/SKILL.md
 - etc/default_skills/pwn/ai/agent/task_summarizer/SKILL.md
@@ -6010,6 +6011,7 @@ files:
 - lib/pwn/ai/agent/reward.rb
 - lib/pwn/ai/agent/sast.rb
 - lib/pwn/ai/agent/skill_consolidation.rb
+- lib/pwn/ai/agent/skill_review.rb
 - lib/pwn/ai/agent/swarm.rb
 - lib/pwn/ai/agent/task_dag.rb
 - lib/pwn/ai/agent/task_summarizer.rb
@@ -6676,6 +6678,7 @@ files:
 - spec/lib/pwn/ai/agent/scoreboard_roadmap_spec.rb
 - spec/lib/pwn/ai/agent/signal_hygiene_spec.rb
 - spec/lib/pwn/ai/agent/skill_consolidation_spec.rb
+- spec/lib/pwn/ai/agent/skill_review_spec.rb
 - spec/lib/pwn/ai/agent/swarm_roster_spec.rb
 - spec/lib/pwn/ai/agent/swarm_spec.rb
 - spec/lib/pwn/ai/agent/task_dag_spec.rb