auxiliar-mcp 0.7.0 → 0.9.0

package/dist/data/event-sources.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Event-source feed URLs for the service-event scanner (Phase 1 pilot).
+ *
+ * One entry per pilot service. Each service lists zero-or-more
+ * machine-readable feeds we monitor daily. Source types:
+ *
+ *   - "status":    Statuspage.io (or equivalent) incident/history RSS
+ *   - "changelog": Vendor product changelog RSS/Atom
+ *   - "security":  Vendor security-bulletin RSS/Atom (rare but prized)
+ *   - "releases":  GitHub releases Atom (OSS projects)
+ *
+ * Phase 1 scope is detector-only — URLs here are data for the Python
+ * scanner (`src/auxiliar/scanner/`) to fetch daily. The config is
+ * intentionally versioned in-repo (not auto-discovered) so changes are
+ * reviewable and a noisy feed can be dropped with a single commit.
+ *
+ * Verification status: URLs below are the ones we expect each vendor
+ * publishes; they MUST be smoke-tested by the detector's first
+ * production run and any 404s/parse errors logged. A failing fetch is
+ * NOT a false positive — it's a missing positive, tracked separately in
+ * the scanner summary.
+ *
+ * Adding a service: add an entry, redeploy, wait 24h, confirm the
+ * source shows up in the next scanner-report.md. Removing is cheap
+ * (delete the entry; cursor rows become orphans and can be cleaned up
+ * later).
+ *
+ * This file is written by humans, read by the Python scanner via the
+ * build step (`scripts/build-service-api.py` will export it as JSON for
+ * Python — Phase 1 scanner reads the JSON snapshot so we don't need a
+ * TS runtime in the Lambda).
+ */
+export type EventSourceType = "status" | "changelog" | "security" | "releases";
+export interface EventSource {
+    type: EventSourceType;
+    url: string;
+    /** Human-readable note about the feed — why we picked it, caveats. */
+    note?: string;
+}
+export interface ServiceEventSources {
+    /** Slug matching content/service/<slug>.md and mcp/src/data/risks.ts keys. */
+    slug: string;
+    /** Human-readable service name. */
+    name: string;
+    sources: EventSource[];
+}
+export declare const eventSources: ServiceEventSources[];

package/dist/data/event-sources.js

@@ -0,0 +1,126 @@
+/**
+ * Event-source feed URLs for the service-event scanner (Phase 1 pilot).
+ *
+ * One entry per pilot service. Each service lists zero-or-more
+ * machine-readable feeds we monitor daily. Source types:
+ *
+ *   - "status":    Statuspage.io (or equivalent) incident/history RSS
+ *   - "changelog": Vendor product changelog RSS/Atom
+ *   - "security":  Vendor security-bulletin RSS/Atom (rare but prized)
+ *   - "releases":  GitHub releases Atom (OSS projects)
+ *
+ * Phase 1 scope is detector-only — URLs here are data for the Python
+ * scanner (`src/auxiliar/scanner/`) to fetch daily. The config is
+ * intentionally versioned in-repo (not auto-discovered) so changes are
+ * reviewable and a noisy feed can be dropped with a single commit.
+ *
+ * Verification status: URLs below are the ones we expect each vendor
+ * publishes; they MUST be smoke-tested by the detector's first
+ * production run and any 404s/parse errors logged. A failing fetch is
+ * NOT a false positive — it's a missing positive, tracked separately in
+ * the scanner summary.
+ *
+ * Adding a service: add an entry, redeploy, wait 24h, confirm the
+ * source shows up in the next scanner-report.md. Removing is cheap
+ * (delete the entry; cursor rows become orphans and can be cleaned up
+ * later).
+ *
+ * This file is written by humans, read by the Python scanner via the
+ * build step (`scripts/build-service-api.py` will export it as JSON for
+ * Python — Phase 1 scanner reads the JSON snapshot so we don't need a
+ * TS runtime in the Lambda).
+ */
+export const eventSources = [
+    {
+        slug: "vercel",
+        name: "Vercel",
+        sources: [
+            { type: "status", url: "https://www.vercel-status.com/history.rss" },
+            { type: "changelog", url: "https://vercel.com/changelog/feed.xml" },
+            {
+                type: "security",
+                url: "https://vercel.com/kb/bulletin",
+                note: "Ground-truth fixture source (April 2026 incident). HTML page, not RSS — detector polls with low-frequency hash comparison.",
+            },
+        ],
+    },
+    {
+        slug: "stripe",
+        name: "Stripe",
+        sources: [
+            { type: "status", url: "https://status.stripe.com/history.rss" },
+            { type: "changelog", url: "https://stripe.com/blog/feed.rss" },
+        ],
+    },
+    {
+        slug: "supabase",
+        name: "Supabase",
+        sources: [
+            { type: "status", url: "https://status.supabase.com/history.rss" },
+            { type: "changelog", url: "https://supabase.com/changelog/feed.xml" },
+        ],
+    },
+    {
+        slug: "neon",
+        name: "Neon",
+        sources: [
+            { type: "status", url: "https://neonstatus.com/history.rss" },
+            { type: "changelog", url: "https://neon.tech/changelog/feed.xml" },
+        ],
+    },
+    {
+        slug: "clerk",
+        name: "Clerk",
+        sources: [
+            { type: "status", url: "https://status.clerk.com/history.rss" },
+            { type: "changelog", url: "https://clerk.com/changelog/feed.xml" },
+        ],
+    },
+    {
+        slug: "auth0",
+        name: "Auth0",
+        sources: [
+            { type: "status", url: "https://status.auth0.com/history.rss" },
+            {
+                type: "security",
+                url: "https://auth0.com/docs/secure/security-bulletins/rss",
+                note: "Auth0 maintains a dedicated security-bulletin feed — historically reliable.",
+            },
+        ],
+    },
+    {
+        slug: "railway",
+        name: "Railway",
+        sources: [
+            { type: "status", url: "https://status.railway.com/history.rss" },
+            { type: "changelog", url: "https://blog.railway.com/feed.xml" },
+        ],
+    },
+    {
+        slug: "render",
+        name: "Render",
+        sources: [
+            { type: "status", url: "https://status.render.com/history.rss" },
+            { type: "changelog", url: "https://render.com/changelog/rss.xml" },
+        ],
+    },
+    {
+        slug: "resend",
+        name: "Resend",
+        sources: [
+            { type: "status", url: "https://resend-status.com/history.rss" },
+            { type: "changelog", url: "https://resend.com/changelog/feed.xml" },
+        ],
+    },
+    {
+        slug: "authjs",
+        name: "Auth.js",
+        sources: [
+            {
+                type: "releases",
+                url: "https://github.com/nextauthjs/next-auth/releases.atom",
+                note: "OSS project — GitHub releases is the only structured feed. CVEs land here as security-labelled releases.",
+            },
+        ],
+    },
+];

