[MISSION #80-82] Elite Search & Infrastructure Upgrade (T1 Full Suite)

.github/workflows/ci.yml

@@ -229,7 +229,10 @@ jobs:
 
       - name: Install Anchor
         if: steps.check.outputs.has_anchor == 'true'
-        run: cargo install --git https://github.com/coral-xyz/anchor avm --locked --force
+        run: |
+          cargo install --git https://github.com/coral-xyz/anchor --tag v0.30.1 avm --locked --force
+          avm install latest
+          avm use latest
 
       - name: Build Anchor Program
         if: steps.check.outputs.has_anchor == 'true'

Mission_80_Prompt.md

@@ -0,0 +1,21 @@
+# System Reliability Engineering Prompt (Mission #80)
+
+Act as a Senior Backend Architect specializing in Reliability Engineering and FastAPI.
+
+## Context
+We are upgrading the SolFoundry backend health monitoring suite. The goal is to move from basic connectivity checks to comprehensive infrastructure telemetry.
+
+## Task
+Implement the `GET /api/health` logic in `backend/app/api/health.py` based on the provided specifications.
+
+## Key Requirements for the Implementation:
+1. **Parallelism**: Use `asyncio.gather` to poll PostgreSQL, Redis, Solana RPC, and GitHub API simultaneously.
+2. **Robustness**: Implement strict timeouts for each check to avoid cascading delays. 
+3. **Telemetry**: Integrate `psutil` to extract core system health (CPU/RAM).
+4. **Clean Schema**: Ensure the JSON response is structured for easy parsing by external monitors (e.g., Datadog, Prometheus).
+
+## Input Files:
+- `backend/app/api/health.py` (Current implementation)
+- `Mission_80_Specs.md`
+
+Please provide the complete Python code for the enhanced `health.py` module.

Mission_80_Specs.md

@@ -0,0 +1,32 @@
+# Mission #80: SolFoundry API Health Check Upgrade (Elite Suite)
+
+## 🎯 Objective
+Implement a robust, production-grade health monitoring system for the SolFoundry FastAPI backend. This system must provide real-time status of internal dependencies and external infrastructure integrations.
+
+## 🏗️ Technical Requirements
+
+### 1. Endpoint Specification
+- **Path**: `GET /api/health`
+- **Output**: JSON object with nested service statuses.
+- **Success Code**: `200 OK` (All core services healthy).
+- **Failure Code**: `503 Service Unavailable` (Core services degraded).
+
+### 2. Monitoring Targets
+
+#### A. Internal Services
+- **Database**: PostgreSQL connectivity (SQLAlchemy/Alembic).
+- **Redis**: Cache and Task Queue availability.
+
+#### B. External Infrastructure
+- **Solana RPC**: Execute `getHealth` on the configured cluster (Mainnet/Devnet).
+- **GitHub API**: Check current rate-limit usage to prevent integration downtime during bounty sync.
+
+#### C. System Telemetry
+- **CPU Usage**: Average percentage across all cores.
+- **Memory Consumption**: Available vs. Total RAM.
+- **Disk I/O**: Available space on the logging/data partition.
+
+### 🛠️ Architecture Guidelines
+- Use `asyncio.gather` for parallelized checking to prevent endpoint lag.
+- Implement short timeouts (e.g., 200ms) for dependency checks to ensure fast failover detection.
+- Unified status mapping: `healthy`, `degraded`, or `unavailable`.

Mission_82_Prompt.md

@@ -0,0 +1,29 @@
+# AI Prompt: Implementing Elite Search for SolFoundry (Mission #82)
+
+**Role**: Senior Backend Architect (FastAPI / PostgreSQL Specialist).
+**Task**: Upgrade the SolFoundry Bounty Search Engine to "Elite" Tier (Mission #82).
+
+**Current Context**:
+- Repository: SolFoundry (Solana-based AI Software Factory).
+- Language: Python 3.11, FastAPI, SQLAlchemy (Async).
+- Search: PostgreSQL `tsvector` with `plainto_tsquery`.
+- Files for reference: 
+    - `backend/app/api/bounties.py` (Router with the bug)
+    - `backend/app/services/bounty_search_service.py` (Core search logic)
+    - `backend/app/models/bounty_table.py` (SQLAlchemy schema)
+    - `backend/app/models/bounty.py` (Pydantic models)
+
+**Mission Objectives**:
+1.  **Add `project_name`**: The frontend (React) expects `projectName` (camelCase in JSON, `project_name` in DB). Add it to all layers and ensure it's searchable.
+2.  **Optimizer Search Vector**: Currently, the `search_vector` handles title and description. Extend it to include `project_name` with higher weight.
+3.  **Fix Router Bug**: Ensure `deadline_before` is correctly passed and handled as a `datetime` object in `BountySearchParams`.
+4.  **Skills Selection Logic**: Implement a way to toggle between "Contains ANY of these skills" (OR) and "Contains ALL of these skills" (AND) in the API. PostgreSQL `?&` vs `?|` operators.
+5.  **Refine Ranking**: How can we balance text relevance (Rank) with bounty popularity and reward size?
+
+**Instructions**:
+- Provide the corrected code blocks for `bounties.py`, `bounty_search_service.py`, and the model files.
+- Ensure type safety (Pydantic) and asynchronous DB access.
+- Propose a SQL migration strategy or explain how the `search_vector` should be regenerated.
+- Keep the code "Elite": performant, clean, and properly documented.
+
+**Let's build the best search engine on Solana.**

Mission_82_Specs.md

@@ -0,0 +1,36 @@
+# Technical Specification: SolFoundry Bounty Search Engine (Mission #82)
+
+## Context
+SolFoundry requires a high-performance "Elite" search engine for the bounty board. The current implementation uses PostgreSQL Full-Text Search (TSVECTOR) but has significant gaps:
+1.  **Missing Metadata**: `projectName` is used in the frontend but doesn't exist in the database or search index.
+2.  **Routing Bug**: The `deadline_before` filter is present in the API schema but isn't passed from the router to the search service.
+3.  **Skill Filtering Logic**: Currently uses a simple "OR" check (`?|` operator). Advanced hunters need "AND" logic to find specific multi-skill stacks.
+
+## Core Requirements
+
+### 1. Unified Search Vector
+Update the PostgreSQL `search_vector` to include more weights:
+- **Weight A**: Title
+- **Weight B**: Project Name (NEW)
+- **Weight C**: Description
+- **Weight D**: Category / Required Skills (optional)
+
+### 2. Schema Normalization
+- Add `project_name: VARCHAR(100)` to the `bounties` table.
+- Sync Pydantic models: `BountyBase`, `BountyDB`, `BountyListItem`, `BountyResponse`.
+
+### 3. Advanced Filtering & Logic
+- **AND Logic for Skills**: Add an optional `skills_logic` parameter (`"any"` | `"all"`) to the search API.
+- **Solana/FNDRY Pricing**: Ability to filter by exact currency type if multi-currency support expands.
+- **Deadline Fix**: Restore the functional `deadline_before` ISO filtering.
+
+### 4. Search Ranking System
+Refine `best_match` sorting:
+- Rank results by title match first, then project name, then description.
+- Combine text relevance with `popularity` and `reward_amount` for a "Hot Relevance" score.
+
+## Architectural Constraints
+- **Database**: PostgreSQL 15+ using `AsyncSession`.
+- **Backend**: FastAPI / Pydantic v2.
+- **Performance**: Search must resolve in < 150ms for the average query.
+- **Fallback**: Maintain the `search_bounties_memory` fallback for development environments without DB access.

backend/app/api/bounties.py

@@ -211,6 +211,7 @@ async def search_bounties(
     sort: str = Query("newest"),
     page: int = Query(1, ge=1),
     per_page: int = Query(20, ge=1, le=100),
+    skills_logic: str = Query("any", description="Logic for multiple skills: any (OR) or all (AND)"),
     svc: BountySearchService = Depends(_get_search_service),
 ) -> BountySearchResponse:
     """Execute a full-text search with filters and return ranked results."""
@@ -222,11 +223,13 @@ async def search_bounties(
         status=status,
         tier=tier,
         skills=skill_list,
+        skills_logic=skills_logic,
         category=category,
         creator_type=creator_type,
         creator_id=creator_id,
         reward_min=reward_min,
         reward_max=reward_max,
+        deadline_before=deadline_before,
         sort=sort,
         page=page,
         per_page=per_page,

backend/app/api/buybacks.py

@@ -0,0 +1,17 @@
+"""Buyback API endpoints for $FNDRY tokenomics."""
+
+from fastapi import APIRouter
+from app.models.payout import BuybackCreate, BuybackResponse, BuybackListResponse
+from app.services import payout_service
+
+router = APIRouter(prefix="/buybacks", tags=["treasury"])
+
+@router.post("/", response_model=BuybackResponse, summary="Record a buyback")
+async def record_buyback(buyback_in: BuybackCreate):
+    """Record a manual SOL -> FNDRY buyback event and update treasury stats."""
+    return await payout_service.create_buyback(buyback_in)
+
+@router.get("/", response_model=BuybackListResponse, summary="List buybacks")
+async def list_buybacks(skip: int = 0, limit: int = 100):
+    """Retrieve a paginated list of all recorded buyback events."""
+    return await payout_service.list_buybacks(skip=skip, limit=limit)