@ansvar/ch-pest-management-mcp 0.1.0

package/src/server.ts

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+import { createDatabase } from './db.js';
+import { handleAbout } from './tools/about.js';
+import { handleListSources } from './tools/list-sources.js';
+import { handleCheckFreshness } from './tools/check-freshness.js';
+import { handleSearchPests } from './tools/search-pests.js';
+import { handleGetPestDetails } from './tools/get-pest-details.js';
+import { handleGetTreatments } from './tools/get-treatments.js';
+import { handleGetIpmGuidance } from './tools/get-ipm-guidance.js';
+import { handleSearchCropThreats } from './tools/search-crop-threats.js';
+import { handleIdentifyFromSymptoms } from './tools/identify-from-symptoms.js';
+import { handleGetApprovedProducts } from './tools/get-approved-products.js';
+
+const SERVER_NAME = 'ch-pest-management-mcp';
+const SERVER_VERSION = '0.1.0';
+
+const TOOLS = [
+  {
+    name: 'about',
+    description: 'Get server metadata: name, version, coverage, data sources, and links.',
+    inputSchema: { type: 'object' as const, properties: {} },
+  },
+  {
+    name: 'list_sources',
+    description: 'List all data sources with authority, URL, license, and freshness info.',
+    inputSchema: { type: 'object' as const, properties: {} },
+  },
+  {
+    name: 'check_data_freshness',
+    description: 'Check when data was last ingested, staleness status, and how to trigger a refresh.',
+    inputSchema: { type: 'object' as const, properties: {} },
+  },
+  {
+    name: 'search_pests',
+    description: 'Search pests, diseases, and weeds affecting Swiss crops. Use for broad queries about Schaedlinge, Krankheiten, Unkraeuter.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        query: { type: 'string', description: 'Free-text search query (German or English, e.g. "Blattlaeuse Weizen", "Septoria")' },
+        pest_type: { type: 'string', description: 'Filter by type: insect, disease, or weed' },
+        crop: { type: 'string', description: 'Filter by affected crop (e.g. Winterweizen, Kartoffeln, Reben)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+        limit: { type: 'number', description: 'Max results (default: 20, max: 50)' },
+      },
+      required: ['query'],
+    },
+  },
+  {
+    name: 'get_pest_details',
+    description: 'Get full profile for a pest: lifecycle, identification, crops affected, and treatments. Use pest ID from search_pests.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        pest_id: { type: 'string', description: 'Pest ID (e.g. blattlaeuse, septoria, ackerfuchsschwanz)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+      required: ['pest_id'],
+    },
+  },
+  {
+    name: 'get_treatments',
+    description: 'Get approved chemical and non-chemical controls for a specific pest. Includes products, active substances, and OELN alternatives.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        pest_id: { type: 'string', description: 'Pest ID (e.g. rapsglanzkaefer, krautfaeule)' },
+        approach: { type: 'string', description: 'Filter by approach: chemical, biological, cultural, or mechanical' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+      required: ['pest_id'],
+    },
+  },
+  {
+    name: 'get_ipm_guidance',
+    description: 'Get IPM (Integrierter Pflanzenschutz) guidance for a crop: OELN Schadschwellen, monitoring methods, cultural controls, prognosis systems.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        crop: { type: 'string', description: 'Crop name (e.g. Winterweizen, Kartoffeln, Reben, Apfel)' },
+        pest_id: { type: 'string', description: 'Optional: filter to specific pest' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+      required: ['crop'],
+    },
+  },
+  {
+    name: 'search_crop_threats',
+    description: 'List all pests, diseases, and weeds that threaten a specific crop, with damage thresholds and monitoring advice.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        crop: { type: 'string', description: 'Crop name (e.g. Winterweizen, Winterraps, Kartoffeln)' },
+        growth_stage: { type: 'string', description: 'Optional growth stage filter (e.g. Bestockung, Bluete, Knollenbildung)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+      required: ['crop'],
+    },
+  },
+  {
+    name: 'identify_from_symptoms',
+    description: 'Identify a pest, disease, or weed from symptom descriptions. Returns ranked differential diagnosis.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        symptoms: { type: 'string', description: 'Symptom description (e.g. "gelbe Flecken auf Weizenblaettern", "Frass an Rapsblueten")' },
+        crop: { type: 'string', description: 'Affected crop for narrowing results' },
+        season: { type: 'string', description: 'Time of year (e.g. Fruehling, Sommer, Herbst)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+      required: ['symptoms'],
+    },
+  },
+  {
+    name: 'get_approved_products',
+    description: 'Search approved plant protection products (Pflanzenschutzmittel) from the BLW Verzeichnis. Filter by active substance, target pest, or crop.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        active_substance: { type: 'string', description: 'Active substance name (e.g. Glyphosat, Mancozeb, Spinosad)' },
+        target_pest: { type: 'string', description: 'Target organism (e.g. Blattlaeuse, Unkraeuter, Pilzkrankheiten)' },
+        crop: { type: 'string', description: 'Target crop (e.g. Winterweizen, Kartoffeln, Reben)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+    },
+  },
+];
+
+const SearchPestsArgsSchema = z.object({
+  query: z.string(),
+  pest_type: z.string().optional(),
+  crop: z.string().optional(),
+  jurisdiction: z.string().optional(),
+  limit: z.number().optional(),
+});
+
+const PestDetailsArgsSchema = z.object({
+  pest_id: z.string(),
+  jurisdiction: z.string().optional(),
+});
+
+const TreatmentsArgsSchema = z.object({
+  pest_id: z.string(),
+  approach: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const IpmGuidanceArgsSchema = z.object({
+  crop: z.string(),
+  pest_id: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const CropThreatsArgsSchema = z.object({
+  crop: z.string(),
+  growth_stage: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const IdentifyArgsSchema = z.object({
+  symptoms: z.string(),
+  crop: z.string().optional(),
+  season: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const ApprovedProductsArgsSchema = z.object({
+  active_substance: z.string().optional(),
+  target_pest: z.string().optional(),
+  crop: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+function textResult(data: unknown) {
+  return { content: [{ type: 'text' as const, text: JSON.stringify(data, null, 2) }] };
+}
+
+function errorResult(message: string) {
+  return { content: [{ type: 'text' as const, text: JSON.stringify({ error: message }) }], isError: true };
+}
+
+const db = createDatabase();
+
+const server = new Server(
+  { name: SERVER_NAME, version: SERVER_VERSION },
+  { capabilities: { tools: {} } }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args = {} } = request.params;
+
+  try {
+    switch (name) {
+      case 'about':
+        return textResult(handleAbout());
+      case 'list_sources':
+        return textResult(handleListSources(db));
+      case 'check_data_freshness':
+        return textResult(handleCheckFreshness(db));
+      case 'search_pests':
+        return textResult(handleSearchPests(db, SearchPestsArgsSchema.parse(args)));
+      case 'get_pest_details':
+        return textResult(handleGetPestDetails(db, PestDetailsArgsSchema.parse(args)));
+      case 'get_treatments':
+        return textResult(handleGetTreatments(db, TreatmentsArgsSchema.parse(args)));
+      case 'get_ipm_guidance':
+        return textResult(handleGetIpmGuidance(db, IpmGuidanceArgsSchema.parse(args)));
+      case 'search_crop_threats':
+        return textResult(handleSearchCropThreats(db, CropThreatsArgsSchema.parse(args)));
+      case 'identify_from_symptoms':
+        return textResult(handleIdentifyFromSymptoms(db, IdentifyArgsSchema.parse(args)));
+      case 'get_approved_products':
+        return textResult(handleGetApprovedProducts(db, ApprovedProductsArgsSchema.parse(args)));
+      default:
+        return errorResult(`Unknown tool: ${name}`);
+    }
+  } catch (err) {
+    return errorResult(err instanceof Error ? err.message : String(err));
+  }
+});
+
+async function main(): Promise<void> {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch((err) => {
+  process.stderr.write(`Fatal error: ${err.message}\n`);
+  process.exit(1);
+});

package/src/tools/about.ts

@@ -0,0 +1,28 @@
+import { buildMeta } from '../metadata.js';
+import { SUPPORTED_JURISDICTIONS } from '../jurisdiction.js';
+
+export function handleAbout() {
+  return {
+    name: 'Switzerland Pest Management MCP',
+    description:
+      'Swiss crop protection and pest management data based on the BLW Pflanzenschutzmittelverzeichnis, ' +
+      'Agroscope Pflanzenschutzempfehlungen, OELN-Schadschwellenprinzip, and the Aktionsplan Pflanzenschutzmittel. ' +
+      'Covers pests (insects, diseases, weeds), approved products, IPM guidance, damage thresholds, ' +
+      'and prognosis systems (PhytoPRE, SOPRA, FusaProg) for Swiss agriculture.',
+    version: '0.1.0',
+    jurisdiction: [...SUPPORTED_JURISDICTIONS],
+    data_sources: [
+      'BLW Pflanzenschutzmittelverzeichnis (psm.admin.ch)',
+      'Agroscope Pflanzenschutzempfehlungen',
+      'AGRIDEA OELN-Checklisten (Feldbau, Rebbau, Obstbau)',
+      'Aktionsplan Pflanzenschutzmittel',
+    ],
+    tools_count: 10,
+    links: {
+      homepage: 'https://ansvar.eu/open-agriculture',
+      repository: 'https://github.com/ansvar-systems/ch-pest-management-mcp',
+      mcp_network: 'https://ansvar.ai/mcp',
+    },
+    _meta: buildMeta(),
+  };
+}

package/src/tools/check-freshness.ts

@@ -0,0 +1,42 @@
+import { buildMeta } from '../metadata.js';
+import type { Database } from '../db.js';
+
+interface FreshnessResult {
+  status: 'fresh' | 'stale' | 'unknown';
+  last_ingest: string | null;
+  build_date: string | null;
+  schema_version: string | null;
+  days_since_ingest: number | null;
+  staleness_threshold_days: number;
+  refresh_command: string;
+  _meta: ReturnType<typeof buildMeta>;
+}
+
+const STALENESS_THRESHOLD_DAYS = 90;
+
+export function handleCheckFreshness(db: Database): FreshnessResult {
+  const lastIngest = db.get<{ value: string }>('SELECT value FROM db_metadata WHERE key = ?', ['last_ingest']);
+  const buildDate = db.get<{ value: string }>('SELECT value FROM db_metadata WHERE key = ?', ['build_date']);
+  const schemaVersion = db.get<{ value: string }>('SELECT value FROM db_metadata WHERE key = ?', ['schema_version']);
+
+  let status: 'fresh' | 'stale' | 'unknown' = 'unknown';
+  let daysSinceIngest: number | null = null;
+
+  if (lastIngest?.value) {
+    const ingestDate = new Date(lastIngest.value);
+    const now = new Date();
+    daysSinceIngest = Math.floor((now.getTime() - ingestDate.getTime()) / (1000 * 60 * 60 * 24));
+    status = daysSinceIngest <= STALENESS_THRESHOLD_DAYS ? 'fresh' : 'stale';
+  }
+
+  return {
+    status,
+    last_ingest: lastIngest?.value ?? null,
+    build_date: buildDate?.value ?? null,
+    schema_version: schemaVersion?.value ?? null,
+    days_since_ingest: daysSinceIngest,
+    staleness_threshold_days: STALENESS_THRESHOLD_DAYS,
+    refresh_command: 'gh workflow run ingest.yml -R ansvar-systems/ch-pest-management-mcp',
+    _meta: buildMeta(),
+  };
+}

package/src/tools/get-approved-products.ts

@@ -0,0 +1,68 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface GetApprovedProductsArgs {
+  active_substance?: string;
+  target_pest?: string;
+  crop?: string;
+  jurisdiction?: string;
+}
+
+export function handleGetApprovedProducts(db: Database, args: GetApprovedProductsArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  let sql = 'SELECT * FROM approved_products WHERE jurisdiction = ?';
+  const params: unknown[] = [jv.jurisdiction];
+
+  if (args.active_substance) {
+    sql += ' AND LOWER(active_substance) LIKE LOWER(?)';
+    params.push(`%${args.active_substance}%`);
+  }
+
+  if (args.target_pest) {
+    sql += ' AND LOWER(target_organisms) LIKE LOWER(?)';
+    params.push(`%${args.target_pest}%`);
+  }
+
+  if (args.crop) {
+    sql += ' AND LOWER(crops) LIKE LOWER(?)';
+    params.push(`%${args.crop}%`);
+  }
+
+  sql += ' ORDER BY product_name LIMIT 50';
+
+  const products = db.all<{
+    id: number; w_number: string; product_name: string; active_substance: string;
+    product_type: string; crops: string; target_organisms: string;
+    auflagen: string; wartefrist: string; dosage: string;
+    application_method: string; spe3_buffer: string; aktionsplan_status: string;
+  }>(sql, params);
+
+  return {
+    filters: {
+      active_substance: args.active_substance ?? null,
+      target_pest: args.target_pest ?? null,
+      crop: args.crop ?? null,
+    },
+    jurisdiction: jv.jurisdiction,
+    products_count: products.length,
+    products: products.map(p => ({
+      w_number: p.w_number,
+      product_name: p.product_name,
+      active_substance: p.active_substance,
+      product_type: p.product_type,
+      crops: p.crops,
+      target_organisms: p.target_organisms,
+      auflagen: p.auflagen,
+      wartefrist: p.wartefrist,
+      dosage: p.dosage,
+      application_method: p.application_method,
+      spe3_buffer: p.spe3_buffer,
+      aktionsplan_status: p.aktionsplan_status,
+    })),
+    warning: 'Immer aktuelle Zulassung auf psm.admin.ch pruefen. Fachbewilligung PSM erforderlich.',
+    _meta: buildMeta(),
+  };
+}

package/src/tools/get-ipm-guidance.ts

@@ -0,0 +1,56 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface GetIpmGuidanceArgs {
+  crop: string;
+  pest_id?: string;
+  jurisdiction?: string;
+}
+
+export function handleGetIpmGuidance(db: Database, args: GetIpmGuidanceArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  let sql = 'SELECT g.*, p.name as pest_name, p.pest_type FROM ipm_guidance g LEFT JOIN pests p ON g.pest_id = p.id WHERE LOWER(g.crop) = LOWER(?) AND g.jurisdiction = ?';
+  const params: unknown[] = [args.crop, jv.jurisdiction];
+
+  if (args.pest_id) {
+    sql += ' AND g.pest_id = ?';
+    params.push(args.pest_id);
+  }
+
+  const guidance = db.all<{
+    id: number; crop: string; crop_category: string; pest_id: string;
+    pest_name: string; pest_type: string; threshold: string;
+    monitoring_method: string; cultural_controls: string;
+    prognose_system: string; oeln_requirements: string; notes: string;
+  }>(sql, params);
+
+  if (guidance.length === 0) {
+    return {
+      error: 'not_found',
+      message: `No IPM guidance found for crop '${args.crop}'${args.pest_id ? ` and pest '${args.pest_id}'` : ''}. Try search_pests or search_crop_threats to find valid identifiers.`,
+    };
+  }
+
+  return {
+    crop: args.crop,
+    pest_filter: args.pest_id ?? null,
+    jurisdiction: jv.jurisdiction,
+    guidance_count: guidance.length,
+    guidance: guidance.map(g => ({
+      pest_id: g.pest_id,
+      pest_name: g.pest_name,
+      pest_type: g.pest_type,
+      crop_category: g.crop_category,
+      threshold: g.threshold,
+      monitoring_method: g.monitoring_method,
+      cultural_controls: g.cultural_controls,
+      prognose_system: g.prognose_system,
+      oeln_requirements: g.oeln_requirements,
+      notes: g.notes,
+    })),
+    _meta: buildMeta(),
+  };
+}

package/src/tools/get-pest-details.ts

@@ -0,0 +1,44 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface PestDetailsArgs {
+  pest_id: string;
+  jurisdiction?: string;
+}
+
+export function handleGetPestDetails(db: Database, args: PestDetailsArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  const pest = db.get<{
+    id: string; name: string; pest_type: string; scientific_name: string;
+    crops_affected: string; crop_category: string; lifecycle: string;
+    identification: string; damage_description: string; language: string;
+    jurisdiction: string;
+  }>(
+    'SELECT * FROM pests WHERE (id = ? OR LOWER(name) = LOWER(?)) AND jurisdiction = ?',
+    [args.pest_id, args.pest_id, jv.jurisdiction]
+  );
+
+  if (!pest) {
+    return { error: 'not_found', message: `Pest '${args.pest_id}' not found. Use search_pests to find pest IDs.` };
+  }
+
+  const treatments = db.all<{
+    approach: string; product_name: string; active_substance: string;
+    w_number: string; dosage: string; waiting_period: string;
+    timing: string; restrictions: string; pufferstreifen: string; notes: string;
+  }>(
+    'SELECT approach, product_name, active_substance, w_number, dosage, waiting_period, timing, restrictions, pufferstreifen, notes FROM treatments WHERE pest_id = ? AND jurisdiction = ?',
+    [pest.id, jv.jurisdiction]
+  );
+
+  return {
+    ...pest,
+    crops_affected: pest.crops_affected ? JSON.parse(pest.crops_affected) : [],
+    treatments_count: treatments.length,
+    treatments,
+    _meta: buildMeta(),
+  };
+}

package/src/tools/get-treatments.ts

@@ -0,0 +1,61 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface GetTreatmentsArgs {
+  pest_id: string;
+  approach?: string;
+  jurisdiction?: string;
+}
+
+export function handleGetTreatments(db: Database, args: GetTreatmentsArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  // Verify pest exists
+  const pest = db.get<{ id: string; name: string; pest_type: string }>(
+    'SELECT id, name, pest_type FROM pests WHERE (id = ? OR LOWER(name) = LOWER(?)) AND jurisdiction = ?',
+    [args.pest_id, args.pest_id, jv.jurisdiction]
+  );
+
+  if (!pest) {
+    return { error: 'not_found', message: `Pest '${args.pest_id}' not found. Use search_pests to find pest IDs.` };
+  }
+
+  let sql = 'SELECT * FROM treatments WHERE pest_id = ? AND jurisdiction = ?';
+  const params: unknown[] = [pest.id, jv.jurisdiction];
+
+  if (args.approach) {
+    sql += ' AND approach = ?';
+    params.push(args.approach.toLowerCase());
+  }
+
+  const treatments = db.all<{
+    id: number; pest_id: string; approach: string; product_name: string;
+    active_substance: string; w_number: string; dosage: string;
+    waiting_period: string; timing: string; restrictions: string;
+    pufferstreifen: string; notes: string;
+  }>(sql, params);
+
+  return {
+    pest_id: pest.id,
+    pest_name: pest.name,
+    pest_type: pest.pest_type,
+    approach_filter: args.approach ?? 'all',
+    jurisdiction: jv.jurisdiction,
+    treatments_count: treatments.length,
+    treatments: treatments.map(t => ({
+      approach: t.approach,
+      product_name: t.product_name,
+      active_substance: t.active_substance,
+      w_number: t.w_number,
+      dosage: t.dosage,
+      waiting_period: t.waiting_period,
+      timing: t.timing,
+      restrictions: t.restrictions,
+      pufferstreifen: t.pufferstreifen,
+      notes: t.notes,
+    })),
+    _meta: buildMeta(),
+  };
+}

package/src/tools/identify-from-symptoms.ts

@@ -0,0 +1,64 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import { ftsSearch, type Database } from '../db.js';
+
+interface IdentifyArgs {
+  symptoms: string;
+  crop?: string;
+  season?: string;
+  jurisdiction?: string;
+}
+
+export function handleIdentifyFromSymptoms(db: Database, args: IdentifyArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  // Use FTS to search symptoms + identification descriptions
+  let results = ftsSearch(db, args.symptoms, 30);
+
+  // Filter by crop if provided
+  if (args.crop) {
+    const cropLower = args.crop.toLowerCase();
+    results = results.filter(r =>
+      r.body.toLowerCase().includes(cropLower) ||
+      r.crop_category?.toLowerCase().includes(cropLower)
+    );
+  }
+
+  // Get full pest details for top matches
+  const pestIds = results.slice(0, 10).map(r => {
+    // Extract pest ID from the title (format: "PestName — Type")
+    const pest = db.get<{ id: string; name: string; pest_type: string; scientific_name: string; identification: string; damage_description: string; crops_affected: string }>(
+      `SELECT id, name, pest_type, scientific_name, identification, damage_description, crops_affected FROM pests WHERE LOWER(name) = LOWER(?) OR LOWER(identification) LIKE LOWER(?) LIMIT 1`,
+      [r.title.split(' — ')[0], `%${r.title.split(' — ')[0]}%`]
+    );
+    return pest;
+  }).filter(Boolean);
+
+  // De-duplicate
+  const seen = new Set<string>();
+  const matches = pestIds.filter(p => {
+    if (!p || seen.has(p.id)) return false;
+    seen.add(p.id);
+    return true;
+  });
+
+  return {
+    symptoms: args.symptoms,
+    crop_filter: args.crop ?? null,
+    season: args.season ?? null,
+    jurisdiction: jv.jurisdiction,
+    matches_count: matches.length,
+    possible_matches: matches.map(p => ({
+      pest_id: p!.id,
+      name: p!.name,
+      pest_type: p!.pest_type,
+      scientific_name: p!.scientific_name,
+      identification: p!.identification,
+      damage_description: p!.damage_description,
+      crops_affected: p!.crops_affected ? JSON.parse(p!.crops_affected) : [],
+    })),
+    recommendation: 'Bei Unsicherheit kantonale Pflanzenschutzfachstelle oder AGRIDEA kontaktieren. Bestimmung durch Fachperson empfohlen.',
+    _meta: buildMeta(),
+  };
+}

package/src/tools/list-sources.ts

@@ -0,0 +1,65 @@
+import { buildMeta } from '../metadata.js';
+import type { Database } from '../db.js';
+
+interface Source {
+  name: string;
+  authority: string;
+  official_url: string;
+  retrieval_method: string;
+  update_frequency: string;
+  license: string;
+  coverage: string;
+  last_retrieved?: string;
+}
+
+export function handleListSources(db: Database): { sources: Source[]; _meta: ReturnType<typeof buildMeta> } {
+  const lastIngest = db.get<{ value: string }>('SELECT value FROM db_metadata WHERE key = ?', ['last_ingest']);
+
+  const sources: Source[] = [
+    {
+      name: 'BLW Pflanzenschutzmittelverzeichnis',
+      authority: 'Bundesamt fuer Landwirtschaft (BLW)',
+      official_url: 'https://www.psm.admin.ch/de/produkte',
+      retrieval_method: 'STRUCTURED_EXTRACT',
+      update_frequency: 'continuous (products added/removed as authorisations change)',
+      license: 'Swiss Federal Administration — free reuse',
+      coverage: 'Approved plant protection products: W-number, active substance, crops, auflagen, wartefrist',
+      last_retrieved: lastIngest?.value,
+    },
+    {
+      name: 'Agroscope Pflanzenschutzempfehlungen / Schadschwellen',
+      authority: 'Agroscope',
+      official_url: 'https://www.agroscope.admin.ch/agroscope/de/home/themen/pflanzenbau/pflanzenschutz.html',
+      retrieval_method: 'PDF_EXTRACT',
+      update_frequency: 'annual (updated per growing season)',
+      license: 'Swiss Federal Administration — free reuse',
+      coverage: 'Damage thresholds, monitoring methods, prognosis systems (PhytoPRE, SOPRA, FusaProg)',
+      last_retrieved: lastIngest?.value,
+    },
+    {
+      name: 'AGRIDEA OELN-Pflanzenschutz-Checklisten',
+      authority: 'AGRIDEA',
+      official_url: 'https://www.agridea.ch/de/themen/pflanzenbau/pflanzenschutz/',
+      retrieval_method: 'PDF_EXTRACT',
+      update_frequency: 'annual',
+      license: 'Public advisory material',
+      coverage: 'OELN crop protection requirements, approved products lists (Feldbau, Rebbau, Obstbau)',
+      last_retrieved: lastIngest?.value,
+    },
+    {
+      name: 'Aktionsplan Pflanzenschutzmittel',
+      authority: 'Bundesrat / BLW',
+      official_url: 'https://www.blw.admin.ch/blw/de/home/nachhaltige-produktion/pflanzenschutz/aktionsplan.html',
+      retrieval_method: 'PDF_EXTRACT',
+      update_frequency: 'periodic (adopted 2017, targets to 2027)',
+      license: 'Swiss Federal Administration — free reuse',
+      coverage: '50% risk reduction targets, indicators, IPM strategy, buffer zone requirements',
+      last_retrieved: lastIngest?.value,
+    },
+  ];
+
+  return {
+    sources,
+    _meta: buildMeta(),
+  };
+}