@burdenoff/mcp-libs 2026.627.6 → 2026.629.1

package/dist/modules/labsofscience/index.cjs

@@ -0,0 +1,2039 @@
+'use strict';
+
+var zod = require('zod');
+require('graphql-request');
+require('cross-fetch');
+require('@modelcontextprotocol/sdk/server/mcp.js');
+require('@modelcontextprotocol/sdk/types.js');
+
+// src/modules/labsofscience/tools/projects.ts
+
+// src/core/errors.ts
+var McpInternalError = class extends Error {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.name = "McpInternalError";
+    this.cause = cause;
+  }
+};
+
+// 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/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/modules/labsofscience/operations.ts
+var PROJECT_FIELDS = `
+  id code name description field status visibility principalInvestigatorId
+  startDate endDate tags workspaceId createdAt updatedAt
+`;
+var EXPERIMENT_FIELDS = `
+  id title description hypothesis status projectId protocolId leadResearcherId
+  variables tags workspaceId createdAt updatedAt
+`;
+var RUN_FIELDS = `
+  id experimentId runNumber status parameters observations notes performedById
+  startedAt completedAt workspaceId createdAt updatedAt
+`;
+var PROTOCOL_STEP_FIELDS = `
+  id protocolId ordinal instruction kind durationMinutes isCritical
+  workspaceId createdAt updatedAt
+`;
+var PROTOCOL_FIELDS = `
+  id name summary status version estimatedMinutes materials safetyNotes
+  authorId publishedAt tags workspaceId createdAt updatedAt
+`;
+var DATASET_VERSION_FIELDS = `
+  id datasetId version sizeBytes rowCount checksum changeNote
+  file { id } workspaceId createdAt updatedAt
+`;
+var DATASET_FIELDS = `
+  id name description kind status latestVersion experimentId projectId
+  tags workspaceId createdAt updatedAt
+`;
+var PIPELINE_FIELDS = `
+  id name description engine definition version isActive projectId tags
+  workspaceId createdAt updatedAt
+`;
+var PIPELINE_RUN_FIELDS = `
+  id pipelineId datasetId datasetVersionId outputDatasetId status parameters
+  log triggeredById startedAt finishedAt workspaceId createdAt updatedAt
+`;
+var BOOKING_FIELDS = `
+  id instrumentId experimentId bookedById startTime endTime status purpose
+  workspaceId createdAt updatedAt
+`;
+var INSTRUMENT_FIELDS = `
+  id name model location status requiresApproval custodianId tags
+  workspaceId createdAt updatedAt
+`;
+var INVENTORY_FIELDS = `
+  id name category status quantity unit reorderLevel location vendor
+  catalogNumber lotNumber expiresAt sds { id } tags workspaceId
+  createdAt updatedAt
+`;
+var NOTEBOOK_FIELDS = `
+  id title body status projectId experimentId runId authorId signedById
+  signedAt witnessedById witnessedAt files { id } tags workspaceId
+  createdAt updatedAt
+`;
+var PAGE_INFO = `pageInfo { cursor hasMore }`;
+var GET_PROJECT = `
+  query LabsofscienceGetProject($id: ID!) {
+    labProject(id: $id) {
+      ${PROJECT_FIELDS}
+      experiments { id title status }
+    }
+  }
+`;
+var LIST_PROJECTS = `
+  query LabsofscienceListProjects($status: LabProjectStatus, $pagination: PaginationInput) {
+    labListProjects(status: $status, pagination: $pagination) {
+      items { ${PROJECT_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_PROJECT = `
+  mutation LabsofscienceCreateProject($input: LabCreateProjectInput!) {
+    labCreateProject(input: $input) {
+      ${PROJECT_FIELDS}
+    }
+  }
+`;
+var UPDATE_PROJECT = `
+  mutation LabsofscienceUpdateProject($id: ID!, $input: LabUpdateProjectInput!) {
+    labUpdateProject(id: $id, input: $input) {
+      ${PROJECT_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_PROJECT = `
+  mutation LabsofscienceArchiveProject($id: ID!) {
+    labArchiveProject(id: $id)
+  }
+`;
+var GET_EXPERIMENT = `
+  query LabsofscienceGetExperiment($id: ID!) {
+    labExperiment(id: $id) {
+      ${EXPERIMENT_FIELDS}
+      project { id name }
+      runs { id runNumber status }
+    }
+  }
+`;
+var LIST_EXPERIMENTS = `
+  query LabsofscienceListExperiments(
+    $projectId: ID
+    $status: LabExperimentStatus
+    $pagination: PaginationInput
+  ) {
+    labListExperiments(projectId: $projectId, status: $status, pagination: $pagination) {
+      items { ${EXPERIMENT_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_EXPERIMENT = `
+  mutation LabsofscienceCreateExperiment($input: LabCreateExperimentInput!) {
+    labCreateExperiment(input: $input) {
+      ${EXPERIMENT_FIELDS}
+    }
+  }
+`;
+var UPDATE_EXPERIMENT = `
+  mutation LabsofscienceUpdateExperiment($id: ID!, $input: LabUpdateExperimentInput!) {
+    labUpdateExperiment(id: $id, input: $input) {
+      ${EXPERIMENT_FIELDS}
+    }
+  }
+`;
+var TRANSITION_EXPERIMENT = `
+  mutation LabsofscienceTransitionExperiment($id: ID!, $status: LabExperimentStatus!) {
+    labTransitionExperiment(id: $id, status: $status) {
+      ${EXPERIMENT_FIELDS}
+    }
+  }
+`;
+var LIST_RUNS = `
+  query LabsofscienceListRuns(
+    $experimentId: ID
+    $status: LabRunStatus
+    $pagination: PaginationInput
+  ) {
+    labListRuns(experimentId: $experimentId, status: $status, pagination: $pagination) {
+      items { ${RUN_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var START_RUN = `
+  mutation LabsofscienceStartRun($input: LabCreateRunInput!) {
+    labStartRun(input: $input) {
+      ${RUN_FIELDS}
+    }
+  }
+`;
+var COMPLETE_RUN = `
+  mutation LabsofscienceCompleteRun(
+    $id: ID!
+    $status: LabRunStatus!
+    $input: LabRecordRunResultsInput
+  ) {
+    labCompleteRun(id: $id, status: $status, input: $input) {
+      ${RUN_FIELDS}
+    }
+  }
+`;
+var GET_PROTOCOL = `
+  query LabsofscienceGetProtocol($id: ID!) {
+    labProtocol(id: $id) {
+      ${PROTOCOL_FIELDS}
+      steps { ${PROTOCOL_STEP_FIELDS} }
+    }
+  }
+`;
+var LIST_PROTOCOLS = `
+  query LabsofscienceListProtocols($status: LabProtocolStatus, $pagination: PaginationInput) {
+    labListProtocols(status: $status, pagination: $pagination) {
+      items { ${PROTOCOL_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_PROTOCOL = `
+  mutation LabsofscienceCreateProtocol($input: LabCreateProtocolInput!) {
+    labCreateProtocol(input: $input) {
+      ${PROTOCOL_FIELDS}
+    }
+  }
+`;
+var UPDATE_PROTOCOL = `
+  mutation LabsofscienceUpdateProtocol($id: ID!, $input: LabUpdateProtocolInput!) {
+    labUpdateProtocol(id: $id, input: $input) {
+      ${PROTOCOL_FIELDS}
+    }
+  }
+`;
+var ADD_PROTOCOL_STEP = `
+  mutation LabsofscienceAddProtocolStep($input: LabAddProtocolStepInput!) {
+    labAddProtocolStep(input: $input) {
+      ${PROTOCOL_STEP_FIELDS}
+    }
+  }
+`;
+var PUBLISH_PROTOCOL = `
+  mutation LabsofsciencePublishProtocol($id: ID!) {
+    labPublishProtocol(id: $id) {
+      ${PROTOCOL_FIELDS}
+      steps { ${PROTOCOL_STEP_FIELDS} }
+    }
+  }
+`;
+var GET_DATASET = `
+  query LabsofscienceGetDataset($id: ID!) {
+    labDataset(id: $id) {
+      ${DATASET_FIELDS}
+      versions { ${DATASET_VERSION_FIELDS} }
+    }
+  }
+`;
+var LIST_DATASETS = `
+  query LabsofscienceListDatasets(
+    $kind: LabDatasetKind
+    $status: LabDatasetStatus
+    $pagination: PaginationInput
+  ) {
+    labListDatasets(kind: $kind, status: $status, pagination: $pagination) {
+      items { ${DATASET_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_DATASET = `
+  mutation LabsofscienceCreateDataset($input: LabCreateDatasetInput!) {
+    labCreateDataset(input: $input) {
+      ${DATASET_FIELDS}
+    }
+  }
+`;
+var ADD_DATASET_VERSION = `
+  mutation LabsofscienceAddDatasetVersion($input: LabAddDatasetVersionInput!) {
+    labAddDatasetVersion(input: $input) {
+      ${DATASET_VERSION_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_DATASET = `
+  mutation LabsofscienceArchiveDataset($id: ID!) {
+    labArchiveDataset(id: $id)
+  }
+`;
+var LIST_PIPELINES = `
+  query LabsofscienceListPipelines {
+    labListPipelines {
+      ${PIPELINE_FIELDS}
+    }
+  }
+`;
+var CREATE_PIPELINE = `
+  mutation LabsofscienceCreatePipeline($input: LabCreatePipelineInput!) {
+    labCreatePipeline(input: $input) {
+      ${PIPELINE_FIELDS}
+    }
+  }
+`;
+var LIST_PIPELINE_RUNS = `
+  query LabsofscienceListPipelineRuns(
+    $pipelineId: ID
+    $status: LabPipelineRunStatus
+    $pagination: PaginationInput
+  ) {
+    labListPipelineRuns(pipelineId: $pipelineId, status: $status, pagination: $pagination) {
+      items { ${PIPELINE_RUN_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var RUN_PIPELINE = `
+  mutation LabsofscienceRunPipeline($input: LabRunPipelineInput!) {
+    labRunPipeline(input: $input) {
+      ${PIPELINE_RUN_FIELDS}
+    }
+  }
+`;
+var TRANSITION_PIPELINE_RUN = `
+  mutation LabsofscienceTransitionPipelineRun(
+    $id: ID!
+    $status: LabPipelineRunStatus!
+    $log: String
+  ) {
+    labTransitionPipelineRun(id: $id, status: $status, log: $log) {
+      ${PIPELINE_RUN_FIELDS}
+    }
+  }
+`;
+var GET_INSTRUMENT = `
+  query LabsofscienceGetInstrument($id: ID!) {
+    labInstrument(id: $id) {
+      ${INSTRUMENT_FIELDS}
+      bookings { ${BOOKING_FIELDS} }
+    }
+  }
+`;
+var LIST_INSTRUMENTS = `
+  query LabsofscienceListInstruments($status: LabInstrumentStatus) {
+    labListInstruments(status: $status) {
+      ${INSTRUMENT_FIELDS}
+    }
+  }
+`;
+var CREATE_INSTRUMENT = `
+  mutation LabsofscienceCreateInstrument($input: LabCreateInstrumentInput!) {
+    labCreateInstrument(input: $input) {
+      ${INSTRUMENT_FIELDS}
+    }
+  }
+`;
+var BOOK_INSTRUMENT = `
+  mutation LabsofscienceBookInstrument($input: LabBookInstrumentInput!) {
+    labBookInstrument(input: $input) {
+      ${BOOKING_FIELDS}
+    }
+  }
+`;
+var CANCEL_BOOKING = `
+  mutation LabsofscienceCancelBooking($id: ID!) {
+    labCancelBooking(id: $id) {
+      ${BOOKING_FIELDS}
+    }
+  }
+`;
+var GET_INVENTORY_ITEM = `
+  query LabsofscienceGetInventoryItem($id: ID!) {
+    labInventoryItem(id: $id) {
+      ${INVENTORY_FIELDS}
+    }
+  }
+`;
+var LIST_INVENTORY_ITEMS = `
+  query LabsofscienceListInventoryItems(
+    $category: LabInventoryCategory
+    $status: LabInventoryStatus
+    $pagination: PaginationInput
+  ) {
+    labListInventoryItems(category: $category, status: $status, pagination: $pagination) {
+      items { ${INVENTORY_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_INVENTORY_ITEM = `
+  mutation LabsofscienceCreateInventoryItem($input: LabCreateInventoryItemInput!) {
+    labCreateInventoryItem(input: $input) {
+      ${INVENTORY_FIELDS}
+    }
+  }
+`;
+var ADJUST_INVENTORY = `
+  mutation LabsofscienceAdjustInventory($id: ID!, $input: LabAdjustInventoryInput!) {
+    labAdjustInventory(id: $id, input: $input) {
+      ${INVENTORY_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_INVENTORY_ITEM = `
+  mutation LabsofscienceArchiveInventoryItem($id: ID!) {
+    labArchiveInventoryItem(id: $id)
+  }
+`;
+var LIST_NOTEBOOK_ENTRIES = `
+  query LabsofscienceListNotebookEntries(
+    $projectId: ID
+    $experimentId: ID
+    $status: LabNotebookEntryStatus
+    $pagination: PaginationInput
+  ) {
+    labListNotebookEntries(
+      projectId: $projectId
+      experimentId: $experimentId
+      status: $status
+      pagination: $pagination
+    ) {
+      items { ${NOTEBOOK_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_NOTEBOOK_ENTRY = `
+  mutation LabsofscienceCreateNotebookEntry($input: LabCreateNotebookEntryInput!) {
+    labCreateNotebookEntry(input: $input) {
+      ${NOTEBOOK_FIELDS}
+    }
+  }
+`;
+var SIGN_NOTEBOOK_ENTRY = `
+  mutation LabsofscienceSignNotebookEntry($id: ID!) {
+    labSignNotebookEntry(id: $id) {
+      ${NOTEBOOK_FIELDS}
+    }
+  }
+`;
+var HEALTH = `
+  query LabsofscienceHealth {
+    labHealth
+  }
+`;
+var ProjectStatusEnum = zod.z.enum(["ACTIVE", "ARCHIVED", "COMPLETED", "ON_HOLD", "PLANNING"]).describe("Lifecycle status of a research project");
+var ProjectVisibilityEnum = zod.z.enum(["PRIVATE", "PUBLIC", "WORKSPACE"]).describe("Visibility scope of a research project");
+var ExperimentStatusEnum = zod.z.enum(["ABANDONED", "ANALYSIS", "COMPLETE", "DESIGN", "RUNNING"]).describe("Lifecycle status of an experiment");
+var RunStatusEnum = zod.z.enum(["CANCELLED", "FAILED", "IN_PROGRESS", "PLANNED", "SUCCEEDED"]).describe("Status of an experiment run");
+var ProtocolStatusEnum = zod.z.enum(["DEPRECATED", "DRAFT", "PUBLISHED"]).describe("Lifecycle status of a protocol");
+var StepKindEnum = zod.z.enum(["ANALYSIS", "CLEANUP", "INCUBATION", "MEASUREMENT", "PREPARATION", "SAFETY"]).describe("Kind of a protocol step");
+var DatasetKindEnum = zod.z.enum(["PROCESSED", "RAW", "REFERENCE", "RESULT"]).describe("Kind/classification of a dataset");
+var DatasetStatusEnum = zod.z.enum(["ACTIVE", "ARCHIVED", "LOCKED"]).describe("Lifecycle status of a dataset");
+var PipelineRunStatusEnum = zod.z.enum(["CANCELLED", "FAILED", "QUEUED", "RUNNING", "SUCCEEDED"]).describe("Execution status of an analysis-pipeline run");
+var InstrumentStatusEnum = zod.z.enum(["AVAILABLE", "IN_USE", "MAINTENANCE", "OFFLINE"]).describe("Availability status of a lab instrument");
+var InventoryCategoryEnum = zod.z.enum(["BIOLOGICAL", "CHEMICAL", "CONSUMABLE", "EQUIPMENT_PART", "REAGENT", "SAMPLE"]).describe("Category of an inventory item");
+var InventoryStatusEnum = zod.z.enum(["EXPIRED", "IN_STOCK", "LOW", "OUT_OF_STOCK", "QUARANTINED"]).describe("Stock status of an inventory item");
+var NotebookEntryStatusEnum = zod.z.enum(["DRAFT", "SIGNED", "SUBMITTED", "VOID", "WITNESSED"]).describe("Status of an electronic-lab-notebook (ELN) entry");
+var JsonObject = zod.z.record(zod.z.string(), zod.z.unknown());
+
+// src/modules/labsofscience/tools/projects.ts
+function registerProjectTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "projects_get")),
+    {
+      title: "Get Research Project",
+      description: "Fetch a single research project by ID, including its experiments.",
+      inputSchema: { id: zod.z.string().describe("Project ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_PROJECT, { id });
+        if (!data.labProject) return errorResult(`Project ${id} not found`);
+        return jsonResult(data.labProject);
+      } catch (error) {
+        ctx.logger.error("labsofscience projects_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get project: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "projects_list")),
+    {
+      title: "List Research Projects",
+      description: "List research projects in the bound workspace with optional status filter and pagination. Returns a connection ({ items, pageInfo }).",
+      inputSchema: {
+        status: ProjectStatusEnum.optional().describe("Filter by project status"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_PROJECTS, {
+          status,
+          pagination: { limit: limit ?? 50, offset: offset ?? 0, cursor }
+        });
+        return jsonResult(data.labListProjects);
+      } catch (error) {
+        ctx.logger.error("labsofscience projects_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list projects: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "projects_create")),
+    {
+      title: "Create Research Project",
+      description: "Create a research project. `name` is required; `code` (if provided) should be unique within the workspace.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Project name"),
+        code: zod.z.string().optional().describe("Short project code (unique within workspace)"),
+        description: zod.z.string().optional().describe("Project description"),
+        field: zod.z.string().optional().describe("Scientific field / discipline"),
+        principalInvestigatorId: zod.z.string().optional().describe("User ID of the PI"),
+        status: ProjectStatusEnum.optional().describe("Initial status (default PLANNING)"),
+        visibility: ProjectVisibilityEnum.optional().describe("Visibility (default WORKSPACE)"),
+        startDate: zod.z.string().optional().describe("Start date (ISO-8601 DateTime)"),
+        endDate: zod.z.string().optional().describe("End date (ISO-8601 DateTime)"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Discovery tags")
+      }
+    },
+    async ({
+      name,
+      code,
+      description,
+      field,
+      principalInvestigatorId,
+      status,
+      visibility,
+      startDate,
+      endDate,
+      tags
+    }) => {
+      try {
+        const input = { name };
+        if (code !== void 0) input.code = code;
+        if (description !== void 0) input.description = description;
+        if (field !== void 0) input.field = field;
+        if (principalInvestigatorId !== void 0)
+          input.principalInvestigatorId = principalInvestigatorId;
+        if (status !== void 0) input.status = status;
+        if (visibility !== void 0) input.visibility = visibility;
+        if (startDate !== void 0) input.startDate = startDate;
+        if (endDate !== void 0) input.endDate = endDate;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_PROJECT, { input });
+        return jsonResult(data.labCreateProject);
+      } catch (error) {
+        ctx.logger.error("labsofscience projects_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create project: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "projects_update")),
+    {
+      title: "Update Research Project",
+      description: "Update a research project. At least one mutable field must be provided. Use `status` to advance the project lifecycle.",
+      inputSchema: {
+        id: zod.z.string().describe("Project ID"),
+        name: zod.z.string().optional().describe("Updated name"),
+        code: zod.z.string().optional().describe("Updated code"),
+        description: zod.z.string().optional().describe("Updated description"),
+        field: zod.z.string().optional().describe("Updated field/discipline"),
+        principalInvestigatorId: zod.z.string().optional().describe("Updated PI user ID"),
+        status: ProjectStatusEnum.optional().describe("Updated status"),
+        visibility: ProjectVisibilityEnum.optional().describe("Updated visibility"),
+        startDate: zod.z.string().optional().describe("Updated start date (ISO-8601)"),
+        endDate: zod.z.string().optional().describe("Updated end date (ISO-8601)"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({
+      id,
+      name,
+      code,
+      description,
+      field,
+      principalInvestigatorId,
+      status,
+      visibility,
+      startDate,
+      endDate,
+      tags
+    }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (code !== void 0) input.code = code;
+        if (description !== void 0) input.description = description;
+        if (field !== void 0) input.field = field;
+        if (principalInvestigatorId !== void 0)
+          input.principalInvestigatorId = principalInvestigatorId;
+        if (status !== void 0) input.status = status;
+        if (visibility !== void 0) input.visibility = visibility;
+        if (startDate !== void 0) input.startDate = startDate;
+        if (endDate !== void 0) input.endDate = endDate;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult("No updates specified \u2014 provide at least one mutable project field");
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_PROJECT, { id, input });
+        return jsonResult(data.labUpdateProject);
+      } catch (error) {
+        ctx.logger.error("labsofscience projects_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update project: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "projects_archive")),
+    {
+      title: "Archive Research Project",
+      description: "Archive a research project. Returns true on success.",
+      inputSchema: { id: zod.z.string().describe("Project ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_PROJECT,
+          { id }
+        );
+        return jsonResult({ archived: data.labArchiveProject, id });
+      } catch (error) {
+        ctx.logger.error("labsofscience projects_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive project: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerExperimentTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "experiments_get")),
+    {
+      title: "Get Experiment",
+      description: "Fetch a single experiment by ID, including its parent project and runs.",
+      inputSchema: { id: zod.z.string().describe("Experiment ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_EXPERIMENT, { id });
+        if (!data.labExperiment) return errorResult(`Experiment ${id} not found`);
+        return jsonResult(data.labExperiment);
+      } catch (error) {
+        ctx.logger.error("labsofscience experiments_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get experiment: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "experiments_list")),
+    {
+      title: "List Experiments",
+      description: "List experiments, optionally filtered by project and/or status, with pagination. Returns a connection ({ items, pageInfo }).",
+      inputSchema: {
+        projectId: zod.z.string().optional().describe("Filter by project ID"),
+        status: ExperimentStatusEnum.optional().describe("Filter by experiment status"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ projectId, status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_EXPERIMENTS, {
+          projectId,
+          status,
+          pagination: { limit: limit ?? 50, offset: offset ?? 0, cursor }
+        });
+        return jsonResult(data.labListExperiments);
+      } catch (error) {
+        ctx.logger.error("labsofscience experiments_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list experiments: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "experiments_create")),
+    {
+      title: "Create Experiment",
+      description: "Create an experiment under a project. `projectId` and `title` are required. `variables` is arbitrary JSON capturing the experimental design.",
+      inputSchema: {
+        projectId: zod.z.string().min(1).describe("Owning project ID"),
+        title: zod.z.string().min(1).describe("Experiment title"),
+        description: zod.z.string().optional().describe("Experiment description"),
+        hypothesis: zod.z.string().optional().describe("Hypothesis under test"),
+        protocolId: zod.z.string().optional().describe("Protocol this experiment follows"),
+        leadResearcherId: zod.z.string().optional().describe("Lead researcher user ID"),
+        variables: JsonObject.optional().describe("Experimental variables JSON"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Discovery tags")
+      }
+    },
+    async ({
+      projectId,
+      title,
+      description,
+      hypothesis,
+      protocolId,
+      leadResearcherId,
+      variables,
+      tags
+    }) => {
+      try {
+        const input = { projectId, title };
+        if (description !== void 0) input.description = description;
+        if (hypothesis !== void 0) input.hypothesis = hypothesis;
+        if (protocolId !== void 0) input.protocolId = protocolId;
+        if (leadResearcherId !== void 0) input.leadResearcherId = leadResearcherId;
+        if (variables !== void 0) input.variables = variables;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_EXPERIMENT, { input });
+        return jsonResult(data.labCreateExperiment);
+      } catch (error) {
+        ctx.logger.error("labsofscience experiments_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create experiment: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "experiments_update")),
+    {
+      title: "Update Experiment",
+      description: "Update an experiment. At least one mutable field must be provided. To change lifecycle status use experiments_transition.",
+      inputSchema: {
+        id: zod.z.string().describe("Experiment ID"),
+        title: zod.z.string().optional().describe("Updated title"),
+        description: zod.z.string().optional().describe("Updated description"),
+        hypothesis: zod.z.string().optional().describe("Updated hypothesis"),
+        protocolId: zod.z.string().optional().describe("Updated protocol ID"),
+        leadResearcherId: zod.z.string().optional().describe("Updated lead researcher user ID"),
+        variables: JsonObject.optional().describe("Updated experimental variables JSON"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({
+      id,
+      title,
+      description,
+      hypothesis,
+      protocolId,
+      leadResearcherId,
+      variables,
+      tags
+    }) => {
+      try {
+        const input = {};
+        if (title !== void 0) input.title = title;
+        if (description !== void 0) input.description = description;
+        if (hypothesis !== void 0) input.hypothesis = hypothesis;
+        if (protocolId !== void 0) input.protocolId = protocolId;
+        if (leadResearcherId !== void 0) input.leadResearcherId = leadResearcherId;
+        if (variables !== void 0) input.variables = variables;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one mutable experiment field"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_EXPERIMENT, { id, input });
+        return jsonResult(data.labUpdateExperiment);
+      } catch (error) {
+        ctx.logger.error("labsofscience experiments_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update experiment: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "experiments_transition")),
+    {
+      title: "Transition Experiment",
+      description: "Advance an experiment through its lifecycle (DESIGN \u2192 RUNNING \u2192 ANALYSIS \u2192 COMPLETE, or ABANDONED). Transitions are validated server-side.",
+      inputSchema: {
+        id: zod.z.string().describe("Experiment ID"),
+        status: ExperimentStatusEnum.describe("Target status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TRANSITION_EXPERIMENT, { id, status });
+        return jsonResult(data.labTransitionExperiment);
+      } catch (error) {
+        ctx.logger.error("labsofscience experiments_transition failed", { error: String(error) });
+        return errorResult(
+          `Failed to transition experiment: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerRunTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "runs_list")),
+    {
+      title: "List Experiment Runs",
+      description: "List experiment runs, optionally filtered by experiment and/or status, with pagination. Returns a connection ({ items, pageInfo }).",
+      inputSchema: {
+        experimentId: zod.z.string().optional().describe("Filter by experiment ID"),
+        status: RunStatusEnum.optional().describe("Filter by run status"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ experimentId, status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_RUNS, {
+          experimentId,
+          status,
+          pagination: { limit: limit ?? 50, offset: offset ?? 0, cursor }
+        });
+        return jsonResult(data.labListRuns);
+      } catch (error) {
+        ctx.logger.error("labsofscience runs_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list runs: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "runs_start")),
+    {
+      title: "Start Experiment Run",
+      description: "Start a new reproducible run of an experiment (runNumber is auto-incremented). `parameters` is arbitrary JSON capturing the run configuration.",
+      inputSchema: {
+        experimentId: zod.z.string().min(1).describe("Experiment being run"),
+        parameters: JsonObject.optional().describe("Run parameters JSON"),
+        notes: zod.z.string().optional().describe("Free-text notes for the run")
+      }
+    },
+    async ({ experimentId, parameters, notes }) => {
+      try {
+        const input = { experimentId };
+        if (parameters !== void 0) input.parameters = parameters;
+        if (notes !== void 0) input.notes = notes;
+        const data = await ctx.gql.workspace.request(START_RUN, { input });
+        return jsonResult(data.labStartRun);
+      } catch (error) {
+        ctx.logger.error("labsofscience runs_start failed", { error: String(error) });
+        return errorResult(
+          `Failed to start run: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "runs_complete")),
+    {
+      title: "Complete Experiment Run",
+      description: "Record observations and complete a run with a terminal status (SUCCEEDED, FAILED, or CANCELLED).",
+      inputSchema: {
+        id: zod.z.string().describe("Run ID"),
+        status: RunStatusEnum.describe("Terminal run status"),
+        observations: JsonObject.optional().describe("Recorded observations JSON"),
+        notes: zod.z.string().optional().describe("Closing notes for the run")
+      }
+    },
+    async ({ id, status, observations, notes }) => {
+      try {
+        const input = {};
+        if (observations !== void 0) input.observations = observations;
+        if (notes !== void 0) input.notes = notes;
+        const data = await ctx.gql.workspace.request(COMPLETE_RUN, {
+          id,
+          status,
+          input: Object.keys(input).length > 0 ? input : void 0
+        });
+        return jsonResult(data.labCompleteRun);
+      } catch (error) {
+        ctx.logger.error("labsofscience runs_complete failed", { error: String(error) });
+        return errorResult(
+          `Failed to complete run: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerProtocolTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "protocols_get")),
+    {
+      title: "Get Protocol",
+      description: "Fetch a single protocol by ID, including its ordered steps.",
+      inputSchema: { id: zod.z.string().describe("Protocol ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_PROTOCOL, { id });
+        if (!data.labProtocol) return errorResult(`Protocol ${id} not found`);
+        return jsonResult(data.labProtocol);
+      } catch (error) {
+        ctx.logger.error("labsofscience protocols_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get protocol: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "protocols_list")),
+    {
+      title: "List Protocols",
+      description: "List protocols, optionally filtered by status, with pagination. Returns a connection ({ items, pageInfo }).",
+      inputSchema: {
+        status: ProtocolStatusEnum.optional().describe("Filter by protocol status"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_PROTOCOLS, {
+          status,
+          pagination: { limit: limit ?? 50, offset: offset ?? 0, cursor }
+        });
+        return jsonResult(data.labListProtocols);
+      } catch (error) {
+        ctx.logger.error("labsofscience protocols_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list protocols: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "protocols_create")),
+    {
+      title: "Create Protocol",
+      description: "Create a draft protocol (standard operating procedure). `name` is required; add steps with protocols_add_step, then protocols_publish to freeze the version.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Protocol name"),
+        summary: zod.z.string().optional().describe("Short summary"),
+        authorId: zod.z.string().optional().describe("Author user ID"),
+        estimatedMinutes: zod.z.number().int().optional().describe("Estimated total duration (minutes)"),
+        materials: zod.z.array(zod.z.string()).optional().describe("Required materials list"),
+        safetyNotes: zod.z.string().optional().describe("Safety notes"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Discovery tags")
+      }
+    },
+    async ({ name, summary, authorId, estimatedMinutes, materials, safetyNotes, tags }) => {
+      try {
+        const input = { name };
+        if (summary !== void 0) input.summary = summary;
+        if (authorId !== void 0) input.authorId = authorId;
+        if (estimatedMinutes !== void 0) input.estimatedMinutes = estimatedMinutes;
+        if (materials !== void 0) input.materials = materials;
+        if (safetyNotes !== void 0) input.safetyNotes = safetyNotes;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_PROTOCOL, { input });
+        return jsonResult(data.labCreateProtocol);
+      } catch (error) {
+        ctx.logger.error("labsofscience protocols_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create protocol: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "protocols_update")),
+    {
+      title: "Update Protocol",
+      description: "Update a (draft) protocol. At least one mutable field must be provided.",
+      inputSchema: {
+        id: zod.z.string().describe("Protocol ID"),
+        name: zod.z.string().optional().describe("Updated name"),
+        summary: zod.z.string().optional().describe("Updated summary"),
+        estimatedMinutes: zod.z.number().int().optional().describe("Updated estimated duration"),
+        materials: zod.z.array(zod.z.string()).optional().describe("Updated materials list"),
+        safetyNotes: zod.z.string().optional().describe("Updated safety notes"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({ id, name, summary, estimatedMinutes, materials, safetyNotes, tags }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (summary !== void 0) input.summary = summary;
+        if (estimatedMinutes !== void 0) input.estimatedMinutes = estimatedMinutes;
+        if (materials !== void 0) input.materials = materials;
+        if (safetyNotes !== void 0) input.safetyNotes = safetyNotes;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult("No updates specified \u2014 provide at least one mutable protocol field");
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_PROTOCOL, { id, input });
+        return jsonResult(data.labUpdateProtocol);
+      } catch (error) {
+        ctx.logger.error("labsofscience protocols_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update protocol: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "protocols_add_step")),
+    {
+      title: "Add Protocol Step",
+      description: "Append a step to a protocol. `instruction` is required; `kind` defaults to PREPARATION. If `ordinal` is omitted the step is appended at the end.",
+      inputSchema: {
+        protocolId: zod.z.string().min(1).describe("Owning protocol ID"),
+        instruction: zod.z.string().min(1).describe("Step instruction text"),
+        kind: StepKindEnum.optional().describe("Step kind (default PREPARATION)"),
+        ordinal: zod.z.number().int().optional().describe("Position in the protocol (1-based)"),
+        durationMinutes: zod.z.number().int().optional().describe("Step duration in minutes"),
+        isCritical: zod.z.boolean().optional().describe("Mark as a critical step (default false)")
+      }
+    },
+    async ({ protocolId, instruction, kind, ordinal, durationMinutes, isCritical }) => {
+      try {
+        const input = { protocolId, instruction };
+        if (kind !== void 0) input.kind = kind;
+        if (ordinal !== void 0) input.ordinal = ordinal;
+        if (durationMinutes !== void 0) input.durationMinutes = durationMinutes;
+        if (isCritical !== void 0) input.isCritical = isCritical;
+        const data = await ctx.gql.workspace.request(ADD_PROTOCOL_STEP, { input });
+        return jsonResult(data.labAddProtocolStep);
+      } catch (error) {
+        ctx.logger.error("labsofscience protocols_add_step failed", { error: String(error) });
+        return errorResult(
+          `Failed to add protocol step: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "protocols_publish")),
+    {
+      title: "Publish Protocol",
+      description: "Publish a draft protocol, freezing its version for reproducibility. Returns the published protocol with its steps.",
+      inputSchema: { id: zod.z.string().describe("Protocol ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(PUBLISH_PROTOCOL, { id });
+        return jsonResult(data.labPublishProtocol);
+      } catch (error) {
+        ctx.logger.error("labsofscience protocols_publish failed", { error: String(error) });
+        return errorResult(
+          `Failed to publish protocol: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerDatasetTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "datasets_get")),
+    {
+      title: "Get Dataset",
+      description: "Fetch a single dataset by ID, including its version history.",
+      inputSchema: { id: zod.z.string().describe("Dataset ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_DATASET, { id });
+        if (!data.labDataset) return errorResult(`Dataset ${id} not found`);
+        return jsonResult(data.labDataset);
+      } catch (error) {
+        ctx.logger.error("labsofscience datasets_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get dataset: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "datasets_list")),
+    {
+      title: "List Datasets",
+      description: "List datasets, optionally filtered by kind and/or status, with pagination. Returns a connection ({ items, pageInfo }).",
+      inputSchema: {
+        kind: DatasetKindEnum.optional().describe("Filter by dataset kind"),
+        status: DatasetStatusEnum.optional().describe("Filter by dataset status"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ kind, status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_DATASETS, {
+          kind,
+          status,
+          pagination: { limit: limit ?? 50, offset: offset ?? 0, cursor }
+        });
+        return jsonResult(data.labListDatasets);
+      } catch (error) {
+        ctx.logger.error("labsofscience datasets_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list datasets: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "datasets_create")),
+    {
+      title: "Create Dataset",
+      description: "Create a dataset record. `name` is required; `kind` defaults to RAW. Attach the actual bytes later via datasets_add_version.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Dataset name"),
+        kind: DatasetKindEnum.optional().describe("Dataset kind (default RAW)"),
+        description: zod.z.string().optional().describe("Dataset description"),
+        experimentId: zod.z.string().optional().describe("Source experiment ID"),
+        projectId: zod.z.string().optional().describe("Owning project ID"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Discovery tags")
+      }
+    },
+    async ({ name, kind, description, experimentId, projectId, tags }) => {
+      try {
+        const input = { name };
+        if (kind !== void 0) input.kind = kind;
+        if (description !== void 0) input.description = description;
+        if (experimentId !== void 0) input.experimentId = experimentId;
+        if (projectId !== void 0) input.projectId = projectId;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_DATASET, { input });
+        return jsonResult(data.labCreateDataset);
+      } catch (error) {
+        ctx.logger.error("labsofscience datasets_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create dataset: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "datasets_add_version")),
+    {
+      title: "Add Dataset Version",
+      description: "Append an immutable version to a dataset and bump its latestVersion. `fileId` references the snapshot bytes stored in wspace-files-svc.",
+      inputSchema: {
+        datasetId: zod.z.string().min(1).describe("Target dataset ID"),
+        fileId: zod.z.string().optional().describe("wspace-files-svc File ID for the snapshot bytes"),
+        sizeBytes: zod.z.string().optional().describe("Snapshot size in bytes (string for large values)"),
+        rowCount: zod.z.number().int().optional().describe("Number of rows in the snapshot"),
+        checksum: zod.z.string().optional().describe("Content checksum"),
+        changeNote: zod.z.string().optional().describe("What changed in this version")
+      }
+    },
+    async ({ datasetId, fileId, sizeBytes, rowCount, checksum, changeNote }) => {
+      try {
+        const input = { datasetId };
+        if (fileId !== void 0) input.fileId = fileId;
+        if (sizeBytes !== void 0) input.sizeBytes = sizeBytes;
+        if (rowCount !== void 0) input.rowCount = rowCount;
+        if (checksum !== void 0) input.checksum = checksum;
+        if (changeNote !== void 0) input.changeNote = changeNote;
+        const data = await ctx.gql.workspace.request(ADD_DATASET_VERSION, { input });
+        return jsonResult(data.labAddDatasetVersion);
+      } catch (error) {
+        ctx.logger.error("labsofscience datasets_add_version failed", { error: String(error) });
+        return errorResult(
+          `Failed to add dataset version: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "datasets_archive")),
+    {
+      title: "Archive Dataset",
+      description: "Archive a dataset. Returns true on success.",
+      inputSchema: { id: zod.z.string().describe("Dataset ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_DATASET,
+          { id }
+        );
+        return jsonResult({ archived: data.labArchiveDataset, id });
+      } catch (error) {
+        ctx.logger.error("labsofscience datasets_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive dataset: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerPipelineTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "pipelines_list")),
+    {
+      title: "List Analysis Pipelines",
+      description: "List all analysis pipelines in the bound workspace.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_PIPELINES, {});
+        return jsonResult(data.labListPipelines);
+      } catch (error) {
+        ctx.logger.error("labsofscience pipelines_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list pipelines: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "pipelines_create")),
+    {
+      title: "Create Analysis Pipeline",
+      description: "Create a reproducible analysis pipeline. `name` is required; `definition` is arbitrary JSON describing the pipeline graph/steps.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Pipeline name"),
+        engine: zod.z.string().optional().describe('Execution engine (e.g. "python", "nextflow")'),
+        description: zod.z.string().optional().describe("Pipeline description"),
+        definition: JsonObject.optional().describe("Pipeline definition JSON (graph/steps)"),
+        projectId: zod.z.string().optional().describe("Owning project ID"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Discovery tags")
+      }
+    },
+    async ({ name, engine, description, definition, projectId, tags }) => {
+      try {
+        const input = { name };
+        if (engine !== void 0) input.engine = engine;
+        if (description !== void 0) input.description = description;
+        if (definition !== void 0) input.definition = definition;
+        if (projectId !== void 0) input.projectId = projectId;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_PIPELINE, { input });
+        return jsonResult(data.labCreatePipeline);
+      } catch (error) {
+        ctx.logger.error("labsofscience pipelines_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create pipeline: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "pipelines_run")),
+    {
+      title: "Run Analysis Pipeline",
+      description: "Queue a reproducible analysis-pipeline run over a dataset version. `pipelineId` is required; provide `datasetVersionId` (or `datasetId`) for the input data.",
+      inputSchema: {
+        pipelineId: zod.z.string().min(1).describe("Pipeline to run"),
+        datasetId: zod.z.string().optional().describe("Input dataset ID"),
+        datasetVersionId: zod.z.string().optional().describe("Specific input dataset-version ID"),
+        parameters: JsonObject.optional().describe("Run parameters JSON")
+      }
+    },
+    async ({ pipelineId, datasetId, datasetVersionId, parameters }) => {
+      try {
+        const input = { pipelineId };
+        if (datasetId !== void 0) input.datasetId = datasetId;
+        if (datasetVersionId !== void 0) input.datasetVersionId = datasetVersionId;
+        if (parameters !== void 0) input.parameters = parameters;
+        const data = await ctx.gql.workspace.request(RUN_PIPELINE, { input });
+        return jsonResult(data.labRunPipeline);
+      } catch (error) {
+        ctx.logger.error("labsofscience pipelines_run failed", { error: String(error) });
+        return errorResult(
+          `Failed to run pipeline: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "pipeline_runs_list")),
+    {
+      title: "List Pipeline Runs",
+      description: "List analysis-pipeline runs, optionally filtered by pipeline and/or status, with pagination. Returns a connection ({ items, pageInfo }).",
+      inputSchema: {
+        pipelineId: zod.z.string().optional().describe("Filter by pipeline ID"),
+        status: PipelineRunStatusEnum.optional().describe("Filter by run status"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ pipelineId, status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_PIPELINE_RUNS, {
+          pipelineId,
+          status,
+          pagination: { limit: limit ?? 50, offset: offset ?? 0, cursor }
+        });
+        return jsonResult(data.labListPipelineRuns);
+      } catch (error) {
+        ctx.logger.error("labsofscience pipeline_runs_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list pipeline runs: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "pipeline_runs_transition")),
+    {
+      title: "Transition Pipeline Run",
+      description: "Advance a pipeline run through its execution lifecycle (QUEUED \u2192 RUNNING \u2192 SUCCEEDED/FAILED, or CANCELLED). Transitions are validated; `log` appends execution output.",
+      inputSchema: {
+        id: zod.z.string().describe("Pipeline run ID"),
+        status: PipelineRunStatusEnum.describe("Target run status"),
+        log: zod.z.string().optional().describe("Execution log to append")
+      }
+    },
+    async ({ id, status, log }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TRANSITION_PIPELINE_RUN, { id, status, log });
+        return jsonResult(data.labTransitionPipelineRun);
+      } catch (error) {
+        ctx.logger.error("labsofscience pipeline_runs_transition failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to transition pipeline run: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerInstrumentTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "instruments_get")),
+    {
+      title: "Get Instrument",
+      description: "Fetch a single lab instrument by ID, including its bookings.",
+      inputSchema: { id: zod.z.string().describe("Instrument ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_INSTRUMENT, { id });
+        if (!data.labInstrument) return errorResult(`Instrument ${id} not found`);
+        return jsonResult(data.labInstrument);
+      } catch (error) {
+        ctx.logger.error("labsofscience instruments_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get instrument: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "instruments_list")),
+    {
+      title: "List Instruments",
+      description: "List lab instruments, optionally filtered by availability status.",
+      inputSchema: {
+        status: InstrumentStatusEnum.optional().describe("Filter by instrument status")
+      }
+    },
+    async ({ status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_INSTRUMENTS, { status });
+        return jsonResult(data.labListInstruments);
+      } catch (error) {
+        ctx.logger.error("labsofscience instruments_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list instruments: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "instruments_create")),
+    {
+      title: "Create Instrument",
+      description: "Register a lab instrument. `name` is required. Set `requiresApproval` if bookings must be approved before use.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Instrument name"),
+        model: zod.z.string().optional().describe("Make/model"),
+        location: zod.z.string().optional().describe("Physical location"),
+        custodianId: zod.z.string().optional().describe("Custodian user ID"),
+        requiresApproval: zod.z.boolean().optional().describe("Bookings need approval (default false)"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Discovery tags")
+      }
+    },
+    async ({ name, model, location, custodianId, requiresApproval, tags }) => {
+      try {
+        const input = { name };
+        if (model !== void 0) input.model = model;
+        if (location !== void 0) input.location = location;
+        if (custodianId !== void 0) input.custodianId = custodianId;
+        if (requiresApproval !== void 0) input.requiresApproval = requiresApproval;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_INSTRUMENT, { input });
+        return jsonResult(data.labCreateInstrument);
+      } catch (error) {
+        ctx.logger.error("labsofscience instruments_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create instrument: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "instruments_book")),
+    {
+      title: "Book Instrument",
+      description: "Reserve an instrument for a time window. Overlapping bookings are rejected server-side. `startTime`/`endTime` are ISO-8601 DateTimes.",
+      inputSchema: {
+        instrumentId: zod.z.string().min(1).describe("Instrument to book"),
+        startTime: zod.z.string().min(1).describe("Booking start (ISO-8601 DateTime)"),
+        endTime: zod.z.string().min(1).describe("Booking end (ISO-8601 DateTime)"),
+        experimentId: zod.z.string().optional().describe("Associated experiment ID"),
+        purpose: zod.z.string().optional().describe("Purpose of the booking")
+      }
+    },
+    async ({ instrumentId, startTime, endTime, experimentId, purpose }) => {
+      try {
+        const input = { instrumentId, startTime, endTime };
+        if (experimentId !== void 0) input.experimentId = experimentId;
+        if (purpose !== void 0) input.purpose = purpose;
+        const data = await ctx.gql.workspace.request(BOOK_INSTRUMENT, { input });
+        return jsonResult(data.labBookInstrument);
+      } catch (error) {
+        ctx.logger.error("labsofscience instruments_book failed", { error: String(error) });
+        return errorResult(
+          `Failed to book instrument: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "bookings_cancel")),
+    {
+      title: "Cancel Instrument Booking",
+      description: "Cancel an instrument booking by ID. Returns the cancelled booking.",
+      inputSchema: { id: zod.z.string().describe("Booking ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(CANCEL_BOOKING, { id });
+        return jsonResult(data.labCancelBooking);
+      } catch (error) {
+        ctx.logger.error("labsofscience bookings_cancel failed", { error: String(error) });
+        return errorResult(
+          `Failed to cancel booking: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerInventoryTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "inventory_get")),
+    {
+      title: "Get Inventory Item",
+      description: "Fetch a single inventory item (reagent/consumable/sample/etc.) by ID.",
+      inputSchema: { id: zod.z.string().describe("Inventory item ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_INVENTORY_ITEM, { id });
+        if (!data.labInventoryItem) return errorResult(`Inventory item ${id} not found`);
+        return jsonResult(data.labInventoryItem);
+      } catch (error) {
+        ctx.logger.error("labsofscience inventory_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get inventory item: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "inventory_list")),
+    {
+      title: "List Inventory Items",
+      description: "List inventory items, optionally filtered by category and/or stock status, with pagination. Returns a connection ({ items, pageInfo }).",
+      inputSchema: {
+        category: InventoryCategoryEnum.optional().describe("Filter by category"),
+        status: InventoryStatusEnum.optional().describe("Filter by stock status"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ category, status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_INVENTORY_ITEMS, {
+          category,
+          status,
+          pagination: { limit: limit ?? 50, offset: offset ?? 0, cursor }
+        });
+        return jsonResult(data.labListInventoryItems);
+      } catch (error) {
+        ctx.logger.error("labsofscience inventory_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list inventory items: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "inventory_create")),
+    {
+      title: "Create Inventory Item",
+      description: "Add an inventory item. `name` is required; `category` defaults to REAGENT. Set `reorderLevel` to drive LOW/OUT_OF_STOCK status.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Item name"),
+        category: InventoryCategoryEnum.optional().describe("Category (default REAGENT)"),
+        quantity: zod.z.number().optional().describe("Initial quantity"),
+        unit: zod.z.string().optional().describe('Unit of measure (e.g. "mL", "units")'),
+        reorderLevel: zod.z.number().optional().describe("Reorder threshold"),
+        location: zod.z.string().optional().describe("Storage location"),
+        vendor: zod.z.string().optional().describe("Vendor/supplier"),
+        catalogNumber: zod.z.string().optional().describe("Vendor catalog number"),
+        lotNumber: zod.z.string().optional().describe("Lot/batch number"),
+        expiresAt: zod.z.string().optional().describe("Expiry date (ISO-8601 DateTime)"),
+        sdsFileId: zod.z.string().optional().describe("wspace-files-svc File ID for the SDS sheet"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Discovery tags")
+      }
+    },
+    async ({
+      name,
+      category,
+      quantity,
+      unit,
+      reorderLevel,
+      location,
+      vendor,
+      catalogNumber,
+      lotNumber,
+      expiresAt,
+      sdsFileId,
+      tags
+    }) => {
+      try {
+        const input = { name };
+        if (category !== void 0) input.category = category;
+        if (quantity !== void 0) input.quantity = quantity;
+        if (unit !== void 0) input.unit = unit;
+        if (reorderLevel !== void 0) input.reorderLevel = reorderLevel;
+        if (location !== void 0) input.location = location;
+        if (vendor !== void 0) input.vendor = vendor;
+        if (catalogNumber !== void 0) input.catalogNumber = catalogNumber;
+        if (lotNumber !== void 0) input.lotNumber = lotNumber;
+        if (expiresAt !== void 0) input.expiresAt = expiresAt;
+        if (sdsFileId !== void 0) input.sdsFileId = sdsFileId;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_INVENTORY_ITEM, { input });
+        return jsonResult(data.labCreateInventoryItem);
+      } catch (error) {
+        ctx.logger.error("labsofscience inventory_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create inventory item: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "inventory_adjust")),
+    {
+      title: "Adjust Inventory",
+      description: "Apply a signed quantity delta to an item and recompute stock status (positive = restock, negative = consume).",
+      inputSchema: {
+        id: zod.z.string().describe("Inventory item ID"),
+        delta: zod.z.number().describe("Signed quantity delta (positive = restock)"),
+        reason: zod.z.string().optional().describe("Reason for the adjustment")
+      }
+    },
+    async ({ id, delta, reason }) => {
+      try {
+        const input = { delta };
+        if (reason !== void 0) input.reason = reason;
+        const data = await ctx.gql.workspace.request(ADJUST_INVENTORY, { id, input });
+        return jsonResult(data.labAdjustInventory);
+      } catch (error) {
+        ctx.logger.error("labsofscience inventory_adjust failed", { error: String(error) });
+        return errorResult(
+          `Failed to adjust inventory: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "inventory_archive")),
+    {
+      title: "Archive Inventory Item",
+      description: "Archive an inventory item. Returns true on success.",
+      inputSchema: { id: zod.z.string().describe("Inventory item ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_INVENTORY_ITEM,
+          { id }
+        );
+        return jsonResult({ archived: data.labArchiveInventoryItem, id });
+      } catch (error) {
+        ctx.logger.error("labsofscience inventory_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive inventory item: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerNotebookTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "notebook_list")),
+    {
+      title: "List Notebook Entries",
+      description: "List ELN entries, optionally filtered by project, experiment, and/or status, with pagination. Returns a connection ({ items, pageInfo }).",
+      inputSchema: {
+        projectId: zod.z.string().optional().describe("Filter by project ID"),
+        experimentId: zod.z.string().optional().describe("Filter by experiment ID"),
+        status: NotebookEntryStatusEnum.optional().describe("Filter by entry status"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ projectId, experimentId, status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_NOTEBOOK_ENTRIES, {
+          projectId,
+          experimentId,
+          status,
+          pagination: { limit: limit ?? 50, offset: offset ?? 0, cursor }
+        });
+        return jsonResult(data.labListNotebookEntries);
+      } catch (error) {
+        ctx.logger.error("labsofscience notebook_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list notebook entries: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "notebook_create")),
+    {
+      title: "Create Notebook Entry",
+      description: "Create an ELN entry under a project. `projectId` and `title` are required. Attach files via `fileIds` (wspace-files-svc File IDs).",
+      inputSchema: {
+        projectId: zod.z.string().min(1).describe("Owning project ID"),
+        title: zod.z.string().min(1).describe("Entry title"),
+        body: zod.z.string().optional().describe("Entry body (rich text / markdown)"),
+        experimentId: zod.z.string().optional().describe("Associated experiment ID"),
+        runId: zod.z.string().optional().describe("Associated run ID"),
+        fileIds: zod.z.array(zod.z.string()).optional().describe("Attached wspace-files-svc File IDs"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Discovery tags")
+      }
+    },
+    async ({ projectId, title, body, experimentId, runId, fileIds, tags }) => {
+      try {
+        const input = { projectId, title };
+        if (body !== void 0) input.body = body;
+        if (experimentId !== void 0) input.experimentId = experimentId;
+        if (runId !== void 0) input.runId = runId;
+        if (fileIds !== void 0) input.fileIds = fileIds;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_NOTEBOOK_ENTRY, { input });
+        return jsonResult(data.labCreateNotebookEntry);
+      } catch (error) {
+        ctx.logger.error("labsofscience notebook_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create notebook entry: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "notebook_sign")),
+    {
+      title: "Sign Notebook Entry",
+      description: "Sign an ELN entry for record integrity (locks editable content). Returns the signed entry.",
+      inputSchema: { id: zod.z.string().describe("Notebook entry ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(SIGN_NOTEBOOK_ENTRY, { id });
+        return jsonResult(data.labSignNotebookEntry);
+      } catch (error) {
+        ctx.logger.error("labsofscience notebook_sign failed", { error: String(error) });
+        return errorResult(
+          `Failed to sign notebook entry: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/labsofscience/tools/health.ts
+function registerHealthTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "health")),
+    {
+      title: "Labsofscience Health Check",
+      description: "Public health probe for the Labsofscience subgraph (labHealth). Requires no authentication.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(HEALTH, {});
+        return jsonResult({ ok: true, status: data.labHealth });
+      } catch (error) {
+        ctx.logger.error("labsofscience health failed", { error: String(error) });
+        return errorResult(
+          `Labsofscience health check failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/labsofscience/resources.ts
+function registerLabsofscienceResources(server, ctx, track) {
+  const schemaUri = track(mcpResourceUri(ctx.productName, "schema"));
+  const projectsUri = track(mcpResourceUri(ctx.productName, "projects"));
+  const instrumentsUri = track(mcpResourceUri(ctx.productName, "instruments"));
+  const pipelinesUri = track(mcpResourceUri(ctx.productName, "pipelines"));
+  server.registerResource(
+    "labsofscience-schema",
+    schemaUri,
+    {
+      title: "Labsofscience Domain Schema",
+      description: "Overview of the Labsofscience research domain \u2014 entities, enums, and the per-entity tool surface.",
+      mimeType: "text/plain"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${schemaUri} requested`);
+      const schema = `# Labsofscience Domain (Overview)
+
+Science & discovery platform \u2014 a research LIMS / ELN.
+
+## Entities
+- LabProject \u2014 a research project (has experiments)
+- LabExperiment \u2014 an experiment under a project (has runs)
+- LabExperimentRun \u2014 a reproducible run of an experiment
+- LabProtocol (+LabProtocolStep) \u2014 a versioned SOP with ordered steps
+- LabDataset (+LabDatasetVersion) \u2014 a dataset with immutable version snapshots
+- LabAnalysisPipeline (+LabPipelineRun) \u2014 reproducible analysis pipelines and runs
+- LabInstrument (+LabInstrumentBooking) \u2014 lab instruments and time-window bookings
+- LabInventoryItem \u2014 reagents/consumables/samples with stock tracking
+- LabNotebookEntry \u2014 electronic-lab-notebook (ELN) entries (signable)
+
+## Enums
+- LabProjectStatus: PLANNING, ACTIVE, ON_HOLD, COMPLETED, ARCHIVED
+- LabProjectVisibility: PRIVATE, WORKSPACE, PUBLIC
+- LabExperimentStatus: DESIGN, RUNNING, ANALYSIS, COMPLETE, ABANDONED
+- LabRunStatus: PLANNED, IN_PROGRESS, SUCCEEDED, FAILED, CANCELLED
+- LabProtocolStatus: DRAFT, PUBLISHED, DEPRECATED
+- LabStepKind: PREPARATION, INCUBATION, MEASUREMENT, ANALYSIS, CLEANUP, SAFETY
+- LabDatasetKind: RAW, PROCESSED, RESULT, REFERENCE
+- LabDatasetStatus: ACTIVE, LOCKED, ARCHIVED
+- LabPipelineRunStatus: QUEUED, RUNNING, SUCCEEDED, FAILED, CANCELLED
+- LabInstrumentStatus: AVAILABLE, IN_USE, MAINTENANCE, OFFLINE
+- LabBookingStatus: REQUESTED, CONFIRMED, COMPLETED, CANCELLED
+- LabInventoryCategory: REAGENT, CHEMICAL, BIOLOGICAL, CONSUMABLE, SAMPLE, EQUIPMENT_PART
+- LabInventoryStatus: IN_STOCK, LOW, OUT_OF_STOCK, EXPIRED, QUARANTINED
+- LabNotebookEntryStatus: DRAFT, SUBMITTED, SIGNED, WITNESSED, VOID
+
+## Tool groups
+projects, experiments, runs, protocols, datasets, pipelines, instruments, inventory, notebook, health.
+List queries return { items, pageInfo } connections and accept a PaginationInput { limit, offset, cursor };
+instruments_list and pipelines_list return plain arrays. All run against the WORKSPACE gateway
+(workspace-scoped) except the public health probe.
+`;
+      return {
+        contents: [{ uri: schemaUri, text: schema, mimeType: "text/plain" }]
+      };
+    }
+  );
+  server.registerResource(
+    "labsofscience-projects",
+    projectsUri,
+    {
+      title: "Labsofscience Project Directory",
+      description: "The first 50 research projects in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${projectsUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(LIST_PROJECTS, {
+          pagination: { limit: 50, offset: 0 }
+        });
+        return {
+          contents: [
+            {
+              uri: projectsUri,
+              text: JSON.stringify(data.labListProjects, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: projectsUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "labsofscience-instruments",
+    instrumentsUri,
+    {
+      title: "Labsofscience Instrument Catalog",
+      description: "All lab instruments in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${instrumentsUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_INSTRUMENTS,
+          {}
+        );
+        return {
+          contents: [
+            {
+              uri: instrumentsUri,
+              text: JSON.stringify(data.labListInstruments, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: instrumentsUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "labsofscience-pipelines",
+    pipelinesUri,
+    {
+      title: "Labsofscience Analysis Pipelines",
+      description: "All analysis pipelines in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${pipelinesUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_PIPELINES,
+          {}
+        );
+        return {
+          contents: [
+            {
+              uri: pipelinesUri,
+              text: JSON.stringify(data.labListPipelines, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: pipelinesUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function registerLabsofsciencePrompts(server, ctx, track) {
+  const p = ctx.productName;
+  const setupName = track(mcpPromptName(p, "experiment-setup"));
+  const opsName = track(mcpPromptName(p, "lab-operations"));
+  server.registerPrompt(
+    setupName,
+    {
+      title: "Experiment Setup",
+      description: "Guide for standing up a reproducible experiment end to end: create the project, author + publish a protocol, create the experiment, start a run, and register a dataset.",
+      argsSchema: {
+        projectName: zod.z.string().optional().describe("Research project name"),
+        field: zod.z.string().optional().describe("Scientific field / discipline")
+      }
+    },
+    ({ projectName, field }) => {
+      ctx.logger.debug(`Prompt ${setupName} called`, { projectName, field });
+      const nameNote = projectName ? `Use the project name "${projectName}".` : "Ask the user for the project name.";
+      const fieldNote = field ? `Field: ${field}.` : "Optionally capture the scientific field.";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Help me set up a reproducible Labsofscience experiment.
+
+1. **Create Project**: Use ${p}_projects_create. ${nameNote} ${fieldNote} Optionally set principalInvestigatorId and visibility.
+2. **Author Protocol**: Use ${p}_protocols_create, then add ordered steps with ${p}_protocols_add_step (set kind per step), and ${p}_protocols_publish to freeze the version.
+3. **Create Experiment**: Use ${p}_experiments_create under the new projectId, referencing the published protocolId and a hypothesis + variables JSON.
+4. **Start a Run**: Use ${p}_runs_start with the experimentId and parameters; later close it with ${p}_runs_complete (status SUCCEEDED/FAILED) and observations.
+5. **Register Dataset**: Use ${p}_datasets_create for the run output, then ${p}_datasets_add_version with the fileId snapshot.
+6. **Advance**: Use ${p}_experiments_transition to move DESIGN \u2192 RUNNING \u2192 ANALYSIS \u2192 COMPLETE.
+
+Show results at each step and confirm before publishing the protocol.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server.registerPrompt(
+    opsName,
+    {
+      title: "Lab Operations",
+      description: "Daily lab operations workflow: check instrument availability + bookings, restock low inventory, run analysis pipelines, and sign off notebook entries.",
+      argsSchema: {
+        projectId: zod.z.string().optional().describe("Project ID to focus on")
+      }
+    },
+    ({ projectId }) => {
+      ctx.logger.debug(`Prompt ${opsName} called`, { projectId });
+      const projectNote = projectId ? `Focus on project "${projectId}".` : `First list projects with ${p}_projects_list and pick one.`;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Run daily Labsofscience lab operations. ${projectNote}
+
+1. **Instruments**: Use ${p}_instruments_list (status AVAILABLE) to see free instruments; book one with ${p}_instruments_book for an upcoming run, or cancel stale holds with ${p}_bookings_cancel.
+2. **Inventory**: Use ${p}_inventory_list with status=LOW (and OUT_OF_STOCK) to find items to restock, then ${p}_inventory_adjust with a positive delta to record receipts.
+3. **Pipelines**: Use ${p}_pipelines_list and ${p}_pipeline_runs_list (status QUEUED/RUNNING) to monitor analysis; trigger new work with ${p}_pipelines_run and advance with ${p}_pipeline_runs_transition.
+4. **Notebook**: Use ${p}_notebook_list (status SUBMITTED) for the project and sign approved entries with ${p}_notebook_sign.
+5. **Experiments**: Use ${p}_experiments_list filtered by projectId to review status and surface runs needing completion via ${p}_runs_list.
+
+Summarize what needs attention after each step.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/modules/labsofscience/index.ts
+var labsofscienceModule = {
+  id: "labsofscience",
+  version: "0.0.1",
+  displayName: "Labsofscience",
+  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;
+    };
+    registerProjectTools(server, ctx, trackTool);
+    registerExperimentTools(server, ctx, trackTool);
+    registerRunTools(server, ctx, trackTool);
+    registerProtocolTools(server, ctx, trackTool);
+    registerDatasetTools(server, ctx, trackTool);
+    registerPipelineTools(server, ctx, trackTool);
+    registerInstrumentTools(server, ctx, trackTool);
+    registerInventoryTools(server, ctx, trackTool);
+    registerNotebookTools(server, ctx, trackTool);
+    registerHealthTools(server, ctx, trackTool);
+    registerLabsofscienceResources(server, ctx, trackResource);
+    registerLabsofsciencePrompts(server, ctx, trackPrompt);
+    return { tools, resources, prompts };
+  }
+};
+var labsofscience_default = labsofscienceModule;
+
+module.exports = labsofscience_default;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map