formlab-mcp 0.3.0 → 0.4.0

package/README.md

@@ -34,6 +34,7 @@ Ask Claude (or another MCP client) things like:
 | `list_ingredients` | Filtered list of raw materials. Filters: `family`, `supplier`, `name_contains`, `in_stock_only`, `ingredient_class` (small-molecule / surfactant / polymer / extract / fragrance / pigment / sequence / mixture), `sequence_contains` (e.g. `KTTKS` → Matrixyl), `taxon_contains` (e.g. `Centella`) |
 | `get_ingredient` | Full record + supplier / **cost ($/kg)** / stock / formulations using it, plus **GHS safety** (pictograms, H/P codes, signal word), **per-jurisdiction regulatory status**, and **inventory lots** (balances + expiry). Returns every class-specific sub-object when present: `sequence` (peptide / oligo), `taxon` (NCBI ID + scientific name), `ingredientClass`, `extractDetails`, `sequenceDetails`, `polymerDetails`, `surfactantDetails`, `pigmentDetails`, `fragranceDetails` |
 | `list_lots` | Inventory lots across ingredients (each a received batch with its own remaining balance, supplier, expiry). Filters: `ingredient_id`, `expiring_within_days`, `status` |
+| `list_inventory` | Portfolio stock rollup — one row per ingredient with on-hand qty, summed lot balance, nearest expiry, and a low-stock flag (on-hand ≤ `reorderThreshold`, or zero). Filters: `low_stock_only`, `expiring_within_days`, `family` |
 | `list_batches` | Filtered list of production / lab-prep events |
 | `get_batch` | Full record + actual composition + samples + blend lineage |
 | `list_samples` | Filtered list of physical specimens |
@@ -44,6 +45,18 @@ Ask Claude (or another MCP client) things like:
 | `find_failures` | Pareto-style: parameters that fail acceptance most often |
 | `get_coverage_matrix` | Which formulations × parameters have been measured |
 | `find_by_smarts` | SMARTS-pattern substructure search across every ingredient with a SMILES. Requires `@rdkit/rdkit` (optional dependency — install with `npm install @rdkit/rdkit` in `mcp/` if you get a "not installed" error). Examples: `c1ccccc1` (any aromatic 6-ring), `[OX2H1]` (any hydroxyl), `C(=O)O` (carboxylic acid), `[F,Cl,Br,I]` (any halogen). |
+| `list_equipment` | Filtered list of the Equipment registry (mixers, ovens, viscometers, balances…). Filters: `category`, `status`, `manufacturer`, `name_contains` |
+| `get_equipment` | Full equipment record + a summary of where it's used (panels, step presets, test methods, formulas, batches) |
+| `list_test_methods` | Filtered list of Test Methods (the parameter library). Filter by `analyte` (the property measured, e.g. `Viscosity` — finds every method for it), `category`, `name_contains`, `include_retired` |
+| `get_test_method` | Full method definition (SOP / sample prep / equipment / calculation / acceptance spec) + sibling methods sharing its analyte |
+| `list_step_presets` | Filtered list of Step Presets (reusable procedure steps: duration / temp / RPM / equipment). Filters: `industry`, `name_contains` |
+| `get_step_preset` | Full step-preset record incl. the multi-value equipment list (`{name, equipmentId}`) |
+| `list_test_panels` | Filtered list of Test Panels (reusable column-sets — the parameters measured together on a sample). Filters: `industry`, `name_contains` |
+| `get_test_panel` | Full panel record — ordered parameter list (each with resolved Test Method UID, unit, spec) + instruments |
+| `list_projects` | Filtered list of projects (the buckets formulations are filed under) + per-project formulation count. Filters: `status`, `name_contains` |
+| `get_project` | Full project record + the formulations filed under it |
+| `list_notebook_entries` | ELN feed — dated authored notes attached to records. Filters: `entity_type`, `entity_id`, `author`, `text_contains`, `since`, `until` |
+| `get_notebook_entry` | One notebook entry — full body, author, attachment metadata, resolved linked record |
 
 ## Install
 
