clawpowers 1.1.4 → 2.0.0

package/dist/index.d.ts

@@ -0,0 +1,844 @@
+/**
+ * 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.0.0";
+declare const PACKAGE_NAME = "clawpowers";
+declare const CLAWPOWERS_HOME: string;
+declare const DEFAULT_CONFIG: ConfigFile;
+
+/**
+ * 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;
+}
+
+/**
+ * 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[]>;
+}
+
+/**
+ * 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-compatible wallet generation, import, and signing using Node.js crypto.
+ * No external dependencies for key generation.
+ */
+
+/**
+ * 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.
+ */
+declare function signMessage(message: string, keyFile: string, passphrase: string): Promise<SignedMessage>;
+
+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 };