package/dist/data/pricing.js

@@ -532,4 +532,51 @@ export const pricing = {
         verified_date: "2026-03-28",
         source: "Chrome-verified from postgresql.org/docs",
     },
+    "surya": {
+        provider: "Surya",
+        pricing_model: "free",
+        tiers: [
+            { name: "Self-hosted", price: "$0", includes: "Unlimited pages, fully local CPU/GPU inference, JSON output with text lines and bounding boxes", catches: "GPL-3.0 code license; model weights under AI Pubs Open Rail-M with <$2M funding/revenue clause for free use" },
+        ],
+        hidden_costs: [
+            "Compute: CPU inference averages ~20s/doc on a multi-page scanned PDF; 3-5× faster on MPS (Apple Silicon) or CUDA",
+            "~150 MB model weights downloaded on first run",
+            "Requires a Python venv and a 'transformers<5.0.0' pin as of 2026-04 (issue #484)",
+            "License diligence for distributed/shipped products — internal tooling and SaaS backends typically fine",
+        ],
+        verified_date: "2026-04-21",
+        source: "Verified from github.com/datalab-to/surya and eval on 10-doc corpus (see /solve/pdf-text-extraction-mcp)",
+    },
+    "tesseract": {
+        provider: "Tesseract 5",
+        pricing_model: "free",
+        tiers: [
+            { name: "Self-hosted", price: "$0", includes: "Unlimited pages, Apache 2.0, 100+ languages via .traineddata packs, plain-text output", catches: "PDFs must be pre-rendered with pdftoppm; plain text only (no layout/bounding boxes by default)" },
+        ],
+        hidden_costs: [
+            "Add poppler (pdftoppm) to handle PDF inputs — one extra shell step per doc",
+            "Language packs must be installed explicitly: tesseract-lang on brew includes 'por' for Portuguese",
+            "Multi-column reading order can diverge from top-to-bottom on dense layouts — downstream may need post-processing",
+        ],
+        verified_date: "2026-04-21",
+        source: "Verified from github.com/tesseract-ocr/tesseract and eval on 10-doc corpus (see /solve/pdf-text-extraction-mcp)",
+    },
+    "google-document-ai": {
+        provider: "Google Document AI",
+        pricing_model: "usage-based",
+        tiers: [
+            { name: "Free tier", price: "$0", includes: "1,000 pages/month per processor (Document OCR)", catches: "Requires a GCP project with billing account linked" },
+            { name: "Document OCR", price: "~$1.50 per 1,000 pages", includes: "Generic text + layout extraction", catches: "Sync endpoint caps at 15 pages/request — split or use async batch for larger PDFs" },
+            { name: "Form Parser", price: "~$30 per 1,000 pages", includes: "Form fields, tables, key-value pairs", catches: "Higher per-page rate; pick only if you need structured field extraction" },
+            { name: "Invoice Parser", price: "~$50 per 1,000 pages (first 1M); ~$30 after", includes: "Invoice-specific schema (line items, totals, vendor)", catches: "Tuned for US invoices; NFS-e and boletos may not map cleanly to the schema" },
+        ],
+        hidden_costs: [
+            "Billing account required — personal Google accounts can't provision processors",
+            "Data leaves your local machine — confirm with compliance/counsel before sending confidential financial docs",
+            "Third place on word accuracy (69.7%) on a 10-doc mixed corpus against local Surya (76.9%) and Tesseract (75.4%) — paying doesn't automatically mean more accurate extraction",
+            "Async batch has separate quotas; large PDF processing may need processor quota increases",
+        ],
+        verified_date: "2026-04-21",
+        source: "Verified from cloud.google.com/document-ai/pricing and eval on 10-doc corpus (see /solve/pdf-text-extraction-mcp)",
+    },
 };

package/dist/data/recommendations.js

@@ -2233,4 +2233,118 @@ export const recommendations = {
             },
         ],
     },