@@ -129,7 +142,7 @@ Or for local-dev (from the repo):
 }
 ```
 
-Restart Claude Desktop. You should see a hammer icon indicating tools are available, and FormLab's 17 tools become callable in any conversation.
+Restart Claude Desktop. You should see a hammer icon indicating tools are available, and FormLab's 30 tools become callable in any conversation.
 
 ## Wire it up to Claude Code
 

package/index.js

@@ -7,7 +7,7 @@
 //   FORMLAB_EXPORT=/path/to/export.json node index.js
 //   formlab-mcp /path/to/export.json   (when installed via npm)
 //
-// Exposes 17 tools (see ./tools/) over stdio. The MCP host (Claude
+// Exposes 30 tools (see ./tools/) over stdio. The MCP host (Claude
 // Desktop, Claude Code, etc.) handles tool discovery, invocation
 // and response formatting. We just register handlers and stay out
 // of the way.
@@ -30,6 +30,9 @@ import * as formulations from './tools/formulations.js';
 import * as ingredients  from './tools/ingredients.js';
 import * as lab          from './tools/lab.js';
 import * as analytics    from './tools/analytics.js';
+import * as library      from './tools/library.js';
+import * as projects     from './tools/projects.js';
+import * as notebook     from './tools/notebook.js';
 
 // ----- Data source: LIVE cloud workspace OR a static export file -----
 // Cloud mode kicks in when the Supabase env vars are present (copy them from
@@ -97,17 +100,20 @@ if (CLOUD) {
 }
 
 // All tools live in tools/*.js as a flat { definition, handler } pair.
-// Concatenate the four modules' exports into a single registry the
-// MCP server can use for both list_tools and call_tool dispatch.
+// Concatenate every module's exports into a single registry the MCP
+// server can use for both list_tools and call_tool dispatch.
 const TOOLS = [
   ...Object.values(formulations.tools),
   ...Object.values(ingredients.tools),
   ...Object.values(lab.tools),
   ...Object.values(analytics.tools),
+  ...Object.values(library.tools),
+  ...Object.values(projects.tools),
+  ...Object.values(notebook.tools),
 ];
 
 const server = new Server(
-  { name: 'formlab-mcp', version: '0.1.0' },
+  { name: 'formlab-mcp', version: '0.4.0' },
   { capabilities: { tools: {} } }
 );
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "formlab-mcp",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "mcpName": "io.github.juliu1980/formlab-mcp",
   "description": "Read-only Model Context Protocol server for FormLab — lets Claude (and other MCP clients) read and analyze your FormLab data, from a local export file OR your live cloud workspace.",
   "type": "module",

package/tools/ingredients.js

@@ -328,4 +328,81 @@ const list_lots = {
   },
 };
 
-export const tools = { list_ingredients, get_ingredient, find_by_smarts, list_lots };
+// =====================================================================
+// list_inventory — portfolio stock view. One row per ingredient rolling
+// up on-hand quantity, lot balances, nearest expiry, and a low-stock flag
+// (stockOnHand at/below its reorderThreshold, or zero). Answers "what's
+// low / expiring / out" across the whole library in a single call —
+// list_lots is per-lot and get_ingredient is one ingredient at a time.
+// =====================================================================
+const list_inventory = {
+  definition: {
+    name: 'list_inventory',
+    description: 'Portfolio inventory status — one row per ingredient with on-hand quantity, summed lot balance, lot count, nearest lot expiry, and a low-stock flag (on-hand at/below its reorder threshold, or zero). Filter to low-stock or expiring items. Sorted low-stock first, then by on-hand ascending.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        low_stock_only: { type: 'boolean', description: 'Only ingredients flagged low (on-hand ≤ reorderThreshold, or on-hand is 0).' },
+        expiring_within_days: { type: 'number', description: 'Only ingredients with a lot expiring within this many days from now (already-expired lots always qualify).' },
+        family: { type: 'string', description: 'Filter by ingredient family. Case-insensitive substring.' },
+        limit: { type: 'number', description: 'Max rows (default 200, max 1000).' },
+      },
+    },
+  },
+  handler: async (args) => {
+    const { db } = getStore();
+    const limit = Math.min(1000, Math.max(1, args.limit || 200));
+    const norm = (s) => String(s || '').toLowerCase();
+    const nowMs = Date.now();
+    // Group lots by ingredient once (avoids an O(n²) scan per ingredient).
+    const lotsByIng = new Map();
+    (db.lots || []).forEach(l => {
+      if (!l || l._trashed || !l.ingredientId) return;
+      if (!lotsByIng.has(l.ingredientId)) lotsByIng.set(l.ingredientId, []);
+      lotsByIng.get(l.ingredientId).push(l);
+    });
+    const rows = (db.ingredients || []).filter(i => {
+      if (!i || i._trashed) return false;
+      if (args.family && !norm(i.family).includes(norm(args.family))) return false;
+      return true;
+    }).map(i => {
+      const lots = lotsByIng.get(i.id) || [];
+      const onHand = i.stockOnHand != null ? Number(i.stockOnHand) : null;
+      const reorder = i.reorderThreshold != null ? Number(i.reorderThreshold) : null;
+      const lotBalance = lots.reduce((s, l) => s + (isFinite(Number(l.qtyRemaining)) ? Number(l.qtyRemaining) : 0), 0);
+      const expiries = lots.map(l => Date.parse(l.expiryDate)).filter(isFinite);
+      const nearestExpiryMs = expiries.length ? Math.min(...expiries) : null;
+      const lowStock = (onHand === 0) || (onHand != null && reorder != null && onHand <= reorder);
+      return {
+        id: i.id, uid: i.uid, name: i.name || '', family: i.family || '',
+        stockOnHand: onHand, stockUnit: i.stockUnit || null,
+        reorderThreshold: reorder,
+        lotCount: lots.length,
+        lotBalance: lots.length ? +lotBalance.toFixed(4) : null,
+        nearestExpiry: nearestExpiryMs != null ? new Date(nearestExpiryMs).toISOString().slice(0, 10) : null,
+        daysToNearestExpiry: nearestExpiryMs != null ? Math.floor((nearestExpiryMs - nowMs) / 86400000) : null,
+        lowStock,
+      };
+    }).filter(r => {
+      if (args.low_stock_only && !r.lowStock) return false;
+      if (args.expiring_within_days != null) {
+        if (r.daysToNearestExpiry == null) return false;
+        if (r.daysToNearestExpiry > args.expiring_within_days) return false;
+      }
+      return true;
+    }).sort((a, b) => {
+      if (a.lowStock !== b.lowStock) return a.lowStock ? -1 : 1;
+      const av = a.stockOnHand == null ? Infinity : a.stockOnHand;
+      const bv = b.stockOnHand == null ? Infinity : b.stockOnHand;
+      return av - bv;
+    });
+    return {
+      totalMatching: rows.length,
+      returned: Math.min(rows.length, limit),
+      lowStockCount: rows.filter(r => r.lowStock).length,
+      inventory: rows.slice(0, limit),
+    };
+  },
+};
+
+export const tools = { list_ingredients, get_ingredient, find_by_smarts, list_lots, list_inventory };

package/tools/library.js

@@ -0,0 +1,360 @@
+// ============================================================
+// LIBRARY TOOLS — the shared reference entities that Panels,
+// Step Presets, formula steps, and test results point at:
+//   - Equipment       (list_equipment / get_equipment)
+//   - Test Methods    (list_test_methods / get_test_method)   [db.parameters]
+//   - Step Presets    (list_step_presets / get_step_preset)   [db.procedureTemplates]
+//   - Test Panels     (list_test_panels / get_test_panel)     [db.templates]
+//
+// All read-only. These expose the first-class Equipment registry,
+// the parameter/analyte library, and reusable procedure steps —
+// previously synced into the store but not queryable.
+// ============================================================
+
+import { getStore, resolveById } from '../data.js';
+
+const _norm = (s) => String(s == null ? '' : s).toLowerCase();
+const _clampLimit = (n) => Math.min(1000, Math.max(1, n || 100));
+
+// ── Equipment ───────────────────────────────────────────────
+function _trimEquipment(e) {
+  if (!e) return null;
+  return {
+    id: e.id, uid: e.uid, name: e.name || '',
+    category: e.category || '', status: e.status || '',
+    model: e.model || '', serial: e.serial || '',
+    manufacturer: e.manufacturer || '', location: e.location || '',
+    owner: e.owner || '', assetTag: e.assetTag || '',
+    ...(e.notes ? { notes: e.notes } : {}),
+  };
+}
+
+// Where an equipment record is referenced. Prefers the stable equipmentId,
+// falls back to a case-insensitive exact name match (legacy free-text entries).
+function _equipUsage(e, db) {
+  const id = e.id;
+  const nm = _norm(e.name);
+  const instMatch = (arr) => (arr || []).some(x =>
+    (x.equipmentId && x.equipmentId === id) || (!x.equipmentId && _norm(x.name) === nm));
+  const fieldMatch = (eqId, eqName) =>
+    (eqId && eqId === id) || (!eqId && nm && _norm(eqName) === nm);
+  // A step references equipment via the new equipmentList[] or the legacy flat field.
+  const stepMatch = (s) =>
+    (Array.isArray(s.equipmentList) && s.equipmentList.some(le => fieldMatch(le.equipmentId, le.name)))
+    || fieldMatch(s.equipmentId, s.equipment);
+
+  const panels   = (db.templates || []).filter(t => instMatch(t.instruments));
+  const presets  = (db.procedureTemplates || []).filter(t =>
+    instMatch(t.instruments) || (Array.isArray(t.equipmentList) && t.equipmentList.some(le => fieldMatch(le.equipmentId, le.name))) || fieldMatch(t.equipmentId, t.equipment));
+  const methods  = (db.parameters || []).filter(p => fieldMatch(p.equipmentId, p.equipment));
+  const formulas = (db.formulations || []).filter(f => (f.steps || []).some(stepMatch));
+  const batches  = (db.batches || []).filter(b =>
+    fieldMatch(b.equipmentUsedId, b.equipmentUsed) || (b.steps || []).some(stepMatch));
+  const name = (arr) => arr.map(x => x.uid || x.name).slice(0, 20);
+  return {
+    total: panels.length + presets.length + methods.length + formulas.length + batches.length,
+    panels: name(panels), stepPresets: name(presets), testMethods: name(methods),
+    formulas: name(formulas), batches: name(batches),
+  };
+}
+
+const list_equipment = {
+  definition: {
+    name: 'list_equipment',
+    description: 'List equipment / instruments in the FormLab Equipment registry (mixers, ovens, viscometers, balances…), optionally filtered by category, status, manufacturer, or name. Returns metadata; use get_equipment for one record plus where it is used.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        category: { type: 'string', description: 'Filter by category (e.g. "Viscometers & rheology", "Mixing & dispersion"). Case-insensitive substring.' },
+        status: { type: 'string', description: 'Filter by status (e.g. "In service", "Retired"). Case-insensitive substring.' },
+        manufacturer: { type: 'string', description: 'Filter by manufacturer. Case-insensitive substring.' },
+        name_contains: { type: 'string', description: 'Case-insensitive substring on equipment name / model / serial / asset tag.' },
+        limit: { type: 'number', description: 'Max rows (default 100, max 1000).' },
+      },
+    },
+  },
+  handler: async (args) => {
+    const { db } = getStore();
+    const limit = _clampLimit(args.limit);
+    const filtered = (db.equipment || []).filter(e => {
+      if (!e || e._trashed) return false;
+      if (args.category && !_norm(e.category).includes(_norm(args.category))) return false;
+      if (args.status && !_norm(e.status).includes(_norm(args.status))) return false;
+      if (args.manufacturer && !_norm(e.manufacturer).includes(_norm(args.manufacturer))) return false;
+      if (args.name_contains) {
+        const q = _norm(args.name_contains);
+        const hay = [e.name, e.model, e.serial, e.assetTag].map(_norm).join(' ');
+        if (!hay.includes(q)) return false;
+      }
+      return true;
+    });
+    return {
+      totalMatching: filtered.length,
+      returned: Math.min(filtered.length, limit),
+      equipment: filtered.slice(0, limit).map(_trimEquipment),
+    };
+  },
+};
+
+const get_equipment = {
+  definition: {
+    name: 'get_equipment',
+    description: 'Get one equipment record by UID (e.g. EQP-001) or id, including a summary of everywhere it is referenced (test panels, step presets, test methods, formulas, batches).',
+    inputSchema: {
+      type: 'object',
+      properties: { id: { type: 'string', description: 'Equipment UID or internal id.' } },
+      required: ['id'],
+    },
+  },
+  handler: async (args) => {
+    const { db } = getStore();
+    const e = resolveById('equipment', args.id);
+    if (!e) return { error: `No equipment found for "${args.id}".` };
+    return { ...(_trimEquipment(e)), usedIn: _equipUsage(e, db) };
+  },
+};
+
+// ── Test Methods (parameters) ───────────────────────────────
+function _trimMethod(p, { full = false } = {}) {
+  if (!p) return null;
+  const base = {
+    id: p.id, uid: p.uid, name: p.name || '',
+    analyte: p.analyte || '',
+    category: p.category || '', type: p.type || 'scalar',
+    defaultUnit: p.defaultUnit || '', defaultMethod: p.defaultMethod || '',
+    spec: p.specRaw || '', decimals: p.decimals != null ? p.decimals : null,
+    retired: !!p.retired,
+  };
+  if (!full) return base;
+  return {
+    ...base,
+    acceptanceCriteria: p.acceptanceCriteria || null,
+    sopText: p.sopText || '', samplePrep: p.samplePrep || '',
+    equipment: p.equipment || '', equipmentId: p.equipmentId || '',
+    calcFormula: p.calcFormula || '', version: p.version != null ? p.version : null,
+    approvedBy: p.approvedBy || '', notes: p.notes || '',
+  };
+}
+
+const list_test_methods = {
+  definition: {
+    name: 'list_test_methods',
+    description: 'List Test Methods (the parameter library — the canonical definition of each measured reading: viscosity, gloss, pH…), optionally filtered by analyte (the property measured), category, name, or retired state. Methods of the same property at different conditions share an analyte.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        analyte: { type: 'string', description: 'Filter by analyte / property (e.g. "Viscosity"). Case-insensitive substring — finds every method measuring that property.' },
+        category: { type: 'string', description: 'Filter by category. Case-insensitive substring.' },
+        name_contains: { type: 'string', description: 'Case-insensitive substring on method name / default method-standard.' },
+        include_retired: { type: 'boolean', description: 'Include retired methods (default false).' },
+        limit: { type: 'number', description: 'Max rows (default 100, max 1000).' },
+      },
+    },
+  },
+  handler: async (args) => {
+    const { db } = getStore();
+    const limit = _clampLimit(args.limit);
+    const filtered = (db.parameters || []).filter(p => {
+      if (!p || p._trashed) return false;
+      if (!args.include_retired && p.retired) return false;
+      if (args.analyte && !_norm(p.analyte).includes(_norm(args.analyte))) return false;
+      if (args.category && !_norm(p.category).includes(_norm(args.category))) return false;
+      if (args.name_contains) {
+        const q = _norm(args.name_contains);
+        if (!_norm(p.name).includes(q) && !_norm(p.defaultMethod).includes(q)) return false;
+      }
+      return true;
+    });
+    return {
+      totalMatching: filtered.length,
+      returned: Math.min(filtered.length, limit),
+      testMethods: filtered.slice(0, limit).map(p => _trimMethod(p)),
+    };
+  },
+};
+
+const get_test_method = {
+  definition: {
+    name: 'get_test_method',
+    description: 'Get one Test Method by UID (e.g. PARAM-001) or id — full definition including SOP / sample prep / equipment / calculation / acceptance spec, plus sibling methods that share its analyte (the same property measured at other conditions).',
+    inputSchema: {
+      type: 'object',
+      properties: { id: { type: 'string', description: 'Test Method UID or internal id.' } },
+      required: ['id'],
+    },
+  },
+  handler: async (args) => {
+    const { db } = getStore();
+    const p = resolveById('parameters', args.id);
+    if (!p) return { error: `No test method found for "${args.id}".` };
+    const an = _norm(p.analyte);
+    const siblings = an
+      ? (db.parameters || []).filter(x => x.id !== p.id && _norm(x.analyte) === an).map(x => x.uid || x.name).slice(0, 20)
+      : [];
+    return { ...(_trimMethod(p, { full: true })), analyteSiblings: siblings };
+  },
+};
+
+// ── Step Presets (procedureTemplates) ───────────────────────
+function _trimPreset(t, { full = false } = {}) {
+  if (!t) return null;
+  const eqList = (Array.isArray(t.equipmentList) && t.equipmentList.length)
+    ? t.equipmentList.map(e => ({ name: e.name || '', equipmentId: e.equipmentId || '' })).filter(e => e.name)
+    : (t.equipment ? [{ name: t.equipment, equipmentId: t.equipmentId || '' }] : []);
+  const base = {
+    id: t.id, uid: t.uid, name: t.name || '',
+    industry: t.industry || '',
+    duration: t.duration != null ? t.duration : null,
+    temperature: t.temperature != null ? t.temperature : null,
+    rpm: t.rpm != null ? t.rpm : null,
+    equipment: eqList,
+  };
+  if (!full) return { ...base, description: (t.description || '').slice(0, 200) };
+  return { ...base, description: t.description || '', notes: t.notes || '' };
+}
+
+const list_step_presets = {
+  definition: {
+    name: 'list_step_presets',
+    description: 'List Step Presets (reusable manufacturing-step definitions — duration / temperature / RPM / equipment used when building a formula procedure), optionally filtered by industry or name. Equipment is the multi-value list of {name, equipmentId}.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        industry: { type: 'string', description: 'Filter by industry (e.g. "Paints & Coatings"). Case-insensitive substring.' },
+        name_contains: { type: 'string', description: 'Case-insensitive substring on preset name / description.' },
+        limit: { type: 'number', description: 'Max rows (default 100, max 1000).' },
+      },
+    },
+  },
+  handler: async (args) => {
+    const { db } = getStore();
+    const limit = _clampLimit(args.limit);
+    const filtered = (db.procedureTemplates || []).filter(t => {
+      if (!t || t._trashed) return false;
+      if (args.industry && !_norm(t.industry).includes(_norm(args.industry))) return false;
+      if (args.name_contains) {
+        const q = _norm(args.name_contains);
+        if (!_norm(t.name).includes(q) && !_norm(t.description).includes(q)) return false;
+      }
+      return true;
+    });
+    return {
+      totalMatching: filtered.length,
+      returned: Math.min(filtered.length, limit),
+      stepPresets: filtered.slice(0, limit).map(t => _trimPreset(t)),
+    };
+  },
+};
+
+const get_step_preset = {
+  definition: {
+    name: 'get_step_preset',
+    description: 'Get one Step Preset by UID (e.g. PROC-001) or id — full description, notes, conditions, and equipment list (each {name, equipmentId}).',
+    inputSchema: {
+      type: 'object',
+      properties: { id: { type: 'string', description: 'Step Preset UID or internal id.' } },
+      required: ['id'],
+    },
+  },
+  handler: async (args) => {
+    const t = resolveById('procedureTemplates', args.id);
+    if (!t) return { error: `No step preset found for "${args.id}".` };
+    return _trimPreset(t, { full: true });
+  },
+};
+
+// ── Test Panels (templates) ─────────────────────────────────
+// A Test Panel is a reusable column-set: the ordered list of parameters
+// (test methods) measured together on a sample, plus the instruments used.
+// Each parameter row carries {parameter (name), parameterId, unit, spec…};
+// we resolve parameterId back to the Test Method UID for cross-reference.
+function _trimPanelParam(row, db) {
+  if (!row) return null;
+  const method = row.parameterId
+    ? (db.parameters || []).find(p => p && p.id === row.parameterId)
+    : null;
+  return {
+    parameter: row.parameter || row.name || '',
+    parameterId: row.parameterId || null,
+    methodUid: method ? (method.uid || null) : null,
+    unit: row.unit || (method && method.defaultUnit) || '',
+    ...(row.spec ? { spec: row.spec } : {}),
+    ...(row.method ? { method: row.method } : {}),
+  };
+}
+
+function _trimPanel(t, db, { full = false } = {}) {
+  if (!t) return null;
+  const params = Array.isArray(t.parameters) ? t.parameters : [];
+  const base = {
+    id: t.id, uid: t.uid, name: t.name || '',
+    industry: t.industry || '',
+    instruments: t.instruments || [],
+    parameterCount: params.length,
+  };
+  if (!full) return { ...base, description: (t.description || '').slice(0, 200) };
+  return {
+    ...base,
+    description: t.description || '',
+    notes: t.notes || '',
+    parameters: params.map(row => _trimPanelParam(row, db)),
+  };
+}
+
+const list_test_panels = {
+  definition: {
+    name: 'list_test_panels',
+    description: 'List Test Panels (reusable column-sets — the ordered group of parameters measured together on a sample, e.g. a "QC release" panel), optionally filtered by industry or name. Returns metadata + parameter count; use get_test_panel for the full parameter list.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        industry: { type: 'string', description: 'Filter by industry. Case-insensitive substring.' },
+        name_contains: { type: 'string', description: 'Case-insensitive substring on panel name / description.' },
+        limit: { type: 'number', description: 'Max rows (default 100, max 1000).' },
+      },
+    },
+  },
+  handler: async (args) => {
+    const { db } = getStore();
+    const limit = _clampLimit(args.limit);
+    const filtered = (db.templates || []).filter(t => {
+      if (!t || t._trashed) return false;
+      if (args.industry && !_norm(t.industry).includes(_norm(args.industry))) return false;
+      if (args.name_contains) {
+        const q = _norm(args.name_contains);
+        if (!_norm(t.name).includes(q) && !_norm(t.description).includes(q)) return false;
+      }
+      return true;
+    });
+    return {
+      totalMatching: filtered.length,
+      returned: Math.min(filtered.length, limit),
+      testPanels: filtered.slice(0, limit).map(t => _trimPanel(t, db)),
+    };
+  },
+};
+
+const get_test_panel = {
+  definition: {
+    name: 'get_test_panel',
+    description: 'Get one Test Panel by UID (e.g. TMPL-001) or id — full ordered parameter list (each with its resolved Test Method UID, unit, and spec), instruments, and notes.',
+    inputSchema: {
+      type: 'object',
+      properties: { id: { type: 'string', description: 'Test Panel UID or internal id.' } },
+      required: ['id'],
+    },
+  },
+  handler: async (args) => {
+    const { db } = getStore();
+    const t = resolveById('templates', args.id);
+    if (!t) return { error: `No test panel found for "${args.id}".` };
+    return _trimPanel(t, db, { full: true });
+  },
+};
+
+export const tools = {
+  list_equipment, get_equipment,
+  list_test_methods, get_test_method,
+  list_step_presets, get_step_preset,
+  list_test_panels, get_test_panel,
+};

package/tools/notebook.js

@@ -0,0 +1,128 @@
+// ============================================================
+// NOTEBOOK TOOLS — the ELN thread. Each notebook entry is a dated,
+// authored note attached to some record (ingredient, formulation,
+// batch, sample, test result, project…) via {entityType, entityId}.
+//   - list_notebook_entries: filtered feed (by entity, author, text, date)
+//   - get_notebook_entry:    one entry, full body + attachment metadata
+//
+// The store syncs notebook_entries but nothing surfaced them, so the
+// lab's written record was invisible to the model. Read-only.
+// ============================================================
+
+import { getStore, resolveById } from '../data.js';
+
+const _norm = (s) => String(s == null ? '' : s).toLowerCase();
+const _clampLimit = (n) => Math.min(1000, Math.max(1, n || 100));
+
+// entityType → the db collection it points at, so we can resolve a
+// human label (uid / name) for the record an entry is attached to.
+const _ENTITY_COLLECTION = {
+  ingredient: 'ingredients', formulation: 'formulations', batch: 'batches',
+  sample: 'samples', test: 'testResults', testResult: 'testResults',
+  project: 'projects', equipment: 'equipment', parameter: 'parameters',
+};
+
+function _resolveEntity(entityType, entityId, db) {
+  const coll = _ENTITY_COLLECTION[entityType];
+  if (!coll || !entityId) return null;
+  const rec = (db[coll] || []).find(x => x && (x.id === entityId || x.uid === entityId));
+  if (!rec) return null;
+  return { uid: rec.uid || null, name: rec.name || rec.title || '' };
+}
+
+function _entryTs(e) { return e.ts || e.createdAt || e.updatedAt || null; }
+
+function _trimEntry(e, db, { full = false } = {}) {
+  if (!e) return null;
+  const linked = _resolveEntity(e.entityType, e.entityId, db);
+  const atts = Array.isArray(e.attachments) ? e.attachments : [];
+  const base = {
+    id: e.id,
+    entityType: e.entityType || '',
+    entityId: e.entityId || '',
+    entityUid: linked ? linked.uid : null,
+    entityName: linked ? linked.name : '',
+    ts: _entryTs(e),
+    updatedAt: e.updatedAt || null,
+    author: e.author || '',
+    attachmentCount: atts.length,
+  };
+  if (!full) return { ...base, body: (e.body || '').slice(0, 240) };
+  return {
+    ...base,
+    body: e.body || '',
+    attachments: atts.map(a => ({ id: a.id || null, filename: a.filename || '', type: a.type || '' })),
+  };
+}
+
+const list_notebook_entries = {
+  definition: {
+    name: 'list_notebook_entries',
+    description: 'List ELN notebook entries — dated, authored notes attached to records — optionally filtered by the record they hang off (entity_type + entity_id), author, text, or date range. Newest first. Use get_notebook_entry for the full body + attachments.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        entity_type: { type: 'string', description: 'Kind of record the note is attached to: ingredient, formulation, batch, sample, test, project, equipment, parameter.' },
+        entity_id: { type: 'string', description: 'The specific record the note is attached to (internal id or UID, e.g. FORM-001). Resolved to its id automatically.' },
+        author: { type: 'string', description: 'Filter by author. Case-insensitive substring.' },
+        text_contains: { type: 'string', description: 'Case-insensitive substring on the note body.' },
+        since: { type: 'string', description: 'ISO date/time — only entries at or after this timestamp.' },
+        until: { type: 'string', description: 'ISO date/time — only entries at or before this timestamp.' },
+        limit: { type: 'number', description: 'Max rows (default 100, max 1000).' },
+      },
+    },
+  },
+  handler: async (args) => {
+    const { db } = getStore();
+    const limit = _clampLimit(args.limit);
+    // Resolve a UID-or-id entity reference down to its internal id so the
+    // filter matches regardless of which form the caller passed.
+    let wantEntityId = args.entity_id || null;
+    if (wantEntityId) {
+      const coll = _ENTITY_COLLECTION[args.entity_type] || null;
+      const rec = coll ? (db[coll] || []).find(x => x && (x.id === wantEntityId || x.uid === wantEntityId)) : null;
+      if (rec) wantEntityId = rec.id;
+    }
+    const sinceMs = args.since ? Date.parse(args.since) : null;
+    const untilMs = args.until ? Date.parse(args.until) : null;
+    const filtered = (db.notebookEntries || []).filter(e => {
+      if (!e || e._trashed) return false;
+      if (args.entity_type && _norm(e.entityType) !== _norm(args.entity_type)) return false;
+      if (wantEntityId && e.entityId !== wantEntityId) return false;
+      if (args.author && !_norm(e.author).includes(_norm(args.author))) return false;
+      if (args.text_contains && !_norm(e.body).includes(_norm(args.text_contains))) return false;
+      if (sinceMs != null || untilMs != null) {
+        const t = Date.parse(_entryTs(e));
+        if (!isFinite(t)) return false;
+        if (sinceMs != null && t < sinceMs) return false;
+        if (untilMs != null && t > untilMs) return false;
+      }
+      return true;
+    }).sort((a, b) => Date.parse(_entryTs(b) || 0) - Date.parse(_entryTs(a) || 0));
+    return {
+      totalMatching: filtered.length,
+      returned: Math.min(filtered.length, limit),
+      entries: filtered.slice(0, limit).map(e => _trimEntry(e, db)),
+    };
+  },
+};
+
+const get_notebook_entry = {
+  definition: {
+    name: 'get_notebook_entry',
+    description: 'Get one ELN notebook entry by id — full note body, author, timestamp, the record it is attached to (resolved to uid/name), and attachment metadata (filename / type). Attachment binaries are not returned.',
+    inputSchema: {
+      type: 'object',
+      properties: { id: { type: 'string', description: 'Internal id of the notebook entry.' } },
+      required: ['id'],
+    },
+  },
+  handler: async (args) => {
+    const { db } = getStore();
+    const e = (db.notebookEntries || []).find(x => x && x.id === args.id);
+    if (!e) return { error: `No notebook entry found for id "${args.id}".` };
+    return _trimEntry(e, db, { full: true });
+  },
+};
+
+export const tools = { list_notebook_entries, get_notebook_entry };

package/tools/projects.js

@@ -0,0 +1,90 @@
+// ============================================================
+// PROJECT TOOLS
+//   - list_projects: the project register (name / status / description)
+//   - get_project:   one project + the formulations filed under it
+//
+// Projects are the top-level organizing bucket: formulations point at a
+// project via `projectId`. Previously the store synced projects but they
+// were only usable as a *filter* on list_formulations — never listable or
+// openable on their own. These two tools close that gap.
+// ============================================================
+
+import { getStore, resolveById } from '../data.js';
+
+const _norm = (s) => String(s == null ? '' : s).toLowerCase();
+const _clampLimit = (n) => Math.min(1000, Math.max(1, n || 100));
+
+function _trimProject(p, formulationCount) {
+  if (!p) return null;
+  return {
+    id: p.id, uid: p.uid, name: p.name || '',
+    status: p.status || '',
+    description: (p.description || '').slice(0, 200),
+    createdAt: p.createdAt || null,
+    updatedAt: p.updatedAt || null,
+    formulationCount,
+  };
+}
+
+// Formulations filed under a project (top-level projectId link).
+function _projectFormulas(projectId, db) {
+  return (db.formulations || []).filter(f => f && !f._trashed && f.projectId === projectId);
+}
+
+const list_projects = {
+  definition: {
+    name: 'list_projects',
+    description: 'List projects — the top-level buckets that formulations are filed under — optionally filtered by status or name. Each row includes how many formulations belong to the project. Use get_project for one project plus its formulation list.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        status: { type: 'string', description: 'Filter by status (e.g. "Active", "On hold"). Case-insensitive substring.' },
+        name_contains: { type: 'string', description: 'Case-insensitive substring on project name / description.' },
+        limit: { type: 'number', description: 'Max rows (default 100, max 1000).' },
+      },
+    },
+  },
+  handler: async (args) => {
+    const { db } = getStore();
+    const limit = _clampLimit(args.limit);
+    const filtered = (db.projects || []).filter(p => {
+      if (!p || p._trashed) return false;
+      if (args.status && !_norm(p.status).includes(_norm(args.status))) return false;
+      if (args.name_contains) {
+        const q = _norm(args.name_contains);
+        if (!_norm(p.name).includes(q) && !_norm(p.description).includes(q)) return false;
+      }
+      return true;
+    });
+    return {
+      totalMatching: filtered.length,
+      returned: Math.min(filtered.length, limit),
+      projects: filtered.slice(0, limit).map(p => _trimProject(p, _projectFormulas(p.id, db).length)),
+    };
+  },
+};
+
+const get_project = {
+  definition: {
+    name: 'get_project',
+    description: 'Get one project by UID (e.g. PROJ-001) or id — full description plus the list of formulations filed under it (id / uid / name / status).',
+    inputSchema: {
+      type: 'object',
+      properties: { id: { type: 'string', description: 'Project UID or internal id.' } },
+      required: ['id'],
+    },
+  },
+  handler: async (args) => {
+    const { db } = getStore();
+    const p = resolveById('projects', args.id);
+    if (!p) return { error: `No project found for "${args.id}".` };
+    const formulas = _projectFormulas(p.id, db);
+    return {
+      ..._trimProject(p, formulas.length),
+      description: p.description || '',
+      formulations: formulas.slice(0, 200).map(f => ({ id: f.id, uid: f.uid, name: f.name || '', status: f.status || '' })),
+    };
+  },
+};
+
+export const tools = { list_projects, get_project };