@ansvar/ch-farm-safety-mcp 0.1.0

package/src/server.ts

@@ -0,0 +1,219 @@
+#!/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 { handleSearchSafetyRules } from './tools/search-safety-rules.js';
+import { handleGetRiskAssessmentRequirements } from './tools/get-risk-assessment-requirements.js';
+import { handleGetMachinerySafety } from './tools/get-machinery-safety.js';
+import { handleGetChemicalSafety } from './tools/get-chemical-safety.js';
+import { handleGetYoungWorkerRules } from './tools/get-young-worker-rules.js';
+import { handleGetAccidentReporting } from './tools/get-accident-reporting.js';
+import { handleSearchBulGuidance } from './tools/search-bul-guidance.js';
+
+const SERVER_NAME = 'ch-farm-safety-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_safety_rules',
+    description: 'Search Swiss farm workplace safety rules (BUL lebenswichtige Regeln, Suva, EKAS). Use for broad queries about farm safety in Switzerland.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        query: { type: 'string', description: 'Free-text search query (German or English)' },
+        topic: { type: 'string', description: 'Filter by safety area: maschinen, tiere, wald, hoehe, chemie, silogas, allgemein' },
+        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_risk_assessment_requirements',
+    description: 'Get risk assessment (Risikobeurteilung) obligations for farm activities. Based on EKAS Branchenloesung Landwirtschaft and VUV.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        activity_type: { type: 'string', description: 'Activity type (e.g. Alleinarbeit, Siloarbeiten, Holzerei, Tierhaltung)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+    },
+  },
+  {
+    name: 'get_machinery_safety',
+    description: 'Get safety requirements for agricultural machinery. Covers ROPS, Gurtpflicht, MFK, speed limits, PTO guards.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        machine_type: { type: 'string', description: 'Machine type (e.g. Traktor, Maehdrescher, Motorsaege, Kreiselmaeher)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+    },
+  },
+  {
+    name: 'get_chemical_safety',
+    description: 'Get chemical safety data: exposure limits (MAK), required PPE, and storage rules. Covers PSM (Pflanzenschutzmittel), Silogas, Duenger.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        substance_type: { type: 'string', description: 'Substance type (e.g. Pflanzenschutzmittel, Silogas, Ammoniak, Dieselkraftstoff)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+    },
+  },
+  {
+    name: 'get_young_worker_rules',
+    description: 'Get restrictions for young workers (Jugendarbeitsschutz) on Swiss farms. Covers age thresholds, allowed/forbidden tasks, exceptions for family farms.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        age_group: { type: 'string', description: 'Age group (e.g. unter-13, 13-15, 15-18)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+    },
+  },
+  {
+    name: 'get_accident_reporting',
+    description: 'Get accident reporting obligations: deadlines, forms, and responsible insurer (Suva for employees, private for self-employed).',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        severity: { type: 'string', description: 'Accident severity (e.g. toedlich, schwer, leicht, Berufskrankheit)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+    },
+  },
+  {
+    name: 'search_bul_guidance',
+    description: 'Search BUL/SPAA safety guidance documents, fact sheets, and campaigns. Returns topic, title, description, and URL.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        query: { type: 'string', description: 'Free-text search query (German or English)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+      required: ['query'],
+    },
+  },
+];
+
+const SearchArgsSchema = z.object({
+  query: z.string(),
+  topic: z.string().optional(),
+  jurisdiction: z.string().optional(),
+  limit: z.number().optional(),
+});
+
+const RiskAssessmentArgsSchema = z.object({
+  activity_type: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const MachinerySafetyArgsSchema = z.object({
+  machine_type: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const ChemicalSafetyArgsSchema = z.object({
+  substance_type: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const YoungWorkerArgsSchema = z.object({
+  age_group: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const AccidentReportingArgsSchema = z.object({
+  severity: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const BulGuidanceArgsSchema = z.object({
+  query: z.string(),
+  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_safety_rules':
+        return textResult(handleSearchSafetyRules(db, SearchArgsSchema.parse(args)));
+      case 'get_risk_assessment_requirements':
+        return textResult(handleGetRiskAssessmentRequirements(db, RiskAssessmentArgsSchema.parse(args)));
+      case 'get_machinery_safety':
+        return textResult(handleGetMachinerySafety(db, MachinerySafetyArgsSchema.parse(args)));
+      case 'get_chemical_safety':
+        return textResult(handleGetChemicalSafety(db, ChemicalSafetyArgsSchema.parse(args)));
+      case 'get_young_worker_rules':
+        return textResult(handleGetYoungWorkerRules(db, YoungWorkerArgsSchema.parse(args)));
+      case 'get_accident_reporting':
+        return textResult(handleGetAccidentReporting(db, AccidentReportingArgsSchema.parse(args)));
+      case 'search_bul_guidance':
+        return textResult(handleSearchBulGuidance(db, BulGuidanceArgsSchema.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 Farm Safety MCP',
+    description:
+      'Swiss farm workplace safety data based on BUL/SPAA safety rules, Suva requirements, ' +
+      'EKAS Branchenloesung Landwirtschaft, and Agriss accident statistics. Covers machinery safety (ROPS, MFK), ' +
+      'chemical exposure (PSM-Anwenderschutz), young worker restrictions, accident reporting obligations, ' +
+      'risk assessment requirements, and first aid / emergency numbers for Swiss agriculture.',
+    version: '0.1.0',
+    jurisdiction: [...SUPPORTED_JURISDICTIONS],
+    data_sources: [
+      'BUL/SPAA — Sicherheitsregeln, Merkblaetter',
+      'Suva — Arbeitssicherheit Landwirtschaft, MAK-Werte',
+      'EKAS — Branchenloesung Landwirtschaft',
+      'Agriss — Unfallstatistik Schweizer Landwirtschaft',
+    ],
+    tools_count: 10,
+    links: {
+      homepage: 'https://ansvar.eu/open-agriculture',
+      repository: 'https://github.com/ansvar-systems/ch-farm-safety-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-farm-safety-mcp',
+    _meta: buildMeta(),
+  };
+}

package/src/tools/get-accident-reporting.ts

@@ -0,0 +1,52 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface AccidentReportingArgs {
+  severity?: string;
+  jurisdiction?: string;
+}
+
+export function handleGetAccidentReporting(db: Database, args: AccidentReportingArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  if (args.severity) {
+    const results = db.all<{
+      id: number; severity: string; obligation: string;
+      deadline: string; form: string; insurer: string;
+    }>(
+      'SELECT * FROM accident_reporting WHERE LOWER(severity) LIKE LOWER(?) AND jurisdiction = ?',
+      [`%${args.severity}%`, jv.jurisdiction]
+    );
+
+    if (results.length === 0) {
+      return {
+        error: 'not_found',
+        message: `No reporting obligations found for severity '${args.severity}'.`,
+      };
+    }
+
+    return {
+      severity: args.severity,
+      jurisdiction: jv.jurisdiction,
+      results_count: results.length,
+      results,
+      _meta: buildMeta({ source_url: 'https://www.suva.ch/de-ch/unfall-melden' }),
+    };
+  }
+
+  const all = db.all<{
+    severity: string; obligation: string; deadline: string; form: string; insurer: string;
+  }>(
+    'SELECT severity, obligation, deadline, form, insurer FROM accident_reporting WHERE jurisdiction = ? ORDER BY severity',
+    [jv.jurisdiction]
+  );
+
+  return {
+    jurisdiction: jv.jurisdiction,
+    results_count: all.length,
+    results: all,
+    _meta: buildMeta({ source_url: 'https://www.suva.ch/de-ch/unfall-melden' }),
+  };
+}

package/src/tools/get-chemical-safety.ts

@@ -0,0 +1,52 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface ChemicalSafetyArgs {
+  substance_type?: string;
+  jurisdiction?: string;
+}
+
+export function handleGetChemicalSafety(db: Database, args: ChemicalSafetyArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  if (args.substance_type) {
+    const results = db.all<{
+      id: number; substance_type: string; exposure_limit: string;
+      ppe_required: string; storage_rule: string;
+    }>(
+      'SELECT * FROM chemical_safety WHERE LOWER(substance_type) LIKE LOWER(?) AND jurisdiction = ?',
+      [`%${args.substance_type}%`, jv.jurisdiction]
+    );
+
+    if (results.length === 0) {
+      return {
+        error: 'not_found',
+        message: `No chemical safety data found for substance type '${args.substance_type}'.`,
+      };
+    }
+
+    return {
+      substance_type: args.substance_type,
+      jurisdiction: jv.jurisdiction,
+      results_count: results.length,
+      results,
+      _meta: buildMeta({ source_url: 'https://www.suva.ch/de-ch/praevention/sachthemen/chemische-produkte' }),
+    };
+  }
+
+  const all = db.all<{
+    substance_type: string; exposure_limit: string; ppe_required: string; storage_rule: string;
+  }>(
+    'SELECT substance_type, exposure_limit, ppe_required, storage_rule FROM chemical_safety WHERE jurisdiction = ? ORDER BY substance_type',
+    [jv.jurisdiction]
+  );
+
+  return {
+    jurisdiction: jv.jurisdiction,
+    results_count: all.length,
+    results: all,
+    _meta: buildMeta({ source_url: 'https://www.suva.ch/de-ch/praevention/sachthemen/chemische-produkte' }),
+  };
+}

package/src/tools/get-machinery-safety.ts

@@ -0,0 +1,52 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface MachinerySafetyArgs {
+  machine_type?: string;
+  jurisdiction?: string;
+}
+
+export function handleGetMachinerySafety(db: Database, args: MachinerySafetyArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  if (args.machine_type) {
+    const results = db.all<{
+      id: number; machine_type: string; requirement: string;
+      certification: string; notes: string;
+    }>(
+      'SELECT * FROM machinery_safety WHERE LOWER(machine_type) LIKE LOWER(?) AND jurisdiction = ?',
+      [`%${args.machine_type}%`, jv.jurisdiction]
+    );
+
+    if (results.length === 0) {
+      return {
+        error: 'not_found',
+        message: `No machinery safety requirements found for '${args.machine_type}'.`,
+      };
+    }
+
+    return {
+      machine_type: args.machine_type,
+      jurisdiction: jv.jurisdiction,
+      results_count: results.length,
+      results,
+      _meta: buildMeta({ source_url: 'https://www.bul.ch/de/themen/maschinen' }),
+    };
+  }
+
+  const all = db.all<{
+    machine_type: string; requirement: string; certification: string;
+  }>(
+    'SELECT machine_type, requirement, certification FROM machinery_safety WHERE jurisdiction = ? ORDER BY machine_type',
+    [jv.jurisdiction]
+  );
+
+  return {
+    jurisdiction: jv.jurisdiction,
+    results_count: all.length,
+    results: all,
+    _meta: buildMeta({ source_url: 'https://www.bul.ch/de/themen/maschinen' }),
+  };
+}

package/src/tools/get-risk-assessment-requirements.ts

@@ -0,0 +1,52 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface RiskAssessmentArgs {
+  activity_type?: string;
+  jurisdiction?: string;
+}
+
+export function handleGetRiskAssessmentRequirements(db: Database, args: RiskAssessmentArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  if (args.activity_type) {
+    const results = db.all<{
+      id: number; activity_type: string; requirement: string;
+      content: string; update_trigger: string; legal_basis: string;
+    }>(
+      'SELECT * FROM risk_assessments WHERE LOWER(activity_type) LIKE LOWER(?) AND jurisdiction = ?',
+      [`%${args.activity_type}%`, jv.jurisdiction]
+    );
+
+    if (results.length === 0) {
+      return {
+        error: 'not_found',
+        message: `No risk assessment requirements found for activity type '${args.activity_type}'.`,
+      };
+    }
+
+    return {
+      activity_type: args.activity_type,
+      jurisdiction: jv.jurisdiction,
+      results_count: results.length,
+      results,
+      _meta: buildMeta({ source_url: 'https://www.bul.ch/de/themen/risikobeurteilung' }),
+    };
+  }
+
+  const all = db.all<{
+    activity_type: string; requirement: string; legal_basis: string;
+  }>(
+    'SELECT activity_type, requirement, legal_basis FROM risk_assessments WHERE jurisdiction = ? ORDER BY activity_type',
+    [jv.jurisdiction]
+  );
+
+  return {
+    jurisdiction: jv.jurisdiction,
+    results_count: all.length,
+    results: all,
+    _meta: buildMeta({ source_url: 'https://www.bul.ch/de/themen/risikobeurteilung' }),
+  };
+}

package/src/tools/get-young-worker-rules.ts

@@ -0,0 +1,52 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface YoungWorkerArgs {
+  age_group?: string;
+  jurisdiction?: string;
+}
+
+export function handleGetYoungWorkerRules(db: Database, args: YoungWorkerArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  if (args.age_group) {
+    const results = db.all<{
+      id: number; age_group: string; restriction: string;
+      exception: string; legal_basis: string;
+    }>(
+      'SELECT * FROM young_worker_rules WHERE LOWER(age_group) LIKE LOWER(?) AND jurisdiction = ?',
+      [`%${args.age_group}%`, jv.jurisdiction]
+    );
+
+    if (results.length === 0) {
+      return {
+        error: 'not_found',
+        message: `No rules found for age group '${args.age_group}'.`,
+      };
+    }
+
+    return {
+      age_group: args.age_group,
+      jurisdiction: jv.jurisdiction,
+      results_count: results.length,
+      results,
+      _meta: buildMeta({ source_url: 'https://www.seco.admin.ch/seco/de/home/Arbeit/Arbeitsbedingungen/jugendarbeitsschutz.html' }),
+    };
+  }
+
+  const all = db.all<{
+    age_group: string; restriction: string; exception: string; legal_basis: string;
+  }>(
+    'SELECT age_group, restriction, exception, legal_basis FROM young_worker_rules WHERE jurisdiction = ? ORDER BY age_group',
+    [jv.jurisdiction]
+  );
+
+  return {
+    jurisdiction: jv.jurisdiction,
+    results_count: all.length,
+    results: all,
+    _meta: buildMeta({ source_url: 'https://www.seco.admin.ch/seco/de/home/Arbeit/Arbeitsbedingungen/jugendarbeitsschutz.html' }),
+  };
+}

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: 'BUL/SPAA — Sicherheitsregeln und Merkblaetter',
+      authority: 'Beratungsstelle fuer Unfallverhuetung in der Landwirtschaft (BUL)',
+      official_url: 'https://www.bul.ch',
+      retrieval_method: 'PDF_EXTRACT + HTML_SCRAPE',
+      update_frequency: 'periodic (rules updated as needed)',
+      license: 'Swiss public-sector information — free reuse',
+      coverage: 'Lebenswichtige Regeln per Arbeitsbereich, Merkblaetter, Safe@Work-Kampagne',
+      last_retrieved: lastIngest?.value,
+    },
+    {
+      name: 'Suva — Arbeitssicherheit Landwirtschaft',
+      authority: 'Schweizerische Unfallversicherungsanstalt (Suva)',
+      official_url: 'https://www.suva.ch/de-ch/praevention/nach-branche/landwirtschaft',
+      retrieval_method: 'PDF_EXTRACT + HTML_SCRAPE',
+      update_frequency: 'periodic',
+      license: 'Swiss public-sector information — free reuse',
+      coverage: 'MAK-Werte, Grenzwerte, Unfallmeldung, PSA-Anforderungen',
+      last_retrieved: lastIngest?.value,
+    },
+    {
+      name: 'EKAS — Branchenloesung Landwirtschaft',
+      authority: 'Eidgenoessische Koordinationskommission fuer Arbeitssicherheit (EKAS)',
+      official_url: 'https://www.ekas.admin.ch',
+      retrieval_method: 'PDF_EXTRACT',
+      update_frequency: 'periodic',
+      license: 'Swiss Federal Administration — free reuse',
+      coverage: 'ASA-Konzept, systematische Sicherheitsarbeit, Branchenspezifisches',
+      last_retrieved: lastIngest?.value,
+    },
+    {
+      name: 'Agriss — Unfallstatistik Schweizer Landwirtschaft',
+      authority: 'BUL / Agroscope',
+      official_url: 'https://www.bul.ch/de/themen/unfallstatistik',
+      retrieval_method: 'PDF_EXTRACT',
+      update_frequency: 'annual',
+      license: 'Swiss public-sector information — free reuse',
+      coverage: 'Toedliche und schwere Unfaelle, Unfallursachen, saisonale Verteilung',
+      last_retrieved: lastIngest?.value,
+    },
+  ];
+
+  return {
+    sources,
+    _meta: buildMeta(),
+  };
+}

package/src/tools/search-bul-guidance.ts

@@ -0,0 +1,51 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface BulGuidanceArgs {
+  query: string;
+  jurisdiction?: string;
+}
+
+export function handleSearchBulGuidance(db: Database, args: BulGuidanceArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  // Search bul_guidance table using LIKE since it is not indexed in FTS
+  const words = args.query.split(/\s+/).filter(w => w.length > 1);
+  if (words.length === 0) {
+    return {
+      query: args.query,
+      jurisdiction: jv.jurisdiction,
+      results_count: 0,
+      results: [],
+      _meta: buildMeta({ source_url: 'https://www.bul.ch' }),
+    };
+  }
+
+  const conditions = words.map(() =>
+    '(LOWER(topic) LIKE LOWER(?) OR LOWER(title) LIKE LOWER(?) OR LOWER(description) LIKE LOWER(?))'
+  ).join(' AND ');
+  const params: unknown[] = words.flatMap(w => [`%${w}%`, `%${w}%`, `%${w}%`]);
+  params.push(jv.jurisdiction);
+
+  const results = db.all<{
+    id: number; topic: string; title: string; description: string; url: string;
+  }>(
+    `SELECT * FROM bul_guidance WHERE ${conditions} AND jurisdiction = ? ORDER BY topic LIMIT 20`,
+    params
+  );
+
+  return {
+    query: args.query,
+    jurisdiction: jv.jurisdiction,
+    results_count: results.length,
+    results: results.map(r => ({
+      topic: r.topic,
+      title: r.title,
+      description: r.description,
+      url: r.url,
+    })),
+    _meta: buildMeta({ source_url: 'https://www.bul.ch' }),
+  };
+}