+    "pdf-extraction": {
+        services: [
+            {
+                slug: "surya",
+                name: "Surya",
+                choose_if: "Best overall word accuracy on mixed PDF corpora (76.9%) with the strongest layout preservation (7.0/10). Runs fully local, handles PDFs natively, free. Top pick for bookkeeping, NFS-e, invoices, and scanned legal docs when accuracy matters more than latency.",
+                avoid_if: "p50 latency is 22s/doc on CPU (14× slower than Tesseract). GPL-3.0 license (+ AI Pubs Open Rail-M on weights, <$2M revenue clause) may complicate end-user-distributed products. Needs Python venv and a transformers<5.0.0 pin.",
+                pricing_model: "free",
+                free_tier: "Unlimited — fully local inference, no API",
+                paid_starts_at: "$0 (self-hosted only)",
+                risks: [
+                    "GPL-3.0 code license + AI Pubs Open Rail-M weights license (<$2M funding/revenue clause) — fine for internal tooling and SaaS backends, verify with counsel for distributed products",
+                    "Requires transformers<5.0.0 pin as of 2026-04 — bare 'pip install surya-ocr' fails with 'SuryaDecoderConfig' object has no attribute 'pad_token_id' (upstream issue #484)",
+                    "~150 MB model weights downloaded on first run",
+                    "CPU inference ~20s/doc — expect 3-5× speedup on MPS/CUDA",
+                ],
+                provision_command: "python -m venv .venv && source .venv/bin/activate && pip install surya-ocr 'transformers<5.0.0'",
+                setup_available: false,
+                has_free_tier: true,
+                cheap: true,
+                enterprise: true,
+                eu_regions: true,
+                gdpr_ready: true,
+                open_source: true,
+                provider_cloud: "multi",
+                edge_compatible: false,
+                has_cold_starts: false,
+                has_cli: true,
+                cli_name: "surya_ocr",
+                cli_install: "pip install surya-ocr 'transformers<5.0.0'",
+                has_mcp: false,
+                migration_difficulty: "low",
+                migration_note: "Outputs JSON with text_lines per page. Swap with Tesseract or Document AI by changing the extraction step — downstream code consumes plain text.",
+                key_features: ["local OCR", "native PDF input", "layout-aware extraction", "table detection", "multi-language", "JSON output with bounding boxes", "Brazilian Portuguese supported", "NFS-e", "invoices", "bookkeeping documents", "scanned corporate filings"],
+                best_for_frameworks: ["claude-code", "claude-desktop", "cursor", "openclaw", "python"],
+                default_score: 8,
+                last_reviewed: "2026-04-21",
+            },
+            {
+                slug: "tesseract",
+                name: "Tesseract 5",
+                choose_if: "Fastest local OCR with the cleanest install path — one brew command, 1.6s p50, 75.4% word accuracy (1.5pp behind Surya). Best when throughput matters more than layout fidelity, or when you need a zero-dependency fallback.",
+                avoid_if: "Plain text output only — no layout, no bounding boxes by default. PDFs need a pdftoppm render step first (Tesseract takes images, not PDFs).",
+                pricing_model: "free",
+                free_tier: "Unlimited — fully local, Apache 2.0",
+                paid_starts_at: "$0 (self-hosted only)",
+                risks: [
+                    "PDFs need pdftoppm pre-render (one extra step vs. Surya which takes PDFs natively)",
+                    "Plain text output — no structured data (form fields, tables, bounding boxes)",
+                    "Reading order on multi-column layouts can diverge from top-to-bottom",
+                    "Language packs must be installed explicitly (e.g., por for Portuguese)",
+                ],
+                provision_command: "brew install tesseract tesseract-lang poppler",
+                setup_available: false,
+                has_free_tier: true,
+                cheap: true,
+                enterprise: true,
+                eu_regions: true,
+                gdpr_ready: true,
+                open_source: true,
+                provider_cloud: "multi",
+                edge_compatible: false,
+                has_cold_starts: false,
+                has_cli: true,
+                cli_name: "tesseract",
+                cli_install: "brew install tesseract tesseract-lang poppler",
+                has_mcp: false,
+                migration_difficulty: "low",
+                migration_note: "Plain text out. Swapping with Surya/Document AI changes one shell step — downstream text consumers are unchanged.",
+                key_features: ["local OCR", "Apache 2.0", "Portuguese language pack (por.traineddata)", "English, Spanish, 100+ languages", "fast p50", "minimal install", "CLI-first"],
+                best_for_frameworks: ["claude-code", "claude-desktop", "cursor", "openclaw", "bash"],
+                default_score: 7,
+                last_reviewed: "2026-04-21",
+            },
+            {
+                slug: "google-document-ai",
+                name: "Google Document AI",
+                choose_if: "Best results on phone-photographed receipts and mobile-captured documents (94.6% on our corpus's Pix receipt vs. 93.1% for Surya). Structured output (form fields, tables, bounding boxes). 1,000 pages/month free tier, then ~$0.002/page. Pick this when you're already on GCP or need auditable enterprise auth.",
+                avoid_if: "On our 10-doc corpus Document AI placed third overall on word accuracy (69.7%) behind local Surya and Tesseract — paying for a cloud API does not guarantee better extraction on corporate filings or native-text PDFs. Reading order diverges from top-to-bottom. Enterprise-auth install flow.",
+                pricing_model: "usage-based",
+                free_tier: "1,000 pages/month per processor (Document OCR), then billed",
+                paid_starts_at: "~$0.0015/page (Document OCR) to ~$0.05/page (Invoice Parser)",
+                risks: [
+                    "Requires a GCP project with billing account linked — not reachable with a personal Google account alone",
+                    "Third place overall word accuracy on our 10-doc mixed corpus (0.697 vs. 0.769 for Surya, 0.754 for Tesseract) — the paid option is not automatically the most accurate",
+                    "Sync endpoint caps at 15 pages per request — split PDFs or use async batch for larger",
+                    "Per-page billing adds up — $0.002 × 10,000 pages = $20, $0.002 × 100,000 = $200",
+                    "Data leaves the local machine — confirm with compliance before sending confidential financial docs",
+                ],
+                provision_command: "gcloud services enable documentai.googleapis.com && gcloud auth application-default login",
+                setup_available: false,
+                has_free_tier: true,
+                cheap: false,
+                enterprise: true,
+                eu_regions: true,
+                gdpr_ready: true,
+                open_source: false,
+                provider_cloud: "gcp",
+                edge_compatible: false,
+                has_cold_starts: false,
+                has_cli: true,
+                cli_name: "gcloud",
+                cli_install: "brew install --cask google-cloud-sdk",
+                has_mcp: false,
+                mcp_install: null,
+                migration_difficulty: "medium",
+                migration_note: "JSON response with document.text + layout. Moving off GCP means rewriting the API call + auth; downstream text consumers survive if you abstract the call behind a function.",
+                key_features: ["cloud OCR API", "structured layout output", "bounding boxes", "form fields", "tables", "invoice parser processor", "Portuguese supported", "phone photo receipts", "async batch for large PDFs", "audit logging"],
+                best_for_frameworks: ["claude-code", "claude-desktop", "cursor", "openclaw", "python", "node"],
+                default_score: 6,
+                last_reviewed: "2026-04-21",
+            },
+        ],
+    },
 };

package/dist/data/risks.js

