pwn 0.5.721 → 0.5.723

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c26adc03f68a0e0275c0eb1a85aa2bb06def95aeb014411b000f52c6a83e3e40
-  data.tar.gz: 6a082b81f8f1885de1b3ac42c604f1f21a08d48e7260609ce35e00d1461afa79
+  metadata.gz: 5ba71758dbd8a3d5231af6489af4c3dd2bd25c0c16df3fd3292b14a77abdf851
+  data.tar.gz: 31c99dda2f5bac281c8ba2b4cc7b7b4493f6c3f09cbbe6788a1067d177ec5ecc
 SHA512:
-  metadata.gz: 719d713266b6a3d4200895bb41d4ac5ec7ccfc6d142463cb70085cd6c8d02a514191553b5b12317de45a38abf3d4d1ccb47101f54dc5e588e596a13bc3e77af8
-  data.tar.gz: 271d9ff938ac37275ebe9da7d3031305bd09f587e5b6d14f0386fc006bd120b6e684b00aa651c935da7eefbd3a71c298b114ef07ec21b7a9099a75d9f71df647
+  metadata.gz: 5f17d3c8729c22425cfef5b71746c82bc03eaec569b2d470a83e0734a72e8f411bf8542bc302091211f5f6dc578e5fb64b5a72f97fdb2d8d2f4b8f9f7601100d
+  data.tar.gz: 6359d1601fa3cc2f340c3edd8efbe71578c0d580c1c7da6dcc212cd2ab56011455cb10578e11d7be9c359c406b2da5d33a6c1eedaa46f73a5a2a0e59d12c8199

data/Gemfile

@@ -49,7 +49,7 @@ gem 'jwt', '3.2.0'
 gem 'libusb', '0.8.0'
 gem 'luhn', '3.0.0'
 gem 'mail', '2.9.1'
-gem 'mcp', '1.4.0'
+gem 'mcp', '1.5.0'
 gem 'meshtastic', '0.0.175'
 gem 'metasm', '1.0.6'
 gem 'mongo', '2.25.0'
@@ -77,7 +77,7 @@ gem 'rbvmomi2', '3.10.0'
 gem 'rdoc', '7.0.4'
 gem 'rest-client', '2.1.0'
 gem 'rex', '2.0.13'
-gem 'rmagick', '7.1.3'
+gem 'rmagick', '7.1.4'
 gem 'rqrcode', '3.2.0'
 gem 'rspec', '3.13.2'
 gem 'rtesseract', '3.1.4'

data/bin/pwn_setup

