clawpowers 1.1.4 → 2.0.0

package/CHANGELOG.md

@@ -0,0 +1,94 @@
+# Changelog
+
+All notable changes to ClawPowers are documented here.
+
+## [2.0.0] - 2026-04-03
+
+### Breaking Changes
+
+- **Complete TypeScript rewrite.** The v1.x shell-script runtime has been replaced with a fully typed TypeScript library.
+- **No agent control loop.** ClawPowers is now a pure capability library — bring your own agent framework.
+- **ESM-only.** Requires Node.js 20+.
+
+### Added
+
+- **Payments module** — x402 detection (`detect402`), `SpendingPolicy` enforcement, `PaymentExecutor` with append-only audit log. Fees: 0.77% tx / 0.30% swap.
+- **Memory module** — `WorkingMemoryManager` (in-process, token-budgeted), `EpisodicMemory` (JSONL append-only), `ProceduralMemory` (atomic JSON), `CheckpointManager` (crash recovery), `ContextInjector` (relevant memory selection).
+- **RSI module** — `MetricsCollector`, `HypothesisEngine`, `MutationEngine`, `ABTestManager`, `RSIAuditLog`, `AutoResearcher`. Full measure → hypothesize → mutate → A/B test → promote/rollback cycle.
+- **Wallet module** — `WalletManager`, `generateWallet`, `importWallet`, `signMessage` with AES-256-GCM encryption at rest.
+- **Skills module** — `discoverSkills`, `loadSkillManifest`, `SkillExecutor` with outcome tracking.
+- **Config module** — Zod-validated config, dot-notation access, profile support.
+- **Framework demos** — LangChain (`demos/langchain.ts`), Claude Code (`demos/claude-code.md`), ElizaOS (`demos/elizaos.ts`).
+- **231 TypeScript tests** — full coverage across all modules.
+- **BSL 1.1 license** with Change Date April 3, 2030.
+- **SECURITY.md** with vulnerability reporting policy and security design principles.
+
+### Compatibility
+
+Drop-in library for: LangChain, LangGraph, Claude Code, Cursor, ElizaOS, AutoGen, CrewAI, Agent Zero, any MCP-compatible host.
+
+### Removed
+
+- Shell-script runtime (v1.x skills)
+- CLI binary (`clawpowers` command)
+- Agent control loop (use ClawPowers-Agent for that)
+
+
+## [1.1.3] - 2026-03-22
+
+### Added
+
+- **Unified Payment Decision Pipeline** (`runtime/payments/pipeline.js`) — 8-step flow for evaluating payment boundaries across all skills
+- **Agent-to-Agent Bounties skill** (`skills/agent-bounties/`) — 6-phase escrow lifecycle for agent hiring
+- **Premium enrichment** in prospecting skill — x402-aware paid data sources
+- **5-minute transaction quickstart** (`docs/quickstart-first-transaction.md`) — JS + Python paths
+- **Demo README** (`runtime/demo/README.md`) — x402 flow walkthrough with curl examples
+- **30 natural language triggers** in skill.json — purchase intents, payment management, demo commands
+- "Payments are optional" README section with regulatory disclaimer and patent positioning
+- Smart `update` command — detects npm vs git install
+
+## [1.1.2] - 2026-03-22
+
+### Added
+
+- **Config.json on init** — payments disabled by default, dry-run mode, $0 limits
+- **Payment ledger** (`~/.clawpowers/logs/payments.jsonl`) — full audit trail
+- **Wallet activation wizard** (`npx clawpowers payments setup`) — interactive, non-scary
+- **x402 Mock Merchant** (`npx clawpowers demo x402`) — test payments with zero risk
+- **Dry-run mode** documentation in agent-payments skill
+- **Payment moment hooks** in market-intelligence + security-audit skills
+- Updated using-clawpowers trigger map
+- Standardized `.env.example` across all projects
+
+## [1.1.1] - 2026-03-22
+
+### Added
+
+- **economic-code-optimization skill** (25th skill) — ROI-tracked micro-budget spending
+- 4 RSI intelligence skills: meta-skill-evolution, self-healing-code, cross-project-knowledge, formal-verification-lite
+- 2 skills enhanced: test-driven-development (+mutation testing), systematic-debugging (+hypothesis memory)
+
+### Changed
+
+- README rewritten (381 lines)
+- +994 lines inline JSDoc comments across 12 code files
+
+## [1.1.0] - 2026-03-21
+
+### Added
+
+- agent-payments skill rewritten for agentwallet-sdk v6.0.0
+- OpenClaw skill.json manifest
+- Security Model section in README
+- Agent Payment Demo (3-step walkthrough)
+- Demo GIF (asciinema recording, 621KB)
+
+## [1.0.0] - 2026-03-21
+
+### Added
+
+- Initial release — 20 core skills
+- Dual runtime (bash + Node.js)
+- Session hooks for Claude Code, Cursor, Codex, OpenCode, Gemini CLI
+- Metrics collection and RSI feedback loop
+- 366 tests passing