@@ -312,12 +312,55 @@ export const risks = {
     "vercel": {
         provider: "Vercel",
         risks: [
+            { severity: "CRITICAL", title: "Active security incident (April 2026)", detail: "Vercel disclosed on 2026-04-19 that a compromise of Context.ai (a third-party AI tool used by a Vercel employee) was escalated to their internal systems via the employee's Google Workspace. A limited subset of customers had credentials compromised; environment variables not marked 'sensitive' on affected accounts may have been accessed. Vercel recommends rotating non-sensitive env vars as a priority, enabling the 'sensitive env vars' feature, reviewing recent deployments, and rotating Deployment Protection tokens. Investigation ongoing; services remain operational. Full advisory: https://vercel.com/kb/bulletin/vercel-april-2026-security-incident" },
             { severity: "HIGH", title: "Bandwidth overage shock", detail: "Vercel charges starting at $0.15/GB for bandwidth beyond your plan's included usage. The Pro plan includes $20 of usage credit, but a viral post or product launch can still generate surprise charges. " },
             { severity: "MEDIUM", title: "Hobby tier is non-commercial", detail: "The free Hobby plan explicitly prohibits commercial use. Any revenue-generating app needs the $20/month Pro plan." },
             { severity: "MEDIUM", title: "Framework lock-in", detail: "Advanced features (ISR, edge middleware, image optimization) are deeply integrated with Next.js. Migrating to another platform means losing these optimizations." },
             { severity: "LOW", title: "Cold starts on serverless functions", detail: "Serverless functions can have cold starts of 200-500ms. Edge functions are faster but have runtime limitations (no Node.js APIs)." },
         ],
-        recent_changes: [],
-        verified_date: "2026-03-30",
+        recent_changes: [
+            { date: "2026-04-19", change: "Security incident disclosed — Context.ai supply-chain compromise pivoted into Vercel internal systems via employee Google Workspace. Limited-subset customer credentials affected. See: https://vercel.com/kb/bulletin/vercel-april-2026-security-incident" },
+        ],
+        verified_date: "2026-04-20",
+    },
+    "surya": {
+        provider: "Surya",
+        risks: [
+            { severity: "HIGH", title: "Install requires a transformers<5.0.0 pin", detail: "As of 2026-04, 'pip install surya-ocr' alone fails at runtime with 'SuryaDecoderConfig' object has no attribute 'pad_token_id' (upstream issue #484). Pin transformers<5.0.0 in the same install step. Without the pin, bookkeeping runs will fail on the first document." },
+            { severity: "MEDIUM", title: "Licensing nuance: GPL-3.0 code + AI Pubs Open Rail-M weights", detail: "Code is GPL-3.0; model weights carry a separate AI Pubs Open Rail-M license with a <$2M funding/revenue clause for free use. Fine for internal tooling, production SaaS backends where outputs stay internal, and bookkeeping pipelines. For products distributed to end users or weights embedded in shipped software, consult counsel." },
+            { severity: "MEDIUM", title: "CPU inference is slow (~20s/doc p50)", detail: "A 10-doc bookkeeping batch takes ~3.5 min on CPU. Expect 3-5× speedup on MPS (Apple Silicon) or CUDA. Plan for GPU access or batch processing overnight if you have hundreds of docs/month." },
+            { severity: "LOW", title: "Reading order on multi-column layouts", detail: "On dense corporate filings, Surya's reading order can diverge from top-to-bottom, dragging word-error-rate (WER) down. Token F1 (93.4% on our corpus) is the more representative accuracy metric for downstream agent use — the words are captured, the sequencing is imperfect." },
+        ],
+        recent_changes: [
+            { date: "2026-04-21", change: "Eval on 10-document real-world corpus (native PDFs, legal docs, Brazilian corporate registry scans, NFS-e, boleto, phone-photo receipts). Surya placed first on word accuracy (76.9%) and layout (7.0/10). See /solve/pdf-text-extraction-mcp." },
+        ],
+        verified_date: "2026-04-21",
+    },
+    "tesseract": {
+        provider: "Tesseract 5",
+        risks: [
+            { severity: "MEDIUM", title: "PDFs require a pre-render step", detail: "Tesseract takes images, not PDFs. You need pdftoppm (from poppler) to render each page first: 'pdftoppm -r 300 doc.pdf page && tesseract page-1.ppm - -l por'. One extra shell step per doc — easy to script, but not zero-config." },
+            { severity: "MEDIUM", title: "Plain text output only (no layout)", detail: "Default output is a plain string — no bounding boxes, no form fields, no table structure. If your bookkeeping workflow needs structured invoice fields (line items, totals, vendor), Tesseract alone is not enough; pair it with an LLM for field extraction, or switch to Surya / Document AI." },
+            { severity: "LOW", title: "Language pack must be installed explicitly", detail: "brew install tesseract only ships with English. Add 'tesseract-lang' for the full set (includes 'por' for Portuguese). Missing language packs show up as garbage output on non-English docs — easy to miss in CI until a Portuguese invoice lands." },
+            { severity: "LOW", title: "Reading order on multi-column", detail: "Like Surya, Tesseract's reading order on dense multi-column layouts can diverge from top-to-bottom. Token F1 (91.4% on our corpus) remains high — the words are captured." },
+        ],
+        recent_changes: [
+            { date: "2026-04-21", change: "Eval on 10-document real-world corpus. Tesseract placed second on word accuracy (75.4%), first on latency (1.6s p50 — 14× faster than Surya), first on install friction (3/10). See /solve/pdf-text-extraction-mcp." },
+        ],
+        verified_date: "2026-04-21",
+    },
+    "google-document-ai": {
+        provider: "Google Document AI",
+        risks: [
+            { severity: "HIGH", title: "Paid cloud API is not automatically more accurate than free local tools", detail: "On our 10-doc mixed corpus Document AI placed third on word accuracy (0.697) behind local Surya (0.769) and Tesseract (0.754). Don't assume that paying per page buys you better extraction — for native-text PDFs and Brazilian corporate filings, the local options matched or beat the paid API. Document AI's edge was on phone-photographed receipts (94.6% vs. 93.1% for Surya on a Pix receipt)." },
+            { severity: "HIGH", title: "Requires GCP billing account", detail: "Personal Google accounts can't provision processors. You need a GCP project with billing linked (credit card required) even to stay under the 1,000 pages/month free tier. Enterprise-auth install flow: 'gcloud auth application-default login' + processor creation in the console." },
+            { severity: "MEDIUM", title: "Data leaves the local machine", detail: "Every PDF is uploaded to Google before extraction. For confidential financial docs (NFS-e with client info, internal invoices, salary receipts), confirm with compliance/counsel before routing through a cloud OCR API. Local tools (Surya, Tesseract) keep documents on the machine." },
+            { severity: "MEDIUM", title: "Sync endpoint capped at 15 pages per request", detail: "For larger PDFs you must split the document or switch to async batch. Batch has separate quotas and an extra setup step. Easy to hit on multi-page bank statements." },
+            { severity: "LOW", title: "Reading order diverges", detail: "Document AI's reading order on multi-column / watermarked layouts diverges from top-to-bottom. Token F1 (93.4% on our corpus) is strong — use it for downstream agent extraction rather than raw WER." },
+        ],
+        recent_changes: [
+            { date: "2026-04-21", change: "Eval on 10-document real-world corpus. Document AI placed third on word accuracy (69.7%), best on phone-photo receipts specifically. Cost: $0.069 total for 10 docs. See /solve/pdf-text-extraction-mcp." },
+        ],
+        verified_date: "2026-04-21",
     },
 };

package/dist/data/solve.d.ts

