'use strict';
const db = require('./db.js');
const { McpServer } = require('@modelcontextprotocol/sdk/server/mcp.js');
const { z } = require('zod');

// ── Helpers ────────────────────────────────────────────────
function today() {
  return new Date().toISOString().slice(0, 10);
}

function json(obj) {
  return { content: [{ type: 'text', text: JSON.stringify(obj, null, 2) }] };
}

function errResult(msg) {
  return { content: [{ type: 'text', text: JSON.stringify({ error: msg }) }], isError: true };
}

// Like the HTTP safeErr: only surface error text on db.isSafeError's allowlist
// (validator messages); otherwise return a generic message so unexpected errors
// — raw SQLite "constraint failed: <table>.<col>", fs paths, etc. — don't leak
// schema/internals to the MCP client. Use for caught exceptions; intentional
// tool messages still pass through errResult() directly.
function safeErrResult(e) {
  const msg = String((e && e.message) || '');
  return errResult(db.isSafeError(msg) ? msg : 'Internal error');
}

// Build a map of bagId → current location by replaying scan log
function buildBagLocationMap(scanLog) {
  const map = new Map();
  for (const e of scanLog) {
    if (e.action === 'ADD' && e.to) {
      map.set(e.bag, e.to);
    } else if (e.action === 'MOVE' && e.to) {
      map.set(e.bag, e.to);
    } else if (e.action === 'REMOVE') {
      map.delete(e.bag);
    }
  }
  return map;
}

// ── ZPL Label Generation ─────────────────────────────────
// Ported from app.js — server-side copy so MCP tools can generate labels
// without a browser. Canvas is 400×240 dots (50×30mm @ 203dpi).

function bcParams(val, qzMult) {
  const mods = 35 + val.length * 11;
  let mw = 3;
  qzMult = qzMult || 10;
  const qz = (m) => m * qzMult;
  while (mw > 1 && mods * mw + 2 * qz(mw) > 400) mw--;
  const w = mods * mw;
  return { mw, x: Math.max(qz(mw), Math.round((400 - w) / 2)) };
}

function zplText(s) {
  return String(s || '').replace(/[\^~]/g, '');
}

function fmtDt(d) {
  if (!(d instanceof Date)) d = new Date(d);
  const dd = String(d.getDate()).padStart(2, '0');
  const mm = String(d.getMonth() + 1).padStart(2, '0');
  const yy = String(d.getFullYear()).slice(-2);
  return dd + '.' + mm + '.' + yy;
}

// Label size from LABEL_WIDTH_DOTS / LABEL_HEIGHT_DOTS env vars.
// Default 400×240 dots = 50×30mm at 203dpi (Zebra GK420d small label).
// Field positions in itemsToZPL/bagLabelItems/labLabelItems assume
// 400 dots wide; significantly different sizes need their own layout.
const _LABEL_W = (() => {
  const v = parseInt(process.env.LABEL_WIDTH_DOTS, 10);
  return Number.isFinite(v) && v >= 100 && v <= 4000 ? v : 400;
})();
const _LABEL_H = (() => {
  const v = parseInt(process.env.LABEL_HEIGHT_DOTS, 10);
  return Number.isFinite(v) && v >= 100 && v <= 4000 ? v : 240;
})();
function itemsToZPL(items) {
  // ^LT0/^LS0 reset stored offsets, ^PON/^FWN force normal orientation.
  let z = '^XA^PW' + _LABEL_W + '^LL' + _LABEL_H + '^CI28^LH0,0^LT0^LS0^PON^FWN';
  for (const it of items) {
    if (it.type === 'barcode') {
      z +=
        '^FO' +
        it.x +
        ',' +
        it.y +
        '^BY' +
        it.mw +
        ',2.0,' +
        it.h +
        '^BCN,' +
        it.h +
        ',N,N,N^FD' +
        zplText(it.val) +
        '^FS';
    } else if (it.type === 'text') {
      const fw = it.fontW || it.fontH;
      const bw = it.blockW || 400;
      const bx = it.x || 0;
      z +=
        '^FO' + bx + ',' + it.y + '^FB' + bw + ',1,0,C^A0N,' + it.fontH + ',' + fw + '^FD' + zplText(it.text) + '^FS';
      if (it.bold) {
        z +=
          '^FO' +
          (bx + 1) +
          ',' +
          it.y +
          '^FB' +
          bw +
          ',1,0,C^A0N,' +
          it.fontH +
          ',' +
          fw +
          '^FD' +
          zplText(it.text) +
          '^FS';
      }
    } else if (it.type === 'qr') {
      // Reset label home immediately before QR to ensure ^FO works from true origin.
      z += '^LH0,0^FO' + it.x + ',' + it.y + '^BQN,2,' + (it.mag || 4) + '^FDMA,' + zplText(it.val) + '^FS';
    }
  }
  return z + '^XZ';
}

