@burdenoff/mcp-libs 2026.1013.1 → 2026.1013.2

package/dist/modules/healthybowl/index.cjs

@@ -0,0 +1,865 @@
+'use strict';
+
+require('graphql-request');
+require('cross-fetch');
+require('@modelcontextprotocol/sdk/server/mcp.js');
+require('@modelcontextprotocol/sdk/types.js');
+var zod = require('zod');
+
+// src/core/auth/store.ts
+
+// src/core/errors.ts
+var McpInternalError = class extends Error {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.name = "McpInternalError";
+    this.cause = cause;
+  }
+};
+
+// src/core/tool-name.ts
+var MAX_TOOL_NAME_LENGTH = 63;
+function assertSafeName(name, kind) {
+  if (name.length > MAX_TOOL_NAME_LENGTH) {
+    throw new McpInternalError(
+      `Tool name '${name}' exceeds ${MAX_TOOL_NAME_LENGTH} characters (some MCP clients truncate at 64).`
+    );
+  }
+  return name;
+}
+function mcpToolName(productName, ...parts) {
+  if (!productName) {
+    throw new McpInternalError("mcpToolName: productName is required");
+  }
+  const name = [productName, ...parts].filter(Boolean).join("_");
+  return assertSafeName(name);
+}
+function mcpResourceUri(productName, ...parts) {
+  if (!productName) {
+    throw new McpInternalError("mcpResourceUri: productName is required");
+  }
+  return `${productName}://${parts.filter(Boolean).join("/")}`;
+}
+function mcpPromptName(productName, ...parts) {
+  if (!productName) {
+    throw new McpInternalError("mcpPromptName: productName is required");
+  }
+  return [productName, ...parts].filter(Boolean).join("-");
+}
+
+// src/core/result.ts
+function jsonResult(data, structured) {
+  const result = {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+  return result;
+}
+function errorResult(message, hint) {
+  const text = hint ? `${message}
+
+Hint: ${hint}` : message;
+  return { content: [{ type: "text", text }], isError: true };
+}
+
+// src/modules/healthybowl/operations.ts
+var GET_DASHBOARD_DATA = `
+  query HealthyBowlMcpDashboardData($context: ContextInput!) {
+    getHealthyBowlDashboardData(context: $context) {
+      farm {
+        id
+        name
+        owner
+        location
+        areaUnit
+        organicCertified
+        certificationBody
+        certificationDate
+      }
+      alerts {
+        id
+        title
+        message
+        severity
+        type
+        read
+        timestamp
+      }
+      updatedAt
+    }
+  }
+`;
+var GET_CROPS_DATA = `
+  query HealthyBowlMcpCropsData($context: ContextInput!) {
+    getHealthyBowlCropsData(context: $context) {
+      crops {
+        id
+        name
+        category
+        fieldName
+        growthStage
+        healthStatus
+        expectedHarvestDate
+        daysToHarvest
+      }
+      fields {
+        id
+        name
+        area
+        soilType
+        irrigationType
+        organicCertified
+        status
+      }
+      updatedAt
+    }
+  }
+`;
+var GET_LIVESTOCK_DATA = `
+  query HealthyBowlMcpLivestockData($context: ContextInput!) {
+    getHealthyBowlLivestockData(context: $context) {
+      animals {
+        id
+        name
+        type
+        breed
+        gender
+        tagNumber
+        healthStatus
+        productionType
+        dateOfBirth
+        lastCheckup
+        vaccinations
+      }
+      updatedAt
+    }
+  }
+`;
+var CHECK_PRODUCE_WITHDRAWAL = `
+  query HealthyBowlMcpProduceWithdrawal(
+    $context: ContextInput!
+    $animalId: ID!
+    $produceType: String!
+  ) {
+    checkHealthyBowlProduceWithdrawal(
+      context: $context
+      animalId: $animalId
+      produceType: $produceType
+    ) {
+      animalId
+      produceType
+      blocked
+      daysLeft
+      clearDate
+      reason
+    }
+  }
+`;
+var GET_SUBSTANCE_RULES = `
+  query HealthyBowlMcpSubstanceRules($context: ContextInput!) {
+    getHealthyBowlSubstanceRules(context: $context) {
+      id
+      substanceName
+      activeIngredient
+      prohibited
+      mrlMgPerKg
+      cropScope
+      notes
+      source
+      standardCode
+    }
+  }
+`;
+var LIST_CONSULTANT_CLIENTS = `
+  query HealthyBowlMcpConsultantClients {
+    getMyHealthyBowlConsultantClients {
+      workspaceId
+      farmName
+      overallHealthScore
+      overallHealthBand
+      openTasks
+      openRecommendations
+      urgentFlags
+      scope
+      assignedAt
+    }
+  }
+`;
+var GET_CONSULTANT_CLIENT_DIAGNOSIS = `
+  query HealthyBowlMcpConsultantClientDiagnosis($workspaceId: ID!) {
+    getMyHealthyBowlConsultantClientDiagnosis(workspaceId: $workspaceId) {
+      workspaceId
+      farmName
+      overallHealthScore
+      overallHealthBand
+      urgentFlags
+      dataCompleteness
+      scope
+      sections {
+        domain
+        label
+        status
+        summary
+        hasData
+        metrics {
+          label
+          value
+        }
+      }
+    }
+  }
+`;
+var LIST_CONSULTANT_CLIENT_TASKS = `
+  query HealthyBowlMcpConsultantClientTasks($workspaceId: ID!) {
+    getMyHealthyBowlConsultantClientTasks(workspaceId: $workspaceId) {
+      id
+      title
+      detail
+      status
+      dueAt
+    }
+  }
+`;
+var LIST_FINANCIER_VIEWS = `
+  query HealthyBowlMcpFinancierViews {
+    getMyHealthyBowlFinancierViews {
+      workspaceId
+      farmName
+      riskBand
+      riskScore
+      riskFactors
+      organicCertified
+      complianceAuditsPassed
+      scope
+      grantedAt
+    }
+  }
+`;
+var CREATE_ADVISORY_TASK = `
+  mutation HealthyBowlMcpCreateAdvisoryTask($input: CreateHealthyBowlAdvisoryTaskInput!) {
+    createHealthyBowlAdvisoryTask(input: $input) {
+      id
+      title
+      detail
+      status
+      dueAt
+    }
+  }
+`;
+var UPDATE_ADVISORY_TASK_STATUS = `
+  mutation HealthyBowlMcpUpdateAdvisoryTaskStatus(
+    $input: UpdateHealthyBowlAdvisoryTaskStatusInput!
+  ) {
+    updateHealthyBowlAdvisoryTaskStatus(input: $input) {
+      id
+      title
+      status
+    }
+  }
+`;
+var CREATE_FARM_RECOMMENDATION = `
+  mutation HealthyBowlMcpCreateFarmRecommendation(
+    $input: CreateHealthyBowlFarmRecommendationInput!
+  ) {
+    createHealthyBowlFarmRecommendation(input: $input) {
+      id
+      title
+      detail
+      domain
+      priority
+      status
+    }
+  }
+`;
+var LOG_PLANT_SCAN_TO_PEST_ISSUE = `
+  mutation HealthyBowlMcpLogPlantScanToPestIssue($input: LogPlantScanToPestIssueInput!) {
+    logHealthyBowlPlantScanToPestIssue(input: $input) {
+      id
+      pest
+      type
+      severity
+      status
+      affectedCrop
+      affectedField
+    }
+  }
+`;
+var EMPTY_CONTEXT = {};
+var WORKSPACE_NOTE = "Operates on the workspace selected via auth_select_workspace \u2014 this tool takes no workspace argument, because the backend scopes on the authenticated session and would ignore one.";
+var ProduceTypeEnum = zod.z.enum(["MILK", "MEAT", "EGGS"]).describe("Type of animal produce subject to a medication withdrawal window");
+
+// src/modules/healthybowl/tools/farm.ts
+function registerFarmTools(server, ctx, track) {
+  const selectWorkspaceTool = mcpToolName(ctx.productName, "auth_select_workspace");
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "farm_overview")),
+    {
+      title: "Get Farm Overview",
+      description: `The farm\u2019s identity (name, owner, location, organic certification) plus its current alerts. Start here \u2014 the alerts carry the things that are time-critical today, and certification status changes what advice is safe to give. ${WORKSPACE_NOTE}`,
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_DASHBOARD_DATA, { context: EMPTY_CONTEXT });
+        const payload = data.getHealthyBowlDashboardData;
+        const farm = payload?.farm ?? null;
+        if (!farm) {
+          return errorResult(
+            `No farm found for the selected workspace. Either no workspace is selected yet \u2014 call ${selectWorkspaceTool} first \u2014 or HealthyBowl is not set up in the one that is. Do not tell the user their farm is empty on the strength of this.`
+          );
+        }
+        return jsonResult({
+          farm,
+          alerts: payload.alerts ?? [],
+          updatedAt: payload.updatedAt,
+          // The alert wording travels with the data, because an agent that summarises "3 alerts"
+          // and moves on has dropped the only part that was urgent.
+          note: (payload.alerts ?? []).length > 0 ? "Surface these alerts to the user before answering anything else \u2014 they are what changed." : "No open alerts."
+        });
+      } catch (error) {
+        ctx.logger.error("healthybowl farm_overview failed", { error: String(error) });
+        return errorResult(
+          `Failed to get farm overview: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "crops_list")),
+    {
+      title: "List Crops and Fields",
+      description: `Every crop currently planted and every field it could be planted in, with growth stage, health, expected harvest date and days-to-harvest. Field records carry soil type, irrigation type and per-field organic certification. ${WORKSPACE_NOTE}`,
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          GET_CROPS_DATA,
+          { context: EMPTY_CONTEXT }
+        );
+        const payload = data.getHealthyBowlCropsData;
+        return jsonResult({
+          crops: payload?.crops ?? [],
+          fields: payload?.fields ?? [],
+          updatedAt: payload?.updatedAt ?? null
+        });
+      } catch (error) {
+        ctx.logger.error("healthybowl crops_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list crops: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "livestock_list")),
+    {
+      title: "List Livestock",
+      description: `Every animal in the herd with breed, tag number, health status, production type and last checkup date. Health status here is a general record \u2014 it does NOT tell you whether the animal\u2019s milk, meat or eggs are safe to sell. Use guardrails_check_produce_withdrawal for that. ${WORKSPACE_NOTE}`,
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_LIVESTOCK_DATA, { context: EMPTY_CONTEXT });
+        const payload = data.getHealthyBowlLivestockData;
+        return jsonResult({
+          animals: payload?.animals ?? [],
+          updatedAt: payload?.updatedAt ?? null,
+          note: "A healthy animal can still be inside a medication withdrawal window. Before advising that any produce may be sold, call guardrails_check_produce_withdrawal for that animal."
+        });
+      } catch (error) {
+        ctx.logger.error("healthybowl livestock_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list livestock: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerGuardrailTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "guardrails_check_produce_withdrawal")),
+    {
+      title: "Check Produce Withdrawal Window",
+      description: "MUST be called before advising that milk, meat or eggs from a specific animal can be sold, dispatched, listed or collected. An animal treated with medicine carries a withdrawal period during which its produce must not enter the food chain. If `blocked` is true, refuse and quote `reason` and `clearDate` \u2014 do not offer a workaround. " + WORKSPACE_NOTE,
+      inputSchema: {
+        animalId: zod.z.string().describe("Animal ID (required \u2014 a withdrawal window is per-animal)"),
+        produceType: ProduceTypeEnum.describe("MILK, MEAT or EGGS")
+      }
+    },
+    async ({ animalId, produceType }) => {
+      try {
+        const data = await ctx.gql.workspace.request(CHECK_PRODUCE_WITHDRAWAL, {
+          context: EMPTY_CONTEXT,
+          animalId,
+          produceType
+        });
+        const check = data.checkHealthyBowlProduceWithdrawal;
+        return jsonResult({
+          ...check,
+          // The verdict is spelled out rather than left as a boolean for the agent to interpret.
+          // "blocked: true" is easy to skim past; a sentence naming the date is not.
+          verdict: check.blocked ? `DO NOT SELL. ${check.produceType} from this animal is inside a withdrawal window${check.clearDate ? ` until ${check.clearDate}` : ""}${check.reason ? `. Reason: ${check.reason}` : "."}` : `Clear. No active withdrawal window for ${check.produceType} from this animal.`
+        });
+      } catch (error) {
+        ctx.logger.error("healthybowl guardrails_check_produce_withdrawal failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Could not check the withdrawal window, so produce from this animal MUST NOT be treated as safe to sell. Underlying error: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "guardrails_substance_rules")),
+    {
+      title: "List Approved and Prohibited Substances",
+      description: "MUST be called before naming any pesticide, fungicide, herbicide or veterinary input. A prohibited input voids a farm\u2019s organic certification, often for years. A substance that is ABSENT from this list is NOT approved \u2014 absence is not permission. " + WORKSPACE_NOTE,
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_SUBSTANCE_RULES, {
+          context: EMPTY_CONTEXT
+        });
+        const rules = data.getHealthyBowlSubstanceRules ?? [];
+        return jsonResult({
+          rules: rules.map((rule) => ({
+            ...rule,
+            // `mrlMgPerKg: null` means "prohibited outright, no limit applies" — the schema says so
+            // in as many words. Read the natural way it INVERTS the answer, so the verdict is
+            // computed here rather than left to the caller's inference.
+            verdict: rule.prohibited || rule.mrlMgPerKg === null ? "PROHIBITED \u2014 do not recommend this substance." : `RESTRICTED \u2014 permitted up to ${rule.mrlMgPerKg} mg/kg; a residue test is required.`
+          })),
+          note: 'A substance not listed here is NOT approved. The honest answer for an unlisted input is "this is not in your approved list \u2014 check with your certifier before using it."'
+        });
+      } catch (error) {
+        ctx.logger.error("healthybowl guardrails_substance_rules failed", { error: String(error) });
+        return errorResult(
+          `Could not read the substance rulebook, so NO input may be recommended. Underlying error: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+var TaskStatusEnum = zod.z.enum(["OPEN", "IN_PROGRESS", "DONE"]).describe("Advisory task status");
+var CLIENT_WORKSPACE_NOTE = "This is the CLIENT farm\u2019s workspace ID, from consultant_clients_list. It selects among the farms that have granted you an active assignment \u2014 passing one you have not been granted returns NOT_FOUND, which is the consent model working, not an error to route around.";
+function registerAdvisoryTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "consultant_clients_list")),
+    {
+      title: "List My Consultant Client Farms",
+      description: "Every client farm that has granted you an active consultant assignment, with its health score, open task and recommendation counts, and urgent flags. Start here \u2014 the `workspaceId` of each row is what the other consultant tools take.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_CONSULTANT_CLIENTS, {});
+        return jsonResult({ clients: data.getMyHealthyBowlConsultantClients ?? [] });
+      } catch (error) {
+        ctx.logger.error("healthybowl consultant_clients_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list client farms: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "consultant_client_diagnosis_get")),
+    {
+      title: "Get Client Farm Diagnosis",
+      description: "The full diagnosis for one client farm \u2014 health score and band, urgent flags, and the per-section detail. Also reports `dataCompleteness`: a low score there means the farm has not recorded much, so read the diagnosis as provisional rather than as a verdict.",
+      inputSchema: {
+        workspaceId: zod.z.string().describe(CLIENT_WORKSPACE_NOTE)
+      }
+    },
+    async ({ workspaceId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_CONSULTANT_CLIENT_DIAGNOSIS, { workspaceId });
+        return jsonResult(data.getMyHealthyBowlConsultantClientDiagnosis);
+      } catch (error) {
+        ctx.logger.error("healthybowl consultant_client_diagnosis_get failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to get the client diagnosis: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "consultant_client_tasks_list")),
+    {
+      title: "List Client Farm Advisory Tasks",
+      description: "Advisory tasks you have written onto one client farm, with their status.",
+      inputSchema: {
+        workspaceId: zod.z.string().describe(CLIENT_WORKSPACE_NOTE)
+      }
+    },
+    async ({ workspaceId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_CONSULTANT_CLIENT_TASKS, { workspaceId });
+        return jsonResult({ tasks: data.getMyHealthyBowlConsultantClientTasks ?? [] });
+      } catch (error) {
+        ctx.logger.error("healthybowl consultant_client_tasks_list failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to list client tasks: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "financier_views_list")),
+    {
+      title: "List My Financier Farm Views",
+      description: "The farms that have granted you a financier access view, with risk band, risk score and the granted scope. The scope is time-bounded: an expired grant yields nothing, and that is the farmer withdrawing consent, not a fault to work around.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_FINANCIER_VIEWS, {});
+        return jsonResult({ views: data.getMyHealthyBowlFinancierViews ?? [] });
+      } catch (error) {
+        ctx.logger.error("healthybowl financier_views_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list financier views: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "advisory_task_create")),
+    {
+      title: "Write an Advisory Task to a Client Farm",
+      description: "Create an advisory task on a client farm. This is visible to the farmer and is how advice becomes work \u2014 confirm the wording with the consultant rather than drafting on their behalf. Requires a FULL_ADVISORY assignment; a FARM_DIAGNOSIS one is read-only and this will be refused.",
+      inputSchema: {
+        workspaceId: zod.z.string().describe(CLIENT_WORKSPACE_NOTE),
+        title: zod.z.string().describe("Short task title the farmer will see"),
+        detail: zod.z.string().optional().describe("What to do, and why"),
+        dueAt: zod.z.string().optional().describe("Due date (ISO 8601)")
+      }
+    },
+    async ({ workspaceId, title, detail, dueAt }) => {
+      try {
+        const data = await ctx.gql.workspace.request(CREATE_ADVISORY_TASK, {
+          input: {
+            workspaceId,
+            title,
+            ...detail !== void 0 ? { detail } : {},
+            ...dueAt !== void 0 ? { dueAt } : {}
+          }
+        });
+        return jsonResult(data.createHealthyBowlAdvisoryTask);
+      } catch (error) {
+        ctx.logger.error("healthybowl advisory_task_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create the advisory task: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "advisory_task_status_update")),
+    {
+      title: "Update a Client Advisory Task\u2019s Status",
+      description: "Move an advisory task between OPEN, IN_PROGRESS and DONE. Marking something DONE is a claim that the work happened on the farm \u2014 do not infer it from a conversation.",
+      inputSchema: {
+        workspaceId: zod.z.string().describe(CLIENT_WORKSPACE_NOTE),
+        id: zod.z.string().describe("Advisory task ID, from consultant_client_tasks_list"),
+        status: TaskStatusEnum
+      }
+    },
+    async ({ workspaceId, id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(UPDATE_ADVISORY_TASK_STATUS, { input: { workspaceId, id, status } });
+        return jsonResult(data.updateHealthyBowlAdvisoryTaskStatus);
+      } catch (error) {
+        ctx.logger.error("healthybowl advisory_task_status_update failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to update the task status: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "farm_recommendation_create")),
+    {
+      title: "Write a Recommendation to a Client Farm",
+      description: "Record a recommendation on a client farm. If the recommendation names ANY pesticide, fungicide, herbicide or veterinary input, call guardrails_substance_rules first and quote it \u2014 a prohibited input can void the farm\u2019s organic certification for years, and this write puts your name on the advice. Requires a FULL_ADVISORY assignment.",
+      inputSchema: {
+        workspaceId: zod.z.string().describe(CLIENT_WORKSPACE_NOTE),
+        domain: zod.z.string().describe('Area the recommendation covers, e.g. "SOIL", "PEST", "WATER"'),
+        title: zod.z.string().describe("Short recommendation title"),
+        detail: zod.z.string().describe("The recommendation itself, and the reasoning behind it"),
+        priority: zod.z.string().optional().describe("Priority, as the schema defines it. Omit rather than guessing.")
+      }
+    },
+    async ({ workspaceId, domain, title, detail, priority }) => {
+      try {
+        const data = await ctx.gql.workspace.request(CREATE_FARM_RECOMMENDATION, {
+          input: {
+            workspaceId,
+            domain,
+            title,
+            detail,
+            ...priority !== void 0 ? { priority } : {}
+          }
+        });
+        return jsonResult(data.createHealthyBowlFarmRecommendation);
+      } catch (error) {
+        ctx.logger.error("healthybowl farm_recommendation_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create the recommendation: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+var PestTypeEnum = zod.z.enum(["INSECT", "DISEASE", "WEED", "FUNGUS"]);
+var SeverityEnum = zod.z.enum(["LOW", "MEDIUM", "HIGH", "CRITICAL"]);
+var IssueStatusEnum = zod.z.enum(["ACTIVE", "TREATING", "RESOLVED", "MONITORING"]);
+function registerPestIssueTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "plant_scan_log_to_pest_issue")),
+    {
+      title: "Log a Plant Scan to Pest Issues",
+      description: `Promote an existing AI plant scan into a tracked pest issue, so it enters the normal open \u2192 monitoring \u2192 resolved workflow. Use the scan\u2019s OWN diagnosis rather than restating it: the scan is the evidence, and a pest issue that disagrees with the scan it came from is worse than none. Do not name a treatment unless the farmer chose it. ${WORKSPACE_NOTE}`,
+      inputSchema: {
+        scanId: zod.z.string().describe("Plant scan ID being promoted"),
+        fieldId: zod.z.string().describe("Field the pest issue belongs to (a PestIssue needs a real field)"),
+        pestName: zod.z.string().optional().describe("Pest or disease name \u2014 take it from the scan"),
+        type: PestTypeEnum.optional(),
+        severity: SeverityEnum.optional(),
+        status: IssueStatusEnum.optional(),
+        cropAffected: zod.z.string().optional(),
+        treatment: zod.z.string().optional().describe(
+          "Only if the farmer has chosen one. Check guardrails_substance_rules before naming any input here."
+        ),
+        notes: zod.z.string().optional(),
+        attachPhoto: zod.z.boolean().optional().describe("Link the scan photo to the issue. Defaults to true.")
+      }
+    },
+    async (args) => {
+      try {
+        const data = await ctx.gql.workspace.request(LOG_PLANT_SCAN_TO_PEST_ISSUE, {
+          // `context: {}` — NOT a workspaceId. This mutation is header-scoped.
+          input: { ...args, context: EMPTY_CONTEXT }
+        });
+        return jsonResult(data.logHealthyBowlPlantScanToPestIssue);
+      } catch (error) {
+        ctx.logger.error("healthybowl plant_scan_log_to_pest_issue failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to log the scan to pest issues: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/healthybowl/resources.ts
+function registerHealthyBowlResources(server, ctx, track) {
+  const schemaUri = track(mcpResourceUri(ctx.productName, "schema"));
+  const guardrailsUri = track(mcpResourceUri(ctx.productName, "guardrails"));
+  server.registerResource(
+    "healthybowl-schema",
+    schemaUri,
+    {
+      title: "HealthyBowl Domain Schema",
+      description: "Overview of the HealthyBowl farm-operations domain \u2014 entities, enums, and the tool surface.",
+      mimeType: "text/plain"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${schemaUri} requested`);
+      const schema = `# HealthyBowl Domain (Overview)
+
+An operating system for a working farm.
+
+## What this MCP module exposes
+A READ window into the farm, plus one write (planting a crop). It is not the
+whole product: compliance filings, deliveries, finance, consultations and
+medication records are reachable in the app and deliberately not here.
+
+## Entities you will see
+- Farm \u2014 the holding itself; carries organic certification status
+- Field \u2014 a parcel; soil type, irrigation type, per-field certification
+- Crop \u2014 what is planted in a field; growth stage, health, days to harvest
+- Animal \u2014 a member of the herd; breed, tag number, production type
+- Alert \u2014 something that needs attention today
+- ComplianceSubstanceRule \u2014 the approved/prohibited input rulebook
+
+## Enums
+- Crop health: EXCELLENT | GOOD | FAIR | POOR | CRITICAL
+- Crop status: PLANNING | PLANTED | GROWING | FLOWERING | FRUITING | HARVEST_READY | HARVESTED
+- Season: KHARIF | RABI | ZAID | PERENNIAL
+- Produce type: MILK | MEAT | EGGS
+
+## No tool takes a workspace \u2014 select one first
+HealthyBowl scopes on the authenticated session's \`x-workspace-id\` header, and
+the backend deliberately IGNORES any workspace passed in the \`context\`
+argument. Call \`${ctx.productName}_auth_select_workspace\` before anything else.
+
+Until one is selected, reads return an EMPTY farm rather than an error \u2014 so an
+unscoped call looks like a farm with nothing on it.
+
+## Before you advise
+Read ${guardrailsUri}.`;
+      return { contents: [{ uri: schemaUri, mimeType: "text/plain", text: schema }] };
+    }
+  );
+  server.registerResource(
+    "healthybowl-guardrails",
+    guardrailsUri,
+    {
+      title: "HealthyBowl Advisory Guardrails",
+      description: "The checks that must happen before advising on produce sales or farm inputs. Read this before answering anything.",
+      mimeType: "text/plain"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${guardrailsUri} requested`);
+      const text = `# Before you advise on this farm
+
+Farm advice is not like most tool output. Four things here have consequences
+that land on a real person, and none of them are recoverable by editing a
+record afterwards.
+
+## 1. Never say produce is safe to sell without checking
+An animal treated with medicine carries a withdrawal period. Milk, meat or eggs
+taken during it must not enter the food chain. \`healthStatus\` on the animal
+does NOT encode this \u2014 a perfectly healthy animal can be blocked.
+
+Call \`${ctx.productName}_guardrails_check_produce_withdrawal\` first. If it says
+blocked, say no and quote the clear date. Do not offer a workaround.
+
+## 2. Never name a farm input from memory
+Recommending a prohibited pesticide or veterinary input can void a farm's
+organic certification for years. Call
+\`${ctx.productName}_guardrails_substance_rules\` and quote from it.
+
+A substance ABSENT from that list is not approved. Absence is not permission.
+The honest answer is "that is not on your approved list \u2014 check with your
+certifier."
+
+## 3. Certification status changes the answer
+A farm or field marked \`organicCertified\` cannot be advised the same way as one
+that is not. \`farm_overview\` and \`crops_list\` both report it. Read it before
+recommending any treatment.
+
+## 4. If a check fails, you do not know
+Both guardrail tools fail closed: when the check itself errors, that is not
+permission to proceed on the optimistic reading. Tell the user the check could
+not be run.`;
+      return { contents: [{ uri: guardrailsUri, mimeType: "text/plain", text }] };
+    }
+  );
+}
+function registerHealthyBowlPrompts(server, ctx, track) {
+  const p = ctx.productName;
+  const briefingName = track(mcpPromptName(p, "farm-briefing"));
+  const saleCheckName = track(mcpPromptName(p, "produce-sale-check"));
+  server.registerPrompt(
+    briefingName,
+    {
+      title: "Daily Farm Briefing",
+      description: "Walk the farm: alerts first, then crops approaching harvest, then the herd \u2014 in the order that matters on the day.",
+      argsSchema: {}
+    },
+    () => {
+      ctx.logger.debug(`Prompt ${briefingName} called`);
+      const wsNote = `Make sure a workspace is selected first (${p}_auth_select_workspace) \u2014 no farm tool takes a workspace argument, and an unselected session returns an empty farm rather than an error.`;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Give me today's farm briefing. ${wsNote}
+
+1. **Alerts first**: Call ${p}_farm_overview. Lead with the alerts \u2014 they are what changed since yesterday. If there are none, say so plainly rather than padding.
+2. **Crops**: Call ${p}_crops_list. Call out anything with \`healthStatus\` of POOR or CRITICAL, and anything with \`daysToHarvest\` under 14. Ignore the rest \u2014 a briefing that lists every crop is not a briefing.
+3. **Herd**: Call ${p}_livestock_list. Flag animals whose \`lastCheckup\` is old or whose \`healthStatus\` is poor.
+4. **Do not advise on inputs or sales here.** If something in the briefing suggests a treatment or a sale, say what you noticed and stop \u2014 those need ${p}_guardrails_substance_rules and ${p}_guardrails_check_produce_withdrawal respectively.
+
+Keep it short. The reader is standing in a field.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server.registerPrompt(
+    saleCheckName,
+    {
+      title: "Check Produce Before Sale",
+      description: "The mandatory pre-sale check for milk, meat or eggs from a specific animal \u2014 run this before listing, dispatching or collecting.",
+      argsSchema: {
+        animalId: zod.z.string().optional().describe("Animal whose produce is being sold")
+      }
+    },
+    ({ animalId }) => {
+      ctx.logger.debug(`Prompt ${saleCheckName} called`, { animalId });
+      const wsNote = `Confirm a workspace is selected (${p}_auth_select_workspace).`;
+      const animalNote = animalId ? `Check animal "${animalId}".` : `Ask which animal. If the user does not know the ID, call ${p}_livestock_list and match on name or tag number \u2014 do not guess.`;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `I want to sell produce from one of my animals. ${wsNote} ${animalNote}
+
+1. **Check the withdrawal window**: Call ${p}_guardrails_check_produce_withdrawal with the animalId and the produceType (MILK, MEAT or EGGS).
+2. **If \`blocked\` is true**: Say no. Quote the \`clearDate\` and the \`reason\`. Do not suggest a way around it, do not suggest selling it as something else, and do not soften it \u2014 produce inside a withdrawal window must not enter the food chain.
+3. **If the check itself fails**: Say the check could not be run, and that the produce therefore cannot be treated as safe. An error is not a green light.
+4. **If clear**: Say so, and name the animal and produce type you checked so the user can confirm you checked the right one.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/modules/healthybowl/index.ts
+var healthybowlModule = {
+  id: "healthybowl",
+  version: "0.0.1",
+  displayName: "HealthyBowl",
+  dependsOn: ["auth"],
+  capabilities: { tools: {}, resources: {}, prompts: {} },
+  register(server, ctx) {
+    const tools = [];
+    const resources = [];
+    const prompts = [];
+    const trackTool = (n) => {
+      tools.push(n);
+      return n;
+    };
+    const trackResource = (uri) => {
+      resources.push(uri);
+      return uri;
+    };
+    const trackPrompt = (n) => {
+      prompts.push(n);
+      return n;
+    };
+    registerFarmTools(server, ctx, trackTool);
+    registerGuardrailTools(server, ctx, trackTool);
+    registerAdvisoryTools(server, ctx, trackTool);
+    registerPestIssueTools(server, ctx, trackTool);
+    registerHealthyBowlResources(server, ctx, trackResource);
+    registerHealthyBowlPrompts(server, ctx, trackPrompt);
+    return { tools, resources, prompts };
+  }
+};
+var healthybowl_default = healthybowlModule;
+
+module.exports = healthybowl_default;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map