clawpowers 2.0.0 → 2.2.1

package/dist/index.d.ts

@@ -347,11 +347,202 @@ declare function setConfigValue(config: ConfigFile, key: string, value: string):
  * Default paths, version, config values, RSI tier boundaries.
  */
 
-declare const VERSION = "2.0.0";
+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.
@@ -462,6 +653,37 @@ declare class PaymentExecutor {
     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.
@@ -553,6 +775,77 @@ declare class ContextInjector {
     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.
@@ -823,8 +1116,9 @@ declare class WalletManager {
 
 /**
  * ClawPowers Skills — Wallet Crypto
- * Ethereum-compatible wallet generation, import, and signing using Node.js crypto.
- * No external dependencies for key generation.
+ * 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.
  */
 
 /**
@@ -837,8 +1131,347 @@ declare function generateWallet(config: WalletConfig): Promise<WalletInfo>;
  */
 declare function importWallet(privateKeyHex: string, config: WalletConfig): Promise<WalletInfo>;
 /**
- * Sign a message using an encrypted key file and passphrase.
+ * 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 ConfigFile, ContextInjector, type CriterionResult, DEFAULT_CONFIG, type EpisodicEntry, EpisodicMemory, type Goal, type GoalSource, HypothesisEngine, type LoggingConfig, type MCPPaymentClient, type MemoryEntry, type MemoryOutcome, type MemoryStats, MetricsCollector, MutationEngine, type MutationRecord, 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 TaskCompletion, type TaskMetrics, type TaskOutcome, type TrendDirection, VERSION, type WalletConfig, type WalletInfo, WalletManager, type WorkingMemory, WorkingMemoryManager, detect402, discoverSkills, generateWallet, getActiveSkills, getConfigValue, importWallet, initConfig, isPaymentRequired, listSkillsWithStatus, loadConfig, loadConfigSafe, loadSkillManifest, parseFrontmatter, runAutoResearch, saveConfig, setConfigValue, signMessage };
+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 };