genesis-ai-cli 14.4.1 → 14.5.1

package/dist/src/cli/agentic.js

@@ -486,8 +486,8 @@ class AgenticToolExecutor {
     async handleMemory(args) {
         const memory = this.memory;
         // Normalize action - support common aliases
+        const action = String(args.action || '').toLowerCase();
         const normalizedAction = (() => {
-            const action = args.action?.toLowerCase() || '';
             if (['store', 'save', 'remember', 'add', 'write'].includes(action))
                 return 'store';
             if (['search', 'query', 'find', 'retrieve', 'recall', 'get', 'read', 'load', 'fetch'].includes(action))
@@ -496,24 +496,26 @@ class AgenticToolExecutor {
                 return 'list';
             return action;
         })();
+        // v14.5.1: Accept multiple parameter names for content
+        const content = String(args.content || args.text || args.message || args.data || args.value || args.input || '');
+        const query = String(args.query || args.search || args.q || content || '');
+        const tags = String(args.tags || args.tag || args.categories || '');
         switch (normalizedAction) {
             case 'store':
-                if (!args.content)
-                    return 'Missing content to store';
+                if (!content)
+                    return 'Missing content to store. Use: {"action":"store","content":"text to remember"}';
                 // Use remember for simple episodic storage
                 memory.remember({
-                    what: args.content,
-                    tags: args.tags?.split(',').map(t => t.trim()) || [],
+                    what: content,
+                    tags: tags ? tags.split(',').map(t => t.trim()) : [],
                 });
-                return 'Stored in memory';
+                return `Stored in memory: "${content.slice(0, 100)}${content.length > 100 ? '...' : ''}"`;
             case 'search':
-                // If no query but has content, use content as query
-                const searchQuery = args.query || args.content;
-                if (!searchQuery)
-                    return 'Missing search query';
-                const results = await memory.recall(searchQuery, { limit: 5 });
+                if (!query)
+                    return 'Missing search query. Use: {"action":"search","query":"what to find"}';
+                const results = await memory.recall(query, { limit: 5 });
                 if (!results || results.length === 0) {
-                    return 'No memories found matching query';
+                    return `No memories found matching: "${query}"`;
                 }
                 return results.map((r, i) => {
                     const text = typeof r === 'string' ? r : (r.content || r.text || JSON.stringify(r));
@@ -523,7 +525,7 @@ class AgenticToolExecutor {
                 const stats = memory.getStats();
                 return `Memory stats: ${JSON.stringify(stats, null, 2)}`;
             default:
-                return `Unknown memory action: ${args.action}. Valid actions: store, search, list (or aliases: save, retrieve, recall, get, etc.)`;
+                return `Unknown memory action: "${action}". Valid actions: store, search, list (aliases: save, retrieve, recall, get, remember)`;
         }
     }
 }
@@ -572,26 +574,52 @@ ${(0, ui_js_1.muted)('Claude Code-like capabilities:')}
     buildSystemPrompt() {
         return `You are Genesis, an autonomous AI agent with full agentic capabilities.
 
-You have access to these tools:
+## Available Tools
 ${AGENTIC_TOOLS.map(t => `- ${t.name}: ${t.description}`).join('\n')}
 
-Current working directory: ${this.config.cwd}
-Current date: ${new Date().toISOString().split('T')[0]}
+## Tool Call Format
+When you need to use a tool, respond with ONLY a JSON block:
+\`\`\`tool
+{"name": "ToolName", "arguments": {"param": "value"}}
+\`\`\`
 
-Guidelines:
-1. Use tools proactively to accomplish tasks
-2. Read files before editing them
-3. Use Glob/Grep to explore codebases
-4. Execute bash commands for git, npm, etc.
-5. Break complex tasks into steps
-6. Store important information in memory
+## Common Tool Examples
+
+Read a file:
+\`\`\`tool
+{"name": "Read", "arguments": {"path": "package.json"}}
+\`\`\`
 
-When you need to use a tool, respond with a JSON tool call in this format:
+Search for files:
 \`\`\`tool
-{"name": "ToolName", "arguments": {...}}
+{"name": "Glob", "arguments": {"pattern": "**/*.ts"}}
 \`\`\`
 
-You can make multiple tool calls in sequence. After each tool result, continue your work.`;
+Run bash command:
+\`\`\`tool
+{"name": "Bash", "arguments": {"command": "npm test"}}
+\`\`\`
+
+Store in memory:
+\`\`\`tool
+{"name": "Memory", "arguments": {"action": "store", "content": "Important finding..."}}
+\`\`\`
+
+Search memory:
+\`\`\`tool
+{"name": "Memory", "arguments": {"action": "search", "query": "what I learned about..."}}
+\`\`\`
+
+## Context
+Working directory: ${this.config.cwd}
+Date: ${new Date().toISOString().split('T')[0]}
+
+## Guidelines
+1. Use tools to accomplish tasks - don't just explain what you would do
+2. Read files before editing them
+3. Use Glob to find files, Grep to search content
+4. After using tools, provide a summary of findings or results
+5. When task is complete, provide a final answer WITHOUT a tool block`;
     }
     async chatLoop() {
         return new Promise((resolve) => {
@@ -697,7 +725,7 @@ ${colorize('Commands:', 'cyan')}
         try {
             let continueLoop = true;
             let iterations = 0;
-            const maxIterations = 20;
+            const maxIterations = 30; // v14.5.1: Increased from 20
             let currentPrompt = fullPrompt;
             while (continueLoop && iterations < maxIterations) {
                 iterations++;
@@ -731,9 +759,18 @@ ${colorize('Commands:', 'cyan')}
                         // Add to conversation history
                         this.conversationHistory.push(`Assistant: ${content}`);
                         this.conversationHistory.push(`Tool (${toolCall.name}): ${result}`);
-                        // Continue with tool result
-                        currentPrompt = `Tool result for ${toolCall.name}:\n\`\`\`\n${result}\n\`\`\`\n\nContinue with your task.`;
-                        spinner.start();
+                        // v14.5.1: Check if there's meaningful text outside the tool block
+                        const textOutsideTool = content.replace(/```tool\s*\n[\s\S]*?\n```/g, '').trim();
+                        if (textOutsideTool.length > 100) {
+                            // LLM provided explanation alongside tool - this is the final response
+                            console.log('\n' + this.formatResponse(content));
+                            continueLoop = false;
+                        }
+                        else {
+                            // Continue with tool result
+                            currentPrompt = `Tool result for ${toolCall.name}:\n\`\`\`\n${result}\n\`\`\`\n\nContinue with your task. When done, provide a summary without tool calls.`;
+                            spinner.start();
+                        }
                     }
                     catch {
                         // Not a valid tool call, treat as regular response

package/dist/src/economy/generators/bounty-hunter.d.ts

@@ -1,12 +1,19 @@
 /**
- * Bounty Hunter — DeWork / Layer3 / Immunefi
+ * Bounty Hunter — Multi-Platform Autonomous Bounty Discovery
+ *
+ * v14.5.0: Added Algora, Gitcoin, GitHub bounty sources
+ *
+ * Autonomously discovers and completes bounties on multiple platforms:
+ * - DeWork: Web3 DAO bounties (GraphQL API)
+ * - Algora: GitHub-native bounties (REST API) - BEST FOR AI
+ * - Gitcoin: OSS grants and bounties (REST API)
+ * - GitHub: Issues with bounty labels (Search API)
  *
- * Autonomously discovers and completes bounties on Web3 platforms.
  * Revenue model: per-bounty payouts (typically $50-$10,000+).
  *
  * Requirements:
  *   - Capital: $0 (zero capital needed)
- *   - Identity: Wallet only (wallet-based identity on all platforms)
+ *   - Identity: Wallet/GitHub account
  *   - Revenue: $500-$5,000/month depending on bounty availability
  *
  * Bounty types:
@@ -21,10 +28,11 @@
  *   2. Evaluate expected value (reward × success probability)
  *   3. Execute bounty work using kernel task system
  *   4. Submit and track payout
+ *   5. Feed results back to RSI for skill improvement
  */
 export interface Bounty {
     id: string;
-    platform: 'dework' | 'layer3' | 'immunefi' | 'code4rena' | 'gitcoin';
+    platform: 'dework' | 'algora' | 'gitcoin' | 'github' | 'layer3' | 'immunefi' | 'code4rena';
     title: string;
     description: string;
     reward: number;
@@ -37,6 +45,13 @@ export interface Bounty {
     tags: string[];
     discovered: number;
     status: 'open' | 'claimed' | 'submitted' | 'completed' | 'rejected' | 'expired';
+    /** v14.5.0: Source-specific metadata */
+    sourceMetadata?: {
+        org?: string;
+        repo?: string;
+        issueNumber?: number;
+        githubUrl?: string;
+    };
 }
 export interface BountySubmission {
     bountyId: string;
@@ -114,6 +129,7 @@ export declare class BountyHunter {
     private isViable;
     private estimateSuccessProbability;
     private scanPlatform;
+    private mapGitcoinDifficulty;
     private inferDifficulty;
     private inferCategory;
     private mapCurrency;

package/dist/src/economy/generators/bounty-hunter.js

@@ -1,13 +1,20 @@
 "use strict";
 /**
- * Bounty Hunter — DeWork / Layer3 / Immunefi
+ * Bounty Hunter — Multi-Platform Autonomous Bounty Discovery
+ *
+ * v14.5.0: Added Algora, Gitcoin, GitHub bounty sources
+ *
+ * Autonomously discovers and completes bounties on multiple platforms:
+ * - DeWork: Web3 DAO bounties (GraphQL API)
+ * - Algora: GitHub-native bounties (REST API) - BEST FOR AI
+ * - Gitcoin: OSS grants and bounties (REST API)
+ * - GitHub: Issues with bounty labels (Search API)
  *
- * Autonomously discovers and completes bounties on Web3 platforms.
  * Revenue model: per-bounty payouts (typically $50-$10,000+).
  *
  * Requirements:
  *   - Capital: $0 (zero capital needed)
- *   - Identity: Wallet only (wallet-based identity on all platforms)
+ *   - Identity: Wallet/GitHub account
  *   - Revenue: $500-$5,000/month depending on bounty availability
  *
  * Bounty types:
@@ -22,6 +29,7 @@
  *   2. Evaluate expected value (reward × success probability)
  *   3. Execute bounty work using kernel task system
  *   4. Submit and track payout
+ *   5. Feed results back to RSI for skill improvement
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BountyHunter = void 0;
@@ -29,6 +37,9 @@ exports.getBountyHunter = getBountyHunter;
 exports.resetBountyHunter = resetBountyHunter;
 const fiber_js_1 = require("../fiber.js");
 const dework_js_1 = require("../live/connectors/dework.js");
+const algora_js_1 = require("../live/connectors/algora.js");
+const gitcoin_js_1 = require("../live/connectors/gitcoin.js");
+const github_bounties_js_1 = require("../live/connectors/github-bounties.js");
 const revenue_tracker_js_1 = require("../live/revenue-tracker.js");
 // ============================================================================
 // Bounty Hunter
@@ -41,7 +52,8 @@ class BountyHunter {
     lastScan = 0;
     constructor(config) {
         this.config = {
-            platforms: config?.platforms ?? ['dework', 'layer3', 'immunefi'],
+            // v14.5.0: Added algora, gitcoin, github as primary platforms
+            platforms: config?.platforms ?? ['algora', 'github', 'gitcoin', 'dework'],
             categories: config?.categories ?? ['code', 'audit', 'content', 'research'],
             minReward: config?.minReward ?? 50,
             maxDifficulty: config?.maxDifficulty ?? 'hard',
@@ -253,11 +265,12 @@ class BountyHunter {
     }
     async scanPlatform(platform) {
         try {
-            // Use real DeWork connector for dework platform
+            // ══════════════════════════════════════════════════════════════════════
+            // DEWORK - Web3 DAO bounties
+            // ══════════════════════════════════════════════════════════════════════
             if (platform === 'dework') {
                 const connector = (0, dework_js_1.getDeworkConnector)();
                 const tags = this.config.categories.map(c => {
-                    // Map our categories to DeWork tags
                     const tagMap = {
                         code: ['solidity', 'typescript', 'smart-contract', 'rust'],
                         audit: ['security', 'audit', 'bug-bounty'],
@@ -286,8 +299,99 @@ class BountyHunter {
                     status: 'open',
                 }));
             }
+            // ══════════════════════════════════════════════════════════════════════
+            // ALGORA - GitHub-native bounties (BEST API for AI agents)
+            // ══════════════════════════════════════════════════════════════════════
+            if (platform === 'algora') {
+                const connector = (0, algora_js_1.getAlgoraConnector)();
+                const algoraBounties = await connector.scanBounties();
+                return algoraBounties
+                    .filter(b => (b.reward / 100) >= this.config.minReward) // Algora uses cents
+                    .map((b) => ({
+                    id: `algora:${b.id}`,
+                    platform: 'algora',
+                    title: b.title,
+                    description: b.description || '',
+                    reward: b.reward / 100, // Convert from cents to dollars
+                    currency: 'USD',
+                    difficulty: this.inferDifficulty(b.reward / 100),
+                    category: 'code', // Algora is primarily code bounties
+                    deadline: b.deadline ? new Date(b.deadline).getTime() : undefined,
+                    submissionUrl: b.url,
+                    protocol: b.org,
+                    tags: b.tags,
+                    discovered: Date.now(),
+                    status: 'open',
+                    sourceMetadata: {
+                        org: b.org,
+                        repo: b.repo,
+                        githubUrl: b.issueUrl,
+                    },
+                }));
+            }
+            // ══════════════════════════════════════════════════════════════════════
+            // GITCOIN - OSS grants and bounties
+            // ══════════════════════════════════════════════════════════════════════
+            if (platform === 'gitcoin') {
+                const connector = (0, gitcoin_js_1.getGitcoinConnector)();
+                const gitcoinBounties = await connector.scanBounties({
+                    isOpen: true,
+                    keywords: this.config.categories,
+                });
+                return gitcoinBounties
+                    .filter(b => b.reward >= this.config.minReward)
+                    .map((b) => ({
+                    id: `gitcoin:${b.id}`,
+                    platform: 'gitcoin',
+                    title: b.title,
+                    description: b.description || '',
+                    reward: b.reward,
+                    currency: this.mapCurrency(b.currency),
+                    difficulty: this.mapGitcoinDifficulty(b.experienceLevel),
+                    category: this.inferCategory(b.tags),
+                    deadline: b.deadline ? new Date(b.deadline).getTime() : undefined,
+                    submissionUrl: b.url,
+                    protocol: b.projectType,
+                    tags: b.tags,
+                    discovered: Date.now(),
+                    status: 'open',
+                    sourceMetadata: {
+                        githubUrl: b.githubUrl,
+                    },
+                }));
+            }
+            // ══════════════════════════════════════════════════════════════════════
+            // GITHUB - Issues with bounty labels
+            // ══════════════════════════════════════════════════════════════════════
+            if (platform === 'github') {
+                const connector = (0, github_bounties_js_1.getGitHubBountyConnector)();
+                const githubBounties = await connector.scanBounties();
+                return githubBounties
+                    .filter(b => b.reward >= this.config.minReward && b.status === 'open')
+                    .map((b) => ({
+                    id: b.id,
+                    platform: 'github',
+                    title: b.title,
+                    description: b.description || '',
+                    reward: b.reward,
+                    currency: this.mapCurrency(b.currency),
+                    difficulty: this.inferDifficulty(b.reward),
+                    category: 'code', // GitHub bounties are typically code
+                    deadline: undefined,
+                    submissionUrl: b.url,
+                    protocol: `${b.owner}/${b.repo}`,
+                    tags: b.tags,
+                    discovered: Date.now(),
+                    status: 'open',
+                    sourceMetadata: {
+                        org: b.owner,
+                        repo: b.repo,
+                        issueNumber: b.issueNumber,
+                        githubUrl: b.url,
+                    },
+                }));
+            }
             // For other platforms (layer3, immunefi), return empty for now
-            // Can add more connectors later
             console.log(`[BountyHunter] Platform ${platform} not yet connected to real API`);
             return [];
         }
@@ -296,6 +400,14 @@ class BountyHunter {
             return [];
         }
     }
+    mapGitcoinDifficulty(level) {
+        switch (level) {
+            case 'beginner': return 'easy';
+            case 'intermediate': return 'medium';
+            case 'advanced': return 'hard';
+            default: return 'medium';
+        }
+    }
     inferDifficulty(reward) {
         if (reward < 100)
             return 'easy';

package/dist/src/economy/live/connectors/algora.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Algora API Connector
+ *
+ * Real connector for bounty discovery using Algora REST API.
+ * Algora is GitHub-native with full CRUD API - best for AI agents.
+ *
+ * API Reference: https://api.docs.algora.io/bounties
+ * - GET /api/orgs/{org}/bounties - Public, no auth required
+ * - GET /api/bounties/{id} - Get specific bounty
+ *
+ * Amount format: Cents (100 = $1.00)
+ */
+export interface AlgoraBounty {
+    id: string;
+    title: string;
+    reward: number;
+    currency: string;
+    tags: string[];
+    deadline: string | null;
+    url: string;
+    description?: string;
+    status: 'open' | 'claimed' | 'completed' | 'cancelled';
+    org: string;
+    repo?: string;
+    issueUrl?: string;
+}
+export interface AlgoraConnector {
+    scanBounties(orgs?: string[]): Promise<AlgoraBounty[]>;
+    getBountyDetails(id: string): Promise<AlgoraBounty | null>;
+    searchBounties(query: string): Promise<AlgoraBounty[]>;
+}
+export declare function getAlgoraConnector(): AlgoraConnector;

package/dist/src/economy/live/connectors/algora.js

@@ -0,0 +1,174 @@
+"use strict";
+/**
+ * Algora API Connector
+ *
+ * Real connector for bounty discovery using Algora REST API.
+ * Algora is GitHub-native with full CRUD API - best for AI agents.
+ *
+ * API Reference: https://api.docs.algora.io/bounties
+ * - GET /api/orgs/{org}/bounties - Public, no auth required
+ * - GET /api/bounties/{id} - Get specific bounty
+ *
+ * Amount format: Cents (100 = $1.00)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAlgoraConnector = getAlgoraConnector;
+const ALGORA_API = 'https://console.algora.io/api';
+const TIMEOUT_MS = 15000;
+const RATE_LIMIT_MS = 500;
+let lastRequestTime = 0;
+async function rateLimit() {
+    const now = Date.now();
+    const elapsed = now - lastRequestTime;
+    if (elapsed < RATE_LIMIT_MS) {
+        await new Promise(resolve => setTimeout(resolve, RATE_LIMIT_MS - elapsed));
+    }
+    lastRequestTime = Date.now();
+}
+async function fetchWithTimeout(url, options, timeoutMs) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(url, {
+            ...options,
+            signal: controller.signal,
+        });
+        return response;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function mapApiBounty(b, org) {
+    return {
+        id: b.id,
+        title: b.title,
+        reward: b.amount_cents, // Keep in cents
+        currency: b.currency || 'USD',
+        tags: b.skills || [],
+        deadline: b.expires_at || null,
+        url: b.url || `https://console.algora.io/${org}/bounties/${b.id}`,
+        description: b.title, // Algora doesn't always include description in list
+        status: mapStatus(b.status),
+        org: org,
+        repo: b.repo_slug,
+        issueUrl: b.issue_url,
+    };
+}
+function mapStatus(status) {
+    switch (status?.toLowerCase()) {
+        case 'open':
+        case 'available':
+            return 'open';
+        case 'claimed':
+        case 'in_progress':
+        case 'assigned':
+            return 'claimed';
+        case 'completed':
+        case 'paid':
+        case 'rewarded':
+            return 'completed';
+        case 'cancelled':
+        case 'expired':
+        case 'closed':
+            return 'cancelled';
+        default:
+            return 'open';
+    }
+}
+/**
+ * Scan bounties from specific orgs
+ */
+async function scanBounties(orgs) {
+    const targetOrgs = orgs || [
+        // Popular orgs with active bounties
+        'calcom',
+        'twentyhq',
+        'formbricks',
+        'triggerdotdev',
+        'dubinc',
+        'infisical',
+        'documenso',
+        'latitude-dev',
+        'boxyhq',
+    ];
+    const allBounties = [];
+    for (const org of targetOrgs) {
+        await rateLimit();
+        try {
+            const response = await fetchWithTimeout(`${ALGORA_API}/orgs/${org}/bounties?limit=50`, {
+                method: 'GET',
+                headers: {
+                    'Accept': 'application/json',
+                },
+            }, TIMEOUT_MS);
+            if (!response.ok) {
+                if (response.status === 404) {
+                    // Org not found or no bounties, skip silently
+                    continue;
+                }
+                console.warn(`[AlgoraConnector] API error for ${org}:`, response.status);
+                continue;
+            }
+            const data = await response.json();
+            if (data.items && Array.isArray(data.items)) {
+                const bounties = data.items
+                    .filter(b => b.status === 'open' || b.status === 'available')
+                    .map(b => mapApiBounty(b, org));
+                allBounties.push(...bounties);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError') {
+                console.warn(`[AlgoraConnector] Timeout for ${org}`);
+            }
+            else {
+                console.warn(`[AlgoraConnector] Error for ${org}:`, error);
+            }
+        }
+    }
+    console.log(`[AlgoraConnector] Found ${allBounties.length} open bounties from ${targetOrgs.length} orgs`);
+    return allBounties;
+}
+/**
+ * Get details of a specific bounty
+ */
+async function getBountyDetails(id) {
+    await rateLimit();
+    try {
+        const response = await fetchWithTimeout(`${ALGORA_API}/bounties/${id}`, {
+            method: 'GET',
+            headers: {
+                'Accept': 'application/json',
+            },
+        }, TIMEOUT_MS);
+        if (!response.ok) {
+            console.warn(`[AlgoraConnector] Bounty ${id} not found:`, response.status);
+            return null;
+        }
+        const data = await response.json();
+        return mapApiBounty(data, data.org_slug);
+    }
+    catch (error) {
+        console.warn(`[AlgoraConnector] Error getting bounty ${id}:`, error);
+        return null;
+    }
+}
+/**
+ * Search bounties by keyword (searches across all orgs)
+ */
+async function searchBounties(query) {
+    // Algora doesn't have a public search endpoint, so we scan popular orgs
+    // and filter locally
+    const allBounties = await scanBounties();
+    const lowerQuery = query.toLowerCase();
+    return allBounties.filter(b => b.title.toLowerCase().includes(lowerQuery) ||
+        b.tags.some(t => t.toLowerCase().includes(lowerQuery)));
+}
+function getAlgoraConnector() {
+    return {
+        scanBounties,
+        getBountyDetails,
+        searchBounties,
+    };
+}

package/dist/src/economy/live/connectors/gitcoin.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Gitcoin API Connector
+ *
+ * Read-only connector for bounty discovery using Gitcoin REST API.
+ * API Reference: https://github.com/gitcoinco/web/blob/master/docs/API.md
+ *
+ * Note: Gitcoin has deprecated bounties in favor of Grants.
+ * This connector focuses on grants discovery for research opportunities.
+ */
+export interface GitcoinBounty {
+    id: string;
+    title: string;
+    reward: number;
+    currency: string;
+    tags: string[];
+    deadline: string | null;
+    url: string;
+    description?: string;
+    status: 'open' | 'started' | 'submitted' | 'done' | 'cancelled';
+    experienceLevel: 'beginner' | 'intermediate' | 'advanced';
+    projectType: string;
+    githubUrl?: string;
+}
+export interface GitcoinConnector {
+    scanBounties(filters?: GitcoinFilters): Promise<GitcoinBounty[]>;
+    getBountyDetails(id: string): Promise<GitcoinBounty | null>;
+}
+export interface GitcoinFilters {
+    isOpen?: boolean;
+    experienceLevel?: string;
+    projectLength?: string;
+    bountyType?: string;
+    keywords?: string[];
+}
+export declare function getGitcoinConnector(): GitcoinConnector;

package/dist/src/economy/live/connectors/gitcoin.js

@@ -0,0 +1,173 @@
+"use strict";
+/**
+ * Gitcoin API Connector
+ *
+ * Read-only connector for bounty discovery using Gitcoin REST API.
+ * API Reference: https://github.com/gitcoinco/web/blob/master/docs/API.md
+ *
+ * Note: Gitcoin has deprecated bounties in favor of Grants.
+ * This connector focuses on grants discovery for research opportunities.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGitcoinConnector = getGitcoinConnector;
+const GITCOIN_API = 'https://gitcoin.co/api/v0.1';
+const TIMEOUT_MS = 15000;
+const RATE_LIMIT_MS = 1000;
+let lastRequestTime = 0;
+async function rateLimit() {
+    const now = Date.now();
+    const elapsed = now - lastRequestTime;
+    if (elapsed < RATE_LIMIT_MS) {
+        await new Promise(resolve => setTimeout(resolve, RATE_LIMIT_MS - elapsed));
+    }
+    lastRequestTime = Date.now();
+}
+async function fetchWithTimeout(url, options, timeoutMs) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(url, {
+            ...options,
+            signal: controller.signal,
+        });
+        return response;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function mapApiBounty(b) {
+    return {
+        id: String(b.pk),
+        title: b.title,
+        reward: b.value_true || 0,
+        currency: b.token_name || 'USD',
+        tags: b.keywords || [],
+        deadline: b.expires_date,
+        url: b.url || `https://gitcoin.co/issue/${b.pk}`,
+        description: b.issue_description?.slice(0, 500),
+        status: mapStatus(b.status),
+        experienceLevel: mapExperienceLevel(b.experience_level),
+        projectType: b.project_type || 'unknown',
+        githubUrl: b.github_url,
+    };
+}
+function mapStatus(status) {
+    switch (status?.toLowerCase()) {
+        case 'open':
+            return 'open';
+        case 'started':
+        case 'work_started':
+            return 'started';
+        case 'submitted':
+        case 'work_submitted':
+            return 'submitted';
+        case 'done':
+        case 'completed':
+            return 'done';
+        case 'cancelled':
+        case 'expired':
+            return 'cancelled';
+        default:
+            return 'open';
+    }
+}
+function mapExperienceLevel(level) {
+    switch (level?.toLowerCase()) {
+        case 'beginner':
+        case 'easy':
+            return 'beginner';
+        case 'intermediate':
+        case 'medium':
+            return 'intermediate';
+        case 'advanced':
+        case 'hard':
+        case 'expert':
+            return 'advanced';
+        default:
+            return 'intermediate';
+    }
+}
+/**
+ * Scan open bounties with optional filters
+ */
+async function scanBounties(filters) {
+    await rateLimit();
+    const params = new URLSearchParams();
+    params.set('is_open', filters?.isOpen !== false ? 'true' : 'false');
+    params.set('order_by', '-value_true'); // Highest value first
+    params.set('limit', '50');
+    if (filters?.experienceLevel) {
+        params.set('experience_level', filters.experienceLevel);
+    }
+    if (filters?.projectLength) {
+        params.set('project_length', filters.projectLength);
+    }
+    if (filters?.bountyType) {
+        params.set('bounty_type', filters.bountyType);
+    }
+    if (filters?.keywords && filters.keywords.length > 0) {
+        params.set('keywords', filters.keywords.join(','));
+    }
+    try {
+        const response = await fetchWithTimeout(`${GITCOIN_API}/bounties/?${params.toString()}`, {
+            method: 'GET',
+            headers: {
+                'Accept': 'application/json',
+            },
+        }, TIMEOUT_MS);
+        if (!response.ok) {
+            console.warn(`[GitcoinConnector] API error:`, response.status);
+            return [];
+        }
+        const data = await response.json();
+        if (!Array.isArray(data)) {
+            console.warn('[GitcoinConnector] Unexpected response format');
+            return [];
+        }
+        const bounties = data
+            .filter(b => b.status === 'open')
+            .map(mapApiBounty);
+        console.log(`[GitcoinConnector] Found ${bounties.length} open bounties`);
+        return bounties;
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            console.warn('[GitcoinConnector] Request timeout');
+        }
+        else {
+            console.warn('[GitcoinConnector] Request failed:', error);
+        }
+        return [];
+    }
+}
+/**
+ * Get details of a specific bounty
+ */
+async function getBountyDetails(id) {
+    await rateLimit();
+    try {
+        const response = await fetchWithTimeout(`${GITCOIN_API}/bounties/${id}/`, {
+            method: 'GET',
+            headers: {
+                'Accept': 'application/json',
+            },
+        }, TIMEOUT_MS);
+        if (!response.ok) {
+            console.warn(`[GitcoinConnector] Bounty ${id} not found:`, response.status);
+            return null;
+        }
+        const data = await response.json();
+        return mapApiBounty(data);
+    }
+    catch (error) {
+        console.warn(`[GitcoinConnector] Error getting bounty ${id}:`, error);
+        return null;
+    }
+}
+function getGitcoinConnector() {
+    return {
+        scanBounties,
+        getBountyDetails,
+    };
+}

package/dist/src/economy/live/connectors/github-bounties.d.ts

@@ -0,0 +1,30 @@
+/**
+ * GitHub Bounty Connector
+ *
+ * Discovers bounties from GitHub issues with bounty labels.
+ * Uses GitHub Search API to find issues with common bounty labels:
+ * - "bounty"
+ * - "reward"
+ * - "help wanted" + "good first issue" (filtered by reward mentions)
+ *
+ * Requires GITHUB_TOKEN for higher rate limits.
+ */
+export interface GitHubBounty {
+    id: string;
+    title: string;
+    reward: number;
+    currency: string;
+    tags: string[];
+    deadline: string | null;
+    url: string;
+    description: string;
+    status: 'open' | 'assigned' | 'closed';
+    repo: string;
+    owner: string;
+    issueNumber: number;
+}
+export interface GitHubBountyConnector {
+    scanBounties(labels?: string[]): Promise<GitHubBounty[]>;
+    getBountyDetails(owner: string, repo: string, issueNumber: number): Promise<GitHubBounty | null>;
+}
+export declare function getGitHubBountyConnector(): GitHubBountyConnector;

package/dist/src/economy/live/connectors/github-bounties.js

@@ -0,0 +1,205 @@
+"use strict";
+/**
+ * GitHub Bounty Connector
+ *
+ * Discovers bounties from GitHub issues with bounty labels.
+ * Uses GitHub Search API to find issues with common bounty labels:
+ * - "bounty"
+ * - "reward"
+ * - "help wanted" + "good first issue" (filtered by reward mentions)
+ *
+ * Requires GITHUB_TOKEN for higher rate limits.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGitHubBountyConnector = getGitHubBountyConnector;
+const GITHUB_API = 'https://api.github.com';
+const TIMEOUT_MS = 15000;
+const RATE_LIMIT_MS = 1000;
+let lastRequestTime = 0;
+async function rateLimit() {
+    const now = Date.now();
+    const elapsed = now - lastRequestTime;
+    if (elapsed < RATE_LIMIT_MS) {
+        await new Promise(resolve => setTimeout(resolve, RATE_LIMIT_MS - elapsed));
+    }
+    lastRequestTime = Date.now();
+}
+async function fetchWithTimeout(url, options, timeoutMs) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(url, {
+            ...options,
+            signal: controller.signal,
+        });
+        return response;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+/**
+ * Extract reward amount from text
+ * Supports: $100, 100 USD, 100 USDC, 0.1 ETH, etc.
+ */
+function extractReward(text) {
+    // Match patterns like: $500, 500 USD, 500 USDC, 0.1 ETH
+    const patterns = [
+        /\$\s*(\d+(?:,\d{3})*(?:\.\d{2})?)/i, // $500 or $1,000.00
+        /(\d+(?:,\d{3})*(?:\.\d{2})?)\s*(?:USD|USDC|DAI)/i, // 500 USD
+        /(\d+(?:\.\d+)?)\s*ETH/i, // 0.1 ETH
+        /bounty[:\s]+\$?\s*(\d+(?:,\d{3})*)/i, // bounty: $500
+        /reward[:\s]+\$?\s*(\d+(?:,\d{3})*)/i, // reward: 500
+    ];
+    for (const pattern of patterns) {
+        const match = text.match(pattern);
+        if (match) {
+            const amountStr = match[1].replace(/,/g, '');
+            const amount = parseFloat(amountStr);
+            // Determine currency
+            let currency = 'USD';
+            if (text.toLowerCase().includes('eth')) {
+                currency = 'ETH';
+                // Convert ETH to USD estimate (rough)
+                return { amount: amount * 2000, currency: 'ETH' };
+            }
+            if (text.toLowerCase().includes('usdc')) {
+                currency = 'USDC';
+            }
+            return { amount, currency };
+        }
+    }
+    return { amount: 0, currency: 'USD' };
+}
+function mapIssueToBoounty(issue) {
+    // Extract repo info from repository_url
+    const repoMatch = issue.repository_url.match(/repos\/([^/]+)\/([^/]+)$/);
+    const owner = repoMatch?.[1] || 'unknown';
+    const repo = repoMatch?.[2] || 'unknown';
+    // Extract reward from title and body
+    const textToSearch = `${issue.title} ${issue.body || ''}`;
+    const { amount, currency } = extractReward(textToSearch);
+    // Determine status
+    let status = 'open';
+    if (issue.state === 'closed') {
+        status = 'closed';
+    }
+    else if (issue.assignees && issue.assignees.length > 0) {
+        status = 'assigned';
+    }
+    return {
+        id: `github:${owner}/${repo}#${issue.number}`,
+        title: issue.title,
+        reward: amount,
+        currency,
+        tags: issue.labels.map(l => l.name),
+        deadline: null, // GitHub issues don't have deadlines
+        url: issue.html_url,
+        description: (issue.body || '').slice(0, 500),
+        status,
+        repo,
+        owner,
+        issueNumber: issue.number,
+    };
+}
+/**
+ * Scan for bounty issues on GitHub
+ */
+async function scanBounties(labels) {
+    const targetLabels = labels || ['bounty', 'reward', 'cash-reward', 'paid'];
+    const allBounties = [];
+    for (const label of targetLabels) {
+        await rateLimit();
+        try {
+            // Search for open issues with bounty-related labels
+            const query = `is:issue is:open label:"${label}"`;
+            const params = new URLSearchParams({
+                q: query,
+                sort: 'updated',
+                order: 'desc',
+                per_page: '30',
+            });
+            const headers = {
+                'Accept': 'application/vnd.github.v3+json',
+                'User-Agent': 'Genesis-AI-Bounty-Hunter',
+            };
+            // Use GitHub token if available for higher rate limits
+            const token = process.env.GITHUB_TOKEN;
+            if (token) {
+                headers['Authorization'] = `token ${token}`;
+            }
+            const response = await fetchWithTimeout(`${GITHUB_API}/search/issues?${params.toString()}`, {
+                method: 'GET',
+                headers,
+            }, TIMEOUT_MS);
+            if (!response.ok) {
+                if (response.status === 403) {
+                    console.warn('[GitHubBountyConnector] Rate limited, try setting GITHUB_TOKEN');
+                }
+                else {
+                    console.warn(`[GitHubBountyConnector] API error:`, response.status);
+                }
+                continue;
+            }
+            const data = await response.json();
+            if (data.items && Array.isArray(data.items)) {
+                const bounties = data.items
+                    .filter(issue => issue.state === 'open')
+                    .map(mapIssueToBoounty)
+                    // Filter out zero-reward issues (no bounty amount found)
+                    .filter(b => b.reward > 0);
+                allBounties.push(...bounties);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError') {
+                console.warn(`[GitHubBountyConnector] Timeout for label: ${label}`);
+            }
+            else {
+                console.warn(`[GitHubBountyConnector] Error for label ${label}:`, error);
+            }
+        }
+    }
+    // Deduplicate by URL
+    const uniqueBounties = Array.from(new Map(allBounties.map(b => [b.url, b])).values());
+    console.log(`[GitHubBountyConnector] Found ${uniqueBounties.length} bounties with rewards`);
+    return uniqueBounties;
+}
+/**
+ * Get details of a specific issue
+ */
+async function getBountyDetails(owner, repo, issueNumber) {
+    await rateLimit();
+    try {
+        const headers = {
+            'Accept': 'application/vnd.github.v3+json',
+            'User-Agent': 'Genesis-AI-Bounty-Hunter',
+        };
+        const token = process.env.GITHUB_TOKEN;
+        if (token) {
+            headers['Authorization'] = `token ${token}`;
+        }
+        const response = await fetchWithTimeout(`${GITHUB_API}/repos/${owner}/${repo}/issues/${issueNumber}`, {
+            method: 'GET',
+            headers,
+        }, TIMEOUT_MS);
+        if (!response.ok) {
+            console.warn(`[GitHubBountyConnector] Issue not found:`, response.status);
+            return null;
+        }
+        const issue = await response.json();
+        // Add repository_url for mapping
+        issue.repository_url = `https://api.github.com/repos/${owner}/${repo}`;
+        return mapIssueToBoounty(issue);
+    }
+    catch (error) {
+        console.warn(`[GitHubBountyConnector] Error getting issue:`, error);
+        return null;
+    }
+}
+function getGitHubBountyConnector() {
+    return {
+        scanBounties,
+        getBountyDetails,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genesis-ai-cli",
-  "version": "14.4.1",
+  "version": "14.5.1",
   "description": "Fully Autonomous AI System with RSI (Recursive Self-Improvement) - Self-funding, Self-deploying, Production Memory, A2A Protocol & Governance",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",