@@ -0,0 +1,43 @@
+export interface SolveCandidate {
+    slug: string;
+    name: string;
+    rank: number;
+    install: string;
+    scorecard: {
+        word_accuracy?: number;
+        token_f1?: number;
+        layout?: number;
+        p50_latency_sec?: number;
+        install_friction?: number;
+        cost_per_10_docs_usd?: number;
+    };
+    notes: string;
+    license?: string;
+}
+export interface SolveAlternativeConsidered {
+    name: string;
+    dropped_because: string;
+}
+export interface SolveFaq {
+    q: string;
+    a: string;
+}
+export interface SolveTask {
+    slug: string;
+    title: string;
+    url: string;
+    last_verified: string;
+    categories: string[];
+    works_with: string[];
+    alternatives: string[];
+    eval_method: string;
+    answer: string;
+    candidates: SolveCandidate[];
+    corpus_summary: string;
+    alternatives_considered: SolveAlternativeConsidered[];
+    faq: SolveFaq[];
+    methodological_caveats: string[];
+    update_cadence: string;
+    fit_by_agent: Record<string, Record<string, boolean>>;
+}
+export declare const solveTasks: Record<string, SolveTask>;

package/dist/data/solve.js

@@ -0,0 +1,127 @@
+// Structured data for /solve/ task-first tool rankings.
+//
+// Each entry mirrors the published /solve/<slug>/ page on auxiliar.ai.
+// Agents consume this via the solve_task and list_solve_tasks MCP tools so
+// they can get the full eval data (scorecard, install commands, alternatives
+// considered, FAQs, caveats) without depending on a search engine having
+// indexed the page.
+//
+// Keep in sync with content/solve/<slug>.md. Update last_verified when the
+// content/solve/ markdown changes. A build-time generator can automate this
+// later; while only one task is live, hand-maintaining is cheaper than the
+// pipeline.
+export const solveTasks = {
+    "pdf-text-extraction-mcp": {
+        slug: "pdf-text-extraction-mcp",
+        title: "PDF text extraction for Claude Code agents — what to install, ranked by accuracy",
+        url: "https://auxiliar.ai/solve/pdf-text-extraction-mcp/",
+        last_verified: "2026-04-21",
+        categories: ["pdf-processing", "ocr", "agent-tools"],
+        works_with: ["claude-code", "claude-desktop", "cursor", "openclaw"],
+        alternatives: ["tesseract", "surya", "google-document-ai"],
+        eval_method: "auxiliar-ocr-walkthrough-v1",
+        answer: "If your Claude Code agent needs to parse PDFs and photo-captured documents reliably, install Surya (`pip install surya-ocr` + pin `transformers<5.0.0`). It led our 10-document real-world corpus on word accuracy (76.9%), layout preservation (7.0/10), and token F1 (93.4%) — while costing zero dollars per page, running entirely local, and handling PDFs natively. For latency-critical workflows where throughput matters more than layout, Tesseract 5 + por.traineddata runs 14× faster (1.6s p50) and installs in one brew command, trading 1.5 percentage points of word accuracy for dramatic speed and the cleanest install path. Google Document AI costs ~$0.002 per page after a 1000-page/month free tier and wins on mobile-captured receipts (94.6% vs 93.1% for Surya on a phone-photo Pix receipt) — but it places third on overall word accuracy on this corpus, diverges from top-to-bottom reading order, and carries an enterprise-auth install flow. For Brazilian corporate filings specifically, local models match or beat the paid vendor API.",
+        candidates: [
+            {
+                slug: "surya",
+                name: "Surya",
+                rank: 1,
+                install: "python -m venv .venv && source .venv/bin/activate && pip install surya-ocr 'transformers<5.0.0'",
+                scorecard: {
+                    word_accuracy: 0.769,
+                    token_f1: 0.934,
+                    layout: 7.0,
+                    p50_latency_sec: 22.1,
+                    install_friction: 7,
+                    cost_per_10_docs_usd: 0,
+                },
+                notes: "Led the corpus on word accuracy and layout preservation. The transformers<5.0.0 pin is required as of 2026-04: 'pip install surya-ocr' alone fails at runtime with 'SuryaDecoderConfig' object has no attribute 'pad_token_id' (issue #484). CPU inference ~22s/doc p50; 3-5× faster on MPS/CUDA.",
+                license: "GPL-3.0 (code) + AI Pubs Open Rail-M (weights, <$2M funding/revenue clause)",
+            },
+            {
+                slug: "tesseract",
+                name: "Tesseract 5",
+                rank: 2,
+                install: "brew install tesseract tesseract-lang poppler && pdftoppm -r 300 doc.pdf page && tesseract page-1.ppm - -l por",
+                scorecard: {
+                    word_accuracy: 0.754,
+                    token_f1: 0.914,
+                    layout: 5.0,
+                    p50_latency_sec: 1.6,
+                    install_friction: 3,
+                    cost_per_10_docs_usd: 0,
+                },
+                notes: "14× faster than Surya at p50 latency. Trades 1.5pp of word accuracy for throughput and the cleanest install path. PDFs need pdftoppm pre-render — Tesseract takes images, not PDFs. Plain text output only (no layout/bounding boxes). Language pack 'por' required for Portuguese via tesseract-lang.",
+                license: "Apache 2.0",
+            },
+            {
+                slug: "google-document-ai",
+                name: "Google Document AI",
+                rank: 3,
+                install: "gcloud auth application-default login && gcloud services enable documentai.googleapis.com --project YOUR_PROJECT && export DOCUMENT_AI_PROCESSOR_ID=<copied-id>",
+                scorecard: {
+                    word_accuracy: 0.697,
+                    token_f1: 0.934,
+                    layout: 5.7,
+                    p50_latency_sec: 3.8,
+                    install_friction: 7,
+                    cost_per_10_docs_usd: 0.069,
+                },
+                notes: "Third on overall word accuracy on this corpus, but best on phone-photographed receipts specifically (94.6% vs. 93.1% for Surya on a Pix receipt). Structured JSON output (form fields, tables, bounding boxes) is richer than plain text. Requires GCP billing account; 1,000 pages/month free per processor. Sync endpoint caps at 15 pages/request — split or use async batch. Data leaves the local machine.",
+                license: "Proprietary (Google Cloud)",
+            },
+        ],
+        corpus_summary: "10 real-world documents spanning OCR stress dimensions: 2 native-text PDFs (clean text layer), 3 digital legal docs (Word-generated PDFs), 2 image-heavy scans (Brazilian corporate-registry certifications with body content in image layer and government watermarks in text layer), 3 structured Brazilian forms (NFSe invoices, boleto), 2 phone-photographed receipts (real lighting and perspective). Ground truth is LLM-drafted, human-finalized transcription. Corpus is git-ignored (contains real business information).",
+        alternatives_considered: [
+            {
+                name: "yescan-ocr-universal (ClawHub skill)",
+                dropped_because: "Requires a SCAN_WEBSERVICE_KEY from Quark Scan (Chinese sign-up) and doesn't support PDFs natively (image-only, 5 MB limit). Practical install friction 9/10 for non-Chinese users.",
+            },
+            {
+                name: "Mistral OCR 3 (via everaldo/mcp-mistral-ocr MCP)",
+                dropped_because: "Strong on paper (88.9% handwriting, 96.6% table extraction per vendor benchmarks); deferred because no MISTRAL_API_KEY was available. Runner at scripts/ocr-walkthrough/run-mistral-ocr.sh is ready; re-enable when API key is provisioned.",
+            },
+            {
+                name: "pdf-reader-mcp",
+                dropped_because: "Looks like an MCP OCR tool but its 2.3.1 docs explicitly list OCR as 'planned, not implemented.' Only does text-layer extraction from native-text PDFs — equivalent to pdftotext. Unsuitable for scanned corpora.",
+            },
+        ],
+        faq: [
+            {
+                q: "Why is Surya slow compared to Google Document AI?",
+                a: "Surya runs locally on PyTorch. First invocation downloads ~150 MB of model weights. Steady-state inference on CPU averages ~20 s/doc on a multi-page scanned PDF. On GPU (MPS on Apple Silicon, CUDA on NVIDIA), expect 3-5× speedup. Google Document AI is a remote server farm.",
+            },
+            {
+                q: "Does 'word accuracy 76.9%' mean Surya gets only 76.9% of words right?",
+                a: "No. WER is an order-sensitive metric; it penalizes insertions, deletions, AND reordering. Token F1 (93.4%) is the order-insensitive accuracy — meaning Surya captures 93.4% of the correct words, but in a sequence that differs from ground-truth order in enough places to drag WER down. For downstream agent use, token F1 is usually the relevant metric: did the OCR see the content at all? Surya, Google Document AI, and Tesseract all score 0.91-0.94 on token F1.",
+            },
+            {
+                q: "When should I pay for Document AI over the free local options?",
+                a: "Three cases. (1) Your workflow depends on structured output (form fields, tables, bounding boxes) — Document AI's JSON is richer than plain text. (2) You're processing phone photos — Document AI was marginally best on the two phone-photo receipts in our corpus. (3) You're already in GCP and want auditable enterprise auth. Otherwise: local models match or beat Document AI on word accuracy, at $0.",
+            },
+            {
+                q: "Why do all three candidates score 0 on slot 07 (the boleto)?",
+                a: "The ground-truth transcription for the boleto is conservative — it excludes visible-decoration text like 'Aponte a câmera do seu celular para este QRCode...' All three OCR engines correctly capture that text, inflating candidate output relative to ground truth. WER explodes on insertions. Token F1 scores for slot 07 (0.575-0.646) are more representative of actual capture quality. If downstream use is agent-driven extraction of boleto fields specifically, all three are usable; if you need exactly ground-truth shape, consider post-processing to filter known-noise phrases.",
+            },
+            {
+                q: "Is Surya's GPL-3.0 license a problem for my startup?",
+                a: "Probably not for internal tooling, production services where outputs are consumed internally, or SaaS backends. Note: model weights are under a separate AI Pubs Open Rail-M license, with a <$2M funding/revenue clause for free use. For anything distributed to end users or embedded in shipped software, consult counsel.",
+            },
+        ],
+        methodological_caveats: [
+            "Corpus is 10 documents. Statistical confidence intervals are wide; differences under ~5 percentage points in word accuracy should be treated as noise.",
+            "Ground truth was LLM-drafted then human-reviewed. Some drafts (especially slot 07 boleto) may be under-conservative on visible-decoration text; WER on those docs is artifactually low.",
+            "Layout judge was the same Claude Opus 4.7 model handling the walkthrough (inline, in-conversation). A separate API-isolated judge run with fresh context is the more rigorous approach and is scripted but not yet executed.",
+            "Install-friction scores reflect actual install experience in April 2026; versions and paths drift.",
+            "Costs: $0.069 total for 10 docs on Document AI; $0 for both local tools. Budget consumed from a $20 walkthrough cap.",
+            "Not tested: native multimodal capabilities of Claude, GPT-4o, or Gemini themselves (agents with strong native vision may not need an added OCR tool).",
+        ],
+        update_cadence: "Re-run this walkthrough when: (a) any candidate ships a major version, (b) new OCR MCPs or ClawHub skills emerge that might outrank the top 3, (c) 90 days after first publish (2026-07-20), (d) Google Document AI pricing changes.",
+        fit_by_agent: {
+            "claude-code": { tesseract: true, surya: true, "google-document-ai": true },
+            "claude-desktop": { tesseract: true, surya: true, "google-document-ai": true },
+            cursor: { tesseract: true, surya: true, "google-document-ai": true },
+            openclaw: { tesseract: true, surya: true, "google-document-ai": true },
+        },
+    },
+};