package/LICENSE

@@ -0,0 +1,44 @@
+Business Source License 1.1
+
+Parameters
+
+Licensor:             AI Agent Economy
+Licensed Work:        ClawPowers v2.0.0
+                      The Licensed Work is (c) 2026 AI Agent Economy.
+Additional Use Grant: Non-production use (development, testing, personal
+                      projects, academic research) is permitted without a
+                      commercial license.
+Change Date:          April 3, 2030
+Change License:       Apache License, Version 2.0
+
+-----------------------------------------------------------------------------
+
+Terms
+
+The Licensor grants you the right to copy, modify, create derivative works,
+redistribute, and make non-production use of the Licensed Work. The Licensor
+may make an Additional Use Grant permitting limited production use.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly
+available distribution of a specific version of the Licensed Work under this
+License, whichever comes first, the Licensor grants you rights under the terms
+of the Change License, and the rights granted above terminate.
+
+If your use of the Licensed Work does not comply with the requirements in this
+License, you must purchase a commercial license from the Licensor or refrain
+from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative works,
+are subject to this License. This License applies separately for each version
+of the Licensed Work.
+
+You must conspicuously display this License on each original or modified copy
+of the Licensed Work.
+
+Any use of the Licensed Work in violation of this License will automatically
+terminate your rights under this License.
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
+AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
+EXPRESS OR IMPLIED, INCLUDING WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE, AND NON-INFRINGEMENT.

package/README.md

@@ -1,287 +1,263 @@
-# 🦞 ClawPowers
+# ClawPowers
 
-> **v1.1.3** · 26 skills · 372 tests · MIT · **Patent Pending**
+**Skills library for AI agents — payments, memory, RSI, wallet.** Drop-in capability layer for any agent framework.
 