// Siehe app.js: dieselbe Beschriftung, damit gedruckt und angezeigt nicht
// auseinanderlaufen.
function labelKg(kg) {
  return String(Math.round(kg * 1000) / 1000).replace('.', ',') + 'kg';
}
function bagLabelKg(batch, bagId) {
  const w = batch && batch.bagWeights ? batch.bagWeights[bagId] : null;
  if (Number.isFinite(w) && w > 0) return w;
  return Number.isFinite(batch && batch.bagKg) && batch.bagKg > 0 ? batch.bagKg : null;
}
// Width a centred text line may use. The bottom-right badge sits over the band
// the last line(s) occupy, so any line overlapping it vertically is narrowed to
// stop short — the text re-centres in the space left rather than running under
// the box. Lines clear of the badge keep the full width they always had.
function _lineBlockW(y, fontH, badge) {
  return badge && y < badge.y + badge.h && badge.y < y + fontH ? badge.x - 6 : 400;
}
// ─── Jede Zeile passt ────────────────────────────────────────
// Ein Textfeld auf dem Etikett ist ein ^FB-Block für eine Zeile, und der
// schneidet nichts ab: was nicht hineinpasst, bricht der Drucker um und druckt
// es ÜBER die Zeile. So stand der Stammcode mitten auf "Ganoderma", weil
// "Reishi – 2,0kg – Ganoderma multipileum KQ07" für eine Zeile zu lang war.
// Deshalb geht keine Zeile mehr zum Drucker, die nicht passt: sie wird hier
// gemessen, und was zu lang ist, kommt in die zweite Zeile. Eine Nummer wird
// stattdessen kleiner geschrieben, die liest man in einem Stück.
//
// Die Breiten sind die von Helvetica Bold, in Tausendsteln der Schriftbreite.
// Schrift 0 des Druckers (CG Triumvirate Bold Condensed), an diesem Etikett
// nachgemessen, ist bei Großbuchstaben so breit, bei Ziffern und
// Kleinbuchstaben schmaler; nur den Bindestrich zieht sie breiter, er steht mit
// 600. Dazu 5 % Luft in labelTextW(): was hier passt, passt auf dem Etikett.
// Ein Zeichen, das nicht in der Liste steht, zählt ganz breit.
//
// Dieser Block steht wortgleich in app.js und in mcp-server.js, die beide
// Etiketten drucken; test/etiketten-zeilen.test.js hält die zwei gleich.
const _LABEL_EM = [
  [" \u00a0,./\\|ijlI'\u00b7", 278],
  ['!():;[]ft', 333],
  ['r*{}', 389],
  ['z', 500],
  ['0123456789acekvsxyJ_#$"', 556],
  ['+<=>~', 584],
  ['-', 600],
  ['bdghnopquFLTZ?\u00df', 611],
  ['EPSVXY', 667],
  ['ABCDHKNRU&', 722],
  ['GOQw', 778],
  ['M', 833],
  ['m%', 889],
  ['W', 944],
  ['@', 975]
];
let _labelEmMap = null;
function labelTextW(text, fontW) {
  if (!_labelEmMap) {
    _labelEmMap = new Map();
    for (const [zeichen, breite] of _LABEL_EM) for (const c of zeichen) _labelEmMap.set(c, breite);
  }
  let em = 0;
  // Umlaute und Akzente zählen wie ihr Grundbuchstabe: ä wie a.
  for (const c of String(text)) em += _labelEmMap.get(c) || _labelEmMap.get(c.normalize('NFD')[0]) || 1000;
  return (em * fontW * 1.05) / 1000;
}
// Zeichen, die Schrift 0 nicht hat. Der Gedankenstrich zwischen "Reishi" und
// "2,0kg" kam auf demselben Etikett gar nicht erst heraus, an seiner Stelle
// stand eine Lücke. Ersetzt wird im Text der Zeile selbst und nicht erst beim
// Drucken: so misst labelTextW(), was gedruckt wird, und die Vorschau zeigt es.
const _LABEL_ERSATZ = {
  '\u2013': '-',
  '\u2014': '-',
  '\u2026': '...',
  '\u2190': '<-',
  '\u2192': '->',
  '\u2018': "'",
  '\u2019': "'",
  '\u201a': "'",
  '\u201c': '"',
  '\u201d': '"',
  '\u201e': '"'
};
function labelGlyphs(s) {
  return String(s || '').replace(
    /[\u2013\u2014\u2026\u2190\u2192\u2018-\u201a\u201c-\u201e]/g,
    (c) => _LABEL_ERSATZ[c]
  );
}
// Bricht `text` in höchstens `maxZeilen` Zeilen, keine breiter als `breite(i)`
// — wieviel Platz eine Zeile hat, hängt davon ab, wo sie steht, neben dem
// Zähler unten rechts ist es weniger. Umbrochen wird an Leerzeichen, ein Wort,
// das allein zu lang ist, hinter seinem letzten Bindestrich, der noch passt.
// Bleibt dann noch etwas übrig, endet die letzte Zeile mit "...", und das
// Ergebnis trägt `gekuerzt`.
//
// Der Gedankenstrich zwischen zwei Angaben steht nie am Anfang oder Ende einer
// Zeile, dort trennt schon der Umbruch. Ein geschütztes Leerzeichen hält
// zusammen, was zusammengehört ("<- PD-…"), und wird gedruckt wie ein normales.
function labelWrap(text, fontW, breite, maxZeilen) {
  const w = (s) => labelTextW(s, fontW);
  const rest = String(text || '')
    .split(' ')
    .filter(Boolean)
    .map((s) => ({ s: labelGlyphs(s).replace(/\u00a0/g, ' '), trenner: s === '\u2013' }));
  const alsZeile = (toks) => {
    let a = 0;
    let e = toks.length;
    while (a < e && toks[a].trenner) a++;
    while (e > a && toks[e - 1].trenner) e--;
    return toks
      .slice(a, e)
      .map((x) => x.s)
      .join(' ');
  };
  const zeilen = [];
  while (zeilen.length < maxZeilen) {
    while (rest.length && rest[0].trenner) rest.shift();
    if (!rest.length) break;
    const max = breite(zeilen.length);
    const toks = [];
    while (rest.length && w(alsZeile(toks.concat(rest[0]))) <= max) toks.push(rest.shift());
    if (!toks.length) {
      // Schon das erste Wort allein ist zu breit für die Zeile.
      const wort = rest[0].s;
      let n = Math.max(1, wort.length - 1);
      while (n > 1 && w(wort.slice(0, n)) > max) n--;
      const strich = wort.lastIndexOf('-', n - 1);
      if (strich > 0) n = strich + 1;
      toks.push({ s: wort.slice(0, n), trenner: false });
      if (n < wort.length) rest[0] = { s: wort.slice(n), trenner: false };
      else rest.shift();
    }
    zeilen.push(alsZeile(toks));
  }
  while (rest.length && rest[0].trenner) rest.shift();
  if (rest.length && zeilen.length) {
    // Lieber ein ganzes Wort weglassen als eines anschneiden. Angeschnitten wird
    // nur, was allein in der Zeile steht.
    const max = breite(zeilen.length - 1);
    const woerter = zeilen[zeilen.length - 1].split(' ');
    while (woerter.length > 1 && w(woerter.join(' ') + '...') > max) woerter.pop();
    let letzte = woerter.join(' ');
    while (letzte && w(letzte + '...') > max) letzte = letzte.slice(0, -1);
    zeilen[zeilen.length - 1] = letzte.replace(/[\s-]+$/, '') + '...';
    zeilen.gekuerzt = true;
  }
  return zeilen;
}
// Setzt Absätze untereinander, ab `y`. Ein Absatz ist { text, fontH, bold,
// maxZeilen, minH, kuerzbar }. Jede Zeile bekommt die Breite, die auf ihrer
// Höhe frei ist, und steht 4 Punkte unter der vorigen — die Abstände, die das
// Etikett immer hatte. Zurück kommen die Zeilen und die Unterkante der letzten.
//
// Mit minH ist der Absatz eine Nummer, und die liest man am besten in einem
// Stück: sie wird erst kleiner, bis minH, solange sie dann in eine Zeile
// passt. Passt sie auch so nicht, bekommt sie die größte Schrift, in der sie
// in ihren Zeilen ganz dasteht — umbrochen, aber nicht auch noch winzig.
function labelLines(absaetze, y, badge) {
  const items = [];
  let unten = y;
  for (const a of absaetze) {
    if (!a.text) continue;
    const setze = (h) => {
      const zeileY = (i) => y + i * (h + 4);
      const breite = (i) => _lineBlockW(zeileY(i), h, badge);
      const max = a.maxZeilen === undefined ? 1 : a.maxZeilen;
      return { h, zeileY, breite, zeilen: labelWrap(a.text, h, (i) => breite(i) - 6, max) };
    };
    let satz = null;
    if (a.minH) {
      const groessen = [];
      for (let h = a.fontH; h >= a.minH; h -= 2) groessen.push(h);
      const versuche = groessen.map(setze);
      satz =
        versuche.find((s) => s.zeilen.length === 1 && !s.zeilen.gekuerzt) ||
        versuche.find((s) => !s.zeilen.gekuerzt) ||
        versuche[versuche.length - 1];
    } else {
      satz = setze(a.fontH);
    }
    satz.zeilen.forEach((text, i) => {
      const item = { type: 'text', y: satz.zeileY(i), blockW: satz.breite(i), fontH: satz.h, text: text };
      if (a.bold) item.bold = true;
      items.push(item);
    });
    if (satz.zeilen.length) {
      unten = satz.zeileY(satz.zeilen.length - 1) + satz.h;
      y = unten + 4;
    }
  }
  return { items: items, unten: unten };
}
// Tiefer als die Unterkante des Zählers unten rechts (232) steht kein Text.
const LABEL_UNTEN = 234;
// Code und Zeilen zu einem Etikett. Passt der Text nicht unter den Code, wird
// ein kürzbarer Absatz — die Angaben zur Sorte — eine Zeile kürzer, und seine
// letzte endet mit "...". Reicht auch eine Zeile nicht (unter einem QR, neben
// einer Kultur mit langer Herkunft), fällt er ganz weg. Die Nummer und das
// Datum kürzt nichts.
function labelLayout(bcVal, qr, absaetze, badge) {
  let liste = absaetze;
  for (;;) {
    const versuch = qr ? _labelQr(bcVal, liste, badge) : _labelBarcode(bcVal, liste, badge);
    const i = liste.findIndex((a) => a.kuerzbar && a.maxZeilen > 0);
    if (versuch.passt || i < 0) return versuch.items;
    liste = liste.map((a, j) => (j === i ? Object.assign({}, a, { maxZeilen: a.maxZeilen - 1 }) : a));
  }
}
// Strichcode oben, die Zeilen darunter, das Ganze senkrecht mittig, aber nie
// über y=40: darüber schneidet dieses Material ab. Braucht der Text mehr Platz,
// als unter einem 90 Punkte hohen Code frei ist, gibt der Code Höhe ab, in
// Schritten bis 60 — 7,5 mm liest jede Kamera noch.
function _labelBarcode(bcVal, absaetze, badge) {
  const bc = bcParams(bcVal);
  const hoehe = labelLines(absaetze, 0, null).unten;
  let versuch = null;
  for (let bcH = 90; bcH >= 60; bcH -= 6) {
    const bcY = Math.max(40, Math.round((240 - (bcH + 6 + hoehe)) / 2));
    const text = labelLines(absaetze, bcY + bcH + 6, badge);
    const code = { type: 'barcode', x: bc.x, y: bcY, w: 400 - 2 * bc.x, h: bcH, val: bcVal, mw: bc.mw };
    versuch = { passt: text.unten <= LABEL_UNTEN, items: [code].concat(text.items) };
    if (versuch.passt) break;
  }
  return versuch;
}
// QR oben links, mag 5 → 125 Punkte (25 Module), die Zeilen darunter über die
// ganze Breite.
function _labelQr(bcVal, absaetze, badge) {
  const text = labelLines(absaetze, 155, badge);
  const code = { type: 'qr', x: 0, y: 10, size: 125, mag: 5, val: bcVal };
  return { passt: text.unten <= 240, items: [code].concat(text.items) };
}
function bagLabelItems(bagId, batch, detail, barcodeNum, qr, bagKg) {
  const bcVal = barcodeNum ? String(barcodeNum) : bagId.replace(/-/g, '_');
  // Dieselben Zeilen wie in app.js: die Nummer (lieber kleiner als umbrochen),
  // die Angaben zur Sorte bis zwei Zeilen, bei "full" das Fälligkeitsdatum.
  const absaetze = [{ text: bagId, fontH: qr ? 28 : 24, minH: 18, maxZeilen: 2 }];
  if (detail === 'sorte' || detail === 'full') {
    const species = batch.strainName || batch.species || '';
    const strainTxt = (batch.strainText || '').trim();
    const rawNotes = (batch.notes || '').trim();
    const notes = rawNotes.length > 13 ? rawNotes.slice(0, 13) + '\u2026' : rawNotes;
    const parts = [species];
    if (bagKg != null) parts.push(labelKg(bagKg));
    if (strainTxt) parts.push(strainTxt);
    if (notes) parts.push(notes);
    absaetze.push({ text: parts.filter(Boolean).join(' \u2013 '), fontH: 24, maxZeilen: 2, kuerzbar: true });
  }
  if (detail === 'full' && batch.due) {
    const due = new Date(batch.due);
    const dueStr =
      String(due.getDate()).padStart(2, '0') +
      '.' +
      String(due.getMonth() + 1).padStart(2, '0') +
      '.' +
      due.getFullYear();
    absaetze.push({ text: 'F\u00e4llig: ' + dueStr, fontH: qr ? 24 : 28, minH: 18, bold: true });
  }
  return labelLayout(bcVal, qr, absaetze, null);
}

function labLabelItems(id, c, detail, barcodeNum, qr) {
  // Build info line matching batch label pattern: strainName – strainText – notes(13)
  const species = c.strainName || c.species || '';
  const strainTxt = (c.strainText || '').trim();
  const rawNotes = (c.notes || '').trim();
  const notes = rawNotes.length > 13 ? rawNotes.slice(0, 13) + '\u2026' : rawNotes;
  const spParts = [species];
  if (strainTxt) spParts.push(strainTxt);
  if (notes) spParts.push(notes);
  const bcVal = barcodeNum ? String(barcodeNum) : id.replace(/-/g, '_');
  // Die Herkunft hängt mit einem geschützten Leerzeichen an ihrem Pfeil, wie
  // in app.js: bricht die erste Zeile um, steht "<- PD-…" zusammen darunter.
  const absaetze = [
    { text: c.parentId ? id + ' \u2190\u00a0' + c.parentId : id, fontH: qr ? 28 : 24, minH: 18, maxZeilen: 2 }
  ];
  if (detail === 'sorte' || detail === 'full') {
    absaetze.push({ text: spParts.filter(Boolean).join(' \u2013 '), fontH: 24, maxZeilen: 2, kuerzbar: true });
  }
  if (detail === 'full' && c.created) {
    absaetze.push({ text: fmtDt(c.created), fontH: qr ? 24 : 28, minH: 18, bold: true });
  }
  return labelLayout(bcVal, qr, absaetze, null);
}