package/dist/server.js

@@ -8,13 +8,14 @@ import { checkCompatibility } from "./tools/compatibility.js";
 import { getPricing } from "./tools/pricing.js";
 import { getRisks } from "./tools/risks.js";
 import { listServices } from "./tools/list.js";
+import { solveTask, listSolveTasks } from "./tools/solve.js";
 const server = new McpServer({
     name: "auxiliar",
-    version: "0.7.0",
+    version: "0.9.0",
 });
 // Tool: recommend_service
 server.tool("recommend_service", "Get a current, verified recommendation for a cloud service based on your constraints. Returns pricing, risks, provision commands, and alternatives. Data is Chrome-verified from actual service websites (not stale training data).", {
-    need: z.string().max(100).describe("What kind of service you need (database, email, auth, deploy, payments, search, cms, storage, monitoring, cache, queues, vector, llm, sms, feature-flags, cron — aliases like 'llm-api', 'file-storage', 'vector-db' also work)"),
+    need: z.string().max(100).describe("What kind of service you need (database, email, auth, deploy, payments, search, cms, storage, monitoring, cache, queues, vector, llm, sms, feature-flags, cron, pdf-extraction — aliases like 'llm-api', 'file-storage', 'vector-db', 'ocr', 'document-ai', 'invoice-extraction', 'nfs-e' also work)"),
     framework: z.string().max(100).optional().describe("Your framework (nextjs, express, sveltekit, etc.)"),
     region: z.string().max(50).optional().describe("Preferred region (us, eu, etc.)"),
     budget: z.enum(["free", "cheap", "moderate", "enterprise"]).optional().describe("Budget constraint"),
@@ -73,6 +74,23 @@ server.tool("list_services", "List all available services and categories. Use wi
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
     };
 });
