clawpowers 1.1.4 → 2.2.0

package/dist/index.d.ts

@@ -0,0 +1,1477 @@
+/**
+ * ClawPowers Skills — Core Type System
+ * Zero `any` types. Discriminated unions for all status fields.
+ * Agent control-loop types (AgentStatus, AgentState, Goal, Plan, Step) removed —
+ * this is a skills library, not an agent runtime.
+ */
+type GoalSource = 'cli' | 'interactive' | 'resume';
+interface Goal {
+    readonly taskId: string;
+    readonly description: string;
+    readonly constraints: readonly string[];
+    readonly successCriteria: readonly string[];
+    readonly createdAt: string;
+    readonly source: GoalSource;
+}
+type StepStatus = 'pending' | 'in-progress' | 'complete' | 'failed' | 'skipped';
+interface Step {
+    readonly stepId: string;
+    readonly description: string;
+    readonly assignedSkills: readonly string[];
+    readonly status: StepStatus;
+    readonly dependsOn: readonly string[];
+    readonly output: string | null;
+    readonly retryCount: number;
+    readonly maxRetries: number;
+}
+type PlanStatus = 'draft' | 'approved' | 'executing' | 'complete' | 'failed';
+interface Plan {
+    readonly taskId: string;
+    readonly steps: readonly Step[];
+    readonly status: PlanStatus;
+    readonly createdAt: string;
+    readonly approvedAt: string | null;
+    readonly parallelizable: boolean;
+}
+type AgentStatus = 'idle' | 'intake' | 'planning' | 'executing' | 'reviewing' | 'complete' | 'failed' | 'paused';
+interface MemoryStats {
+    readonly workingCount: number;
+    readonly episodicCount: number;
+    readonly proceduralCount: number;
+    readonly lastCheckpoint: string | null;
+    readonly memoryBytes: number;
+}
+type MemoryOutcome = 'success' | 'failure' | 'partial';
+interface MemoryEntry {
+    readonly taskId: string;
+    readonly timestamp: string;
+    readonly description: string;
+    readonly outcome: MemoryOutcome;
+    readonly lessonsLearned: readonly string[];
+    readonly skillsUsed: readonly string[];
+    readonly durationMs: number;
+    readonly tags: readonly string[];
+}
+type ProfileName = 'dev' | 'lead' | 'secure' | 'growth' | 'full';
+interface Profile {
+    readonly name: ProfileName;
+    readonly description: string;
+    readonly skills: readonly string[];
+    readonly defaultModel: string;
+    readonly maxConcurrentAgents: number;
+    readonly paymentEnabled: boolean;
+    readonly rsiEnabled: boolean;
+}
+interface SkillRequirements {
+    readonly bins: readonly string[];
+    readonly env: readonly string[];
+    readonly config: readonly string[];
+}
+interface SkillManifest {
+    readonly name: string;
+    readonly description: string;
+    readonly path: string;
+    readonly requirements: SkillRequirements | null;
+}
+type RSITierMode = 'auto' | 'ask' | 'off';
+type RSITierT4Mode = 'ask' | 'off';
+interface RSITier {
+    readonly t1: RSITierMode;
+    readonly t2: RSITierMode;
+    readonly t3: RSITierMode;
+    readonly t4: RSITierT4Mode;
+}
+type RSIMutationStatus = 'active' | 'rolled-back';
+interface RSIMutation {
+    readonly mutationId: string;
+    readonly appliedAt: string;
+    readonly delta: number;
+    readonly status: RSIMutationStatus;
+}
+type PaymentMode = 'human-first' | 'auto' | 'disabled';
+interface PaymentConfig {
+    readonly mode: PaymentMode;
+    readonly dailyLimitUsd: number;
+    readonly weeklyLimitUsd: number;
+    readonly allowedDomains: readonly string[];
+}
+interface RSIConfig {
+    readonly enabled: boolean;
+    readonly tiers: RSITier;
+}
+interface LoggingConfig {
+    readonly level: 'debug' | 'info' | 'warn' | 'error';
+    readonly retentionDays: number;
+}
+interface ConfigFile {
+    readonly version: string;
+    readonly profile: ProfileName;
+    readonly rsi: RSIConfig;
+    readonly payments: PaymentConfig;
+    readonly logging: LoggingConfig;
+    readonly skillsDir: string;
+    readonly dataDir: string;
+}
+interface StepResult {
+    readonly stepId: string;
+    readonly status: 'success' | 'failure';
+    readonly output: string;
+    readonly durationMs: number;
+    readonly retriesUsed: number;
+    readonly error: string | null;
+}
+interface PlanResult {
+    readonly taskId: string;
+    readonly status: 'success' | 'failure' | 'partial';
+    readonly stepResults: readonly StepResult[];
+    readonly durationMs: number;
+    readonly completedSteps: number;
+    readonly failedSteps: number;
+    readonly skippedSteps: number;
+}
+interface CriterionResult {
+    readonly criterion: string;
+    readonly met: boolean;
+    readonly evidence: string;
+}
+interface ReviewResult {
+    readonly passed: boolean;
+    readonly criteria: readonly CriterionResult[];
+    readonly suggestions: readonly string[];
+}
+type TaskOutcome = 'success' | 'failure' | 'partial';
+interface TaskCompletion {
+    readonly taskId: string;
+    readonly outcome: TaskOutcome;
+    readonly summary: string;
+    readonly durationMs: number;
+    readonly skillsUsed: readonly string[];
+    readonly lessonsLearned: readonly string[];
+}
+interface WorkingMemory {
+    readonly taskId: string;
+    readonly goal: Goal;
+    readonly plan: Plan;
+    readonly currentStepId: string | null;
+    readonly intermediateOutputs: Readonly<Record<string, string>>;
+    readonly contextWindow: readonly string[];
+}
+interface PaymentRequired {
+    readonly amount: number;
+    readonly currency: string;
+    readonly recipient: string;
+    readonly network: string;
+    readonly x402Headers: Readonly<Record<string, string>>;
+}
+interface PaymentRequest {
+    readonly amount: number;
+    readonly currency: string;
+    readonly recipient: string;
+    readonly x402Headers: Readonly<Record<string, string>>;
+    readonly domain: string;
+}
+interface PaymentResult {
+    readonly success: boolean;
+    readonly txHash?: string;
+    readonly error?: string;
+}
+interface SpendingDecision {
+    readonly allowed: boolean;
+    readonly reason: string;
+    readonly remainingDaily: number;
+}
+interface PaymentAuditEntry {
+    readonly timestamp: string;
+    readonly request: PaymentRequest;
+    readonly result: PaymentResult;
+    readonly spendingSnapshot: {
+        readonly dailySpent: number;
+        readonly dailyLimit: number;
+    };
+}
+interface EpisodicEntry {
+    readonly taskId: string;
+    readonly timestamp: string;
+    readonly description: string;
+    readonly outcome: MemoryOutcome;
+    readonly lessonsLearned: readonly string[];
+    readonly skillsUsed: readonly string[];
+    readonly durationMs: number;
+    readonly tags: readonly string[];
+}
+interface MutationRecord {
+    readonly mutationId: string;
+    readonly description: string;
+    readonly appliedAt: string;
+    readonly revertedAt: string | null;
+    readonly status: 'active' | 'reverted';
+}
+interface ProceduralEntry {
+    readonly skillName: string;
+    readonly invocationCount: number;
+    readonly successRate: number;
+    readonly avgContribution: number;
+    readonly preferredContexts: readonly string[];
+    readonly lastUsed: string;
+    readonly mutations: readonly MutationRecord[];
+}
+interface CheckpointState {
+    readonly taskId: string;
+    readonly goal: Goal;
+    readonly plan: Plan;
+    readonly currentStepId: string | null;
+    readonly intermediateOutputs: Readonly<Record<string, string>>;
+    readonly workingMemory: WorkingMemory;
+    readonly savedAt: string;
+    readonly agentStatus: AgentStatus;
+}
+interface CheckpointInfo {
+    readonly taskId: string;
+    readonly description: string;
+    readonly savedAt: string;
+    readonly isStale: boolean;
+}
+interface TaskMetrics {
+    readonly taskId: string;
+    readonly timestamp: string;
+    readonly durationMs: number;
+    readonly stepCount: number;
+    readonly stepsCompleted: number;
+    readonly stepsFailed: number;
+    readonly retryCount: number;
+    readonly skillsUsed: readonly string[];
+    readonly outcome: TaskOutcome;
+    readonly memoryEntriesCreated: number;
+}
+interface SkillMetrics {
+    readonly skillName: string;
+    readonly timestamp: string;
+    readonly invoked: boolean;
+    readonly succeeded: boolean;
+    readonly durationMs: number;
+    readonly taskId: string;
+    readonly mutationActive: boolean;
+}
+type TrendDirection = 'improving' | 'declining' | 'stable';
+interface SkillAggregateStats {
+    readonly skillName: string;
+    readonly totalInvocations: number;
+    readonly successRate: number;
+    readonly avgDurationMs: number;
+    readonly trendDirection: TrendDirection;
+}
+type RSITierLabel = 'T1' | 'T2' | 'T3' | 'T4';
+interface RSIHypothesis {
+    readonly hypothesisId: string;
+    readonly skillName: string;
+    readonly description: string;
+    readonly expectedImprovement: number;
+    readonly tier: RSITierLabel;
+    readonly confidence: number;
+    readonly evidence: readonly string[];
+}
+type RSIMutationExtendedStatus = 'proposed' | 'applied' | 'reverted' | 'promoted';
+interface RSIMutationExtended {
+    readonly mutationId: string;
+    readonly hypothesisId: string;
+    readonly skillName: string;
+    readonly tier: RSITierLabel;
+    readonly description: string;
+    readonly originalValue: string;
+    readonly mutatedValue: string;
+    readonly status: RSIMutationExtendedStatus;
+    readonly appliedAt: string | null;
+    readonly revertedAt: string | null;
+}
+type ABTestStatus = 'running' | 'completed' | 'cancelled';
+type ABTestDecision = 'promote' | 'rollback' | 'continue';
+interface ABTest {
+    readonly testId: string;
+    readonly mutationId: string;
+    readonly skillName: string;
+    readonly baselineStats: SkillAggregateStats;
+    readonly variantStats: SkillAggregateStats;
+    readonly sampleSize: number;
+    readonly minSampleSize: number;
+    readonly startedAt: string;
+    readonly status: ABTestStatus;
+}
+interface ABTestResult {
+    readonly testId: string;
+    readonly decision: ABTestDecision;
+    readonly improvement: number;
+    readonly confidence: number;
+}
+interface RSIAuditMetrics {
+    readonly baseline: number;
+    readonly current: number;
+    readonly delta: number;
+}
+interface RSIAuditEntry {
+    readonly timestamp: string;
+    readonly action: string;
+    readonly skillName: string;
+    readonly mutationId: string;
+    readonly hypothesis: string;
+    readonly metrics: RSIAuditMetrics;
+    readonly decision: string;
+}
+
+/**
+ * ClawPowers Agent — Config Manager
+ * CRUD for ~/.clawpowers/config.json with Zod validation.
+ * T4 can never be set to "auto" — enforced at validation layer.
+ */
+
+declare function loadConfig(configPath?: string): ConfigFile;
+/**
+ * Safe config loader — returns defaults if file is missing or invalid.
+ * Used by CLI where crashing on stale config is bad UX.
+ */
+declare function loadConfigSafe(configPath?: string): ConfigFile;
+declare function saveConfig(config: ConfigFile, configPath?: string): void;
+declare function initConfig(configPath?: string): ConfigFile;
+/**
+ * Get a value from config using dot notation (e.g., "rsi.tiers.t1")
+ */
+declare function getConfigValue(config: ConfigFile, key: string): unknown;
+/**
+ * Set a value in config using dot notation. Returns the updated config.
+ * Validates the entire config after the set to ensure consistency.
+ * Throws on invalid values (e.g., T4 = "auto").
+ */
+declare function setConfigValue(config: ConfigFile, key: string, value: string): ConfigFile;
+
+/**
+ * ClawPowers Skills — Constants
+ * Default paths, version, config values, RSI tier boundaries.
+ */
+
+declare const VERSION = "2.2.0";
+declare const PACKAGE_NAME = "clawpowers";
+declare const CLAWPOWERS_HOME: string;
+declare const DEFAULT_CONFIG: ConfigFile;
+
+interface NativeWallet {
+    address(): string;
+    signMessage(msg: Buffer): string;
+}
+interface NativeWalletConstructor {
+    generate(): NativeWallet;
+    fromPrivateKey(hex: string): NativeWallet;
+}
+interface NativeFeeSchedule {
+    calculate(amount: number, decimals: number, feeType: string): string;
+}
+interface NativeFeeScheduleConstructor {
+    withDefaults(): NativeFeeSchedule;
+    new (txBps: number, swapBps: number, recipientHex: string): NativeFeeSchedule;
+}
+interface NativeX402Client {
+    createPaymentHeader(paymentJson: string, signature: string): string;
+}
+interface NativeX402ClientConstructor {
+    new (): NativeX402Client;
+}
+interface NativeCanonicalStore {
+    insert(recordJson: string): string;
+    get(id: string): string | null;
+    verifyIntegrity(id: string): boolean;
+}
+interface NativeCanonicalStoreConstructor {
+    open(path: string): NativeCanonicalStore;
+    inMemory(): NativeCanonicalStore;
+}
+interface NativeTurboCompressor {
+    compress(vector: Float32Array): string;
+    decompress(compressedJson: string): Float32Array;
+}
+interface NativeTurboCompressorConstructor {
+    new (dimensions: number, bits: number): NativeTurboCompressor;
+}
+interface NativeWriteFirewall {
+    evaluate(requestJson: string): string;
+}
+interface NativeWriteFirewallConstructor {
+    new (configJson: string): NativeWriteFirewall;
+}
+interface NativeModule {
+    JsAgentWallet: NativeWalletConstructor;
+    JsFeeSchedule: NativeFeeScheduleConstructor;
+    JsX402Client: NativeX402ClientConstructor;
+    JsCanonicalStore: NativeCanonicalStoreConstructor;
+    JsTurboCompressor: NativeTurboCompressorConstructor;
+    JsWriteFirewall: NativeWriteFirewallConstructor;
+    /** Present when `clawpowers-ffi` was built with keccak helper (ClawPowers-Skills ≥2.1.0). */
+    keccak256Bytes?: (data: Buffer) => string;
+    /** secp256k1 + Keccak address (ClawPowers-Skills ≥2.2.0). */
+    deriveEthereumAddress?: (privateKey: Buffer) => string;
+    derivePublicKey?: (privateKey: Buffer) => Buffer;
+    signEcdsa?: (privateKey: Buffer, messageHash: Buffer) => Buffer;
+    verifyEcdsa?: (publicKey: Buffer, messageHash: Buffer, signature: Buffer) => boolean;
+}
+interface WasmModule {
+    tokenAmountFromHuman(human: number, decimals: number): string;
+    tokenAmountToHuman(json: string): number;
+    tokenAmountAdd(aJson: string, bJson: string): string;
+    tokenAmountSub(aJson: string, bJson: string): string;
+    tokenAmountMulBps(json: string, bps: bigint): string;
+    getDefaultTokenRegistry(): string;
+    calculateFee(amountJson: string, feeType: string, txFeeBps?: bigint, swapFeeBps?: bigint): string;
+    compressVector(vectorJson: string, dimensions: number): string;
+    decompressVector(compressedJson: string, dimensions: number): string;
+    approximateDistance(aJson: string, bJson: string, dimensions: number): number;
+    WasmCanonicalStore: {
+        new (): WasmCanonicalStoreInstance;
+    };
+    evaluateWriteFirewall(json: string): string;
+    computeSha256(content: string): string;
+    /** Keccak-256 over raw bytes (`0x` + 64 hex). Present in wasm builds from ClawPowers-Skills ≥2.1.0. */
+    computeKeccak256?(bytes: Uint8Array): string;
+    /** secp256k1 Ethereum address (ClawPowers-Skills ≥2.2.0). */
+    deriveEthereumAddress?(privateKey: Uint8Array): string;
+    derivePublicKey?(privateKey: Uint8Array): Uint8Array;
+    signEcdsa?(privateKey: Uint8Array, messageHash: Uint8Array): Uint8Array;
+    verifyEcdsa?(publicKey: Uint8Array, messageHash: Uint8Array, signature: Uint8Array): boolean;
+    getVersion(): string;
+    getAvailableModules(): string;
+}
+interface WasmCanonicalStoreInstance {
+    insert(json: string): string;
+    get(id: string): string | null;
+    getByHash(hash: string): string | null;
+    queryNamespace(namespace: string, limit: number): string;
+    softDelete(id: string): boolean;
+    verifyIntegrity(id: string): boolean;
+    exportJson(): string;
+    importJson(json: string): number;
+}
+type LoadTier = 'native' | 'wasm' | 'typescript';
+/**
+ * Get the native .node module, or null if unavailable.
+ */
+declare function getNative(): NativeModule | null;
+/**
+ * Get the WASM module, or null if unavailable.
+ */
+declare function getWasm(): WasmModule | null;
+/**
+ * Returns true if the native Rust addon was loaded successfully.
+ */
+declare function isNativeAvailable(): boolean;
+/**
+ * Returns true if the WASM module was loaded successfully.
+ */
+declare function isWasmAvailable(): boolean;
+/**
+ * Returns the active loading tier.
+ */
+declare function getActiveTier(): LoadTier;
+/**
+ * Returns a summary of available modules per tier.
+ */
+declare function getCapabilitySummary(): {
+    tier: LoadTier;
+    nativeModules: string[];
+    wasmModules: string[];
+    typescriptFallback: string[];
+};
+/**
+ * Compute SHA-256 hash, using the fastest available backend.
+ */
+declare function computeSha256(content: string): string;
+/**
+ * 32-byte digest as `0x` + 64 hex chars for wallet address derivation (last 20 bytes used as address).
+ *
+ * Tier 1: native `keccak256Bytes` when the `.node` addon includes it (custom `cargo build` of ffi).
+ * Tier 2: WASM `computeKeccak256` (pre-built `pkg-node` ships with the npm package).
+ * Tier 3: SHA-256 via Node.js `crypto` (legacy; use native/WASM for keccak256 parity).
+ */
+declare function digestForWalletAddress(keyMaterial: Buffer): string;
+/**
+ * Keccak-256 digest of raw bytes as a 32-byte `Buffer`.
+ * Tier 1: native `keccak256Bytes`; Tier 2: WASM `computeKeccak256`; Tier 3: `null`.
+ */
+declare function keccak256Digest(data: Buffer): Buffer | null;
+/**
+ * Ethereum address from 32-byte secp256k1 private key (EIP-55). Tier 1 → Tier 2 → `null`.
+ */
+declare function deriveEthereumAddress(privateKey: Buffer): string | null;
+/**
+ * Uncompressed public key (64 bytes, no `0x04` prefix). Tier 1 → Tier 2 → `null`.
+ */
+declare function derivePublicKey(privateKey: Buffer): Buffer | null;
+/**
+ * ECDSA sign a 32-byte message hash (65 bytes: r‖s‖recovery_id). Tier 1 → Tier 2 → `null`.
+ */
+declare function signEcdsa(privateKey: Buffer, messageHash: Buffer): Buffer | null;
+/**
+ * Verify ECDSA over a 32-byte prehash. Tier 1 → Tier 2; otherwise `false`.
+ */
+declare function verifyEcdsa(publicKey: Buffer, messageHash: Buffer, signature: Buffer): boolean;
+/**
+ * Create a token amount from a human-readable number.
+ * Routes to WASM if available, otherwise pure TypeScript.
+ */
+declare function tokenAmountFromHuman(human: number, decimals: number): {
+    raw: string;
+    decimals: number;
+};
+/**
+ * Calculate a fee, routing to the best available backend.
+ */
+declare function calculateFee(amountHuman: number, decimals: number, feeType: 'transaction' | 'swap' | string, txFeeBps?: number, swapFeeBps?: number): {
+    gross_amount: number;
+    fee_amount: number;
+    net_amount: number;
+};
+/**
+ * Evaluate a write request against the security firewall.
+ * Routes to WASM if available, otherwise TypeScript.
+ */
+declare function evaluateWriteFirewall(request: {
+    namespace: string;
+    content: string;
+    trust_level: string;
+    source: string;
+    allowed_namespaces?: string[];
+    blocked_patterns?: string[];
+    max_content_length?: number;
+}): {
+    decision: 'allow' | 'deny' | 'sanitize';
+    reason?: string;
+    sanitized?: string;
+};
+
+/**
+ * ClawPowers Agent — Payment Discovery
+ * Detects HTTP 402 Payment Required responses and parses x402 headers.
+ */
+
+interface HttpResponse {
+    readonly status: number;
+    readonly headers: Readonly<Record<string, string>>;
+}
+/**
+ * Detect a 402 Payment Required response and extract payment details from x402 headers.
+ * Returns null if the response is not a 402 or if required headers are missing.
+ */
+declare function detect402(response: HttpResponse): PaymentRequired | null;
+/**
+ * Type guard to check if an error represents a 402 Payment Required response.
+ */
+declare function isPaymentRequired(error: unknown): boolean;
+
+/**
+ * ClawPowers Agent — Spending Policy
+ * Enforces daily limits, per-transaction limits, and domain allowlists.
+ * Fail-closed: any policy error results in rejection.
+ */
+
+interface SpendingRecord {
+    amount: number;
+    timestamp: number;
+    domain: string;
+}
+declare class SpendingPolicy {
+    readonly dailyLimit: number;
+    readonly transactionLimit: number;
+    readonly allowedDomains: readonly string[];
+    private spendingLog;
+    constructor(options: {
+        dailyLimit: number;
+        transactionLimit: number;
+        allowedDomains: readonly string[];
+    });
+    /**
+     * Get total spending for the current UTC day.
+     */
+    getDailySpent(): number;
+    /**
+     * Check whether a transaction is allowed under the current policy.
+     * Fail-closed: any validation error results in rejection.
+     */
+    checkTransaction(amount: number, domain: string): SpendingDecision;
+    /**
+     * Record a completed spending transaction.
+     */
+    recordSpend(amount: number, domain: string): void;
+    /**
+     * Reset all spending records (used for testing).
+     */
+    reset(): void;
+    /**
+     * Get the full spending log (for audit purposes).
+     */
+    getSpendingLog(): readonly SpendingRecord[];
+}
+
+/**
+ * ClawPowers Agent — Payment Executor
+ * Executes payments via agentpay-mcp with spending policy enforcement.
+ * Never auto-retries failed payments (financial safety).
+ */
+
+/**
+ * Interface for an MCP payment client.
+ * In production, this wraps agentpay-mcp; in tests, it can be substituted.
+ */
+interface MCPPaymentClient {
+    executePayment(params: {
+        amount: number;
+        currency: string;
+        recipient: string;
+        x402Headers: Readonly<Record<string, string>>;
+    }): Promise<{
+        txHash: string;
+        status: 'success' | 'failed';
+    }>;
+}
+/**
+ * Payment executor that enforces spending policy and logs all attempts.
+ */
+declare class PaymentExecutor {
+    private readonly policy;
+    private readonly client;
+    private readonly auditLog;
+    constructor(policy: SpendingPolicy, client: MCPPaymentClient);
+    /**
+     * Execute a payment request.
+     * 1. Check spending policy
+     * 2. If allowed, execute via MCP client
+     * 3. Log the result (success or failure)
+     * 4. Never auto-retry on failure
+     */
+    executePayment(request: PaymentRequest): Promise<PaymentResult>;
+    /**
+     * Get the full payment audit log.
+     */
+    getAuditLog(): readonly PaymentAuditEntry[];
+    /**
+     * Log a payment attempt to the audit trail.
+     */
+    private logAudit;
+}
+
+interface FeeCalculation {
+    gross: number;
+    fee: number;
+    net: number;
+    feeRecipient: string;
+}
+/**
+ * Calculate transaction fee using the best available backend.
+ *
+ * Tier 1: Native Rust fee crate (JsFeeSchedule.withDefaults, 77 bps)
+ * Tier 2: WASM fee crate (calculateFee via index.ts helper)
+ * Tier 3: Pure TypeScript 77 bps calculation
+ */
+declare function calculateTransactionFee(amount: number, decimals?: number): FeeCalculation;
+/**
+ * Build an X-Payment header.
+ *
+ * Tier 1: Native Rust x402 crate (JsX402Client)
+ * Tier 2: Not available in WASM (wallet/x402 excluded from wasm crate)
+ * Tier 3: Base64-encoded JSON representation
+ */
+declare function createPaymentHeader(paymentJson: string, signature: string): string;
+/**
+ * Generate a new EVM agent wallet address.
+ *
+ * Tier 1: Native Rust wallet crate (JsAgentWallet.generate)
+ * Tier 2: WASM secp256k1 + Keccak derivation via the shared loader
+ * Tier 3: throws, because returning a fake zero address would be misleading
+ */
+declare function generateWalletAddress(): string;
+
+/**
+ * ClawPowers Agent — Working Memory Manager
+ * In-process working memory with token budget enforcement.
+ */
+
+declare class WorkingMemoryManager {
+    private memory;
+    create(taskId: string, goal: Goal): WorkingMemory;
+    updateCurrentStep(stepId: string): void;
+    addIntermediateOutput(stepId: string, output: string): void;
+    /**
+     * Inject context entries into working memory, enforcing token budget.
+     * Entries are added until the budget is exhausted, then truncated.
+     */
+    injectContext(entries: readonly string[]): void;
+    getSnapshot(): WorkingMemory;
+    clear(): void;
+}
+
+/**
+ * ClawPowers Agent — Episodic Memory
+ * JSONL append-only storage for task episodes.
+ */
+
+declare class EpisodicMemory {
+    private readonly filePath;
+    constructor(filePath: string);
+    private ensureDir;
+    append(entry: EpisodicEntry): Promise<void>;
+    readAll(): Promise<EpisodicEntry[]>;
+    search(query: string, limit?: number): Promise<EpisodicEntry[]>;
+    readRecent(count: number): Promise<EpisodicEntry[]>;
+    recoverFromCorruption(): Promise<{
+        recovered: number;
+        lost: number;
+    }>;
+    private parseLines;
+}
+
+/**
+ * ClawPowers Agent — Procedural Memory
+ * JSON-based skill effectiveness tracking with atomic writes.
+ */
+
+declare class ProceduralMemory {
+    private readonly filePath;
+    private cache;
+    constructor(filePath: string);
+    private ensureDir;
+    load(): Promise<ProceduralEntry[]>;
+    update(skillName: string, result: {
+        succeeded: boolean;
+        durationMs: number;
+        taskId: string;
+    }): Promise<void>;
+    getSkillScore(skillName: string): ProceduralEntry | null;
+    getTopSkills(context: string, limit: number): ProceduralEntry[];
+    recordMutation(skillName: string, mutation: MutationRecord): Promise<void>;
+    rollbackMutation(skillName: string, mutationId: string): Promise<void>;
+    private atomicWrite;
+}
+
+/**
+ * ClawPowers Agent — Checkpoint Manager
+ * Crash recovery via atomic checkpoint files.
+ */
+
+declare class CheckpointManager {
+    private readonly dir;
+    constructor(dir: string);
+    private ensureDir;
+    private filePath;
+    save(taskId: string, state: CheckpointState): Promise<void>;
+    load(taskId: string): Promise<CheckpointState | null>;
+    remove(taskId: string): Promise<void>;
+    listIncomplete(): Promise<CheckpointInfo[]>;
+    isStale(checkpoint: CheckpointState, maxAgeMs?: number): boolean;
+}
+
+/**
+ * ClawPowers Agent — Context Injector
+ * Selects and compresses relevant memories for working memory injection.
+ */
+
+declare class ContextInjector {
+    private readonly episodic;
+    private readonly procedural;
+    constructor(episodic: EpisodicMemory, procedural: ProceduralMemory);
+    inject(goal: Goal, maxTokens?: number): Promise<string[]>;
+}
+
+/**
+ * Native acceleration bridge for memory storage.
+ *
+ * Tier 1: Native Rust .node addon (canonical store, TurboQuant compressor, write firewall)
+ * Tier 2: WASM module (WasmCanonicalStore, compressVector, evaluateWriteFirewall)
+ * Tier 3: Pure TypeScript fallback (null returns / fail-open defaults)
+ *
+ * Note: Wallet and x402 are excluded from the WASM build; memory functions
+ * (canonical store, compression, security, verification) are all available in WASM.
+ */
+
+/** Get a native persistent canonical store, or null if unavailable. */
+declare function getNativeCanonicalStore(dbPath: string): NativeCanonicalStore | null;
+/** Get an in-memory native canonical store for testing, or null if unavailable. */
+declare function getNativeCanonicalStoreInMemory(): NativeCanonicalStore | null;
+/**
+ * Get an in-memory WASM canonical store, or null if WASM is unavailable.
+ * This is the Tier 2 alternative to getNativeCanonicalStoreInMemory().
+ */
+declare function getWasmCanonicalStore(): WasmCanonicalStoreInstance | null;
+/**
+ * Get the best available in-memory canonical store.
+ * Returns a unified interface regardless of which tier is active.
+ *
+ * Tier 1: Native canonical store (SQLite-backed in-memory)
+ * Tier 2: WASM canonical store (in-memory HashMap)
+ * Tier 3: null (caller must handle)
+ */
+declare function getBestCanonicalStore(): NativeCanonicalStore | WasmCanonicalStoreInstance | null;
+interface CompressionResult {
+    compressed: string;
+    originalSize: number;
+    compressedSize: number;
+}
+/**
+ * Compress a float32 vector using the best available backend.
+ *
+ * Tier 1: Native TurboQuant compressor (JsTurboCompressor)
+ * Tier 2: WASM vector compression (compressVector)
+ * Tier 3: null (no compression available)
+ */
+declare function compressVector(vector: Float32Array, bits?: number): CompressionResult | null;
+/**
+ * Decompress a previously compressed vector using the best available backend.
+ *
+ * Tier 1: Native TurboQuant decompressor
+ * Tier 2: WASM vector decompressor
+ * Tier 3: null (no decompression available)
+ */
+declare function decompressVector(compressedJson: string, dimensions: number, bits?: number): Float32Array | null;
+/**
+ * Compute approximate distance between two compressed vectors.
+ *
+ * Tier 1: Not exposed on native JsTurboCompressor directly
+ * Tier 2: WASM approximateDistance
+ * Tier 3: null
+ */
+declare function approximateDistance(aJson: string, bJson: string, dimensions: number): number | null;
+/**
+ * Evaluate a write request through the security firewall.
+ * Fail-open: returns allowed:true if no backend is available.
+ *
+ * Tier 1: Native JsWriteFirewall
+ * Tier 2: WASM evaluateWriteFirewall (via index.ts unified helper)
+ * Tier 3: Basic TypeScript checks (via index.ts unified helper)
+ */
+declare function evaluateWriteSecurity(namespace: string, content: string, allowedNamespaces: string[], source?: string, trustLevel?: string): {
+    allowed: boolean;
+    reason?: string;
+};
+
+/**
+ * ClawPowers Agent — RSI Metrics Collector
+ * Per-task and per-skill metric collection in JSONL format.
+ */
+
+declare class MetricsCollector {
+    private readonly taskMetricsPath;
+    private readonly skillMetricsPath;
+    constructor(taskMetricsPath: string, skillMetricsPath: string);
+    private ensureDir;
+    recordTaskMetrics(task: TaskMetrics): Promise<void>;
+    recordSkillMetrics(skill: SkillMetrics): Promise<void>;
+    getTaskHistory(limit?: number): Promise<TaskMetrics[]>;
+    getSkillHistory(skillName: string, limit?: number): Promise<SkillMetrics[]>;
+    getAggregatedSkillStats(skillName: string): Promise<SkillAggregateStats>;
+    private calculateTrend;
+    private readJsonl;
+}
+
+/**
+ * ClawPowers Agent — RSI Hypothesis Engine
+ * Analyzes skill stats and task history to generate improvement hypotheses.
+ */
+
+declare class HypothesisEngine {
+    analyze(skillStats: readonly SkillAggregateStats[], taskHistory: readonly TaskMetrics[]): RSIHypothesis[];
+    private detectLowSuccessRate;
+    private detectSlowSkills;
+    private detectFrequentlyPairedSkills;
+    private detectUnusedInSuccessful;
+}
+
+/**
+ * ClawPowers Agent — RSI Mutation Engine
+ * Creates and manages mutations from hypotheses with tier enforcement.
+ */
+
+declare class MutationEngine {
+    private readonly historyPath;
+    constructor(historyPath: string);
+    private ensureDir;
+    createMutation(hypothesis: RSIHypothesis): RSIMutationExtended;
+    applyMutation(mutation: RSIMutationExtended): Promise<void>;
+    revertMutation(mutation: RSIMutationExtended): Promise<void>;
+    getMutationHistory(): Promise<RSIMutationExtended[]>;
+    private appendHistory;
+    private validateSafety;
+    private isSafetyInvariant;
+}
+
+/**
+ * ClawPowers Agent — A/B Test Manager
+ * Orchestrates A/B tests for RSI mutations.
+ */
+
+declare class ABTestManager {
+    private readonly tests;
+    private readonly results;
+    startTest(mutation: RSIMutationExtended, baselineMetrics: SkillAggregateStats): ABTest;
+    recordResult(testId: string, taskMetrics: TaskMetrics): void;
+    evaluateTest(testId: string): ABTestResult;
+    getActiveTests(): ABTest[];
+}
+
+/**
+ * ClawPowers Agent — RSI Audit Log
+ * Append-only JSONL audit trail for all RSI actions.
+ */
+
+declare class RSIAuditLog {
+    private readonly filePath;
+    constructor(filePath: string);
+    private ensureDir;
+    log(entry: RSIAuditEntry): Promise<void>;
+    getHistory(limit?: number): Promise<RSIAuditEntry[]>;
+    getByMutation(mutationId: string): Promise<RSIAuditEntry[]>;
+}
+
+/**
+ * ClawPowers Agent — RSI AutoResearch Module
+ *
+ * Runs BEFORE the mutation engine when T3 is triggered.
+ * Searches for solutions to task failures, tests candidates in sandbox,
+ * and promotes successful solutions to new skills.
+ */
+interface FailureTrace {
+    taskDescription: string;
+    error: string;
+    executionSteps: string[];
+    skillsUsed: string[];
+    attemptCount: number;
+}
+interface CandidateSolution {
+    source: 'web-search' | 'npm-registry' | 'skill-catalog';
+    description: string;
+    approach: string;
+    confidence: number;
+}
+interface TestResult {
+    passed: boolean;
+    output: string;
+    durationMs: number;
+    attempt: number;
+}
+interface SkillDefinition {
+    skillId: string;
+    name: string;
+    description: string;
+    approach: string;
+    source: CandidateSolution['source'];
+    promotedAt: string;
+    testResults: TestResult[];
+}
+interface TaskContext {
+    taskId: string;
+    description: string;
+    constraints: string[];
+    successCriteria: string[];
+}
+declare class AutoResearcher {
+    private readonly skillsDir;
+    constructor(skillsDir?: string);
+    /**
+     * Search for candidate solutions to a failure.
+     *
+     * Sources queried (in order of reliability):
+     *   1. skill-catalog  — skills already available that match the error domain
+     *   2. npm-registry   — packages that match the error keywords
+     *   3. web-search     — constructs a query from the failure trace
+     *
+     * Returns candidates sorted by confidence (highest first).
+     */
+    research(failure: FailureTrace): Promise<CandidateSolution[]>;
+    /**
+     * Test a candidate solution in an isolated sandbox.
+     * Runs the candidate's approach as a shell command in a temp directory.
+     * Returns a TestResult with pass/fail, output, and duration.
+     */
+    testCandidate(candidate: CandidateSolution, task: TaskContext): Promise<TestResult>;
+    /**
+     * Run a candidate through REQUIRED_PASSING_RUNS sandbox tests.
+     * Returns all TestResult objects. If fewer than REQUIRED_PASSING_RUNS pass,
+     * the candidate is NOT promoted (caller must check).
+     */
+    runSandboxTests(candidate: CandidateSolution, task: TaskContext): Promise<TestResult[]>;
+    /**
+     * Promote a candidate solution to a new skill definition.
+     * Writes a minimal SKILL.md to the skills directory and returns
+     * the SkillDefinition.
+     */
+    promoteToSkill(candidate: CandidateSolution, testResults: TestResult[]): Promise<SkillDefinition>;
+    private searchSkillCatalog;
+    private searchNpmRegistry;
+    private buildWebSearchCandidates;
+    /**
+     * Build a sandboxed test script for a candidate solution.
+     * Validates the candidate's approach by checking its core prerequisites
+     * (e.g. that a package is installed, or a command is available).
+     */
+    private buildTestScript;
+    private deriveSkillName;
+    private renderSkillMd;
+}
+/**
+ * Run the full AutoResearch cycle for a failed task.
+ * Returns the promoted SkillDefinition if a solution was found and promoted,
+ * or null if no solution was found (caller should fall through to mutation).
+ */
+declare function runAutoResearch(failure: FailureTrace, task: TaskContext, skillsDir?: string): Promise<SkillDefinition | null>;
+
+/**
+ * ClawPowers Agent — Skill Loader
+ * Discovers skills from skill directories, validates SKILL.md frontmatter.
+ */
+
+interface ParsedFrontmatter {
+    name?: string;
+    description?: string;
+    metadata?: {
+        openclaw?: {
+            requires?: {
+                bins?: string[];
+                env?: string[];
+                config?: string[];
+            };
+        };
+    };
+}
+/**
+ * Parse YAML frontmatter from a SKILL.md file content.
+ * Expects format: ---\n<yaml>\n---\n<content>
+ */
+declare function parseFrontmatter(content: string): ParsedFrontmatter;
+/**
+ * Load a single skill manifest from a directory containing SKILL.md
+ */
+declare function loadSkillManifest(skillDir: string): SkillManifest | null;
+/**
+ * Discover all skills in a directory. Each subdirectory with a valid SKILL.md
+ * becomes a skill manifest.
+ */
+declare function discoverSkills(skillsDir: string): SkillManifest[];
+/**
+ * Filter skills based on active profile.
+ * Returns only skills that are listed in the profile's skill list.
+ */
+declare function getActiveSkills(allSkills: SkillManifest[], profile: Profile): SkillManifest[];
+/**
+ * List skills with their active/inactive status for a given profile.
+ */
+declare function listSkillsWithStatus(allSkills: SkillManifest[], profile: Profile): Array<{
+    skill: SkillManifest;
+    active: boolean;
+}>;
+
+/**
+ * ClawPowers Skills — Skill Executor
+ * Execute skills and track outcomes in procedural memory.
+ */
+
+interface SkillExecutionContext {
+    readonly taskId: string;
+    readonly input: string;
+    readonly metadata?: Record<string, unknown>;
+}
+interface SkillExecutionResult {
+    readonly success: boolean;
+    readonly output: string;
+    readonly durationMs: number;
+    readonly error?: string;
+}
+declare class SkillExecutor {
+    private readonly skillsDir;
+    private readonly memory;
+    constructor(skillsDir: string, memory: ProceduralMemory);
+    execute(skillName: string, context: SkillExecutionContext): Promise<SkillExecutionResult>;
+}
+
+interface WalletConfig {
+    readonly chain: 'base' | 'ethereum' | 'polygon';
+    readonly dataDir: string;
+}
+interface WalletInfo {
+    readonly address: string;
+    readonly chain: string;
+    readonly createdAt: string;
+    readonly keyFile: string;
+}
+interface SignedMessage {
+    readonly message: string;
+    readonly signature: string;
+    readonly address: string;
+}
+
+/**
+ * ClawPowers Skills — Wallet Manager
+ * High-level wallet management: generate, import, sign, list.
+ */
+
+declare class WalletManager {
+    private readonly config;
+    constructor(config: WalletConfig);
+    generate(): Promise<WalletInfo>;
+    import(privateKey: string): Promise<WalletInfo>;
+    sign(message: string, walletInfo: WalletInfo, passphrase: string): Promise<string>;
+    listWallets(): Promise<WalletInfo[]>;
+}
+
+/**
+ * ClawPowers Skills — Wallet Crypto
+ * Ethereum-oriented wallet generation, import, and signing.
+ * Address derivation: secp256k1 public key → Keccak-256 → last 20 bytes (MetaMask-compatible)
+ * when Tier 1 (native) or Tier 2 (WASM) is available; legacy hash-of-key digest only on Tier 3.
+ */
+
+/**
+ * Generate a new Ethereum-compatible wallet.
+ * Private key is encrypted with a random passphrase and stored to disk.
+ */
+declare function generateWallet(config: WalletConfig): Promise<WalletInfo>;
+/**
+ * Import an existing wallet from a private key hex string.
+ */
+declare function importWallet(privateKeyHex: string, config: WalletConfig): Promise<WalletInfo>;
+/**
+ * Sign a message using an encrypted key file and passphrase (returns structured result).
+ * Uses secp256k1 ECDSA over Keccak-256(UTF-8 message) when native/WASM tiers provide it;
+ * otherwise falls back to HMAC-SHA256 for backward compatibility.
+ */
+declare function signMessage(message: string, keyFile: string, passphrase: string): Promise<SignedMessage>;
+/**
+ * Sign a message with a raw hex private key. Returns 65-byte ECDSA signature (r‖s‖v) as hex.
+ * Requires Tier 1 or Tier 2 (Keccak + secp256k1).
+ */
+declare function signMessage(privateKeyHex: string, message: string): Promise<string>;
+
+/**
+ * ITP TypeScript Client — Identical Twins Protocol
+ *
+ * Wraps the Python ITP server HTTP API (http://localhost:8100).
+ * Provides encode(), decode(), healthCheck() utilities.
+ * Falls back gracefully if server not running (returns original message).
+ */
+interface EncodeResult {
+    encoded: string;
+    wasCompressed: boolean;
+    savingsPct: number;
+}
+interface DecodeResult {
+    decoded: string;
+    wasItp: boolean;
+}
+/**
+ * Encode a natural language message using the ITP codebook.
+ * If the server is unreachable, returns the original message unchanged.
+ */
+declare function encode(message: string, sourceAgent?: string): Promise<EncodeResult>;
+/**
+ * Decode an ITP-encoded message back to natural language.
+ * If the server is unreachable, returns the original message unchanged.
+ */
+declare function decode(message: string): Promise<DecodeResult>;
+/**
+ * Check if the ITP server is running and healthy.
+ */
+declare function healthCheck(): Promise<boolean>;
+
+/**
+ * Parallel Swarm Types
+ *
+ * Type definitions for the parallel swarm execution module.
+ * Mirrors the Python a0-parallel-swarm-plugin API surface.
+ */
+type ModelComplexity = 'simple' | 'moderate' | 'complex';
+type TaskStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+interface SwarmTask {
+    /** Unique task identifier. Auto-generated if omitted. */
+    id: string;
+    /** Human-readable description of the task. */
+    description: string;
+    /** The message/prompt to send to the agent. */
+    message: string;
+    /** Task complexity for model routing. Defaults to 'moderate'. */
+    complexity?: ModelComplexity;
+    /** Optional profile/persona for the agent. */
+    profile?: string;
+    /** Priority within an execution level (lower = higher priority). */
+    priority?: number;
+    /** Task IDs this task depends on. Forms a DAG. */
+    depends_on?: string[];
+    /** Token budget override for this specific task. */
+    token_budget?: number;
+    /** Arbitrary metadata attached to the task. */
+    metadata?: Record<string, unknown>;
+}
+interface SwarmResult {
+    /** The task ID this result belongs to. */
+    task_id: string;
+    /** Task description (copied from input). */
+    description: string;
+    /** Final status. */
+    status: TaskStatus;
+    /** The result string on success. */
+    result: string | null;
+    /** Error message on failure. */
+    error: string | null;
+    /** Resolved complexity used for model routing. */
+    complexity: ModelComplexity;
+    /** Tokens consumed by this task. */
+    tokens_used: number;
+    /** Token budget allocated to this task. */
+    token_budget: number;
+    /** ISO timestamp when the task started. */
+    started_at: string | null;
+    /** ISO timestamp when the task completed. */
+    completed_at: string | null;
+    /** Duration in milliseconds. */
+    duration_ms: number;
+}
+interface SwarmConfig {
+    /** Maximum parallel tasks. 1–20, default 5. */
+    max_concurrency?: number;
+    /** Total token budget across all tasks. Default 100_000. */
+    token_budget?: number;
+    /** Per-task token budget default. Default 20_000. */
+    per_task_budget?: number;
+    /** Whether to auto-classify task complexity. Default true. */
+    auto_classify?: boolean;
+    /** Model overrides by complexity tier. */
+    models?: {
+        simple?: string;
+        moderate?: string;
+        complex?: string;
+    };
+    /** Backpressure threshold (0–1). Default 0.8. */
+    backpressure_threshold?: number;
+}
+interface SwarmMemoryEntry {
+    /** ID of the agent that shared this finding. */
+    agent_id: string;
+    /** Unique key for the finding. */
+    key: string;
+    /** The finding value. */
+    value: string;
+    /** Tags for querying. */
+    tags: string[];
+    /** ISO timestamp when stored. */
+    timestamp: string;
+}
+/** Subset of SwarmMemory exposed to task executors. */
+interface SwarmMemoryHandle {
+    share(agentId: string, key: string, value: string, tags?: string[]): void;
+    get(key: string): SwarmMemoryEntry | undefined;
+    query(options?: {
+        tags?: string[];
+        keyword?: string;
+    }): SwarmMemoryEntry[];
+    getAll(): SwarmMemoryEntry[];
+}
+interface TokenAllocation {
+    task_id: string;
+    budget: number;
+    consumed: number;
+    allocated_at: number;
+}
+interface TokenUsageReport {
+    total_budget: number;
+    total_allocated: number;
+    total_consumed: number;
+    total_remaining: number;
+    tasks: Record<string, {
+        budget: number;
+        consumed: number;
+        remaining: number;
+        over_budget: boolean;
+    }>;
+}
+/**
+ * Represents a complete swarm execution run — the top-level result
+ * returned after all tasks in a swarm have completed or failed.
+ */
+interface SwarmRun {
+    /** ISO timestamp when the run started. */
+    started_at: string;
+    /** ISO timestamp when the run completed. */
+    completed_at: string;
+    /** Total duration in milliseconds. */
+    duration_ms: number;
+    /** Results keyed by task ID. */
+    results: Record<string, SwarmResult>;
+    /** Token usage summary for the entire run. */
+    token_usage: TokenUsageReport;
+    /** Whether the run was cancelled. */
+    cancelled: boolean;
+    /** Count of successful tasks. */
+    success_count: number;
+    /** Count of failed tasks. */
+    failure_count: number;
+    /** Total tasks submitted. */
+    total_count: number;
+}
+
+/**
+ * ITP ↔ Swarm Integration Bridge
+ *
+ * Compresses SwarmTask descriptions before fan-out and
+ * decodes SwarmResult content after collection.
+ * Graceful fallback — if ITP is unavailable, tasks/results pass through unchanged.
+ */
+
+/**
+ * Encode the task description and message before fan-out to sub-agents.
+ * Returns a new SwarmTask with compressed fields (original task is not mutated).
+ */
+declare function encodeTaskDescription(task: SwarmTask): Promise<SwarmTask>;
+/**
+ * Decode the result content returned from a sub-agent.
+ * Returns a new SwarmResult with decoded fields (original result is not mutated).
+ */
+declare function decodeSwarmResult(result: SwarmResult): Promise<SwarmResult>;
+
+/**
+ * ConcurrencyManager — Bounded parallelism with adaptive throttling.
+ *
+ * Promise-based semaphore that limits concurrent swarm task execution.
+ * Mirrors the Python a0-parallel-swarm-plugin ConcurrencyManager.
+ */
+declare class ConcurrencyManager {
+    private readonly maxConcurrency;
+    private readonly backpressureThreshold;
+    private activeCount;
+    private throttleDelayMs;
+    private lastErrorTime;
+    private readonly queue;
+    constructor(maxConcurrency?: number, backpressureThreshold?: number);
+    /**
+     * Acquire a concurrency slot. Resolves when a slot is available.
+     * Applies throttle delay if rate limits have been hit recently.
+     */
+    acquire(): Promise<void>;
+    /**
+     * Release a concurrency slot. Unblocks next queued waiter if any.
+     */
+    release(): void;
+    /**
+     * Number of currently active tasks.
+     */
+    get active(): number;
+    /**
+     * Number of tasks waiting for a slot.
+     */
+    get pending(): number;
+    /**
+     * Whether system has capacity for another task.
+     */
+    hasCapacity(): boolean;
+    /**
+     * Increase throttle delay on rate-limit / transient errors.
+     * Multiple errors in quick succession cause exponential backoff.
+     */
+    adaptiveThrottle(_errorType?: string): void;
+    /**
+     * Gradually reduce throttle delay after a successful operation.
+     */
+    resetThrottle(): void;
+    /**
+     * Check if system is above backpressure threshold.
+     */
+    isUnderPressure(): boolean;
+}
+
+/**
+ * TokenPool — Centralized token budget manager for swarm parallel execution.
+ *
+ * Enforces a total token budget across all parallel agents via pre-allocation.
+ * Single-threaded JS means no locking needed — operations are synchronous.
+ *
+ * Mirrors the Python a0-parallel-swarm-plugin TokenPool.
+ */
+
+declare class TokenPool {
+    readonly totalBudget: number;
+    readonly perTaskDefault: number;
+    private readonly allocations;
+    constructor(totalBudget?: number, perTaskDefault?: number);
+    /**
+     * Reserve tokens for a task.
+     * Returns false if the pool doesn't have enough remaining budget.
+     */
+    allocate(taskId: string, budget?: number): boolean;
+    /**
+     * Record actual token usage for a task (cumulative).
+     */
+    consume(taskId: string, tokens: number): void;
+    /**
+     * Free the allocation when a task completes.
+     * Returns tokens consumed by that task.
+     */
+    release(taskId: string): number;
+    /**
+     * Total remaining budget (total - allocated).
+     */
+    remaining(): number;
+    /**
+     * Total tokens consumed across all active tasks.
+     */
+    consumed(): number;
+    /**
+     * Total tokens currently allocated (reserved but not necessarily consumed).
+     */
+    totalAllocated(): number;
+    /**
+     * Check if a specific task has exceeded its allocation.
+     */
+    isTaskOverBudget(taskId: string): boolean;
+    /**
+     * Remaining budget for a specific task.
+     */
+    taskBudgetRemaining(taskId: string): number;
+    /**
+     * Per-task token consumption summary for observability.
+     */
+    usageReport(): TokenUsageReport;
+    /**
+     * Clear all allocations (reset between runs).
+     */
+    reset(): void;
+}
+
+/**
+ * ModelRouter — Complexity classification and model routing for swarm tasks.
+ *
+ * Provides heuristic-based task complexity classification (no LLM required)
+ * and maps complexity tiers to model IDs.
+ *
+ * Mirrors the Python a0-parallel-swarm-plugin model_router helpers.
+ */
+
+/**
+ * Classify task complexity using keyword heuristics and description length.
+ * Fast — no LLM call required.
+ *
+ * @param description - Task description to classify
+ * @returns ModelComplexity: 'simple' | 'moderate' | 'complex'
+ */
+declare function classifyHeuristic(description: string): ModelComplexity;
+/**
+ * Select the model ID for a given complexity tier.
+ * Falls back to default model map if no override is configured.
+ *
+ * @param complexity - Task complexity tier
+ * @param config - Optional SwarmConfig with model overrides
+ * @returns Model ID string
+ */
+declare function selectModel(complexity: ModelComplexity, config?: SwarmConfig): string;
+/**
+ * Auto-classify a list of tasks, assigning complexity if not explicitly set.
+ * Tasks with an existing complexity value are left unchanged.
+ *
+ * @param tasks - Array of tasks with optional complexity fields
+ * @returns Map from task ID to resolved complexity
+ */
+declare function classifyTasks(tasks: Array<{
+    id: string;
+    description: string;
+    complexity?: ModelComplexity;
+}>): Map<string, ModelComplexity>;
+
+export { type ABTest, type ABTestDecision, ABTestManager, type ABTestResult, type ABTestStatus, type AgentStatus, AutoResearcher, CLAWPOWERS_HOME, type CheckpointInfo, CheckpointManager, type CheckpointState, type CompressionResult, ConcurrencyManager, type ConfigFile, ContextInjector, type CriterionResult, DEFAULT_CONFIG, type EpisodicEntry, EpisodicMemory, type Goal, type GoalSource, HypothesisEngine, type DecodeResult as ItpDecodeResult, type EncodeResult as ItpEncodeResult, type LoadTier, type LoggingConfig, type MCPPaymentClient, type MemoryEntry, type MemoryOutcome, type MemoryStats, MetricsCollector, type ModelComplexity, MutationEngine, type MutationRecord, type NativeModule, PACKAGE_NAME, type PaymentAuditEntry, type PaymentConfig, PaymentExecutor, type PaymentMode, type PaymentRequest, type PaymentRequired, type PaymentResult, type Plan, type PlanResult, type PlanStatus, type ProceduralEntry, ProceduralMemory, type Profile, type ProfileName, type RSIAuditEntry, RSIAuditLog, type RSIAuditMetrics, type RSIConfig, type RSIHypothesis, type RSIMutation, type RSIMutationExtended, type RSIMutationExtendedStatus, type RSIMutationStatus, type RSITier, type RSITierLabel, type RSITierMode, type RSITierT4Mode, type ReviewResult, type SignedMessage, type SkillAggregateStats, type SkillExecutionContext, type SkillExecutionResult, SkillExecutor, type SkillManifest, type SkillMetrics, type SkillRequirements, type SpendingDecision, SpendingPolicy, type Step, type StepResult, type StepStatus, type SwarmConfig, type SwarmMemoryEntry, type SwarmMemoryHandle, type SwarmResult, type SwarmRun, type SwarmTask, type TaskCompletion, type TaskMetrics, type TaskOutcome, type TaskStatus, type TokenAllocation, TokenPool, type TokenUsageReport, type TrendDirection, VERSION, type WalletConfig, type WalletInfo, WalletManager, type WasmModule, type WorkingMemory, WorkingMemoryManager, approximateDistance, calculateFee, calculateTransactionFee, classifyHeuristic, classifyTasks, compressVector, computeSha256, createPaymentHeader, decodeSwarmResult, decompressVector, deriveEthereumAddress, derivePublicKey, detect402, digestForWalletAddress, discoverSkills, encodeTaskDescription, evaluateWriteFirewall, evaluateWriteSecurity, generateWallet, generateWalletAddress, getActiveSkills, getActiveTier, getBestCanonicalStore, getCapabilitySummary, getConfigValue, getNative, getNativeCanonicalStore, getNativeCanonicalStoreInMemory, getWasm, getWasmCanonicalStore, importWallet, initConfig, isNativeAvailable, isPaymentRequired, isWasmAvailable, decode as itpDecode, encode as itpEncode, healthCheck as itpHealthCheck, keccak256Digest, listSkillsWithStatus, loadConfig, loadConfigSafe, loadSkillManifest, parseFrontmatter, runAutoResearch, saveConfig, selectModel, setConfigValue, signEcdsa, signMessage, tokenAmountFromHuman, verifyEcdsa };