-**Your agent needs to pay for APIs. ClawPowers makes that work.**
-
-When your agent hits a premium API and gets back HTTP 402 Payment Required, it needs to pay and retry — automatically, within limits you set, with your approval before anything moves. That's the core problem ClawPowers solves. The other 25 skills are a bonus.
-
-## The Pay-to-Complete Flow
-
-```
-Agent calls API
-      │
-      ▼
-  HTTP 402  ←── "Payment required: $0.50 USDC"
-      │
-      ▼
-ClawPowers evaluates:
-  • Is this within your spend cap? ($5/tx limit → ✅)
-  • Is this on the allowlist?     (api.example.com → ✅)
-  • Human approval required?      (under $1 threshold → auto)
-      │
-      ▼
-  Payment sent → API retried → Result returned
-      │
-      ▼
-  Outcome logged (for RSI analysis)
-```
-
-## Quick Start
+[![npm version](https://img.shields.io/npm/v/clawpowers)](https://www.npmjs.com/package/clawpowers)
+[![License: BSL 1.1](https://img.shields.io/badge/License-BSL%201.1-blue.svg)](LICENSE)
 
 ```bash
-npx clawpowers init          # Set up ~/.clawpowers/ runtime
-npx clawpowers demo x402     # See the full 402 → pay → 200 flow (no real money)
-npx clawpowers status        # Check what's running
+npm install clawpowers
 ```
 
-## Human-Approval Mode (the default)
+> **⚠️ Patent Pending:** The x402 payment detection, autonomous spending policy enforcement, and recursive self-improvement (RSI) systems described in this library are subject to pending patent applications. Use is governed by the BSL 1.1 license.
 
-ClawPowers defaults to supervised payments — your agent proposes, you approve. No funds move until you say so.
+---
 
-```typescript
-import { createX402Client } from 'agentwallet-sdk';
-import { createWallet, setSpendPolicy } from 'agentwallet-sdk';
-import { createWalletClient, http } from 'viem';
-import { privateKeyToAccount } from 'viem/accounts';
-import { base } from 'viem/chains';
-
-const account = privateKeyToAccount(process.env.AGENT_PRIVATE_KEY as `0x${string}`);
-const walletClient = createWalletClient({ account, chain: base, transport: http() });
+## What Is This?
 
-const wallet = createWallet({
-  accountAddress: process.env.AGENT_WALLET_ADDRESS as `0x${string}`,
-  chain: 'base',
-  walletClient,
-});
+ClawPowers extracts the core capabilities from [ClawPowers-Agent](https://github.com/up2itnow0822/ClawPowers-Agent) into a standalone library. **No agent control loop** — bring your own agent framework and get:
 
-// Spend policy — enforced on-chain, not in application code
-await setSpendPolicy(wallet, {
-  token: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // USDC on Base
-  perTxLimit: 1_000_000n,    // $1 auto-approved per transaction
-  periodLimit: 10_000_000n,  // $10/day hard cap
-  periodLength: 86400,
-});
+- **x402 Payments** — Detect HTTP 402 responses, enforce spending policies, execute payments
+- **Three-Tier Memory** — Working, episodic, procedural memory with crash recovery
+- **RSI Engine** — Metrics collection, hypothesis generation, mutation, A/B testing
+- **Wallet** — Generate, import, and sign with Ethereum-compatible wallets
+- **Skills** — Discover, load, and track skill execution outcomes
 
-const x402 = createX402Client(wallet, {
-  supportedNetworks: ['base:8453'],
-  globalDailyLimit: 10_000_000n,    // matches spend policy
-  globalPerRequestMax: 1_000_000n,  // $1 per request
-  requireApproval: true,            // human-in-the-loop mode (default)
-});
+## x402 Payment Flow
 
-// Agent hits a paid API
-const response = await x402.fetch('https://api.example.com/premium-data');
-// If cost < $1: auto-approved and paid
-// If cost > $1: queued — you get a notification to approve or reject
-const data = await response.json();
 ```
-
-## Simulation Mode
-
-Test the full payment flow before enabling live payments.
-
-```bash
-# Run a local mock x402 merchant — full 402 → pay → 200 cycle
-npx clawpowers demo x402
+┌─────────┐     ┌──────────────┐     ┌───────────────┐     ┌──────────┐
+│  Agent   │────▶│  API Server  │────▶│   detect402() │────▶│ Spending │
+│          │     │  returns 402 │     │  parse x402   │     │  Policy  │
+└─────────┘     └──────────────┘     │   headers     │     │  check   │
+                                     └───────────────┘     └────┬─────┘
+                                                                │
+                                              ┌─────────────────▼─────────────────┐
+                                              │         PaymentExecutor           │
+                                              │  ┌───────────┐  ┌─────────────┐  │
+                                              │  │ MCP Client │  │ Audit Log   │  │
+                                              │  │ (agentpay) │  │ (append-only│  │
+                                              │  └─────┬─────┘  └─────────────┘  │
+                                              └───────┬───────────────────────────┘
+                                                      │
+                                              ┌───────▼───────┐
+                                              │  Base Network  │
+                                              │  USDC Payment  │
+                                              └───────────────┘
 ```
 
-In code:
+## Framework Compatibility
 
-```typescript
-const x402 = createX402Client(wallet, {
-  supportedNetworks: ['base:8453'],
-  globalDailyLimit: 10_000_000n,
-  globalPerRequestMax: 1_000_000n,
-  dryRun: true,  // logs exactly what would happen, no funds move
-});
+| Framework | Integration | Example |
+|-----------|------------|---------|
+| **LangChain** | `DynamicStructuredTool` | [`demos/langchain.ts`](demos/langchain.ts) |
+| **Claude Code** | `CLAUDE.md` config | [`demos/claude-code.md`](demos/claude-code.md) |
+| **ElizaOS** | Plugin pattern | [`demos/elizaos.ts`](demos/elizaos.ts) |
+| **AutoGPT** | Direct import | See examples below |
+| **CrewAI** | Tool wrapper | See examples below |
+| **Custom** | Direct TypeScript import | See examples below |
 
-const response = await x402.fetch('https://api.example.com/premium-data');
-// Response includes: { simulated: true, wouldHavePaid: '0.50 USDC', withinLimits: true }
-```
-
-## Explicit Spend Caps
+## Quick Start
 
-Caps are enforced by smart contract, not application code. Even a prompt injection or jailbreak can't bypass them.
+### Payments
 
-```
-Agent wants to spend $0.50  → ✅ Auto-approved (under $1/tx cap)
-Agent wants to spend $5.00  → ⏳ Queued for your approval
-Agent spent $9.00 today     → 🛑 Next tx blocked ($10/day cap hit)
-```
+```typescript
+import { SpendingPolicy, PaymentExecutor, detect402 } from 'clawpowers';
 
-```bash
-# Check what your agent has spent
-npx clawpowers store get agent-payments:daily-total
-# → "2.50 USDC spent today, $7.50 remaining"
+// Configure spending limits
+const policy = new SpendingPolicy({
+  dailyLimit: 25,        // $25/day
+  transactionLimit: 10,  // $10 per tx
+  allowedDomains: ['api.example.com'],
+});
 
-# Review and approve queued payments
-npx clawpowers payments queue
-# → [1] $5.00 USDC — api.example.com/premium-report — approve? (y/n)
+// Create executor with your MCP client
+const executor = new PaymentExecutor(policy, mcpClient);
+
+// Detect and handle 402 responses
+const payment = detect402({ status: 402, headers: responseHeaders });
+if (payment) {
+  const result = await executor.executePayment({
+    amount: payment.amount,
+    currency: payment.currency,
+    recipient: payment.recipient,
+    domain: 'api.example.com',
+    x402Headers: payment.x402Headers,
+  });
+}
 ```
 
-## Why Supervised, Not Autonomous
-
-Fully autonomous agent payments sound great until an agent in a loop runs up $500 in API calls overnight. ClawPowers is built around three constraints:
-
-1. **Caps enforced on-chain** — the agent *cannot* exceed them, full stop
-2. **Human approval by default** — auto-approve only below thresholds you set
-3. **Full audit trail** — every payment logged at `~/.clawpowers/metrics/`
-
-When you've verified the agent behaves correctly, raise the auto-approve threshold. Start low.
+### Memory
 
-## Installation
+```typescript
+import { EpisodicMemory, ProceduralMemory, ContextInjector } from 'clawpowers';
+
+// Episodic: Task history (append-only JSONL)
+const episodic = new EpisodicMemory('~/.clawpowers/memory/episodic.jsonl');
+await episodic.append({
+  taskId: 'task-1',
+  timestamp: new Date().toISOString(),
+  description: 'Built authentication module',
+  outcome: 'success',
+  lessonsLearned: ['Always test edge cases'],
+  skillsUsed: ['tdd'],
+  durationMs: 5000,
+  tags: ['auth'],
+});
 
-### Universal (Windows, macOS, Linux)
+// Procedural: Skill effectiveness tracking
+const procedural = new ProceduralMemory('~/.clawpowers/memory/procedural.json');
+await procedural.update('tdd', { succeeded: true, durationMs: 5000, taskId: 'task-1' });
 
-```bash
-npx clawpowers init
+// Context injection: Relevant memories for new tasks
+const injector = new ContextInjector(episodic, procedural);
+const context = await injector.inject(goal, 2000); // 2000 token budget
 ```
 
-### OpenClaw
+### RSI (Recursive Self-Improvement)
 
-```bash
-openclaw skills install clawpowers
-# or from GitHub
-openclaw skills install github:up2itnow0822/clawpowers
+```typescript
+import { MetricsCollector, HypothesisEngine, MutationEngine, ABTestManager } from 'clawpowers';
+
+// Collect metrics
+const metrics = new MetricsCollector('task-metrics.jsonl', 'skill-metrics.jsonl');
+await metrics.recordTaskMetrics({ taskId: 'task-1', outcome: 'success', /* ... */ });
+
+// Generate improvement hypotheses
+const hypothesis = new HypothesisEngine();
+const hypotheses = hypothesis.analyze(skillStats, taskHistory);
+
+// Create and test mutations
+const mutations = new MutationEngine('mutations.jsonl');
+const mutation = mutations.createMutation(hypotheses[0]);
+
+// A/B test mutations
+const ab = new ABTestManager();
+const test = ab.startTest(mutation, baselineStats);
+ab.recordResult(test.testId, newTaskMetrics);
+const result = ab.evaluateTest(test.testId);
+// result.decision: 'promote' | 'rollback' | 'continue'
 ```
 
-### Claude Code
+### Wallet
 
-```bash
-/plugin install clawpowers@claude-plugins-official
-```
+```typescript
+import { WalletManager } from 'clawpowers';
 
-### Cursor
+const wallet = new WalletManager({
+  chain: 'base',
+  dataDir: '~/.clawpowers/wallet',
+});
 
-```text
-/add-plugin clawpowers
+const info = await wallet.generate();
+console.log(info.address); // 0x...
 ```
 
-### Codex / OpenCode
-
-```text
-Fetch and follow instructions from https://raw.githubusercontent.com/up2itnow0822/clawpowers/main/.codex/INSTALL.md
-```
+## Memory Module
 
-### Manual
+| Layer | Storage | Purpose |
+|-------|---------|---------|
+| **Working** | In-process | Current task context with token budget |
+| **Episodic** | JSONL file | Task history, searchable by keywords |
+| **Procedural** | JSON file | Skill effectiveness tracking with atomic writes |
+| **Checkpoint** | JSON files | Crash recovery, stale detection |
+| **Context Injector** | Computed | Selects relevant memories for new tasks |
 
-```bash
-git clone https://github.com/up2itnow0822/clawpowers.git
-cd clawpowers
-node bin/clawpowers.js init
-```
+## RSI Module
 
-## All 26 Skills
-
-### Core Development (14)
-
-| Skill | What It Does |
-|-------|-------------|
-| `subagent-driven-development` | Orchestrate parallel subagents — persistent execution DB, resumable checkpoints |
-| `test-driven-development` | RED-GREEN-REFACTOR with mutation analysis to verify tests actually catch bugs |
-| `writing-plans` | Spec → implementation plan with historical estimation and dependency validation |
-| `executing-plans` | Execute plans with interruption recovery and milestone tracking |
-| `brainstorming` | Structured ideation with cross-session idea persistence |
-| `systematic-debugging` | Persistent hypothesis tree so you never re-investigate the same dead end |
-| `verification-before-completion` | Pre-merge quality gates that actually run the verification suite |
-| `finishing-a-development-branch` | Branch cleanup, changelog, merge prep |
-| `requesting-code-review` | Reviewer match scoring, review history |
-| `receiving-code-review` | Feedback pattern tracking, common issues database |
-| `using-git-worktrees` | Isolated branch development with conflict prediction |
-| `using-clawpowers` | Meta-skill: how to use ClawPowers |
-| `writing-skills` | Create new skills via TDD with quality scoring |
-| `dispatching-parallel-agents` | Fan-out with load balancing, failure isolation, result aggregation |
-
-### Extended Capabilities (6)
-
-| Skill | What It Does |
-|-------|-------------|
-| `agent-payments` | x402 payment protocol — supervised, capped, human-in-the-loop by default |
-| `security-audit` | Automated vulnerability scanning (Trivy, gitleaks, npm audit) |
-| `content-pipeline` | Write → humanize → format → publish with platform-specific formatting |
-| `learn-how-to-learn` | Metacognitive protocols, anti-pattern detection, confidence calibration |
-| `market-intelligence` | Competitive research, trend detection, opportunity scoring |
-| `prospecting` | Lead generation, contact enrichment, CRM sync (Exa + Apollo) |
-
-### RSI Intelligence Layer (4)
-
-Skills that require runtime execution and persistent state — not available in static frameworks.
-
-| Skill | What It Does |
-|-------|-------------|
-| `meta-skill-evolution` | Every 50 tasks: analyzes outcomes, identifies weakest skill, rewrites its methodology |
-| `self-healing-code` | On test failure: hypothesis tree → 2+ patches → applies best → auto-commits |
-| `cross-project-knowledge` | Pattern library across all repos — bug fixes and solutions transfer between projects |
-| `formal-verification-lite` | Property-based testing (fast-check/Hypothesis/QuickCheck) — 1000+ examples per property |
-
-## Cross-Session Memory
-
-Skills persist state across sessions. Your agent's debugging hypotheses, payment outcomes, and learned patterns survive session restarts.
+The RSI engine implements a continuous improvement loop:
 
 ```
-~/.clawpowers/
-├── state/        # Key-value store
-├── metrics/      # Outcome tracking per skill (JSONL)
-├── checkpoints/  # Resumable workflow state
-├── feedback/     # RSI self-improvement data
-└── logs/         # Execution logs
+measure → hypothesize → mutate → A/B test → promote/rollback → repeat
 ```
 
-## CLI Reference
+**Tier Safety:**
+- **T1** (Parameter Tuning) — Can auto-apply
+- **T2** (Strategy Evolution) — Can auto-apply with notification
+- **T3** (Skill Composition) — Requires testing gate
+- **T4** (Architecture Proposals) — **ALWAYS requires human approval**
 
-```bash
-npx clawpowers init                          # Set up runtime
-npx clawpowers status                        # Health check
-npx clawpowers demo x402                     # Payment demo (no real money)
-npx clawpowers metrics record --skill <name> --outcome success|failure
-npx clawpowers metrics summary               # Per-skill stats
-npx clawpowers analyze                       # RSI performance analysis
-npx clawpowers store get <key>               # Read persistent state
-npx clawpowers store set <key> <value>       # Write persistent state
-npx clawpowers payments queue                # Review pending approvals
-```
+Safety invariants (spending limits, identity, RSI definitions, sandbox boundaries, credentials) can **NEVER** be modified by RSI.
 
-## Platform Support
+## Fee Structure
 
-| Platform | Windows | macOS | Linux | WSL2 |
-|----------|:-------:|:-----:|:-----:|:----:|
-| Claude Code | ✅ | ✅ | ✅ | ✅ |
-| Cursor | ✅ | ✅ | ✅ | ✅ |
-| Codex | ✅ | ✅ | ✅ | ✅ |
-| OpenCode | ✅ | ✅ | ✅ | ✅ |
-| Gemini CLI | ✅ | ✅ | ✅ | ✅ |
+| Operation | Fee |
+|-----------|-----|
+| Transaction | 0.77% |
+| Token Swap | 0.30% |
 
-## Requirements
+Fees are applied at the payment execution layer and are included in the transaction amount.
 
-- **Node.js >= 16** (for cross-platform runtime)
-- **OR bash** (for Unix-native runtime)
-- **Zero runtime dependencies** — `package.json` has an empty `dependencies` object
+## Python Integration
 
-## Security Model
+```python
+import subprocess
+import json
 
-- State directory (`~/.clawpowers/`) uses `700` permissions — owner-only
-- No network access in runtime scripts — store, metrics, and analyze are fully offline
-- No `eval()`, `Function()`, or dynamic code execution anywhere in the runtime
-- Payment guardrails enforced by smart contract — application code cannot override them
+# Call ClawPowers via Node.js subprocess
+result = subprocess.run(
+    ['node', '-e', '''
+    import { detect402, SpendingPolicy } from "clawpowers";
+    const policy = new SpendingPolicy({ dailyLimit: 25, transactionLimit: 10, allowedDomains: [] });
+    const decision = policy.checkTransaction(5.00, "api.example.com");
+    console.log(JSON.stringify(decision));
+    '''],
+    capture_output=True, text=True
+)
+decision = json.loads(result.stdout)
+```
 
-## Credential
+## API Reference
+
+### Payments
+- `detect402(response)` — Parse x402 headers from 402 response
+- `isPaymentRequired(error)` — Type guard for 402 errors
+- `SpendingPolicy` — Enforce daily/transaction/domain limits
+- `PaymentExecutor` — Execute payments via MCP client
+
+### Memory
+- `WorkingMemoryManager` — In-process context management
+- `EpisodicMemory` — JSONL task history
+- `ProceduralMemory` — Skill effectiveness tracking
+- `CheckpointManager` — Crash recovery
+- `ContextInjector` — Memory-to-context selection
+
+### RSI
+- `MetricsCollector` — Task/skill metrics in JSONL
+- `HypothesisEngine` — Generate improvement hypotheses
+- `MutationEngine` — Create/apply/revert mutations
+- `ABTestManager` — A/B test mutations
+- `RSIAuditLog` — Append-only audit trail
+- `AutoResearcher` — Research solutions to failures
+
+### Skills
+- `discoverSkills(dir)` — Find skills in a directory
+- `loadSkillManifest(dir)` — Load a single skill manifest
+- `SkillExecutor` — Execute skills with outcome tracking
+
+### Wallet
+- `WalletManager` — High-level wallet operations
+- `generateWallet(config)` — Generate new wallet
+- `importWallet(key, config)` — Import existing wallet
+- `signMessage(msg, keyFile, passphrase)` — Sign a message
+
+### Config
+- `loadConfig()` / `saveConfig()` — Zod-validated config CRUD
+- `initConfig()` — Create default config
+- `getConfigValue()` / `setConfigValue()` — Dot-notation access
 
-Built by [AI Agent Economy](https://github.com/up2itnow0822):
-- Payment infrastructure in [NVIDIA's official NeMo Agent Toolkit](https://github.com/NVIDIA/NeMo-Agent-Toolkit-Examples/pull/17)
-- [agentwallet-sdk](https://www.npmjs.com/package/agentwallet-sdk) — 741+ downloads/week
-- [agentpay-mcp](https://github.com/up2itnow0822/agentpay-mcp) — MCP payment server
+## License
 
-## Patent Notice
+**Business Source License 1.1 (BSL 1.1)**
 
-**Patent Pending** — The underlying financial infrastructure (agentwallet-sdk, agentpay-mcp) is covered by USPTO provisional patent application filed March 2026: "Non-Custodial Multi-Chain Financial Infrastructure System for Autonomous AI Agents."
+This software is licensed under the BSL 1.1. You may use it for non-production purposes freely. Production use requires a commercial license until the Change Date, after which the software converts to the Apache 2.0 license.
 
-We support the open x402 standard. Our provisional filing is defensive — intended to prevent hostile monopolization of open payment rails, not to restrict builders.
+See [LICENSE](LICENSE) for full terms.
 
-## Disclaimer
+## Patent Notice
 
-ClawPowers and agentwallet-sdk are non-custodial developer tooling. You control your own keys and set your own spending limits. You are responsible for compliance with applicable laws in your jurisdiction. This software is provided as-is under the MIT license. Nothing here constitutes financial advice, custody services, or money transmission.
+⚠️ **Patent Pending:** The autonomous payment detection, spending policy enforcement, recursive self-improvement engine, and multi-tier memory systems implemented in this library are subject to pending patent applications filed by AI Agent Economy. Unauthorized commercial use may constitute patent infringement.
 
-## License
+---
 
-MIT
+Built by [AI Agent Economy](https://github.com/up2itnow0822) 🦅