@@ -25,8 +25,10 @@ pwn_driver = PWN::Driver::Parser.new do |options|
   end
 
   options.on('-l', '--list-profiles',
-             '<Optional - List capability profiles and exit>') do |o|
-    opts[:list] = o
+             '<Optional - List capability profiles and exit>') do
+    # Public metadata, like --help: no environment decryption or bootstrap.
+    PWN::Setup.list_profiles
+    exit 0
   end
 
   options.on('-m', '--migrate',
@@ -66,9 +68,7 @@ pwn_driver.parse!
 begin
   status = 0
 
-  if opts[:list]
-    PWN::Setup.list_profiles
-  elsif opts[:migrate]
+  if opts[:migrate]
     r = PWN::Setup.migrate(
       fix: opts[:fix] || opts[:yes],
       dry_run: opts[:dry_run]

data/documentation/AI-Integration.md

@@ -10,7 +10,7 @@ agent code never cares which model is behind it.
 
 | Engine | Client | Auth | Notes |
 |---|---|---|---|
-| `openai` | `PWN::AI::OpenAI` | `key:` | function-calling native |
+| `openai` | `PWN::AI::OpenAI` | ChatGPT/Codex `oauth:` or `key:` | OAuth preferred when configured; subscription chat uses the Codex Responses backend, API keys use the Platform API |
 | `anthropic` | `PWN::AI::Anthropic` | `key:` | tool-use native |
 | `grok` | `PWN::AI::Grok` | `key:` **or** `oauth: true` | OAuth = RFC-8628 device-code flow using xAI's public Grok-CLI client id (no secret) - see skill `xai_grok_oauth_device_flow` |
 | `gemini` | `PWN::AI::Gemini` | `key:` | function-calling native |
@@ -38,6 +38,39 @@ ai:
 PWN::Env[:ai][:active] = :ollama
 ```
 
+## OpenAI OAuth enrollment and persistence
+
+To prefer subscription OAuth, set `ai.openai.oauth.enroll: true` through
+`pwn-vault`, then restart `pwn-ai` and follow the device-code consent prompt.
+An existing bearer or refresh token is preferred over `ai.openai.key`.
+The account must have access to the requested model through Codex; OAuth
+does not grant all Platform API permissions or bypass subscription limits.
+
+You can also enroll explicitly from a PWN Ruby console:
+
+```ruby
+PWN::AI::OpenAI.obtain_oauth_bearer_token; nil
+```
+
+The trailing `nil` prevents the console from echoing the returned bearer.
+Successful enrollment updates the live environment and calls the private
+`persist_oauth_to_vault` helper, as token refresh does. It uses the configured
+`driver_opts.pwn_env_path` and `pwn_dec_path`, defaulting to
+`~/.pwn/pwn.yaml` and its `.decryptor` file. Existing decryption artifacts are
+required; missing artifacts leave tokens in the session only and produce a
+notice. Tokens are not printed by the enrollment success message.
+
+Persistence retains unrelated settings and the existing key/IV, encrypts a
+private temporary file, and replaces the vault only after encryption succeeds.
+The resulting vault has mode `0600`. The original vault remains unchanged on
+a persistence failure; the helper does not create or rotate decryptor secrets.
+
+Subscription OAuth requests must not go to the default Platform
+`/v1/responses` endpoint: that mismatch can produce `Missing scopes:
+api.responses.write`. OAuth chat uses
+`https://chatgpt.com/backend-api/codex/responses` instead. An actual Platform
+API key still needs the relevant project and endpoint permissions.
+
 ## Engine-aware behavior
 
 The harness adapts to the *class* of engine, not the model name:

data/documentation/Policy-Benchmark.md

@@ -0,0 +1,151 @@
+# Independent local Policy/Registry benchmark
+
+This is a **deterministic controller benchmark, not proof of live LLM improvement**.
+It executes real local file tasks and trains the actual tabular
+`PWN::AI::Agent::Policy` implementation, then selects actions through the actual
+`Registry.rank`. No model responses, provider usage, or benchmark gains are
+simulated. The action handlers are explicitly hand-written local algorithms,
+not a simulated language model.
+
+## Run from a source checkout
+
+```sh
+ruby scripts/benchmark_policy.rb --self-check
+ruby scripts/benchmark_policy.rb --output /tmp/pwn-policy-benchmark.json
+bundle exec rubocop scripts/benchmark_policy.rb
+```
+
+The experiment uses Ruby and its standard libraries; it does not require the
+full application boot sequence. Use a fresh Ruby process, not the live agent
+console. JSON is printed to stdout and optionally written to `--output`.
+`--self-check` runs independent scorer tests and both complete experimental arms;
+it prints a short pass message instead of a report. Use the options separately.
+The benchmark exits nonzero if persistence changes during evaluation, splits
+overlap, a negative control succeeds, or a positive control fails. Self-checks
+also require actual training updates in the on arm and none in the off arm.
+They deliberately do **not** require an improvement of a predetermined size.
+
+## Relation to existing evaluation
+
+`lib/pwn/ai/agent/curriculum.rb` provides live self-play, judge-based practice,
+mistake-derived evaluation prompts, and adapter training/promotion gates. This
+standalone script does not invoke those paths. It provides a small, independently
+scored experiment where the training labels come from actual task achievement,
+not `Reward.judge`, model prose, or a previously assigned reward. It calls
+`Policy.begin_episode`, `observe_step`, and `finish` with those labels during
+training. This is not a test of Reward's verification-record binding, the live
+Loop, Metrics learning, memory retrieval, or adapter training.
+
+The new `scripts/` directory keeps this experimental driver outside the installed
+CLI and production module tree; no module manifest or generated skill is needed.
+
+## Protocol
+
+1. **Isolation.** Create a private `/tmp/pwn-policy-benchmark-*` directory. Clear
+   the process environment, set `HOME` and `TMPDIR` to that directory, then load
+   only Policy and Registry. Assert their persistence constants resolve below
+   the temporary `HOME/.pwn`. Do not load user configuration, credentials,
+   registered application tools, providers, or network libraries. Delete the
+   entire temporary directory on normal completion or Ruby exception and restore
+   the process environment. A force-killed process may leave its temporary files.
+   This is isolation for trusted fixed handlers, not a sandbox for untrusted code.
+2. **Paired arms.** Run `off`, then `on`, resetting Policy between them. Both arms
+   start empty and execute the identical training schedule. The only learning
+   switch is `PWN::Env[:ai][:agent][:policy]`. No Q entries, visits, episode counts,
+   or rewards are seeded directly. Other learning modules are not loaded.
+3. **Training only.** There are four training fixtures: two numeric sorting tasks
+   and two active-inventory filtering tasks. Six fixed exploration rounds execute
+   every one of the three candidate actions for each fixture: 72 real handler
+   calls per arm. Every action gets equal exposure; the scheduler does not use
+   answer keys to choose actions. Each call writes into a fresh task directory.
+   Exact artifact correctness supplies a binary training label to Policy; the
+   off arm executes the same work but Policy declines to update.
+4. **Held-out evaluation.** Only after training, materialize eight distinct
+   held-out inputs with literal answer keys: four numeric and four inventory
+   tasks. Assert no training input appears in evaluation. Task families and
+   request wording are intentionally shared with training. The held-out units
+   are **input instances, not unseen families, prompts, or tools**. This is
+   in-distribution transfer within a small public fixture set, not a blind test
+   or a generalization claim about arbitrary operator requests.
+5. **Frozen controller.** Rank the task family's three entries using
+   `Registry.rank(query: ..., entries: ..., preference: [])`. There are no
+   evaluation `begin_episode`, `observe_step`, or `finish` calls. The policy uses
+   Registry's normal fallback state rather than a fabricated state/table. Allow
+   at most three attempts, stopping only when the independent artifact checker
+   passes. The controller does not get corrective feedback or adapt between
+   attempts. Hash all persisted `.pwn` files before evaluation and after controls;
+   abort if they changed.
+6. **Separate controls.** For each held-out input, force a claim-only handler and
+   a handler that writes a wrong JSON object. Both return convincing
+   `PASS: completed successfully...verified` prose and `ok: true`. All 16 forced
+   negative controls must fail objective scoring. Also execute the correct
+   algorithm on each input; all eight positive controls must pass. Controls are
+   reported separately and never trained on or included in evaluation rates.
+
+## Real task behavior and independent scoring
+
+Numeric candidates perform lexical sorting, numeric sorting, or no artifact
+write. Inventory candidates filter active rows, include every row, or write
+nothing. Handlers receive only input/output paths; the literal expected values
+are not passed to them. All handlers claim success, intentionally making textual
+claims unreliable. The checker ignores their prose and action names. It accepts
+only a regular non-symlink output whose parsed JSON exactly equals the answer key,
+with the source input unchanged. Missing output, invalid JSON, a plausible wrong
+artifact, or an altered input is failure. Self-checks separately test missing,
+wrong, prose-only, symlink, and correct artifacts.
+
+Each family has equal keyword-fit descriptions, with preference disabled. The
+unlearned deterministic tie-break favors lexical sort in one family and the
+correct active filter in the other; it is not configured to lose every task.
+Lexical sorting can genuinely solve some numeric fixtures and receives credit
+when it does. The learned controller can change these tied rankings from
+observed outcomes. This construction deliberately isolates the learning-to-router
+connection; it does not measure natural-language tool-selection quality.
+
+The answer keys and algorithms live in the same public script but do not call
+one another. Independence here means scoring actual artifact/task achievement
+without trusting action claims or training rewards, not process-level secrecy or
+an external audit. Extending the task set requires reviewing literal answer keys
+and adding both positive and negative controls before interpreting new results.
+
+## Report definitions
+
+Each arm contains full training/evaluation traces, fixture inputs and answer keys,
+control traces, Policy statistics, persistence fingerprints, and split/freeze
+checks. Source hashes identify the Policy, Registry, and harness revisions used.
+No fixed gains are embedded in the report.
+
+- **Completion:** tasks with at least one objectively successful attempt divided
+  by evaluated tasks. A failed attempt does not count as task completion.
+- **False-success count/rate:** attempts claiming `ok: true` without achieving the
+  task; rate denominator is executed attempts, not tasks. This is false reporting
+  by the handler, not acceptance of that report by the independent checker.
+- **Repeated mistakes:** every failed attempt after the first occurrence of the
+  same `(family, action, checker failure)` signature within that phase and arm.
+  This includes both repeated attempts on one task and recurrence on later
+  held-out inputs. It is not the production Mistakes store's count.
+- **Calls:** `tool_calls` counts actual local handler invocations. Evaluation makes
+  one Registry ranking decision per attempted handler call. Training invokes
+  begin/observe/finish once per training call; the returned update reports are
+  preserved. Each separately listed control row is one additional handler call.
+- **Elapsed:** monotonic measured seconds. Row elapsed time measures the handler;
+  phase elapsed time also includes setup, ranking/checking, and training updates
+  as applicable. Evaluation phase time excludes separately listed controls;
+  top-level elapsed includes both arms and controls but not final JSON output or
+  temporary-directory teardown. Tiny timings vary with caching and filesystem
+  load; fixed arm order is not a timing-performance study.
+- **Cost:** zero LLM calls and zero provider tokens because no provider is invoked.
+  Monetary cost is `null` (not estimated), not a claim that local computing is
+  economically free. No token-price or electricity estimates are invented.
+
+Training completion is descriptive coverage under forced exploration, not a
+learned-policy score. Only the held-out evaluation rates compare the controllers.
+Repeated executions should reproduce actions, counts, fixture hashes, and update
+counts for the same source revisions. Wall times, temporary paths, timestamps,
+and timestamp-bearing persistence hashes are expected to differ.
+
+There is deliberately no external-runner plug-in: accepting arbitrary commands
+would undermine the no-network/no-credentials guarantee. A future live-model
+study should use a separately reviewed runner, identical model/tool budgets,
+external objective verifiers, frozen held-out evaluation, and actual provider
+usage records. Do not present this controller experiment as that study.

data/documentation/Reinforcement-Learning.md

@@ -65,6 +65,32 @@ high-return / high-score episodes.
 
 ## Reward signal (`PWN::AI::Agent::Reward`)
 
+`Reward.resolve_outcome` is the shared decision used by live learning and
+offline practice. The ledger retains the raw judge score, source, confidence,
+verdict, and verification evidence. Heuristic guesses, evaluator errors, and
+unresolved high-score/critic disagreements are unverified, with a nil
+`training_score`; they do not become policy updates, failures, or supervised
+success examples. Requeuing a disputed result rejudges its original session
+instead of raising its score automatically.
+
+Writing “PASS” in an answer, returning exit zero, or confirming one claim does
+not establish completion. A trusted host verifier can call
+`Reward.record_verification` after checking every original-request criterion,
+providing actual boolean check results and evidence. Records are bound to the
+current session request and invalidated by subsequent tool execution. The API
+trusts the host verifier to cover the complete request; it cannot infer missing
+criteria or automatically verify arbitrary tasks. LLM judgments remain fallible.
+
+Policy observations also capture allowlisted operation, argument-role/type
+features, and result classification, without retaining raw argument values.
+These condition next-tool ranking only after enough contextual samples exist,
+with backoff to broad tool scores. Ranking remains advisory.
+
+For an independently checked learning-on/off experiment, see
+[Policy-Benchmark.md](Policy-Benchmark.md). It exercises real local handlers and
+controller updates on separate training and held-out inputs; it does not prove
+that a live language model performs better.
+
 | Method | What it does |
 |--------|--------------|
 | **R1** `.judge` | Cheap LLM outcome score on `(request, final)` -> `{score:0..1, verdict:, rationale:, key_step:, source:}`. Calls the active engine `.chat` with a short timeout (default 12s). `Reflect.on` is used only when `module_reflection` is on. Fallback scores completeness, plan cover, claims, and tool-trace echo. Token overlap is only a small on-topic gate. |
@@ -147,7 +173,7 @@ This is the live control list. Track the outcomes, not source comments.
 |-------|------|
 | **E1** `Metrics.changepoints` + `Loop.attribute_cause` | Env-drift-attributed failures get `cause: :env_drift` and do not inflate `[REPEATING]`. |
 | **E2** `Extrospection.correlate` | Lead-lag style joins ("tool X started failing after toolchain Y changed"). |
-| **E3** `Reward.verify_as_reward` | Browser-backed claim checks can floor/cap the outcome score. |
+| **E3** `Reward.verify_as_reward` | Browser-backed claim checks provide diagnostics and refutation caps; one confirmed claim cannot promote whole-request success. |
 
 ## Config (`PWN::Env[:ai][:agent]`)
 

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

@@ -39,6 +39,7 @@ PWN::AI::Agent::Engagement.open(opts)
 - `current_name`
 - `in_scope`
 - `deny_if_out_of_scope`
+- `load_roe`
 - `authors`
 - `help`
 - `in_scope?`

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

@@ -34,6 +34,8 @@ PWN::AI::Agent::Learning.note_outcome(opts)
 ## Public methods
 
 - `note_outcome`
+- `consistency_check`
+- `disputed_save`
 - `outcomes`
 - `stats`
 - `to_context`

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

@@ -38,6 +38,10 @@ PWN::AI::Agent::Metrics.load(opts)
 - `record`
 - `append_jsonl`
 - `summary`
+- `snapshot`
+- `record_tokens`
+- `usage`
+- `routing`
 - `to_context`
 - `proxy_trust`
 - `ucb`

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

@@ -37,6 +37,7 @@ PWN::AI::Agent::Mistakes.load(opts)
 - `save`
 - `signature`
 - `error_class`
+- `family`
 - `find`
 - `for_tool`
 - `record`
@@ -48,6 +49,7 @@ PWN::AI::Agent::Mistakes.load(opts)
 - `operator_inbox`
 - `to_context`
 - `correction_hint`
+- `note_hint_outcome`
 - `correction`
 - `check_user_correction`
 - `lean`

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

@@ -48,6 +48,7 @@ PWN::AI::Agent::Policy.state(opts)
 - `recommend`
 - `current_state`
 - `current_episode`
+- `current_context_state`
 - `detach_episode`
 - `attach_episode`
 - `load`

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

@@ -34,6 +34,8 @@ PWN::AI::Agent::Reward.judge(opts)
 ## Public methods
 
 - `judge`
+- `resolve_outcome`
+- `record_verification`
 - `promote_to_success`
 - `prm`
 - `plan_coverage`

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

@@ -47,6 +47,12 @@ PWN::AI::Agent::Swarm.personas(opts)
 - `fact_record`
 - `facts_prompt`
 - `claim`
+- `pack_specialist`
+- `child_inbox`
+- `child_honesty`
+- `honesty_unmet`
+- `view_graph`
+- `migrate_personas`
 - `authors`
 - `help`
 

data/etc/default_skills/pwn/ai/agent/tools/capabilities/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: pwn-ai-agent-tools-capabilities
+description: Drive PWN::Ai::Agent::Tools::Capabilities from pwn_eval.
+license: MIT
+allowed-tools: [pwn, pwn_eval]
+metadata:
+  bundled: true
+  generated: true
+  module: PWN::Ai::Agent::Tools::Capabilities
+  source: pwn/ai/agent/tools/capabilities.rb
+---
+
+# PWN::Ai::Agent::Tools::Capabilities
+
+Public API for PWN::Ai::Agent::Tools::Capabilities.
+
+## When to use
+
+Call `PWN::Ai::Agent::Tools::Capabilities` from `pwn_eval` when the task needs this module.
+Do not reimplement it in shell.
+
+## Methodologies
+
+Generated from `pwn/ai/agent/tools/capabilities.rb`. Prefer the public class methods below.
+Class methods take `(opts = {})` and read `opts`.
+
+## How to call
+
+```ruby
+PWN::Ai::Agent::Tools::Capabilities.help
+PWN::Ai::Agent::Tools::Capabilities.help(opts)
+```
+
+## Public methods
+
+- _(no public class methods parsed)_
+
+## Source
+
+`pwn/ai/agent/tools/capabilities.rb`
+
+## Verification
+
+`PWN::Ai::Agent::Tools::Capabilities.respond_to?(:help)` after the
+module is loaded. Read the source for parameter names.

data/etc/default_skills/pwn/ai/agent/tools/context/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: pwn-ai-agent-tools-context
+description: Drive PWN::Ai::Agent::Tools::Context from pwn_eval.
+license: MIT
+allowed-tools: [pwn, pwn_eval]
+metadata:
+  bundled: true
+  generated: true
+  module: PWN::Ai::Agent::Tools::Context
+  source: pwn/ai/agent/tools/context.rb
+---
+
+# PWN::Ai::Agent::Tools::Context
+
+Public API for PWN::Ai::Agent::Tools::Context.
+
+## When to use
+
+Call `PWN::Ai::Agent::Tools::Context` from `pwn_eval` when the task needs this module.
+Do not reimplement it in shell.
+
+## Methodologies
+
+Generated from `pwn/ai/agent/tools/context.rb`. Prefer the public class methods below.
+Class methods take `(opts = {})` and read `opts`.
+
+## How to call
+
+```ruby
+PWN::Ai::Agent::Tools::Context.help
+PWN::Ai::Agent::Tools::Context.help(opts)
+```
+
+## Public methods
+
+- _(no public class methods parsed)_
+
+## Source
+
+`pwn/ai/agent/tools/context.rb`
+
+## Verification
+
+`PWN::Ai::Agent::Tools::Context.respond_to?(:help)` after the
+module is loaded. Read the source for parameter names.

data/etc/default_skills/pwn/ai/context/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: pwn-ai-context
+description: Drive PWN::AI::Context from pwn_eval.
+license: MIT
+allowed-tools: [pwn, pwn_eval]
+metadata:
+  bundled: true
+  generated: true
+  module: PWN::AI::Context
+  source: pwn/ai/context.rb
+---
+
+# PWN::AI::Context
+
+Attach files, hexdumps, disassembly, and HTTP transcripts to model context with auto-chunking. Oversize artifacts are summarized inline and persisted under ~/.pwn/artifacts/<session_id>/ with SHA-256.
+
+## When to use
+
+Call `PWN::AI::Context` from `pwn_eval` when the task needs this module.
+Do not reimplement it in shell.
+
+## Methodologies
+
+Generated from `pwn/ai/context.rb`. Prefer the public class methods below.
+Class methods take `(opts = {})` and read `opts`.
+
+## How to call
+
+```ruby
+PWN::AI::Context.help
+PWN::AI::Context.attach_file(opts)
+```
+
+## Public methods
+
+- `attach_file`
+- `attach_hexdump`
+- `attach_disasm`
+- `attach_http_transcript`
+- `authors`
+- `help`
+
+## Source
+
+`pwn/ai/context.rb`
+
+## Verification
+
+`PWN::AI::Context.respond_to?(:attach_file)` after the
+module is loaded. Read the source for parameter names.

data/etc/default_skills/pwn/ai/http_retry/SKILL.md

@@ -37,11 +37,18 @@ PWN::AI::HttpRetry.timeout_s(opts)
 - `max_attempts`
 - `retryable`
 - `retry_after_s`
+- `quota_exhausted`
+- `quota_message`
 - `report_event`
 - `authors`
 - `help`
+- `quota_exhausted?`
 - `retryable?`
 
+## References
+
+- `references/urls.md` — URLs from source
+
 ## Source
 
 `pwn/ai/http_retry.rb`

data/etc/default_skills/pwn/ai/http_retry/references/urls.md

@@ -0,0 +1,4 @@
+# PWN::AI::HttpRetry source links
+
+- https://platform\.openai\.com/settings/organization/billing/?}]
+- https://platform.openai.com/settings/organization/billing/

data/etc/default_skills/pwn/ai/open_ai/SKILL.md

@@ -37,6 +37,7 @@ PWN::AI::OpenAI.refresh_oauth_bearer_token(opts)
 - `obtain_oauth_bearer_token`
 - `get_models`
 - `chat_with_tools`
+- `api_endpoint`
 - `chat`
 - `img_gen`
 - `vision`

data/etc/default_skills/pwn/ai/open_ai/references/urls.md

@@ -5,3 +5,4 @@
 - https://auth.openai.com/oauth/token
 - https://api.openai.com/auth
 - https://auth.openai.com/codex/device
+- https://chatgpt.com/backend-api/codex

data/etc/default_skills/pwn/plugins/exploit_dev/SKILL.md

@@ -53,6 +53,7 @@ PWN::Plugins::ExploitDev.required_bins(opts)
 - `fmtstr`
 - `io`
 - `scaffold`
+- `from_crash`
 - `authors`
 - `help`
 

data/etc/default_skills/pwn/plugins/findings/SKILL.md

@@ -39,6 +39,7 @@ PWN::Plugins::Findings.required_bins(opts)
 - `report`
 - `query`
 - `chain`
+- `chain_score`
 - `render`
 - `authors`
 - `help`

data/etc/default_skills/pwn/plugins/gdb/SKILL.md

@@ -42,6 +42,7 @@ PWN::Plugins::GDB.required_bins(opts)
 - `breakpoints`
 - `crash_info`
 - `debug_session`
+- `ptrace_preflight`
 - `authors`
 - `help`
 

data/etc/default_skills/pwn/plugins/gdbmi/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: pwn-plugins-gdbmi
+description: Drive PWN::Plugins::GDBMI from pwn_eval.
+license: MIT
+allowed-tools: [pwn, pwn_eval]
+metadata:
+  bundled: true
+  generated: true
+  module: PWN::Plugins::GDBMI
+  source: pwn/plugins/gdbmi.rb
+---
+
+# PWN::Plugins::GDBMI
+
+GDB machine-interface bridge: breakpoints, stepping, registers, memory, backtraces, checksec. Pairs with ProcessTube for interactive sessions.
+
+## When to use
+
+Call `PWN::Plugins::GDBMI` from `pwn_eval` when the task needs this module.
+Do not reimplement it in shell.
+
+## Methodologies
+
+Generated from `pwn/plugins/gdbmi.rb`. Prefer the public class methods below.
+Class methods take `(opts = {})` and read `opts`.
+
+## How to call
+
+```ruby
+PWN::Plugins::GDBMI.help
+PWN::Plugins::GDBMI.required_bins(opts)
+```
+
+## Public methods
+
+- `required_bins`
+- `open`
+- `break`
+- `step`
+- `registers`
+- `read_memory`
+- `backtrace`
+- `checksec`
+- `mi`
+- `authors`
+- `help`
+
+## Source
+
+`pwn/plugins/gdbmi.rb`
+
+## Verification
+
+`PWN::Plugins::GDBMI.respond_to?(:required_bins)` after the
+module is loaded. Read the source for parameter names.