+// Tool: solve_task
+server.tool("solve_task", "Fetch the full /solve/ task ranking for a specific job-to-be-done (e.g., 'extract text from PDFs', 'parse Brazilian NFS-e invoices'). Returns the ranked candidates with install commands, an evaluated scorecard (word accuracy, layout, latency, cost, install friction), alternatives considered and dropped, FAQs, and methodological caveats. Use this when an agent needs to pick an installable tool (skill/MCP/API/local binary) for a task rather than a cloud service. Data comes from a reproducible eval run on a real-world corpus — not training data.", {
+    task_slug: z.string().max(100).optional().describe("Task slug (e.g., 'pdf-text-extraction-mcp'). Aliases like 'pdf', 'ocr', 'invoice-extraction', 'nfs-e', 'boleto', 'receipt-parsing', 'bookkeeping-ocr', 'document-ai' also resolve. Call list_solve_tasks first if you don't know the slug."),
+    category: z.string().max(100).optional().describe("Filter by task category (e.g., 'ocr', 'pdf-processing', 'agent-tools'). Returns all matching tasks."),
+}, async (params) => {
+    const result = await solveTask(params);
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+});
+// Tool: list_solve_tasks
+server.tool("list_solve_tasks", "List all available /solve/ task rankings with their top picks. Use this to discover what jobs-to-be-done auxiliar.ai has evaluated installable tools for. Complementary to list_services (cloud services catalog): list_solve_tasks surfaces agent-installable tooling (skills, MCPs, APIs, local binaries) evaluated on real-world corpora.", {}, async () => {
+    const result = await listSolveTasks();
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+});
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/tools/list.js

@@ -48,6 +48,23 @@ const categoryAliases = {
     "content-management": "cms",
     "text-messaging": "sms",
     "text-messages": "sms",
+    "pdf": "pdf-extraction",
+    "pdfs": "pdf-extraction",
+    "pdf-ocr": "pdf-extraction",
+    "pdf-parsing": "pdf-extraction",
+    "pdf-text-extraction": "pdf-extraction",
+    "ocr": "pdf-extraction",
+    "document-ai": "pdf-extraction",
+    "document-extraction": "pdf-extraction",
+    "document-parsing": "pdf-extraction",
+    "invoice-extraction": "pdf-extraction",
+    "invoice-parsing": "pdf-extraction",
+    "receipt-parsing": "pdf-extraction",
+    "receipt-ocr": "pdf-extraction",
+    "nfs-e": "pdf-extraction",
+    "nfse": "pdf-extraction",
+    "boleto": "pdf-extraction",
+    "bookkeeping-ocr": "pdf-extraction",
 };
 export async function listServices(params) {
     // Ping API for analytics (non-blocking, silent fail)

package/dist/tools/recommend.d.ts

@@ -30,6 +30,12 @@ interface Recommendation {
         reason: string;
         trade_off: string;
     }>;
+    community: {
+        total_reports: number;
+        success_rate: string;
+        avg_integration_time: string | null;
+        recommendation_rate: string | null;
+    } | null;
     data_source: string;
 }
 export declare function recommendService(params: RecommendParams): Promise<Recommendation>;

package/dist/tools/recommend.js

@@ -51,13 +51,30 @@ export async function recommendService(params) {
         "content-management": "cms",
         "text-messaging": "sms",
         "text-messages": "sms",
+        "pdf": "pdf-extraction",
+        "pdfs": "pdf-extraction",
+        "pdf-ocr": "pdf-extraction",
+        "pdf-parsing": "pdf-extraction",
+        "pdf-text-extraction": "pdf-extraction",
+        "ocr": "pdf-extraction",
+        "document-ai": "pdf-extraction",
+        "document-extraction": "pdf-extraction",
+        "document-parsing": "pdf-extraction",
+        "invoice-extraction": "pdf-extraction",
+        "invoice-parsing": "pdf-extraction",
+        "receipt-parsing": "pdf-extraction",
+        "receipt-ocr": "pdf-extraction",
+        "nfs-e": "pdf-extraction",
+        "nfse": "pdf-extraction",
+        "boleto": "pdf-extraction",
+        "bookkeeping-ocr": "pdf-extraction",
     };
     const resolvedNeed = categoryAliases[params.need.toLowerCase()] || params.need.toLowerCase();
     const category = recommendations[resolvedNeed];
     if (!category) {
         return {
             provider: "unknown",
-            reason: `No recommendations available for category: ${params.need}. Supported: database, email, auth, deploy, payments, search, cms, storage, monitoring, cache, queues, vector, llm, sms, feature-flags, cron`,
+            reason: `No recommendations available for category: ${params.need}. Supported: database, email, auth, deploy, payments, search, cms, storage, monitoring, cache, queues, vector, llm, sms, feature-flags, cron, pdf-extraction`,
             pricing: { model: "unknown", free_tier: "unknown", paid_starts_at: "unknown" },
             risks: [],
             warnings: [`No services found for category: ${params.need}. Check auxiliar.ai for supported categories.`],
@@ -72,12 +89,46 @@ export async function recommendService(params) {
             mcp_install: null,
             mcp_note: null,
             alternatives: [],
+            community: null,
             data_source: "auxiliar.ai bundled data",
         };
     }
+    // Fetch community feedback for all services in this category (non-blocking, best-effort)
+    const communityStats = {};
+    try {
+        const feedbackPromises = category.services.map(async (svc) => {
+            try {
+                const resp = await fetch(`https://auxiliar.ai/api/feedback?service=${svc.slug}`, { signal: AbortSignal.timeout(3000) });
+                const data = await resp.json();
+                if (data.stats)
+                    communityStats[svc.slug] = data.stats;
+            }
+            catch { }
+        });
+        await Promise.all(feedbackPromises);
+    }
+    catch { }
     // Score each service based on constraints
     const scored = category.services.map((svc) => {
         let score = svc.default_score || 5;
+        // Community feedback boost/penalty
+        // Verified reports have 1.5x weight, anonymous reports have 1.0x weight
+        const feedback = communityStats[svc.slug];
+        if (feedback) {
+            const verifiedReports = feedback.verified_reports || 0;
+            const anonymousReports = feedback.total_reports - verifiedReports;
+            const weightedReports = anonymousReports * 1.0 + verifiedReports * 1.5;
+            const successRate = feedback.total_reports > 0 ? (feedback.outcomes.success / feedback.total_reports) : 0;
+            if (weightedReports >= 3 && successRate >= 0.8)
+                score += 2;
+            if (weightedReports >= 3 && successRate < 0.5)
+                score -= 3;
+            if (weightedReports >= 5)
+                score += 1; // bonus for well-tested services
+            // Extra boost for verified credibility
+            if (verifiedReports >= 2 && successRate >= 0.8)
+                score += 1;
+        }
         // Budget filter
         if (params.budget === "free" && svc.has_free_tier)
             score += 3;
@@ -269,6 +320,12 @@ export async function recommendService(params) {
             reason: a.choose_if,
             trade_off: a.avoid_if,
         })),
+        community: communityStats[top.slug] ? {
+            total_reports: communityStats[top.slug].total_reports,
+            success_rate: communityStats[top.slug].success_rate,
+            avg_integration_time: communityStats[top.slug].avg_integration_time,
+            recommendation_rate: communityStats[top.slug].recommendation_rate,
+        } : null,
         data_source: `auxiliar.ai bundled data, last updated ${top.last_reviewed}`,
     };
 }