// ── MCP Server Factory ────────────────────────────────────
// S-01: `printer` may also carry `auth = { userId, role }` describing
// the bearer token that opened this session. Destructive tools call
// `requireAdminRole(auth)` and short-circuit with an error result when the
// caller is not an admin. The legacy static MCP token is treated as admin
// (preserves historical behaviour); OAuth tokens carry the user's role.
function createMcpServer(database, onWrite, printer) {
  const server = new McpServer({
    name: 'meistertracker',
    version: '1.0.0'
  });

  // Fail closed: with no auth context, default to no role (not admin) so a caller
  // that forgets to pass auth cannot reach admin-only tools. The real server path
  // always supplies printer.auth from checkMcpAuth (legacy static token -> admin).
  const auth = (printer && printer.auth) || { userId: null, role: null, username: null };

  function notify() {
    if (typeof onWrite === 'function') onWrite();
  }

  function isAdminCaller() {
    return !!(auth && auth.role === 'admin');
  }

  // Returns a refusal, or null when the caller may proceed. Every call site
  // reads `const adminErr = requireAdminRole(); if (adminErr) return adminErr;`
  // — truthy means refuse, at all ten of them. A tool that wants to *narrow* an
  // answer rather than refuse it asks isAdminCaller() instead: reusing this one
  // for that would make truthy mean two opposite things, and the next
  // maintainer sweeping for missing `if (adminErr) return adminErr;` would turn
  // the narrowing into a refusal.
  function requireAdminRole() {
    return isAdminCaller() ? null : errResult('admin role required');
  }

  // ──────────────────────────────────────────────────────────
  // READ TOOLS
  // ──────────────────────────────────────────────────────────

  server.tool(
    'daily_briefing',
    "Get today's operational briefing: batches due/overdue, open tasks by assignee, low-stock alerts, and calendar events. READ-ONLY overview — use other tools to take action on items.",
    { date: z.string().optional().describe('ISO date (YYYY-MM-DD), defaults to today') },
    async ({ date }) => {
      const batches = db.getAllBatches(database);
      // The same filter GET /api/data applies. Without it this briefing was the
      // way around it: it hands back task text grouped by assignee, and an MCP
      // token is something any worker can mint for themselves through the OAuth
      // flow. A read hole with two doors is not closed until both are.
      const manualTasks = db
        .getAllTasks(database)
        .filter((t) => db.canUserSeeTask(database, t, auth.username, auth.role === 'admin'));
      const inventory = db.getInventory(database, 20);
      const calendarEvents = db.getCalendarEvents(database);
      const target = date || today();

      // Batches due today or overdue. A contaminated bag is not an active one:
      // a batch with only those left is nothing to act on.
      const bagLoc = db.getStockBagZoneMap(database);
      const dueToday = [];
      const overdue = [];
      for (const b of batches) {
        if (!b.due) continue;
        const dueDate = b.due.slice(0, 10);
        const activeBags = b.bags.filter((id) => bagLoc.has(id));
        if (activeBags.length === 0) continue;
        if (dueDate === target)
          dueToday.push({
            batchId: b.batchId,
            species: b.species,
            strain: b.strain,
            due: b.due,
            activeBags: activeBags.length,
            totalBags: b.bags.length
          });
        else if (dueDate < target)
          overdue.push({
            batchId: b.batchId,
            species: b.species,
            strain: b.strain,
            due: b.due,
            activeBags: activeBags.length,
            totalBags: b.bags.length
          });
      }

      // Open tasks grouped by assignee
      const openTasks = manualTasks.filter((t) => !t.done);
      // S-10: null-prototype accumulator. `assignee` is free text from the
      // task row, and on a plain {} the key "__proto__" is truthy, so the
      // initialiser is skipped and .push() runs on Object.prototype — which
      // has no push, so the tool throws instead of answering.
      const tasksByAssignee = Object.create(null);
      for (const t of openTasks) {
        const key = t.assignee || 'Unassigned';
        if (!tasksByAssignee[key]) tasksByAssignee[key] = [];
        tasksByAssignee[key].push({ id: t.id, text: t.text, priority: t.priority, dueDate: t.dueDate });
      }

      // Low-stock alerts
      const inv = inventory;
      const lowStock = [];
      for (const mat of ['hardwood', 'wheatbran', 'gypsum', 'grain']) {
        const stock = inv.stock[mat];
        const threshold = inv.thresholds[mat].minKg;
        if (stock < threshold) lowStock.push({ material: mat, stockKg: stock, thresholdKg: threshold });
      }

      // Calendar events for today
      const todayEvents = calendarEvents.filter((e) => {
        const start = e.startDate;
        const end = e.endDate || e.startDate;
        return start <= target && end >= target;
      });

      // Maintenance due/overdue
      let maintenanceDue = [];
      try {
        const allDue = db.getMaintenanceDue(database);
        maintenanceDue = allDue.filter((m) => !m.scheduledDate || m.scheduledDate <= target);
      } catch (_) {
        // maintenance_log table may not exist yet
      }

      return json({
        date: target,
        batchesDueToday: dueToday,
        batchesOverdue: overdue,
        openTaskCount: openTasks.length,
        tasksByAssignee,
        lowStockAlerts: lowStock,
        maintenanceDue,
        calendarEvents: todayEvents.map((e) => ({
          id: e.id,
          title: e.title,
          startDate: e.startDate,
          endDate: e.endDate,
          allDay: e.allDay,
          startTime: e.startTime,
          endTime: e.endTime,
          category: e.category,
          assignees: e.assignees
        }))
      });
    }
  );

  server.tool(
    'list_batches',
    'List production batches with optional filters. READ-ONLY listing. To modify batches use update_batch (metadata), add_bags_to_batch (more bags), rename_batch (change ID), or delete_batch (remove entirely).',
    {
      strainId: z
        .number()
        .optional()
        .describe('Filter by Pilzsorte id (exact match). Use list_mushroom_strains to discover ids.'),
      species: z.string().optional().describe('Filter by species (partial match, case-insensitive)'),
      strain: z.string().optional().describe('Filter by strain kuerzel (partial match, case-insensitive)'),
      batchType: z.enum(['block', 'grain', 'liquid']).optional().describe('Filter by batch type'),
      dueBefore: z.string().optional().describe('ISO date — batches due before this date'),
      dueAfter: z.string().optional().describe('ISO date — batches due after this date')
    },
    async (params) => {
      let batches = db.getAllBatches(database);

      if (params.strainId != null) batches = batches.filter((b) => b.strainId === params.strainId);
      if (params.species) {
        const s = params.species.toLowerCase();
        batches = batches.filter((b) => b.species && b.species.toLowerCase().includes(s));
      }
      if (params.strain) {
        const s = params.strain.toLowerCase();
        batches = batches.filter((b) => b.strain && b.strain.toLowerCase().includes(s));
      }
      if (params.batchType) batches = batches.filter((b) => b.batchType === params.batchType);
      if (params.dueBefore) batches = batches.filter((b) => b.due && b.due.slice(0, 10) < params.dueBefore);
      if (params.dueAfter) batches = batches.filter((b) => b.due && b.due.slice(0, 10) > params.dueAfter);

      return json(
        batches.map((b) => ({
          batchId: b.batchId,
          species: b.species,
          strain: b.strain,
          strainId: b.strainId,
          strainName: b.strainName,
          strainKuerzel: b.strainKuerzel,
          qty: b.qty,
          days: b.days,
          batchType: b.batchType,
          created: b.created,
          due: b.due,
          bagCount: b.bags.length,
          notes: b.notes
        }))
      );
    }
  );

  server.tool(
    'get_batch_details',
    'Get full details for a single batch: bags with current locations, scan history, harvest totals, and per-flush breakdown. READ-ONLY. To modify use update_batch, to record harvests use log_harvest, to move bags use move_bags.',
    { batchId: z.string().describe('Batch ID') },
    async ({ batchId }) => {
      const batch = db.readBatchById(database, batchId);
      if (!batch) return errResult('Batch not found: ' + batchId);

      const scanLog = db.getScanLog(database);
      const bagLoc = buildBagLocationMap(scanLog);
      const scans = scanLog.filter((e) => e.batch === batchId);
      const harvests = db.getAllHarvests(database).filter((h) => h.batch === batchId);

      const totalGrams = harvests.reduce((sum, h) => sum + h.grams, 0);
      const byFlush = Object.create(null);
      for (const h of harvests) {
        const key = 'flush_' + h.flush;
        byFlush[key] = (byFlush[key] || 0) + h.grams;
      }

      const bags = batch.bags.map((id) => ({
        bagId: id,
        bagKg: batch.bagWeights ? batch.bagWeights[id] || batch.bagKg || 3 : batch.bagKg || 3,
        currentLocation: bagLoc.get(id) || null,
        harvests: harvests.filter((h) => h.bag === id).map((h) => ({ grams: h.grams, flush: h.flush, time: h.time }))
      }));

      return json({
        ...batch,
        bags,
        scanHistory: scans.slice(-50),
        harvestSummary: { totalGrams, harvestCount: harvests.length, byFlush }
      });
    }
  );

  server.tool(
    'get_zone_overview',
    'Get all zones with rack counts, current bag counts, and capacity utilization. READ-ONLY. To manage zones use manage_zones, to manage racks use manage_racks.',
    {},
    async () => {
      const zones = db.getZonesWithRacks(database).map((z) => {
        const bagCount = db.zoneBagCount(database, z.id);
        const racks = z.racks.map((r) => ({
          id: r.id,
          bagCount: db.rackBagCount(database, r.id)
        }));
        return {
          id: z.id,
          name: z.name,
          role: z.role,
          color: z.color,
          maxCapacity: z.maxCapacity,
          bagCount,
          capacityPct: z.maxCapacity ? Math.round((bagCount / z.maxCapacity) * 100) : null,
          racks
        };
      });

      return json(zones);
    }
  );

  server.tool(
    'get_inventory_status',
    'Get current substrate inventory levels, thresholds, low-stock alerts, and recent transactions. READ-ONLY. To log deliveries or usage use update_inventory.',
    {},
    async () => {
      const inv = db.getInventory(database, 20);
      const alerts = [];
      for (const mat of ['hardwood', 'wheatbran', 'gypsum', 'grain']) {
        if (inv.stock[mat] < inv.thresholds[mat].minKg) {
          alerts.push({ material: mat, stockKg: inv.stock[mat], thresholdKg: inv.thresholds[mat].minKg });
        }
      }
      return json({
        stock: inv.stock,
        thresholds: inv.thresholds,
        avgComposition: inv.avgComposition,
        alerts,
        recentLog: inv.log
      });
    }
  );

  server.tool(
    'get_tasks',
    'List team tasks with optional filters for assignee, priority, completion status, or date range. READ-ONLY. To create tasks use create_task, to modify use update_task.',
    {
      assignee: z.string().optional().describe('Filter by assignee name'),
      priority: z.enum(['low', 'med', 'high']).optional().describe('Filter by priority'),
      done: z.boolean().optional().describe('true=completed, false=open'),
      dueBefore: z.string().optional().describe('ISO date — tasks due before this date'),
      dueAfter: z.string().optional().describe('ISO date — tasks due after this date')
    },
    async (params) => {
      // The third door. daily_briefing and GET /api/data both filter; this one
      // is a dedicated task lister on the same server, reachable with the same
      // self-minted worker token, and it takes an `assignee` parameter — so it
      // answered "show me everything marked private for this colleague" in one
      // call. A read hole is not closed until every door asks.
      let tasks = db
        .getAllTasks(database)
        .filter((t) => db.canUserSeeTask(database, t, auth.username, auth.role === 'admin'));

      if (params.assignee) {
        const a = params.assignee.toLowerCase();
        tasks = tasks.filter((t) => t.assignee && t.assignee.toLowerCase().includes(a));
      }
      if (params.priority) tasks = tasks.filter((t) => t.priority === params.priority);
      if (params.done !== undefined) tasks = tasks.filter((t) => t.done === params.done);
      if (params.dueBefore) tasks = tasks.filter((t) => t.dueDate && t.dueDate < params.dueBefore);
      if (params.dueAfter) tasks = tasks.filter((t) => t.dueDate && t.dueDate > params.dueAfter);

      return json(
        tasks.map((t) => ({
          id: t.id,
          text: t.text,
          priority: t.priority,
          done: t.done,
          assignee: t.assignee,
          dueDate: t.dueDate,
          description: t.description,
          created: t.created
        }))
      );
    }
  );

  server.tool(
    'get_calendar_events',
    'Get calendar events within a date range, optionally filtered by category. READ-ONLY. To create events use create_calendar_event.',
    {
      startDate: z.string().optional().describe('ISO date — start of range (default: today)'),
      endDate: z.string().optional().describe('ISO date — end of range (default: 30 days from start)'),
      category: z.string().optional().describe('Filter by event category')
    },
    async (params) => {
      const start = params.startDate || today();
      const end = params.endDate || new Date(Date.now() + 30 * 86400000).toISOString().slice(0, 10);

      let events = db.getCalendarEvents(database).filter((e) => {
        const eStart = e.startDate;
        const eEnd = e.endDate || e.startDate;
        return eEnd >= start && eStart <= end;
      });

      if (params.category) events = events.filter((e) => e.category === params.category);

      return json(
        events.map((e) => ({
          id: e.id,
          title: e.title,
          description: e.description,
          startDate: e.startDate,
          endDate: e.endDate,
          allDay: e.allDay,
          startTime: e.startTime,
          endTime: e.endTime,
          category: e.category,
          color: e.color,
          assignees: e.assignees
        }))
      );
    }
  );

  server.tool(
    'list_cultures',
    'List mushroom cultures with optional filters for type (MC/PD/LC/G2G), Pilzsorte (strainId), species, or status. READ-ONLY. To modify use update_culture, to delete use delete_culture.',
    {
      type: z.string().optional().describe('Culture type (MC, PD, or LC)'),
      strainId: z
        .number()
        .optional()
        .describe('Filter by Pilzsorte id (exact match). Use list_mushroom_strains to discover ids.'),
      species: z.string().optional().describe('Filter by species (partial match)'),
      status: z.string().optional().describe('Filter by status (e.g. active, stored, used, sold, contam)')
    },
    async (params) => {
      let cultures = db.getAllCultures(database);

      if (params.type) cultures = cultures.filter((c) => c.type === params.type);
      if (params.strainId != null) cultures = cultures.filter((c) => c.strainId === params.strainId);
      if (params.species) {
        const s = params.species.toLowerCase();
        cultures = cultures.filter((c) => c.species && c.species.toLowerCase().includes(s));
      }
      if (params.status) cultures = cultures.filter((c) => c.status === params.status);

      return json(cultures);
    }
  );

  server.tool(
    'get_harvest_report',
    'Get harvest data aggregated by batch, species, or month with totals and per-flush breakdowns. READ-ONLY. To record a new harvest use log_harvest.',
    {
      groupBy: z.enum(['batch', 'species', 'month']).optional().describe('Aggregation dimension (default: batch)'),
      batchId: z.string().optional().describe('Filter to a specific batch'),
      species: z.string().optional().describe('Filter by species'),
      startDate: z.string().optional().describe('ISO date — harvests after this date'),
      endDate: z.string().optional().describe('ISO date — harvests before this date')
    },
    async (params) => {
      let harvests = db.getAllHarvests(database);

      if (params.batchId) harvests = harvests.filter((h) => h.batch === params.batchId);
      if (params.species) {
        const s = params.species.toLowerCase();
        harvests = harvests.filter((h) => h.species && h.species.toLowerCase().includes(s));
      }
      if (params.startDate) harvests = harvests.filter((h) => h.time && h.time.slice(0, 10) >= params.startDate);
      if (params.endDate) harvests = harvests.filter((h) => h.time && h.time.slice(0, 10) <= params.endDate);

      const groupBy = params.groupBy || 'batch';
      // S-10: keyed by batch id / species / month, all row data.
      const groups = Object.create(null);
      for (const h of harvests) {
        let key;
        if (groupBy === 'batch') key = h.batch || 'unknown';
        else if (groupBy === 'species') key = h.species || 'unknown';
        else key = h.time ? h.time.slice(0, 7) : 'unknown'; // month: YYYY-MM

        if (!groups[key])
          groups[key] = { totalGrams: 0, count: 0, byFlush: Object.create(null), byQuality: Object.create(null) };
        groups[key].totalGrams += h.grams;
        groups[key].count += 1;
        const fKey = 'flush_' + h.flush;
        groups[key].byFlush[fKey] = (groups[key].byFlush[fKey] || 0) + h.grams;
        const qKey = h.quality || 'ungraded';
        groups[key].byQuality[qKey] = (groups[key].byQuality[qKey] || 0) + 1;
      }

      // Overall quality distribution
      const qualityDist = Object.create(null);
      for (const h of harvests) {
        const q = h.quality || 'ungraded';
        qualityDist[q] = (qualityDist[q] || 0) + 1;
      }

      return json({
        groupBy,
        totalHarvests: harvests.length,
        totalGrams: harvests.reduce((s, h) => s + h.grams, 0),
        qualityDistribution: qualityDist,
        groups
      });
    }
  );

  server.tool(
    'get_scan_log',
    'Get scan log entries (bag movements/placements/removals) with optional filters. READ-ONLY history. To log new bag movements use move_bags.',
    {
      batchId: z.string().optional().describe('Filter by batch ID'),
      bagId: z.string().optional().describe('Filter by bag ID'),
      action: z.enum(['ADD', 'MOVE', 'REMOVE']).optional().describe('Filter by action type'),
      reason: z.string().optional().describe('Filter by reason (e.g. contam_tricho, dried_out)'),
      limit: z.number().optional().describe('Max entries to return (default: 50, max: 500)'),
      startDate: z.string().optional().describe('ISO date — entries after this date'),
      endDate: z.string().optional().describe('ISO date — entries before this date')
    },
    async (params) => {
      let log = db.getScanLog(database);

      if (params.batchId) log = log.filter((e) => e.batch === params.batchId);
      if (params.bagId) log = log.filter((e) => e.bag === params.bagId);
      if (params.action) log = log.filter((e) => e.action === params.action);
      if (params.reason) log = log.filter((e) => e.reason === params.reason);
      if (params.startDate) log = log.filter((e) => e.time && e.time.slice(0, 10) >= params.startDate);
      if (params.endDate) log = log.filter((e) => e.time && e.time.slice(0, 10) <= params.endDate);

      const limit = Math.min(params.limit || 50, 500);
      log = log.slice(-limit);

      return json(log);
    }
  );

  // ──────────────────────────────────────────────────────────
  // WRITE TOOLS
  // ──────────────────────────────────────────────────────────

  server.tool(
    'create_batch',
    'Create a new production batch with auto-generated bags. Prefer strainId (use list_mushroom_strains); when omitted, species is required. Does NOT auto-deduct inventory — use update_inventory separately for substrate usage. Does NOT place bags in zones — use move_bags to ADD bags after creation.',
    {
      batchId: z
        .string()
        .regex(/^[A-Za-z0-9_\-@.:]{1,100}$/, 'batchId: letters/digits/_-@.: only, max 100')
        .describe('Batch ID (e.g. FB-2025-042)'),
      strainId: z
        .number()
        .optional()
        .describe('Pilzsorte id. When set, species/strain are auto-filled from mushroom_strains.'),
      species: z.string().max(200).optional().describe('Mushroom species (required when strainId is omitted)'),
      qty: z.number().int().min(1).max(10000).describe('Number of bags (1–10000)'),
      days: z.number().int().min(1).max(3650).describe('Incubation days (1–3650)'),
      strain: z.string().max(200).optional().describe('Strain kuerzel (free-text fallback when strainId is omitted)'),
      subHardwood: z.number().optional().describe('Substrate hardwood %'),
      subWheatbran: z.number().optional().describe('Substrate wheat bran %'),
      subRh: z.number().optional().describe('Substrate relative humidity %'),
      subGypsum: z.boolean().optional().describe('Include gypsum?'),
      bagKg: z.number().optional().describe('Bag weight in kg (default: 3)'),
      batchType: z.enum(['block', 'grain', 'liquid']).optional().describe('Batch type (default: block)'),
      grainRh: z
        .number()
        .optional()
        .describe(
          'Grain water content % (for batchType=grain only). Wet bag weight × (1 - grainRh/100) = dry grain deducted. Typical wheat = 52.'
        ),
      sourceId: z.string().optional().describe('Source culture ID'),
      recipeId: z
        .number()
        .optional()
        .describe('Recipe ID — auto-fills substrate fields (hardwood%, wheatbran%, gypsum%, rh%) from recipe'),
      notes: z.string().optional().describe('Notes')
    },
    async (params) => {
      try {
        if (!params.strainId && !params.species) {
          return errResult('Either strainId or species is required');
        }
        // Apply recipe if provided
        let subHardwood = params.subHardwood || 0;
        let subWheatbran = params.subWheatbran || 0;
        let subRh = params.subRh || 0;
        let subGypsum = params.subGypsum || false;
        if (params.recipeId) {
          const recipe = db.getRecipeById(database, params.recipeId);
          if (!recipe) return errResult('Recipe not found: ' + params.recipeId);
          subHardwood = params.subHardwood != null ? params.subHardwood : recipe.hardwoodPct;
          subWheatbran = params.subWheatbran != null ? params.subWheatbran : recipe.wheatbranPct;
          subRh = params.subRh != null ? params.subRh : recipe.rhPct;
          subGypsum = params.subGypsum != null ? params.subGypsum : recipe.gypsumPct > 0;
        }
        const created = new Date().toISOString();
        const due = new Date(Date.now() + params.days * 86400000).toISOString();
        const bags = [];
        for (let i = 1; i <= params.qty; i++) {
          bags.push(params.batchId + '-' + String(i).padStart(2, '0'));
        }
        db.insertBatch(
          database,
          {
            batchId: params.batchId,
            strainId: params.strainId || null,
            species: params.species,
            strain: params.strain || null,
            qty: params.qty,
            days: params.days,
            substrate: {
              hardwood: subHardwood,
              wheatbran: subWheatbran,
              rh: subRh,
              gypsum: subGypsum
            },
            bagKg: params.bagKg || 3,
            batchType: params.batchType || 'block',
            grainRh: params.grainRh || 0,
            sourceId: params.sourceId || null,
            notes: params.notes || '',
            created,
            due,
            bags
          },
          // I-22: no inventory deltas from create_batch (the tool description
          // already documents that callers must use update_inventory separately),
          // but pass userId for consistency in case that contract changes.
          null,
          auth.userId || null
        );
        notify();
        const persisted = db.readBatchById(database, params.batchId);
        return json({
          success: true,
          batchId: params.batchId,
          created,
          due,
          bagCount: params.qty,
          bags,
          species: persisted ? persisted.species : params.species,
          strain: persisted ? persisted.strain : params.strain || null,
          strainId: persisted ? persisted.strainId : params.strainId || null,
          strainName: persisted ? persisted.strainName : null,
          strainKuerzel: persisted ? persisted.strainKuerzel : null
        });
      } catch (e) {
        return safeErrResult(e);
      }
    }
  );

  server.tool(
    'update_batch',
    'Update batch METADATA ONLY: notes, species, strain, strainId, days, due date. NOT for contamination (→ move_bags with MOVE to contam zone). NOT for harvests/weights (→ log_harvest). NOT for inventory changes (→ update_inventory). NOT for adding bags (→ add_bags_to_batch). Pass strainId to switch Pilzsorte — species/strain auto-update.',
    {
      batchId: z.string().describe('Batch ID'),
      strainId: z.number().optional().describe('Pilzsorte id (auto-fills species/strain from mushroom_strains)'),
      notes: z.string().optional(),
      species: z.string().optional(),
      strain: z.string().optional(),
      days: z.number().optional(),
      due: z.string().optional().describe('ISO date')
    },
    async (params) => {
      try {
        const { batchId, ...fields } = params;
        const updates = {};
        for (const [k, v] of Object.entries(fields)) {
          if (v !== undefined) updates[k] = v;
        }
        if (!Object.keys(updates).length) return errResult('No fields to update');
        db.updateBatchField(database, batchId, updates);
        notify();
        const persisted = db.readBatchById(database, batchId);
        return json({
          success: true,
          batchId,
          updated: Object.keys(updates),
          species: persisted ? persisted.species : null,
          strain: persisted ? persisted.strain : null,
          strainId: persisted ? persisted.strainId : null,
          strainName: persisted ? persisted.strainName : null,
          strainKuerzel: persisted ? persisted.strainKuerzel : null
        });
      } catch (e) {
        return safeErrResult(e);
      }
    }
  );

  server.tool(
    'create_task',
    'Create a team task (todo/work item). ONLY for real team work: cleaning, ordering, maintenance, reviews. NOT for documenting contamination (→ move_bags). NOT for recording harvests (→ log_harvest). NOT for inventory changes (→ update_inventory). NOT for logging bag movements (→ move_bags).',
    {
      text: z.string().describe('Task description'),
      priority: z.enum(['low', 'med', 'high']).optional().describe('Priority (default: med)'),
      assignee: z.string().optional().describe('Assignee name'),
      dueDate: z.string().optional().describe('ISO date for due date'),
      description: z.string().optional().describe('Additional details')
    },
    async (params) => {
      try {
        const id = db.insertTask(database, {
          text: params.text,
          priority: params.priority || 'med',
          done: false,
          created: new Date().toISOString(),
          assignee: params.assignee || null,
          dueDate: params.dueDate || null,
          description: params.description || null
        });
        notify();
        return json({ success: true, id: Number(id), text: params.text, assignee: params.assignee || null });
      } catch (e) {
        return safeErrResult(e);
      }
    }
  );

  server.tool(
    'update_task',
    'Update an existing team task — change text, priority, assignee, due date, description, or mark as done/undone. ONLY for modifying existing tasks. NOT for physical actions like contamination or harvests.',
    {
      id: z.number().describe('Task ID'),
      text: z.string().optional(),
      priority: z.enum(['low', 'med', 'high']).optional(),
      done: z.boolean().optional().describe('Mark as done (true) or reopen (false)'),
      assignee: z.string().optional(),
      dueDate: z.string().optional().describe('ISO date'),
      description: z.string().optional()
    },
    async (params) => {
      try {
        const { id, ...fields } = params;
        const updates = {};
        for (const [k, v] of Object.entries(fields)) {
          if (v !== undefined) updates[k] = v;
        }
        if (!Object.keys(updates).length) return errResult('No fields to update');
        db.updateTaskById(database, id, updates);
        notify();
        return json({ success: true, id, updated: Object.keys(updates) });
      } catch (e) {
        return safeErrResult(e);
      }
    }
  );

  server.tool(
    'create_calendar_event',
    'Create a calendar event (e.g. inoculation day, harvest window, team meeting). To assign to specific users pass assigneeNames (case-insensitive usernames) or assigneeIds. If BOTH are omitted or empty the event is shown to EVERYONE — so when the user asks to assign to specific people you MUST provide one of these fields.',
    {
      title: z.string().describe('Event title'),
      startDate: z.string().describe('ISO date (YYYY-MM-DD)'),
      endDate: z.string().optional().describe('ISO date (YYYY-MM-DD)'),
      allDay: z.boolean().optional().describe('All-day event (default: true)'),
      startTime: z.string().optional().describe('Start time (HH:MM)'),
      endTime: z.string().optional().describe('End time (HH:MM)'),
      category: z.string().optional().describe('Event category (default: custom)'),
      color: z.string().optional().describe('Hex color (e.g. #4CAF50)'),
      description: z.string().optional(),
      assigneeIds: z
        .array(z.number())
        .optional()
        .describe('User IDs to assign. Prefer assigneeNames unless you already have the IDs.'),
      assigneeNames: z
        .array(z.string())
        .optional()
        .describe(
          'Usernames to assign (case-insensitive). Unknown names are skipped and returned in unknownAssigneeNames — check the response.'
        ),
      recurrence: z.enum(['daily', 'weekly', 'monthly']).optional().describe('Recurrence pattern'),
      recurrenceUntil: z.string().optional().describe('ISO date — last allowed recurrence (inclusive)')
    },
    async (params) => {
      // A pickup window is what harvest-feed.js publishes to the shop as a
      // bookable collection slot — day, clock, address, places. The HTTP route
      // and the CalDAV create branch both ask for admin before writing one, and
      // an MCP token is something any worker can mint through the OAuth flow,
      // so this is the third door to the same room. Only that one category:
      // meetings and inoculation days stay everyone's, as they are here and on
      // the other two doors. delete_calendar_event is already requireAdminRole.
      if (params.category === 'pickup') {
        const adminErr = requireAdminRole();
        if (adminErr) return adminErr;
      }
      try {
        const id = 'ev-' + Date.now() + '-' + Math.random().toString(36).slice(2, 8);
        const unknownAssigneeNames = [];
        const resolvedFromNames = [];
        if (Array.isArray(params.assigneeNames)) {
          for (const name of params.assigneeNames) {
            if (!name || typeof name !== 'string') continue;
            const u = db.getUserByUsernameCaseInsensitive(database, name.trim());
            if (u && typeof u.id === 'number') resolvedFromNames.push(u.id);
            else unknownAssigneeNames.push(name);
          }
        }
        const seen = new Set();
        const assigneeIds = [];
        for (const uid of [...(params.assigneeIds || []), ...resolvedFromNames]) {
          if (typeof uid === 'number' && !seen.has(uid)) {
            seen.add(uid);
            assigneeIds.push(uid);
          }
        }
        db.insertCalendarEvent(
          database,
          {
            id,
            title: params.title,
            description: params.description || null,
            startDate: params.startDate,
            endDate: params.endDate || null,
            allDay: params.allDay !== false,
            startTime: params.startTime || null,
            endTime: params.endTime || null,
            category: params.category || 'custom',
            color: params.color || null,
            recurrence: params.recurrence || null,
            recurrenceUntil: params.recurrenceUntil || null
          },
          assigneeIds
        );
        notify();
        const result = { success: true, id, title: params.title, startDate: params.startDate, assigneeIds };
        if (unknownAssigneeNames.length) result.unknownAssigneeNames = unknownAssigneeNames;
        return json(result);
      } catch (e) {
        return safeErrResult(e);
      }
    }
  );

  server.tool(
    'delete_calendar_event',
    'Delete a calendar event. For recurring events, pass occurrence=YYYY-MM-DD to skip only a single date (adds an exception); omit occurrence to delete the entire series.',
    {
      id: z.string().describe('Calendar event ID'),
      occurrence: z
        .string()
        .optional()
        .describe('ISO date (YYYY-MM-DD) — delete only this occurrence of a recurring event')
    },
    async (params) => {
      const adminErr = requireAdminRole();
      if (adminErr) return adminErr;
      try {
        const ev = db.getCalendarEventById(database, params.id);
        if (!ev) return errResult('event not found: ' + params.id);
        if (params.occurrence && ev.recurrence) {
          db.addCalendarEventException(database, params.id, params.occurrence);
          notify();
          return json({ success: true, id: params.id, mode: 'occurrence', occurrence: params.occurrence });
        }
        db.deleteCalendarEvent(database, params.id);
        notify();
        return json({ success: true, id: params.id, mode: 'series' });
      } catch (e) {
        return safeErrResult(e);
      }
    }
  );

  server.tool(
    'log_harvest',
    'Record a mushroom harvest with weight in grams. ALWAYS use this tool when grams, weight, or harvest amount is mentioned — NEVER record harvests as notes in update_batch. Species/strain auto-fill from the batch when omitted; pass strainId to resolve from mushroom_strains.',
    {
      batch: z.string().describe('Batch ID'),
      grams: z.number().describe('Harvest weight in grams (>= 0)'),
      bag: z.string().optional().describe('Specific bag ID'),
      flush: z.number().optional().describe('Flush number (default: 1)'),
      quality: z.enum(['A', 'B', 'C']).optional().describe('Quality grade: A (premium), B (standard), C (low)'),
      notes: z.string().optional().describe('Harvest notes'),
      strainId: z
        .number()
        .optional()
        .describe('Pilzsorte id — when set, species/strain are resolved from mushroom_strains'),
      species: z.string().optional().describe('Auto-filled from batch if omitted'),
      strain: z.string().optional().describe('Auto-filled from batch if omitted')
    },
    async (params) => {
      try {
        let species = params.species;
        let strain = params.strain;
        if (params.strainId && (!species || !strain)) {
          const strains = db.listMushroomStrains(database);
          const ms = strains.find((s) => s.id === params.strainId);
          if (!ms) return errResult('Pilzsorte not found: ' + params.strainId);
          species = species || ms.name;
          strain = strain || ms.kuerzel;
        }
        if (!species || !strain) {
          const b = db.readBatchById(database, params.batch);
          if (b) {
            species = species || b.species;
            strain = strain || b.strain;
          }
        }
        const id = db.insertHarvest(database, {
          time: new Date().toISOString(),
          batch: params.batch,
          bag: params.bag || null,
          species: species || null,
          strain: strain || null,
          grams: params.grams,
          flush: params.flush || 1,
          quality: params.quality || null,
          notes: params.notes || null
        });
        notify();
        return json({
          success: true,
          id: Number(id),
          batch: params.batch,
          grams: params.grams,
          flush: params.flush || 1,
          quality: params.quality || null,
          species,
          strain
        });
      } catch (e) {
        return safeErrResult(e);
      }
    }
  );

  server.tool(
    'move_bags',
    'Log physical bag movements between zones/racks. Use for ALL physical bag state changes: ADD (place bag in zone), MOVE (relocate — including to contamination zone for contaminated bags), REMOVE (permanently remove bag from zone tracking; scan history preserved). DESTRUCTIVE: REMOVE requires confirm: true. For contamination ALWAYS use MOVE to a contam zone first. Only use REMOVE when user explicitly says entsorgen/wegwerfen/löschen. NOT for recording harvests (→ log_harvest). NOT for batch metadata (→ update_batch).',
    {
      entries: z
        .array(
          z.object({
            batch: z.string().describe('Batch ID'),
            bag: z.string().describe('Bag ID'),
            action: z.enum(['ADD', 'MOVE', 'REMOVE']).describe('Movement type'),
            from: z.string().optional().describe('Source zone/rack (required for MOVE/REMOVE)'),
            to: z.string().optional().describe('Destination zone/rack (required for ADD/MOVE)'),
            reason: z
              .string()
              .optional()
              .describe(
                'Reason for MOVE/REMOVE (e.g. contam_tricho, contam_cobweb, contam_bacteria, contam_other, dried_out, damaged, other)'
              )
          })
        )
        .describe('Array of bag movements'),
      confirm: z
        .boolean()
        .optional()
        .describe('Required true for REMOVE actions. Safety confirmation for destructive operations.')
    },
    async ({ entries, confirm }) => {
      try {
        const hasRemove = entries.some((e) => e.action === 'REMOVE');
        if (hasRemove && confirm !== true) {
          return errResult(
            'REMOVE entfernt Bags dauerhaft aus dem Zonen-Tracking (Scan-Historie bleibt erhalten). Bitte mit confirm: true bestätigen. Bei Kontamination besser MOVE in eine Kontam-Zone verwenden.'
          );
        }
        const now = new Date().toISOString();
        const enriched = entries.map((e) => {
          const b = db.readBatchById(database, e.batch);
          return {
            time: now,
            action: e.action,
            batch: e.batch,
            bag: e.bag,
            from: e.from || null,
            to: e.to || null,
            species: b ? b.species : null,
            strain: b ? b.strain : null,
            reason: e.reason || null
          };
        });
        // The acting user, the way create_batch and the other writes already
        // pass it — move_bags was the one that did not. A hardcoded null puts a
        // MOVE or a contamination REMOVE into scan_log with no user, so it reads
        // back nameless out of the forensic query, while the same action through
        // POST /api/scan-log carries its session's user. The legacy static token
        // genuinely belongs to nobody; `|| null` keeps that a null instead of
        // inventing an identity for it.
        const ids = db.appendScanEntries(database, enriched, auth.userId || null);
        notify();
        return json({ success: true, count: entries.length, ids: ids.map(Number) });
      } catch (e) {
        return safeErrResult(e);
      }
    }
  );

  server.tool(
    'update_inventory',
    'Log a substrate inventory change: delivery (positive deltaKg), usage (negative deltaKg), or correction. Materials: hardwood, wheatbran, gypsum, grain. ALWAYS use this for stock changes — NEVER record inventory as task (→ create_task) or batch note (→ update_batch).',
    {
      material: z.enum(['hardwood', 'wheatbran', 'gypsum', 'grain']).describe('Material type'),
      deltaKg: z.number().describe('Change in kg (positive for delivery, negative for usage)'),
      type: z.string().optional().describe('Transaction type (e.g. delivery, batch, correction)'),
      ref: z.string().optional().describe('Reference note (e.g. supplier name, batch ID)')
    },
    async (params) => {
      const adminErr = requireAdminRole();
      if (adminErr) return adminErr;
      try {
        // I-22: forward auth.userId so the inventory_log records the actor.
        const newStock = db.applyInventoryDelta(
          database,
          params.material,
          params.deltaKg,
          params.type || null,
          params.ref || null,
          auth.userId || null
        );
        notify();
        return json({ success: true, material: params.material, deltaKg: params.deltaKg, newStockKg: newStock });
      } catch (e) {
        return safeErrResult(e);
      }
    }
  );

  server.tool(
    'update_culture',
    "Update a mushroom culture's metadata: status, notes, Pilzsorte (strainId), species, strain, or source. For status changes like 'contam' use this. NOT for physical bag handling (→ move_bags). Pass strainId to switch Pilzsorte — species/strain auto-update.",
    {
      id: z.string().describe('Culture ID'),
      status: z.string().optional().describe('New status (e.g. active, archived, contaminated)'),
      notes: z.string().optional(),
      strainId: z.number().optional().describe('Pilzsorte id (auto-fills species/strain from mushroom_strains)'),
      species: z.string().optional(),
      strain: z.string().optional(),
      source: z.string().optional(),
      ml: z.number().optional().describe('SY only: correct the syringe size, 10, 20 or 50 ml')
    },
    async (params) => {
      try {
        const { id, ...fields } = params;
        const updates = {};
        for (const [k, v] of Object.entries(fields)) {
          if (v !== undefined) updates[k] = v;
        }
        if (!Object.keys(updates).length) return errResult('No fields to update');
        db.updateCulture(database, id, updates);
        notify();
        return json({ success: true, id, updated: Object.keys(updates) });
      } catch (e) {
        return safeErrResult(e);
      }
    }
  );

  // ──────────────────────────────────────────────────────────
  // CULTURES: CREATE
  // ──────────────────────────────────────────────────────────

  server.tool(
    'create_culture',
    'Create a single mushroom culture (MC, PD, LC, or G2G). Prefer strainId (use list_mushroom_strains); when omitted, species is required. NOT for creating production batches (→ create_batch).',
    {
      id: z.string().describe('Culture ID (e.g. MC-KINGS-250301-01)'),
      type: z.enum(['MC', 'PD', 'LC', 'G2G', 'SY', 'DU']).describe('Culture type'),
      strainId: z
        .number()
        .optional()
        .describe('Pilzsorte id. When set, species/strain are auto-filled from mushroom_strains.'),
      species: z.string().optional().describe('Species (required when strainId is omitted)'),
      strain: z.string().optional().describe('Strain kuerzel (free-text fallback)'),
      parentId: z.string().optional().describe('Parent culture ID for lineage'),
      source: z.string().optional().describe('Source note (e.g. clone, spore print, wild)'),
      status: z
        .enum(['active', 'stored', 'used', 'sold', 'contam'])
        .optional()
        .describe('Culture status (default: active)'),
      notes: z.string().optional(),
      created: z.string().optional().describe('ISO timestamp (default: now)'),
      ml: z.number().optional().describe('SY only: syringe size in ml, 10, 20 or 50 (default 10)')
    },
    async (params) => {
      try {
        if (!params.strainId && !params.species) {
          return errResult('Either strainId or species is required');
        }
        db.insertCultures(database, [
          {
            id: params.id,
            type: params.type,
            strainId: params.strainId || null,
            species: params.species || null,
            strain: params.strain || null,
            parentId: params.parentId || null,
            source: params.source || null,
            status: params.status || 'active',
            notes: params.notes || '',
            created: params.created || new Date().toISOString(),
            ml: params.ml != null ? params.ml : null
          }
        ]);
        notify();
        const persisted = db.getAllCultures(database).find((c) => c.id === params.id);
        return json({ success: true, id: params.id, culture: persisted });
      } catch (e) {
        return safeErrResult(e);
      }
    }
  );

  // ──────────────────────────────────────────────────────────
  // MUSHROOM STRAINS (Pilzsorten) CRUD
  // ──────────────────────────────────────────────────────────

  server.tool(
    'list_mushroom_strains',
    'List all Pilzsorten (mushroom strains) with id, name, kuerzel, description. READ-ONLY. Use the returned id with create_batch, create_culture, update_batch, update_culture, or log_harvest to link to a strain.',
    {},
    async () => {
      return json(db.listMushroomStrains(database));
    }
  );

  server.tool(
    'create_mushroom_strain',
    'Create a new Pilzsorte (mushroom strain). Name and kuerzel are required and must be unique.',
    {
      name: z.string().describe('Full strain name, e.g. "Pleurotus ostreatus HK35"'),
      kuerzel: z.string().describe('Short code, e.g. "HK35"'),
      description: z.string().optional().describe('Free-text description')
    },
    async (params) => {
      try {
        const id = db.createMushroomStrain(database, {
          name: params.name,
          kuerzel: params.kuerzel,
          description: params.description || ''
        });
        notify();
        return json({ success: true, id: Number(id), name: params.name, kuerzel: params.kuerzel });
      } catch (e) {
        return safeErrResult(e);
      }
    }
  );

  server.tool(
    'update_mushroom_strain',
    'Update a Pilzsorte. Changes to name/kuerzel propagate to all batches and cultures that reference this strain.',
    {
      id: z.number().describe('Pilzsorte id'),
      name: z.string().optional().describe('New name'),
      kuerzel: z.string().optional().describe('New kuerzel'),
      description: z.string().optional().describe('New description')
    },
    async (params) => {
      try {
        const { id, ...fields } = params;
        const updates = {};
        for (const [k, v] of Object.entries(fields)) {
          if (v !== undefined) updates[k] = v;
        }
        if (!Object.keys(updates).length) return errResult('No fields to update');
        db.updateMushroomStrain(database, id, updates);
        notify();
        return json({ success: true, id, updated: Object.keys(updates) });
      } catch (e) {
        return safeErrResult(e);
      }
    }
  );

  server.tool(
    'delete_mushroom_strain',
    'Delete a Pilzsorte. DESTRUCTIVE — fails safely if still referenced by any batch or culture (delete protection). Cannot be undone.',
    {
      id: z.number().describe('Pilzsorte id')
    },
    async (params) => {
      const adminErr = requireAdminRole();
      if (adminErr) return adminErr;
      try {
        const removed = db.deleteMushroomStrain(database, params.id);
        if (!removed) return errResult('Pilzsorte not found: ' + params.id);
        notify();
        return json({ success: true, id: params.id });
      } catch (e) {
        return safeErrResult(e);
      }
    }
  );

  // ──────────────────────────────────────────────────────────
  // ZONE & RACK MANAGEMENT
  // ──────────────────────────────────────────────────────────

  // Example: manage_zones({ action: 'create', id: 'fruiting-2', name: 'Fruiting Room 2', role: 'fruiting' })
  server.tool(
    'manage_zones',
    'Create, rename, delete, or reorder zones. Actions: create (new zone), rename (change name), delete (remove empty zone), reorder (set sort order). READ zones with get_zone_overview. NOT for racks (→ manage_racks).',
    {
      action: z.enum(['create', 'rename', 'delete', 'reorder']).describe('Action to perform'),
      id: z.string().optional().describe('Zone ID (required for create/rename/delete)'),
      name: z.string().optional().describe('Zone name (required for create/rename)'),
      role: z
        .string()
        .optional()
        .describe('Zone role: spawn, incubation, fruiting, contaminated, storage (for create)'),
      color: z.string().optional().describe('Hex color e.g. #4CAF50 (for create)'),
      maxCapacity: z.number().optional().describe('Max bag capacity (for create)'),
      order: z.array(z.string()).optional().describe('Array of zone IDs in desired order (for reorder)')
    },
    async (params) => {
      const adminErr = requireAdminRole();
      if (adminErr) return adminErr;
      try {
        switch (params.action) {
          case 'create': {
            if (!params.id || !params.name) return errResult('id and name are required for create');
            db.insertZone(database, {
              id: params.id,
              name: params.name,
              role: params.role || null,
              color: params.color || null,
              maxCapacity: params.maxCapacity || null,
              created: new Date().toISOString()
            });
            notify();
            return json({ success: true, action: 'create', id: params.id, name: params.name });
          }
          case 'rename': {
            if (!params.id || !params.name) return errResult('id and name are required for rename');
            db.renameZoneName(database, params.id, params.name);
            notify();
            return json({ success: true, action: 'rename', id: params.id, newName: params.name });
          }
          case 'delete': {
            if (!params.id) return errResult('id is required for delete');
            db.deleteZone(database, params.id);
            notify();
            return json({ success: true, action: 'delete', id: params.id });
          }
          case 'reorder': {
            if (!params.order || !params.order.length) return errResult('order array is required for reorder');
            db.reorderZones(database, params.order);
            notify();
            return json({ success: true, action: 'reorder', order: params.order });
          }
          default:
            return errResult('Unknown action: ' + params.action);
        }
      } catch (e) {
        return safeErrResult(e);
      }
    }
  );

  // Example: manage_racks({ action: 'create', id: 'R-FRUIT2-01', zoneId: 'fruiting-2' })
  server.tool(
    'manage_racks',
    'Create or delete racks within zones. Actions: create (new rack in zone), delete (remove empty rack). View racks via get_zone_overview. NOT for zones (→ manage_zones).',
    {
      action: z.enum(['create', 'delete']).describe('Action to perform'),
      id: z.string().optional().describe('Rack ID (required for create/delete)'),
      zoneId: z.string().optional().describe('Zone ID (required for create)')
    },
    async (params) => {
      const adminErr = requireAdminRole();
      if (adminErr) return adminErr;
      try {
        switch (params.action) {
          case 'create': {
            if (!params.id || !params.zoneId) return errResult('id and zoneId are required for create');
            db.insertRack(database, {
              id: params.id,
              zoneId: params.zoneId,
              created: new Date().toISOString()
            });
            notify();
            return json({ success: true, action: 'create', id: params.id, zoneId: params.zoneId });
          }
          case 'delete': {
            if (!params.id) return errResult('id is required for delete');
            db.deleteRack(database, params.id);
            notify();
            return json({ success: true, action: 'delete', id: params.id });
          }
          default:
            return errResult('Unknown action: ' + params.action);
        }
      } catch (e) {
        return safeErrResult(e);
      }
    }
  );

  // ──────────────────────────────────────────────────────────
  // BATCH EXTENSIONS
  // ──────────────────────────────────────────────────────────

  // Example: add_bags_to_batch({ batchId: 'FB-2025-042', count: 5 })
  server.tool(
    'add_bags_to_batch',
    'Add more bags to an existing batch. Generates new bag IDs sequentially. Use this instead of update_batch when you need more bags — it keeps inventory log consistent.',
    {
      batchId: z
        .string()
        .regex(/^[A-Za-z0-9_\-@.:]{1,100}$/, 'batchId: letters/digits/_-@.: only, max 100')
        .describe('Batch ID'),
      count: z.number().int().min(1).max(10000).describe('Number of bags to add (1–10000)')
    },
    async (params) => {
      try {
        const batch = db.readBatchById(database, params.batchId);
        if (!batch) return errResult('Batch not found: ' + params.batchId);
        const existingCount = batch.bags.length;
        const newBags = [];
        for (let i = 1; i <= params.count; i++) {
          newBags.push(params.batchId + '-' + String(existingCount + i).padStart(2, '0'));
        }
        // I-22 + I-23: forward auth.userId; addBagsToBatch now also deducts inventory.
        const result = db.addBagsToBatch(
          database,
          params.batchId,
          newBags,
          existingCount + params.count,
          undefined,
          auth.userId || null
        );
        notify();
        return json({
          success: true,
          batchId: params.batchId,
          newBags,
          totalBags: existingCount + params.count,
          bagBarcodes: result.bagBarcodes
        });
      } catch (e) {
        return safeErrResult(e);
      }
    }
  );

  // Example: delete_batch({ batchId: 'FB-2025-042', confirm: true })
  server.tool(
    'delete_batch',
    'Delete a batch with ALL its bags, scan entries, and harvests. DESTRUCTIVE — cannot be undone. Reverses inventory deltas. Requires confirm: true.',
    {
      batchId: z.string().describe('Batch ID to delete'),
      confirm: z.boolean().optional().describe('Must be true to confirm deletion')
    },
    async (params) => {
      const adminErr = requireAdminRole();
      if (adminErr) return adminErr;
      try {
        if (params.confirm !== true) {
          return errResult(
            'delete_batch löscht den Batch mit ALLEN Bags, Scan-Einträgen und Ernten unwiderruflich. Bitte mit confirm: true bestätigen.'
          );
        }
        const batch = db.readBatchById(database, params.batchId);
        if (!batch) return errResult('Batch not found: ' + params.batchId);
        // I-22: forward acting user so the credit-back inventory rows record the actor.
        db.deleteBatchById(database, params.batchId, auth.userId || null);
        notify();
        return json({ success: true, batchId: params.batchId, deletedBags: batch.bags.length });
      } catch (e) {
        return safeErrResult(e);
      }
    }
  );

  // Example: rename_batch({ oldId: 'FB-2025-042', newId: 'FB-2025-043' })
  server.tool(
    'rename_batch',
    'Rename a batch ID. Updates all references in bags, scan_log, harvests, and inventory_log. NOT for metadata changes (→ update_batch).',
    {
      oldId: z.string().describe('Current batch ID'),
      newId: z
        .string()
        .regex(/^[A-Za-z0-9_\-@.:]{1,100}$/, 'newId: letters/digits/_-@.: only, max 100')
        .describe('New batch ID')
    },
    async (params) => {
      const adminErr = requireAdminRole();
      if (adminErr) return adminErr;
      try {
        db.renameBatch(database, params.oldId, params.newId, { user_id: auth.userId, username: auth.username });
        notify();
        return json({ success: true, oldId: params.oldId, newId: params.newId });
      } catch (e) {
        return safeErrResult(e);
      }
    }
  );

  // ──────────────────────────────────────────────────────────
  // CULTURE EXTENSIONS
  // ──────────────────────────────────────────────────────────

  // Example: delete_culture({ id: 'MC-KINGS-250301-01', confirm: true })
  server.tool(
    'delete_culture',
    'Delete a mushroom culture. DESTRUCTIVE — cannot be undone. Requires confirm: true. Consider setting status to "contam" or "used" via update_culture instead.',
    {
      id: z.string().describe('Culture ID to delete'),
      confirm: z.boolean().optional().describe('Must be true to confirm deletion')
    },
    async (params) => {
      const adminErr = requireAdminRole();
      if (adminErr) return adminErr;
      try {
        if (params.confirm !== true) {
          return errResult(
            'delete_culture löscht die Kultur unwiderruflich. Bitte mit confirm: true bestätigen. Alternativ: update_culture mit status "contam" oder "used".'
          );
        }
        const removed = db.deleteCulture(database, params.id, { user_id: auth.userId, username: auth.username });
        if (!removed) return errResult('Culture not found: ' + params.id);
        notify();
        return json({ success: true, id: params.id });
      } catch (e) {
        return safeErrResult(e);
      }
    }
  );

  // Example: get_culture_details({ id: 'MC-KINGS-250301-01' })
  server.tool(
    'get_culture_details',
    'Get full details for a single culture including strain info, lineage (parent + children), and batches created from it. READ-ONLY. To modify use update_culture.',
    {
      id: z.string().describe('Culture ID')
    },
    async (params) => {
      const culture = db.getCultureById(database, params.id);
      if (!culture) return errResult('Culture not found: ' + params.id);
      return json(culture);
    }
  );

  // ──────────────────────────────────────────────────────────
  // BARCODES
  // ──────────────────────────────────────────────────────────

  // Example: lookup_barcode({ barcode: 1000042 })
  server.tool(
    'lookup_barcode',
    'Resolve a numeric barcode to its entity (bag, culture, zone, rack). Returns entity_type and entity_id. READ-ONLY.',
    {
      barcode: z.number().describe('Numeric barcode to look up')
    },
    async (params) => {
      const result = db.lookupBarcode(database, params.barcode);
      if (!result) return errResult('Barcode not found: ' + params.barcode);
      return json(result);
    }
  );

  // Example: assign_barcode({ entityType: 'bag', entityId: 'FB-2025-042-01' })
  server.tool(
    'assign_barcode',
    'Assign a numeric barcode to an entity (bag, culture, zone, rack). Returns existing barcode if already assigned (idempotent).',
    {
      entityType: z.enum(['bag', 'culture', 'zone', 'rack']).describe('Entity type'),
      entityId: z.string().describe('Entity ID')
    },
    async (params) => {
      try {
        const barcode = db.assignBarcode(database, params.entityType, params.entityId);
        notify();
        return json({ success: true, barcode, entityType: params.entityType, entityId: params.entityId });
      } catch (e) {
        return safeErrResult(e);
      }
    }
  );

  // Example: list_barcodes()
  server.tool('list_barcodes', 'List all assigned barcodes with their entity type and ID. READ-ONLY.', {}, async () => {
    return json(db.getAllBarcodes(database));
  });

  // ──────────────────────────────────────────────────────────
  // SUPPLIERS
  // ──────────────────────────────────────────────────────────

  // Example: manage_suppliers({ action: 'list' })
  // Example: manage_suppliers({ action: 'create', mat: 'hardwood', name: 'Beispiel GmbH', url: 'https://example.de' })
  server.tool(
    'manage_suppliers',
    'Create, update, delete, or list substrate suppliers. Actions: list, create/update (upsert), delete. Suppliers are linked to materials: hardwood, wheatbran, gypsum, grain.',
    {
      action: z.enum(['list', 'create', 'update', 'delete']).describe('Action to perform'),
      id: z.number().optional().describe('Supplier ID (required for update/delete)'),
      mat: z
        .enum(['hardwood', 'wheatbran', 'gypsum', 'grain'])
        .optional()
        .describe('Material type (required for create)'),
      name: z.string().optional().describe('Supplier name (required for create)'),
      url: z.string().optional().describe('Website URL'),
      phone: z.string().optional().describe('Phone number'),
      notes: z.string().optional().describe('Notes')
    },
    async (params) => {
      const adminErr = requireAdminRole();
      if (adminErr) return adminErr;
      try {
        switch (params.action) {
          case 'list':
            return json(db.listSuppliers(database));
          case 'create':
          case 'update': {
            if (params.action === 'create' && (!params.mat || !params.name)) {
              return errResult('mat and name are required for create');
            }
            const id = db.upsertSupplier(database, {
              id: params.id || undefined,
              mat: params.mat,
              name: params.name,
              url: params.url || null,
              phone: params.phone || null,
              notes: params.notes || null
            });
            notify();
            return json({ success: true, action: params.action, id: Number(id) });
          }
          case 'delete': {
            if (params.id == null) return errResult('id is required for delete');
            db.deleteSupplier(database, params.id);
            notify();
            return json({ success: true, action: 'delete', id: params.id });
          }
          default:
            return errResult('Unknown action: ' + params.action);
        }
      } catch (e) {
        return safeErrResult(e);
      }
    }
  );

  // ──────────────────────────────────────────────────────────
  // KPI
  // ──────────────────────────────────────────────────────────

  // Example: get_kpi_history({ limit: 30 })
  server.tool(
    'get_kpi_history',
    'Get KPI snapshots: yield/bag, contamination rate, bags created, stock levels, pipeline counts over time. READ-ONLY historical data.',
    {
      limit: z.number().optional().describe('Max snapshots to return (default: all, most recent first)')
    },
    async (params) => {
      return json(db.getKpiSnapshots(database, params.limit || undefined));
    }
  );

  // ──────────────────────────────────────────────────────────
  // USERS
  // ──────────────────────────────────────────────────────────

  // Example: list_users()
  server.tool(
    'list_users',
    'List users. Everyone gets id and username, which is what assigneeIds need. Admins additionally get role, the can_ship / can_release flags and creation dates. READ-ONLY.',
    {},
    async () => {
      // The web UI splits this on purpose: GET /api/usernames hands every
      // logged-in user {id, username}, GET /api/users returns the whole row
      // behind an admin check. This tool returned the whole row to everyone,
      // and any worker can mint themselves an MCP token through /oauth —
      // so role and the two capability flags were readable by exactly the
      // people they exist to hold back. can_ship is the one that matters
      // there: it reaches postage and the customer's name. Knowing who holds
      // it is a target list.
      //
      // The split is mirrored rather than the tool refused: looking up an
      // assignee is what it is for, and that works on the projection.
      if (!isAdminCaller()) return json(db.listUsersPublic(database));
      return json(db.listUsers(database));
    }
  );

  // ──────────────────────────────────────────────────────────
  // CONTAMINATION REPORT
  // ──────────────────────────────────────────────────────────

  // Example: get_contamination_report({ groupBy: 'species', startDate: '2025-01-01' })
  server.tool(
    'get_contamination_report',
    'Get contamination statistics grouped by species, zone, or month. Shows contamination counts and reason breakdown. READ-ONLY. To log contamination use move_bags with reason.',
    {
      groupBy: z.enum(['species', 'zone', 'month']).optional().describe('Aggregation dimension (default: month)'),
      startDate: z.string().optional().describe('ISO date — start of range'),
      endDate: z.string().optional().describe('ISO date — end of range')
    },
    async (params) => {
      return json(db.getContaminationReport(database, params.groupBy || 'month', params.startDate, params.endDate));
    }
  );

  // ──────────────────────────────────────────────────────────
  // RECIPES
  // ──────────────────────────────────────────────────────────

  // Example: manage_recipes({ action: 'create', name: 'Beispielrezept', hardwoodPct: 85, wheatbranPct: 15, rhPct: 60 })
  server.tool(
    'manage_recipes',
    'Create, update, or delete reusable substrate recipes. Recipes store hardwood%, wheatbran%, gypsum%, rh% for quick batch creation. Use recipeId in create_batch to auto-fill substrate fields.',
    {
      action: z.enum(['create', 'update', 'delete']).describe('Action to perform'),
      id: z.number().optional().describe('Recipe ID (required for update/delete)'),
      name: z.string().optional().describe('Recipe name (required for create, unique)'),
      hardwoodPct: z.number().optional().describe('Hardwood percentage'),
      wheatbranPct: z.number().optional().describe('Wheat bran percentage'),
      gypsumPct: z.number().optional().describe('Gypsum percentage'),
      rhPct: z.number().optional().describe('Relative humidity percentage'),
      notes: z.string().optional().describe('Notes')
    },
    async (params) => {
      const adminErr = requireAdminRole();
      if (adminErr) return adminErr;
      try {
        switch (params.action) {
          case 'create': {
            if (!params.name) return errResult('name is required for create');
            const id = db.insertRecipe(database, {
              name: params.name,
              hardwood_pct: params.hardwoodPct || 0,
              wheatbran_pct: params.wheatbranPct || 0,
              gypsum_pct: params.gypsumPct || 0,
              rh_pct: params.rhPct || 0,
              notes: params.notes || null,
              created: new Date().toISOString()
            });
            notify();
            return json({ success: true, action: 'create', id: Number(id), name: params.name });
          }
          case 'update': {
            if (params.id == null) return errResult('id is required for update');
            db.updateRecipe(database, params.id, {
              name: params.name,
              hardwood_pct: params.hardwoodPct,
              wheatbran_pct: params.wheatbranPct,
              gypsum_pct: params.gypsumPct,
              rh_pct: params.rhPct,
              notes: params.notes
            });
            notify();
            return json({ success: true, action: 'update', id: params.id });
          }
          case 'delete': {
            if (params.id == null) return errResult('id is required for delete');
            const removed = db.deleteRecipe(database, params.id);
            if (!removed) return errResult('Recipe not found: ' + params.id);
            notify();
            return json({ success: true, action: 'delete', id: params.id });
          }
          default:
            return errResult('Unknown action: ' + params.action);
        }
      } catch (e) {
        return safeErrResult(e);
      }
    }
  );

  // Example: list_recipes()
  server.tool(
    'list_recipes',
    'List all substrate recipes with their compositions. READ-ONLY. Use manage_recipes to create/update/delete.',
    {},
    async () => {
      return json(db.getAllRecipes(database));
    }
  );

  // ──────────────────────────────────────────────────────────
  // TRACEABILITY
  // ──────────────────────────────────────────────────────────

  // Example: trace_lineage({ entityType: 'batch', entityId: 'FB-2025-042' })
  server.tool(
    'trace_lineage',
    'Trace the origin chain of a batch or culture backwards: batch → source culture → parent culture → ... Shows the full production genealogy. READ-ONLY.',
    {
      entityType: z.enum(['batch', 'culture']).describe('Type of entity to trace'),
      entityId: z.string().describe('Batch ID or Culture ID')
    },
    async (params) => {
      return json({ chain: db.traceLineageBack(database, params.entityType, params.entityId) });
    }
  );

  // Example: trace_forward({ cultureId: 'MC-KINGS-250301-01' })
  server.tool(
    'trace_forward',
    'Trace everything produced from a culture forward: child cultures, batches, and harvests. Shows the complete downstream output. READ-ONLY.',
    {
      cultureId: z.string().describe('Culture ID to trace from')
    },
    async (params) => {
      return json(db.traceLineageForward(database, params.cultureId));
    }
  );

  // ──────────────────────────────────────────────────────────
  // PRODUCTION PIPELINE
  // ──────────────────────────────────────────────────────────

  // Example: get_production_pipeline()
  server.tool(
    'get_production_pipeline',
    'Get a full production pipeline overview: active cultures by type/status, batches by type and phase (incubating vs ready), bags per zone with capacity utilization. READ-ONLY snapshot of the entire operation.',
    {},
    async () => {
      return json(db.getProductionPipeline(database));
    }
  );

  // ──────────────────────────────────────────────────────────
  // MAINTENANCE
  // ──────────────────────────────────────────────────────────

  // Example: schedule_maintenance({ type: 'autoclave_cycle', assetId: 'AK-001', scheduledDate: '2025-04-15' })
  server.tool(
    'schedule_maintenance',
    'Schedule a maintenance task for a piece of equipment or a zone (e.g. autoclave cycle, HEPA filter change, laminar flow cleaning). Creates an open maintenance entry with a due date.',
    {
      type: z.string().describe('Maintenance type (e.g. autoclave_cycle, hepa_filter, cleaning, calibration)'),
      assetId: z
        .string()
        .optional()
        .describe('Free-text equipment identifier, e.g. "AK-001" (for equipment maintenance)'),
      zoneId: z.string().optional().describe('Zone ID (for room/zone maintenance)'),
      description: z.string().optional().describe('Detailed description'),
      scheduledDate: z.string().optional().describe('ISO date when maintenance is due'),
      notes: z.string().optional().describe('Notes')
    },
    async (params) => {
      try {
        if (!params.assetId && !params.zoneId) {
          return errResult('Either assetId or zoneId is required');
        }
        const id = db.insertMaintenance(database, {
          assetId: params.assetId || null,
          zoneId: params.zoneId || null,
          type: params.type,
          description: params.description || null,
          scheduledDate: params.scheduledDate || null,
          notes: params.notes || null
        });
        notify();
        return json({ success: true, id: Number(id), type: params.type });
      } catch (e) {
        return safeErrResult(e);
      }
    }
  );

  // Example: complete_maintenance({ id: 1, completedBy: 'Alice' })
  server.tool(
    'complete_maintenance',
    'Mark a scheduled maintenance task as completed. Records who completed it and when.',
    {
      id: z.number().describe('Maintenance log entry ID'),
      completedBy: z.string().optional().describe('Name of person who completed the maintenance'),
      notes: z.string().optional().describe('Completion notes')
    },
    async (params) => {
      try {
        db.completeMaintenance(database, params.id, params.completedBy || null, params.notes || null);
        notify();
        return json({ success: true, id: params.id });
      } catch (e) {
        return safeErrResult(e);
      }
    }
  );

  // Example: get_maintenance_due()
  server.tool(
    'get_maintenance_due',
    'Get all due/overdue maintenance tasks (not yet completed). READ-ONLY. To schedule new maintenance use schedule_maintenance, to complete use complete_maintenance.',
    {
      assetId: z.string().optional().describe('Filter by equipment identifier'),
      zoneId: z.string().optional().describe('Filter by zone ID'),
      limit: z.number().optional().describe('Max entries (for history)')
    },
    async (params) => {
      if (params.assetId || params.zoneId || params.limit) {
        return json(
          db.getMaintenanceHistory(database, params.assetId || null, params.zoneId || null, params.limit || 50)
        );
      }
      return json(db.getMaintenanceDue(database));
    }
  );

  // ──────────────────────────────────────────────────────────
  // LABEL PRINTING
  // ──────────────────────────────────────────────────────────

  server.tool(
    'get_printer_status',
    'Check whether the Zebra label printer is connected and available',
    {},
    async () => {
      if (!printer || !printer.checkPrinterAvailable) {
        return errResult('Printer functions not available (server not configured for printing)');
      }
      return new Promise((resolve) => {
        printer.checkPrinterAvailable((err, found) => {
          resolve(json({ available: !!found, printerName: 'ZDesigner GK420d' }));
        });
      });
    }
  );

  server.tool(
    'print_bag_labels',
    'Generate and print bag labels for a batch. Set preview=true to return ZPL without printing.',
    {
      batchId: z.string().describe('Batch ID (e.g. FB-2025-042)'),
      detail: z
        .enum(['minimal', 'sorte', 'full'])
        .optional()
        .describe('Label detail level (default: sorte). minimal=barcode+ID, sorte=+strain/notes, full=+due date'),
      qr: z.boolean().optional().describe('Use QR code instead of barcode (default: false)'),
      bagFrom: z.number().optional().describe('Start of bag range (1-based, inclusive)'),
      bagTo: z.number().optional().describe('End of bag range (1-based, inclusive)'),
      preview: z.boolean().optional().describe('If true, return ZPL string without sending to printer (default: false)')
    },
    async (params) => {
      try {
        const batch = db.readBatchById(database, params.batchId);
        if (!batch) return errResult('Batch not found: ' + params.batchId);

        let bags = batch.bags;
        if (params.bagFrom || params.bagTo) {
          const from = (params.bagFrom || 1) - 1;
          const to = params.bagTo || bags.length;
          bags = bags.slice(from, to);
        }
        if (!bags.length) return errResult('No bags in selected range');

        const barcodes = db.assignBarcodes(database, 'bag', bags);
        const detail = params.detail || 'sorte';
        const useQr = params.qr || false;

        // Jeder Beutel traegt sein eigenes Gewicht -- siehe bagLabelKg in app.js.
        const zpl = bags
          .map((bagId) =>
            itemsToZPL(bagLabelItems(bagId, batch, detail, barcodes[bagId], useQr, bagLabelKg(batch, bagId)))
          )
          .join('\n');

        if (params.preview) {
          return json({ success: true, batchId: params.batchId, labelCount: bags.length, zpl });
        }

        if (!printer || !printer.printZPL) {
          return errResult('Printer functions not available (server not configured for printing)');
        }

        return new Promise((resolve) => {
          printer.checkPrinterAvailable((_, found) => {
            if (!found) {
              resolve(errResult('Printer not found. Check that the Zebra printer is connected and powered on.'));
              return;
            }
            printer.printZPL(zpl, (err) => {
              if (err) {
                resolve(errResult('Print failed: ' + err));
              } else {
                resolve(json({ success: true, batchId: params.batchId, labelCount: bags.length, printed: true }));
              }
            });
          });
        });
      } catch (e) {
        return safeErrResult(e);
      }
    }
  );

  server.tool(
    'print_culture_labels',
    'Generate and print labels for mushroom cultures. Set preview=true to return ZPL without printing.',
    {
      cultureIds: z.array(z.string()).describe('Array of culture IDs to print (e.g. ["MC-KINGS-250301-01"])'),
      detail: z
        .enum(['minimal', 'sorte', 'full'])
        .optional()
        .describe('Label detail level (default: sorte). minimal=barcode+ID, sorte=+species/strain, full=+date'),
      qr: z.boolean().optional().describe('Use QR code instead of barcode (default: false)'),
      preview: z.boolean().optional().describe('If true, return ZPL string without sending to printer (default: false)')
    },
    async (params) => {
      try {
        if (!params.cultureIds.length) return errResult('No culture IDs provided');
        const allCultures = db.getAllCultures(database);
        const cultureMap = new Map(allCultures.map((c) => [c.id, c]));

        const missing = params.cultureIds.filter((id) => !cultureMap.has(id));
        if (missing.length) return errResult('Cultures not found: ' + missing.join(', '));

        const barcodes = db.assignBarcodes(database, 'culture', params.cultureIds);
        const detail = params.detail || 'sorte';
        const useQr = params.qr || false;

        const zpl = params.cultureIds
          .map((id) => {
            const c = cultureMap.get(id);
            return itemsToZPL(labLabelItems(id, c, detail, barcodes[id], useQr));
          })
          .join('\n');

        if (params.preview) {
          return json({ success: true, labelCount: params.cultureIds.length, zpl });
        }

        if (!printer || !printer.printZPL) {
          return errResult('Printer functions not available (server not configured for printing)');
        }

        return new Promise((resolve) => {
          printer.checkPrinterAvailable((_, found) => {
            if (!found) {
              resolve(errResult('Printer not found. Check that the Zebra printer is connected and powered on.'));
              return;
            }
            printer.printZPL(zpl, (err) => {
              if (err) {
                resolve(errResult('Print failed: ' + err));
              } else {
                resolve(json({ success: true, labelCount: params.cultureIds.length, printed: true }));
              }
            });
          });
        });
      } catch (e) {
        return safeErrResult(e);
      }
    }
  );

  return server;
}

module.exports = {
  createMcpServer,
  buildBagLocationMap,
  bcParams,
  zplText,
  itemsToZPL,
  bagLabelItems,
  labLabelItems,
  labelTextW,
  labelWrap,
  labelGlyphs,
  fmtDt
};