package/dist/tools/solve.d.ts

@@ -0,0 +1,31 @@
+import { type SolveTask } from "../data/solve.js";
+interface SolveTaskParams {
+    task_slug?: string;
+    category?: string;
+}
+interface SolveTaskResult {
+    task?: SolveTask;
+    matches?: SolveTask[];
+    error?: string;
+    available_tasks?: Array<{
+        slug: string;
+        title: string;
+        categories: string[];
+    }>;
+}
+export declare function solveTask(params: SolveTaskParams): Promise<SolveTaskResult>;
+interface ListSolveTasksResult {
+    tasks: Array<{
+        slug: string;
+        title: string;
+        url: string;
+        categories: string[];
+        works_with: string[];
+        last_verified: string;
+        candidate_count: number;
+        top_pick: string;
+    }>;
+    total_tasks: number;
+}
+export declare function listSolveTasks(): Promise<ListSolveTasksResult>;
+export {};

package/dist/tools/solve.js

@@ -0,0 +1,85 @@
+import { solveTasks } from "../data/solve.js";
+import { pingApi } from "./analytics.js";
+// Keyword aliases so an agent searching by concept still lands on the right
+// task. Kept separate from the category-alias maps in list.ts / recommend.ts
+// because /solve/ tasks are about *jobs to be done*, not service categories.
+const taskAliases = {
+    // PDF text extraction task
+    "pdf": "pdf-text-extraction-mcp",
+    "pdfs": "pdf-text-extraction-mcp",
+    "pdf-extraction": "pdf-text-extraction-mcp",
+    "pdf-text": "pdf-text-extraction-mcp",
+    "pdf-text-extraction": "pdf-text-extraction-mcp",
+    "pdf-ocr": "pdf-text-extraction-mcp",
+    "ocr": "pdf-text-extraction-mcp",
+    "document-ai": "pdf-text-extraction-mcp",
+    "document-extraction": "pdf-text-extraction-mcp",
+    "invoice-extraction": "pdf-text-extraction-mcp",
+    "invoice-parsing": "pdf-text-extraction-mcp",
+    "receipt-parsing": "pdf-text-extraction-mcp",
+    "receipt-ocr": "pdf-text-extraction-mcp",
+    "nfs-e": "pdf-text-extraction-mcp",
+    "nfse": "pdf-text-extraction-mcp",
+    "boleto": "pdf-text-extraction-mcp",
+    "bookkeeping-ocr": "pdf-text-extraction-mcp",
+};
+function resolveSlug(raw) {
+    const lower = raw.toLowerCase().trim();
+    return taskAliases[lower] || lower;
+}
+function taskSummary(task) {
+    return {
+        slug: task.slug,
+        title: task.title,
+        categories: task.categories,
+    };
+}
+export async function solveTask(params) {
+    pingApi("solve_task", { task_slug: params.task_slug, category: params.category }).catch(() => { });
+    // Slug lookup (with alias resolution)
+    if (params.task_slug) {
+        const resolved = resolveSlug(params.task_slug);
+        const task = solveTasks[resolved];
+        if (task) {
+            return { task };
+        }
+        return {
+            error: `No /solve/ task found for slug or alias: ${params.task_slug}`,
+            available_tasks: Object.values(solveTasks).map(taskSummary),
+        };
+    }
+    // Category filter
+    if (params.category) {
+        const cat = params.category.toLowerCase().trim();
+        const matches = Object.values(solveTasks).filter((t) => t.categories.some((c) => c.toLowerCase() === cat) ||
+            t.categories.some((c) => c.toLowerCase().includes(cat)));
+        if (matches.length === 0) {
+            return {
+                error: `No /solve/ tasks found for category: ${params.category}`,
+                available_tasks: Object.values(solveTasks).map(taskSummary),
+            };
+        }
+        return { matches };
+    }
+    return {
+        error: "Provide either task_slug or category.",
+        available_tasks: Object.values(solveTasks).map(taskSummary),
+    };
+}
+export async function listSolveTasks() {
+    pingApi("list_solve_tasks", {}).catch(() => { });
+    const tasks = Object.values(solveTasks).map((t) => ({
+        slug: t.slug,
+        title: t.title,
+        url: t.url,
+        categories: t.categories,
+        works_with: t.works_with,
+        last_verified: t.last_verified,
+        candidate_count: t.candidates.length,
+        top_pick: t.candidates.find((c) => c.rank === 1)?.name || t.candidates[0]?.name || "",
+    }));
+    return {
+        tasks,
+        total_tasks: tasks.length,
+    };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "auxiliar-mcp",
-  "version": "0.7.0",
-  "description": "MCP server that keeps your AI agent's infrastructure knowledge current. Chrome-verified pricing, risk flags, compatibility checks, and setup guides for 74 cloud services.",
+  "version": "0.9.0",
+  "description": "MCP server that keeps your AI agent's infrastructure knowledge current. Chrome-verified pricing, risk flags, compatibility checks, setup guides for 77 cloud services and local agent tools, plus /solve/ task rankings with reproducible evals for agent-installable tooling (skills, MCPs, APIs, local binaries).",
   "type": "module",
   "main": "dist/server.js",
   "bin": {
@@ -20,11 +20,14 @@
   },
   "keywords": [
     "mcp",
+    "mcp-server",
     "model-context-protocol",
     "ai-agent",
     "claude-code",
     "cursor",
+    "windsurf",
     "cloud-services",
+    "pricing",
     "developer-tools",
     "neon",
     "resend",