@burdenoff/mcp-libs 2026.627.3 → 2026.627.5

package/dist/modules/cosmicintersection/index.cjs

@@ -0,0 +1,1984 @@
+'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/cosmicintersection/tools/sources.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/cosmicintersection/operations.ts
+var SOURCE_FIELDS = `
+  id name description type status endpoint config tags
+  lastSyncedAt createdAt updatedAt workspaceId
+`;
+var DATASET_FIELDS = `
+  id name description status accessLevel format collectionId sourceId
+  coverage rowCount sizeBytes version ingestedAt lineageCaptured tags
+  createdAt updatedAt workspaceId
+`;
+var SCHEMA_FIELD_FIELDS = `
+  id datasetId name fieldType description nullable position provenance unit
+  createdAt updatedAt workspaceId
+`;
+var COLLECTION_FIELDS = `
+  id name slug description isPublic tags createdAt updatedAt workspaceId
+`;
+var PIPELINE_FIELDS = `
+  id name description status trigger schedule definition version lastRunAt
+  tags createdAt updatedAt workspaceId
+`;
+var STEP_FIELDS = `
+  id runId name kind status position inputs outputs logsRef durationMs
+  startedAt finishedAt errorMessage createdAt updatedAt workspaceId
+`;
+var RUN_FIELDS = `
+  id pipelineId runNumber status params metrics datasetId triggeredBy
+  durationMs startedAt finishedAt errorMessage createdAt updatedAt workspaceId
+`;
+var NOTEBOOK_FIELDS = `
+  id title description status runtime environment datasetIds isShared
+  shareSlug tags createdAt updatedAt workspaceId
+`;
+var ANALYSIS_FIELDS = `
+  id title status method aiAssisted datasetId notebookId results
+  errorMessage startedAt finishedAt createdAt updatedAt workspaceId
+`;
+var RELEASE_FIELDS = `
+  id title version status abstract authors license doi datasetIds
+  notebookId publishedAt createdAt updatedAt workspaceId
+`;
+var GRANT_FIELDS = `
+  id datasetId granteeId status scopes reason grantedAt expiresAt
+  revokedAt createdAt updatedAt workspaceId
+`;
+var GET_SOURCE = `
+  query CosmicintersectionGetSource($id: ID!) {
+    cosSource(id: $id) {
+      ${SOURCE_FIELDS}
+      datasets { id name status accessLevel }
+    }
+  }
+`;
+var LIST_SOURCES = `
+  query CosmicintersectionListSources(
+    $status: CosSourceStatus
+    $type: CosSourceType
+    $pagination: PaginationInput
+  ) {
+    cosListSources(status: $status, type: $type, pagination: $pagination) {
+      items { ${SOURCE_FIELDS} }
+      pageInfo { cursor hasMore }
+    }
+  }
+`;
+var CREATE_SOURCE = `
+  mutation CosmicintersectionCreateSource($input: CosCreateSourceInput!) {
+    cosCreateSource(input: $input) {
+      ${SOURCE_FIELDS}
+    }
+  }
+`;
+var UPDATE_SOURCE = `
+  mutation CosmicintersectionUpdateSource($id: ID!, $input: CosUpdateSourceInput!) {
+    cosUpdateSource(id: $id, input: $input) {
+      ${SOURCE_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_SOURCE = `
+  mutation CosmicintersectionArchiveSource($id: ID!) {
+    cosArchiveSource(id: $id)
+  }
+`;
+var MARK_SOURCE_SYNCED = `
+  mutation CosmicintersectionMarkSourceSynced($id: ID!) {
+    cosMarkSourceSynced(id: $id) {
+      ${SOURCE_FIELDS}
+    }
+  }
+`;
+var GET_DATASET = `
+  query CosmicintersectionGetDataset($id: ID!) {
+    cosDataset(id: $id) {
+      ${DATASET_FIELDS}
+      collection { id name slug }
+      source { id name type status }
+      schemaFields { ${SCHEMA_FIELD_FIELDS} }
+    }
+  }
+`;
+var LIST_DATASETS = `
+  query CosmicintersectionListDatasets(
+    $collectionId: ID
+    $sourceId: ID
+    $status: CosDatasetStatus
+    $pagination: PaginationInput
+  ) {
+    cosListDatasets(
+      collectionId: $collectionId
+      sourceId: $sourceId
+      status: $status
+      pagination: $pagination
+    ) {
+      items { ${DATASET_FIELDS} }
+      pageInfo { cursor hasMore }
+    }
+  }
+`;
+var CREATE_DATASET = `
+  mutation CosmicintersectionCreateDataset($input: CosCreateDatasetInput!) {
+    cosCreateDataset(input: $input) {
+      ${DATASET_FIELDS}
+    }
+  }
+`;
+var UPDATE_DATASET = `
+  mutation CosmicintersectionUpdateDataset($id: ID!, $input: CosUpdateDatasetInput!) {
+    cosUpdateDataset(id: $id, input: $input) {
+      ${DATASET_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_DATASET = `
+  mutation CosmicintersectionArchiveDataset($id: ID!) {
+    cosArchiveDataset(id: $id)
+  }
+`;
+var PUBLISH_DATASET = `
+  mutation CosmicintersectionPublishDataset($id: ID!) {
+    cosPublishDataset(id: $id) {
+      ${DATASET_FIELDS}
+    }
+  }
+`;
+var LIST_SCHEMA_FIELDS = `
+  query CosmicintersectionListSchemaFields($datasetId: ID!) {
+    cosListSchemaFields(datasetId: $datasetId) {
+      ${SCHEMA_FIELD_FIELDS}
+    }
+  }
+`;
+var ADD_SCHEMA_FIELD = `
+  mutation CosmicintersectionAddSchemaField($input: CosAddSchemaFieldInput!) {
+    cosAddSchemaField(input: $input) {
+      ${SCHEMA_FIELD_FIELDS}
+    }
+  }
+`;
+var LIST_COLLECTIONS = `
+  query CosmicintersectionListCollections {
+    cosListCollections {
+      ${COLLECTION_FIELDS}
+      datasets { id name status accessLevel }
+    }
+  }
+`;
+var CREATE_COLLECTION = `
+  mutation CosmicintersectionCreateCollection($input: CosCreateCollectionInput!) {
+    cosCreateCollection(input: $input) {
+      ${COLLECTION_FIELDS}
+    }
+  }
+`;
+var GET_PIPELINE = `
+  query CosmicintersectionGetPipeline($id: ID!) {
+    cosPipeline(id: $id) {
+      ${PIPELINE_FIELDS}
+      runs { id runNumber status startedAt finishedAt }
+    }
+  }
+`;
+var LIST_PIPELINES = `
+  query CosmicintersectionListPipelines(
+    $status: CosPipelineStatus
+    $pagination: PaginationInput
+  ) {
+    cosListPipelines(status: $status, pagination: $pagination) {
+      items { ${PIPELINE_FIELDS} }
+      pageInfo { cursor hasMore }
+    }
+  }
+`;
+var CREATE_PIPELINE = `
+  mutation CosmicintersectionCreatePipeline($input: CosCreatePipelineInput!) {
+    cosCreatePipeline(input: $input) {
+      ${PIPELINE_FIELDS}
+    }
+  }
+`;
+var UPDATE_PIPELINE = `
+  mutation CosmicintersectionUpdatePipeline($id: ID!, $input: CosUpdatePipelineInput!) {
+    cosUpdatePipeline(id: $id, input: $input) {
+      ${PIPELINE_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_PIPELINE = `
+  mutation CosmicintersectionArchivePipeline($id: ID!) {
+    cosArchivePipeline(id: $id)
+  }
+`;
+var GET_RUN = `
+  query CosmicintersectionGetRun($id: ID!) {
+    cosRun(id: $id) {
+      ${RUN_FIELDS}
+      pipeline { id name status }
+      steps { ${STEP_FIELDS} }
+    }
+  }
+`;
+var LIST_RUNS = `
+  query CosmicintersectionListRuns(
+    $pipelineId: ID
+    $status: CosRunStatus
+    $pagination: PaginationInput
+  ) {
+    cosListRuns(pipelineId: $pipelineId, status: $status, pagination: $pagination) {
+      items { ${RUN_FIELDS} }
+      pageInfo { cursor hasMore }
+    }
+  }
+`;
+var START_RUN = `
+  mutation CosmicintersectionStartRun($input: CosStartRunInput!) {
+    cosStartRun(input: $input) {
+      ${RUN_FIELDS}
+    }
+  }
+`;
+var TRANSITION_RUN = `
+  mutation CosmicintersectionTransitionRun($id: ID!, $status: CosRunStatus!) {
+    cosTransitionRun(id: $id, status: $status) {
+      ${RUN_FIELDS}
+    }
+  }
+`;
+var LIST_RUN_STEPS = `
+  query CosmicintersectionListRunSteps($runId: ID!) {
+    cosListRunSteps(runId: $runId) {
+      ${STEP_FIELDS}
+    }
+  }
+`;
+var ADD_RUN_STEP = `
+  mutation CosmicintersectionAddRunStep($input: CosAddRunStepInput!) {
+    cosAddRunStep(input: $input) {
+      ${STEP_FIELDS}
+    }
+  }
+`;
+var GET_NOTEBOOK = `
+  query CosmicintersectionGetNotebook($id: ID!) {
+    cosNotebook(id: $id) {
+      ${NOTEBOOK_FIELDS}
+      analyses { ${ANALYSIS_FIELDS} }
+      releases { id title version status }
+    }
+  }
+`;
+var LIST_NOTEBOOKS = `
+  query CosmicintersectionListNotebooks(
+    $status: CosNotebookStatus
+    $pagination: PaginationInput
+  ) {
+    cosListNotebooks(status: $status, pagination: $pagination) {
+      items { ${NOTEBOOK_FIELDS} }
+      pageInfo { cursor hasMore }
+    }
+  }
+`;
+var CREATE_NOTEBOOK = `
+  mutation CosmicintersectionCreateNotebook($input: CosCreateNotebookInput!) {
+    cosCreateNotebook(input: $input) {
+      ${NOTEBOOK_FIELDS}
+    }
+  }
+`;
+var UPDATE_NOTEBOOK = `
+  mutation CosmicintersectionUpdateNotebook($id: ID!, $input: CosUpdateNotebookInput!) {
+    cosUpdateNotebook(id: $id, input: $input) {
+      ${NOTEBOOK_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_NOTEBOOK = `
+  mutation CosmicintersectionArchiveNotebook($id: ID!) {
+    cosArchiveNotebook(id: $id)
+  }
+`;
+var LIST_ANALYSES = `
+  query CosmicintersectionListAnalyses(
+    $datasetId: ID
+    $notebookId: ID
+    $status: CosAnalysisStatus
+  ) {
+    cosListAnalyses(datasetId: $datasetId, notebookId: $notebookId, status: $status) {
+      ${ANALYSIS_FIELDS}
+    }
+  }
+`;
+var RUN_ANALYSIS = `
+  mutation CosmicintersectionRunAnalysis($input: CosRunAnalysisInput!) {
+    cosRunAnalysis(input: $input) {
+      ${ANALYSIS_FIELDS}
+    }
+  }
+`;
+var COMPLETE_ANALYSIS = `
+  mutation CosmicintersectionCompleteAnalysis(
+    $id: ID!
+    $status: CosAnalysisStatus!
+    $results: JSON
+    $outputFileId: ID
+  ) {
+    cosCompleteAnalysis(
+      id: $id
+      status: $status
+      results: $results
+      outputFileId: $outputFileId
+    ) {
+      ${ANALYSIS_FIELDS}
+    }
+  }
+`;
+var LIST_RELEASES = `
+  query CosmicintersectionListReleases(
+    $status: CosReleaseStatus
+    $pagination: PaginationInput
+  ) {
+    cosListReleases(status: $status, pagination: $pagination) {
+      items { ${RELEASE_FIELDS} }
+      pageInfo { cursor hasMore }
+    }
+  }
+`;
+var CREATE_RELEASE = `
+  mutation CosmicintersectionCreateRelease($input: CosCreateReleaseInput!) {
+    cosCreateRelease(input: $input) {
+      ${RELEASE_FIELDS}
+    }
+  }
+`;
+var PUBLISH_RELEASE = `
+  mutation CosmicintersectionPublishRelease($id: ID!, $doi: String) {
+    cosPublishRelease(id: $id, doi: $doi) {
+      ${RELEASE_FIELDS}
+    }
+  }
+`;
+var LIST_ACCESS_GRANTS = `
+  query CosmicintersectionListAccessGrants($datasetId: ID, $status: CosGrantStatus) {
+    cosListAccessGrants(datasetId: $datasetId, status: $status) {
+      ${GRANT_FIELDS}
+    }
+  }
+`;
+var GRANT_ACCESS = `
+  mutation CosmicintersectionGrantAccess($input: CosGrantAccessInput!) {
+    cosGrantAccess(input: $input) {
+      ${GRANT_FIELDS}
+    }
+  }
+`;
+var REVOKE_ACCESS = `
+  mutation CosmicintersectionRevokeAccess($id: ID!) {
+    cosRevokeAccess(id: $id) {
+      ${GRANT_FIELDS}
+    }
+  }
+`;
+var HEALTH = `
+  query CosmicintersectionHealth {
+    cosHealth
+  }
+`;
+var CosSourceTypeEnum = zod.z.enum([
+  "API",
+  "ARCHIVE",
+  "FILE_DROP",
+  "GROUND_SENSOR",
+  "SATELLITE",
+  "SIMULATION",
+  "STREAM",
+  "TELESCOPE"
+]).describe("Kind of upstream data source / connector");
+var CosSourceStatusEnum = zod.z.enum(["CONFIGURING", "CONNECTED", "DEGRADED", "DISABLED", "ERROR", "SYNCING"]).describe("Lifecycle/connectivity status of a source");
+var CosDatasetStatusEnum = zod.z.enum(["ARCHIVED", "AVAILABLE", "DEPRECATED", "DRAFT", "INGESTING"]).describe("Lifecycle status of a dataset");
+var CosAccessLevelEnum = zod.z.enum(["EMBARGOED", "PUBLIC", "RESTRICTED", "WORKSPACE"]).describe("Visibility/access level of a dataset");
+var CosFieldTypeEnum = zod.z.enum([
+  "BOOLEAN",
+  "COORDINATE",
+  "FLOAT",
+  "GEOMETRY",
+  "IMAGE_REF",
+  "INTEGER",
+  "JSON",
+  "SPECTRUM",
+  "STRING",
+  "TIMESTAMP"
+]).describe("Logical type of a dataset schema field");
+var CosPipelineStatusEnum = zod.z.enum(["ACTIVE", "ARCHIVED", "DRAFT", "PAUSED"]).describe("Lifecycle status of a processing pipeline");
+var CosPipelineTriggerEnum = zod.z.enum(["MANUAL", "ON_INGEST", "SCHEDULED", "WEBHOOK"]).describe("How a pipeline is triggered");
+var CosRunStatusEnum = zod.z.enum(["CANCELLED", "FAILED", "QUEUED", "RUNNING", "SUCCEEDED"]).describe("Lifecycle status of a pipeline run or step");
+var CosStepKindEnum = zod.z.enum(["ANALYZE", "CALIBRATE", "EXPORT", "INGEST", "NOTIFY", "TRANSFORM"]).describe("Kind of work a run step performs");
+var CosNotebookStatusEnum = zod.z.enum(["ARCHIVED", "DRAFT", "PUBLISHED", "RUNNING"]).describe("Lifecycle status of a research notebook");
+var CosAnalysisStatusEnum = zod.z.enum(["COMPLETED", "FAILED", "PENDING", "RUNNING"]).describe("Lifecycle status of an analysis run");
+var CosReleaseStatusEnum = zod.z.enum(["DRAFT", "PUBLISHED", "RETRACTED", "UNDER_REVIEW"]).describe("Lifecycle status of a citable release");
+var CosGrantStatusEnum = zod.z.enum(["ACTIVE", "EXPIRED", "PENDING", "REVOKED"]).describe("Status of a dataset access grant");
+var JsonObject = zod.z.record(zod.z.string(), zod.z.unknown());
+
+// src/modules/cosmicintersection/tools/sources.ts
+function registerSourceTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sources_get")),
+    {
+      title: "Get Source",
+      description: "Fetch a single Cosmicintersection data source by ID, including the datasets ingested from it.",
+      inputSchema: { id: zod.z.string().describe("Source ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_SOURCE, { id });
+        if (!data.cosSource) return errorResult(`Source ${id} not found`);
+        return jsonResult(data.cosSource);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection sources_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get source: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sources_list")),
+    {
+      title: "List Sources",
+      description: "List data sources in the bound workspace with optional type/status filters and pagination (returns a connection: { items, pageInfo }).",
+      inputSchema: {
+        type: CosSourceTypeEnum.optional().describe("Filter by source type"),
+        status: CosSourceStatusEnum.optional().describe("Filter by connectivity 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 ({ type, status, limit, offset, cursor }) => {
+      try {
+        const pagination = {};
+        if (limit !== void 0) pagination.limit = limit;
+        if (offset !== void 0) pagination.offset = offset;
+        if (cursor !== void 0) pagination.cursor = cursor;
+        const data = await ctx.gql.workspace.request(LIST_SOURCES, {
+          type,
+          status,
+          pagination: Object.keys(pagination).length > 0 ? pagination : void 0
+        });
+        return jsonResult(data.cosListSources);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection sources_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list sources: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sources_create")),
+    {
+      title: "Create Source",
+      description: "Register a new data source / connector. Defaults: type=ARCHIVE, status=CONFIGURING.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Source display name"),
+        type: CosSourceTypeEnum.optional().describe("Source type (default ARCHIVE)"),
+        status: CosSourceStatusEnum.optional().describe("Initial status (default CONFIGURING)"),
+        description: zod.z.string().optional().describe("Source description"),
+        endpoint: zod.z.string().optional().describe("Connection endpoint / URL"),
+        credentialRef: zod.z.string().optional().describe("Reference to a stored credential"),
+        config: JsonObject.optional().describe("Connector configuration JSON"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Free-form tags")
+      }
+    },
+    async ({ name, type, status, description, endpoint, credentialRef, config, tags }) => {
+      try {
+        const input = { name };
+        if (type !== void 0) input.type = type;
+        if (status !== void 0) input.status = status;
+        if (description !== void 0) input.description = description;
+        if (endpoint !== void 0) input.endpoint = endpoint;
+        if (credentialRef !== void 0) input.credentialRef = credentialRef;
+        if (config !== void 0) input.config = config;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_SOURCE, { input });
+        return jsonResult(data.cosCreateSource);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection sources_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create source: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sources_update")),
+    {
+      title: "Update Source",
+      description: "Update a data source. At least one mutable field must be provided.",
+      inputSchema: {
+        id: zod.z.string().describe("Source ID"),
+        name: zod.z.string().optional().describe("Updated display name"),
+        type: CosSourceTypeEnum.optional().describe("Updated source type"),
+        status: CosSourceStatusEnum.optional().describe("Updated status"),
+        description: zod.z.string().optional().describe("Updated description"),
+        endpoint: zod.z.string().optional().describe("Updated endpoint"),
+        credentialRef: zod.z.string().optional().describe("Updated credential reference"),
+        config: JsonObject.optional().describe("Updated connector configuration JSON"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({ id, name, type, status, description, endpoint, credentialRef, config, tags }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (type !== void 0) input.type = type;
+        if (status !== void 0) input.status = status;
+        if (description !== void 0) input.description = description;
+        if (endpoint !== void 0) input.endpoint = endpoint;
+        if (credentialRef !== void 0) input.credentialRef = credentialRef;
+        if (config !== void 0) input.config = config;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of name/type/status/description/endpoint/credentialRef/config/tags"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_SOURCE, { id, input });
+        return jsonResult(data.cosUpdateSource);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection sources_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update source: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sources_archive")),
+    {
+      title: "Archive Source",
+      description: "Archive (soft-delete) a data source. Returns true on success.",
+      inputSchema: { id: zod.z.string().describe("Source ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_SOURCE,
+          { id }
+        );
+        return jsonResult({ archived: data.cosArchiveSource });
+      } catch (error) {
+        ctx.logger.error("cosmicintersection sources_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive source: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sources_mark_synced")),
+    {
+      title: "Mark Source Synced",
+      description: "Record a successful sync for a source (sets status CONNECTED + lastSyncedAt).",
+      inputSchema: { id: zod.z.string().describe("Source ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(MARK_SOURCE_SYNCED, { id });
+        return jsonResult(data.cosMarkSourceSynced);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection sources_mark_synced failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to mark source synced: ${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 collection, source, and schema fields.",
+      inputSchema: { id: zod.z.string().describe("Dataset ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_DATASET, { id });
+        if (!data.cosDataset) return errorResult(`Dataset ${id} not found`);
+        return jsonResult(data.cosDataset);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection 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 in the bound workspace with optional collection/source/status filters and pagination (returns a connection: { items, pageInfo }).",
+      inputSchema: {
+        collectionId: zod.z.string().optional().describe("Filter by collection ID"),
+        sourceId: zod.z.string().optional().describe("Filter by source ID"),
+        status: CosDatasetStatusEnum.optional().describe("Filter by lifecycle 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 ({ collectionId, sourceId, status, limit, offset, cursor }) => {
+      try {
+        const pagination = {};
+        if (limit !== void 0) pagination.limit = limit;
+        if (offset !== void 0) pagination.offset = offset;
+        if (cursor !== void 0) pagination.cursor = cursor;
+        const data = await ctx.gql.workspace.request(LIST_DATASETS, {
+          collectionId,
+          sourceId,
+          status,
+          pagination: Object.keys(pagination).length > 0 ? pagination : void 0
+        });
+        return jsonResult(data.cosListDatasets);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection 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: "Register a new dataset in the catalog. Defaults: accessLevel=WORKSPACE, status=DRAFT. Reference a wspace-files-svc File via fileId for the raw artifact.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Dataset name"),
+        accessLevel: CosAccessLevelEnum.optional().describe("Access level (default WORKSPACE)"),
+        status: CosDatasetStatusEnum.optional().describe("Initial status (default DRAFT)"),
+        description: zod.z.string().optional().describe("Dataset description"),
+        collectionId: zod.z.string().optional().describe("Parent collection ID"),
+        sourceId: zod.z.string().optional().describe("Originating source ID"),
+        fileId: zod.z.string().optional().describe("wspace-files-svc File ID for the raw artifact"),
+        format: zod.z.string().optional().describe("Data format (e.g. csv, parquet, fits)"),
+        coverage: JsonObject.optional().describe("Spatial/temporal coverage JSON"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Free-form tags")
+      }
+    },
+    async ({
+      name,
+      accessLevel,
+      status,
+      description,
+      collectionId,
+      sourceId,
+      fileId,
+      format,
+      coverage,
+      tags
+    }) => {
+      try {
+        const input = { name };
+        if (accessLevel !== void 0) input.accessLevel = accessLevel;
+        if (status !== void 0) input.status = status;
+        if (description !== void 0) input.description = description;
+        if (collectionId !== void 0) input.collectionId = collectionId;
+        if (sourceId !== void 0) input.sourceId = sourceId;
+        if (fileId !== void 0) input.fileId = fileId;
+        if (format !== void 0) input.format = format;
+        if (coverage !== void 0) input.coverage = coverage;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_DATASET, { input });
+        return jsonResult(data.cosCreateDataset);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection 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_update")),
+    {
+      title: "Update Dataset",
+      description: "Update a dataset. At least one mutable field must be provided.",
+      inputSchema: {
+        id: zod.z.string().describe("Dataset ID"),
+        name: zod.z.string().optional().describe("Updated name"),
+        accessLevel: CosAccessLevelEnum.optional().describe("Updated access level"),
+        description: zod.z.string().optional().describe("Updated description"),
+        collectionId: zod.z.string().optional().describe("Updated collection ID"),
+        format: zod.z.string().optional().describe("Updated data format"),
+        coverage: JsonObject.optional().describe("Updated coverage JSON"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({ id, name, accessLevel, description, collectionId, format, coverage, tags }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (accessLevel !== void 0) input.accessLevel = accessLevel;
+        if (description !== void 0) input.description = description;
+        if (collectionId !== void 0) input.collectionId = collectionId;
+        if (format !== void 0) input.format = format;
+        if (coverage !== void 0) input.coverage = coverage;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of name/accessLevel/description/collectionId/format/coverage/tags"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_DATASET, { id, input });
+        return jsonResult(data.cosUpdateDataset);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection datasets_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update dataset: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "datasets_archive")),
+    {
+      title: "Archive Dataset",
+      description: "Archive (soft-delete) 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.cosArchiveDataset });
+      } catch (error) {
+        ctx.logger.error("cosmicintersection datasets_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive dataset: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "datasets_publish")),
+    {
+      title: "Publish Dataset",
+      description: "Mark a dataset AVAILABLE once ingestion completes (sets ingestedAt).",
+      inputSchema: { id: zod.z.string().describe("Dataset ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(PUBLISH_DATASET, { id });
+        return jsonResult(data.cosPublishDataset);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection datasets_publish failed", { error: String(error) });
+        return errorResult(
+          `Failed to publish dataset: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "datasets_fields_list")),
+    {
+      title: "List Schema Fields",
+      description: "List the schema fields (columns) of a dataset.",
+      inputSchema: { datasetId: zod.z.string().describe("Dataset ID") }
+    },
+    async ({ datasetId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_SCHEMA_FIELDS, { datasetId });
+        return jsonResult(data.cosListSchemaFields);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection datasets_fields_list failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to list schema fields: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "datasets_fields_add")),
+    {
+      title: "Add Schema Field",
+      description: "Add a schema field (column) to a dataset. Defaults: fieldType=STRING, nullable=true.",
+      inputSchema: {
+        datasetId: zod.z.string().describe("Dataset ID"),
+        name: zod.z.string().min(1).describe("Field name"),
+        fieldType: CosFieldTypeEnum.optional().describe("Field logical type (default STRING)"),
+        description: zod.z.string().optional().describe("Field description"),
+        nullable: zod.z.boolean().optional().describe("Whether the field is nullable (default true)"),
+        position: zod.z.number().int().optional().describe("Ordinal position in the schema"),
+        provenance: zod.z.string().optional().describe("Provenance / derivation note"),
+        unit: zod.z.string().optional().describe("Physical unit (e.g. arcsec, Jy)")
+      }
+    },
+    async ({ datasetId, name, fieldType, description, nullable, position, provenance, unit }) => {
+      try {
+        const input = { datasetId, name };
+        if (fieldType !== void 0) input.fieldType = fieldType;
+        if (description !== void 0) input.description = description;
+        if (nullable !== void 0) input.nullable = nullable;
+        if (position !== void 0) input.position = position;
+        if (provenance !== void 0) input.provenance = provenance;
+        if (unit !== void 0) input.unit = unit;
+        const data = await ctx.gql.workspace.request(ADD_SCHEMA_FIELD, { input });
+        return jsonResult(data.cosAddSchemaField);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection datasets_fields_add failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to add schema field: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerCollectionTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "collections_list")),
+    {
+      title: "List Collections",
+      description: "List all dataset collections in the bound workspace, with their datasets.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_COLLECTIONS, {});
+        return jsonResult(data.cosListCollections);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection collections_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list collections: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "collections_create")),
+    {
+      title: "Create Collection",
+      description: "Create a dataset collection. Defaults: isPublic=false.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Collection name"),
+        slug: zod.z.string().optional().describe("URL slug, unique within the workspace"),
+        description: zod.z.string().optional().describe("Collection description"),
+        isPublic: zod.z.boolean().optional().describe("Whether the collection is public (default false)"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Free-form tags")
+      }
+    },
+    async ({ name, slug, description, isPublic, tags }) => {
+      try {
+        const input = { name };
+        if (slug !== void 0) input.slug = slug;
+        if (description !== void 0) input.description = description;
+        if (isPublic !== void 0) input.isPublic = isPublic;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_COLLECTION, { input });
+        return jsonResult(data.cosCreateCollection);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection collections_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create collection: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerPipelineTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "pipelines_get")),
+    {
+      title: "Get Pipeline",
+      description: "Fetch a single processing pipeline by ID, including its recent runs.",
+      inputSchema: { id: zod.z.string().describe("Pipeline ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_PIPELINE, { id });
+        if (!data.cosPipeline) return errorResult(`Pipeline ${id} not found`);
+        return jsonResult(data.cosPipeline);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection pipelines_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get pipeline: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "pipelines_list")),
+    {
+      title: "List Pipelines",
+      description: "List processing pipelines with optional status filter and pagination (returns a connection: { items, pageInfo }).",
+      inputSchema: {
+        status: CosPipelineStatusEnum.optional().describe("Filter by lifecycle 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 pagination = {};
+        if (limit !== void 0) pagination.limit = limit;
+        if (offset !== void 0) pagination.offset = offset;
+        if (cursor !== void 0) pagination.cursor = cursor;
+        const data = await ctx.gql.workspace.request(LIST_PIPELINES, {
+          status,
+          pagination: Object.keys(pagination).length > 0 ? pagination : void 0
+        });
+        return jsonResult(data.cosListPipelines);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection 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 Pipeline",
+      description: "Create a processing pipeline. Defaults: trigger=MANUAL.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Pipeline name"),
+        trigger: CosPipelineTriggerEnum.optional().describe("Trigger mode (default MANUAL)"),
+        description: zod.z.string().optional().describe("Pipeline description"),
+        definition: JsonObject.optional().describe("Pipeline definition JSON (steps/graph)"),
+        schedule: zod.z.string().optional().describe("Cron schedule (when trigger=SCHEDULED)"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Free-form tags")
+      }
+    },
+    async ({ name, trigger, description, definition, schedule, tags }) => {
+      try {
+        const input = { name };
+        if (trigger !== void 0) input.trigger = trigger;
+        if (description !== void 0) input.description = description;
+        if (definition !== void 0) input.definition = definition;
+        if (schedule !== void 0) input.schedule = schedule;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_PIPELINE, { input });
+        return jsonResult(data.cosCreatePipeline);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection 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_update")),
+    {
+      title: "Update Pipeline",
+      description: "Update a pipeline. At least one mutable field must be provided.",
+      inputSchema: {
+        id: zod.z.string().describe("Pipeline ID"),
+        name: zod.z.string().optional().describe("Updated name"),
+        status: CosPipelineStatusEnum.optional().describe("Updated lifecycle status"),
+        trigger: CosPipelineTriggerEnum.optional().describe("Updated trigger mode"),
+        description: zod.z.string().optional().describe("Updated description"),
+        definition: JsonObject.optional().describe("Updated definition JSON"),
+        schedule: zod.z.string().optional().describe("Updated cron schedule"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({ id, name, status, trigger, description, definition, schedule, tags }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (status !== void 0) input.status = status;
+        if (trigger !== void 0) input.trigger = trigger;
+        if (description !== void 0) input.description = description;
+        if (definition !== void 0) input.definition = definition;
+        if (schedule !== void 0) input.schedule = schedule;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of name/status/trigger/description/definition/schedule/tags"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_PIPELINE, { id, input });
+        return jsonResult(data.cosUpdatePipeline);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection pipelines_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update pipeline: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "pipelines_archive")),
+    {
+      title: "Archive Pipeline",
+      description: "Archive (soft-delete) a pipeline. Returns true on success.",
+      inputSchema: { id: zod.z.string().describe("Pipeline ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_PIPELINE,
+          { id }
+        );
+        return jsonResult({ archived: data.cosArchivePipeline });
+      } catch (error) {
+        ctx.logger.error("cosmicintersection pipelines_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive pipeline: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerRunTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "runs_get")),
+    {
+      title: "Get Run",
+      description: "Fetch a single pipeline run by ID, including its pipeline and steps.",
+      inputSchema: { id: zod.z.string().describe("Run ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_RUN, { id });
+        if (!data.cosRun) return errorResult(`Run ${id} not found`);
+        return jsonResult(data.cosRun);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection runs_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get run: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "runs_list")),
+    {
+      title: "List Runs",
+      description: "List pipeline runs with optional pipeline/status filters and pagination (returns a connection: { items, pageInfo }).",
+      inputSchema: {
+        pipelineId: zod.z.string().optional().describe("Filter by pipeline ID"),
+        status: CosRunStatusEnum.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 pagination = {};
+        if (limit !== void 0) pagination.limit = limit;
+        if (offset !== void 0) pagination.offset = offset;
+        if (cursor !== void 0) pagination.cursor = cursor;
+        const data = await ctx.gql.workspace.request(LIST_RUNS, {
+          pipelineId,
+          status,
+          pagination: Object.keys(pagination).length > 0 ? pagination : void 0
+        });
+        return jsonResult(data.cosListRuns);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection 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 Run",
+      description: "Queue a new run of a pipeline (assigns the next run number).",
+      inputSchema: {
+        pipelineId: zod.z.string().describe("Pipeline ID to run"),
+        datasetId: zod.z.string().optional().describe("Input dataset ID"),
+        params: JsonObject.optional().describe("Run parameters JSON")
+      }
+    },
+    async ({ pipelineId, datasetId, params }) => {
+      try {
+        const input = { pipelineId };
+        if (datasetId !== void 0) input.datasetId = datasetId;
+        if (params !== void 0) input.params = params;
+        const data = await ctx.gql.workspace.request(START_RUN, { input });
+        return jsonResult(data.cosStartRun);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection 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_transition")),
+    {
+      title: "Transition Run",
+      description: "Advance a run through its lifecycle (validated transitions): QUEUED \u2192 RUNNING \u2192 SUCCEEDED/FAILED/CANCELLED.",
+      inputSchema: {
+        id: zod.z.string().describe("Run ID"),
+        status: CosRunStatusEnum.describe("Target run status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TRANSITION_RUN, { id, status });
+        return jsonResult(data.cosTransitionRun);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection runs_transition failed", { error: String(error) });
+        return errorResult(
+          `Failed to transition run: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "runs_steps_list")),
+    {
+      title: "List Run Steps",
+      description: "List the steps of a pipeline run, in order.",
+      inputSchema: { runId: zod.z.string().describe("Run ID") }
+    },
+    async ({ runId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_RUN_STEPS, { runId });
+        return jsonResult(data.cosListRunSteps);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection runs_steps_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list run steps: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "runs_steps_add")),
+    {
+      title: "Add Run Step",
+      description: "Append a step to a run. Defaults: kind=TRANSFORM.",
+      inputSchema: {
+        runId: zod.z.string().describe("Run ID"),
+        name: zod.z.string().min(1).describe("Step name"),
+        kind: CosStepKindEnum.optional().describe("Step kind (default TRANSFORM)"),
+        inputs: JsonObject.optional().describe("Step inputs JSON"),
+        position: zod.z.number().int().optional().describe("Ordinal position in the run")
+      }
+    },
+    async ({ runId, name, kind, inputs, position }) => {
+      try {
+        const input = { runId, name };
+        if (kind !== void 0) input.kind = kind;
+        if (inputs !== void 0) input.inputs = inputs;
+        if (position !== void 0) input.position = position;
+        const data = await ctx.gql.workspace.request(ADD_RUN_STEP, { input });
+        return jsonResult(data.cosAddRunStep);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection runs_steps_add failed", { error: String(error) });
+        return errorResult(
+          `Failed to add run step: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerNotebookTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "notebooks_get")),
+    {
+      title: "Get Notebook",
+      description: "Fetch a single research notebook by ID, including its analyses and releases.",
+      inputSchema: { id: zod.z.string().describe("Notebook ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_NOTEBOOK, { id });
+        if (!data.cosNotebook) return errorResult(`Notebook ${id} not found`);
+        return jsonResult(data.cosNotebook);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection notebooks_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get notebook: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "notebooks_list")),
+    {
+      title: "List Notebooks",
+      description: "List research notebooks with optional status filter and pagination (returns a connection: { items, pageInfo }).",
+      inputSchema: {
+        status: CosNotebookStatusEnum.optional().describe("Filter by lifecycle 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 pagination = {};
+        if (limit !== void 0) pagination.limit = limit;
+        if (offset !== void 0) pagination.offset = offset;
+        if (cursor !== void 0) pagination.cursor = cursor;
+        const data = await ctx.gql.workspace.request(LIST_NOTEBOOKS, {
+          status,
+          pagination: Object.keys(pagination).length > 0 ? pagination : void 0
+        });
+        return jsonResult(data.cosListNotebooks);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection notebooks_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list notebooks: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "notebooks_create")),
+    {
+      title: "Create Notebook",
+      description: "Create a research notebook. Reference a wspace-files-svc File via fileId for the notebook document.",
+      inputSchema: {
+        title: zod.z.string().min(1).describe("Notebook title"),
+        description: zod.z.string().optional().describe("Notebook description"),
+        runtime: zod.z.string().optional().describe("Runtime (e.g. python3.11, julia)"),
+        environment: JsonObject.optional().describe("Environment / dependency JSON"),
+        datasetIds: zod.z.array(zod.z.string()).optional().describe("Dataset IDs referenced by the notebook"),
+        fileId: zod.z.string().optional().describe("wspace-files-svc File ID for the notebook document"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Free-form tags")
+      }
+    },
+    async ({ title, description, runtime, environment, datasetIds, fileId, tags }) => {
+      try {
+        const input = { title };
+        if (description !== void 0) input.description = description;
+        if (runtime !== void 0) input.runtime = runtime;
+        if (environment !== void 0) input.environment = environment;
+        if (datasetIds !== void 0) input.datasetIds = datasetIds;
+        if (fileId !== void 0) input.fileId = fileId;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_NOTEBOOK, { input });
+        return jsonResult(data.cosCreateNotebook);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection notebooks_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create notebook: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "notebooks_update")),
+    {
+      title: "Update Notebook",
+      description: "Update a research notebook. At least one mutable field must be provided.",
+      inputSchema: {
+        id: zod.z.string().describe("Notebook ID"),
+        title: zod.z.string().optional().describe("Updated title"),
+        description: zod.z.string().optional().describe("Updated description"),
+        status: CosNotebookStatusEnum.optional().describe("Updated lifecycle status"),
+        runtime: zod.z.string().optional().describe("Updated runtime"),
+        environment: JsonObject.optional().describe("Updated environment JSON"),
+        datasetIds: zod.z.array(zod.z.string()).optional().describe("Updated dataset IDs"),
+        isShared: zod.z.boolean().optional().describe("Whether the notebook is shared"),
+        shareSlug: zod.z.string().optional().describe("Public share slug"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({
+      id,
+      title,
+      description,
+      status,
+      runtime,
+      environment,
+      datasetIds,
+      isShared,
+      shareSlug,
+      tags
+    }) => {
+      try {
+        const input = {};
+        if (title !== void 0) input.title = title;
+        if (description !== void 0) input.description = description;
+        if (status !== void 0) input.status = status;
+        if (runtime !== void 0) input.runtime = runtime;
+        if (environment !== void 0) input.environment = environment;
+        if (datasetIds !== void 0) input.datasetIds = datasetIds;
+        if (isShared !== void 0) input.isShared = isShared;
+        if (shareSlug !== void 0) input.shareSlug = shareSlug;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of title/description/status/runtime/environment/datasetIds/isShared/shareSlug/tags"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_NOTEBOOK, { id, input });
+        return jsonResult(data.cosUpdateNotebook);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection notebooks_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update notebook: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "notebooks_archive")),
+    {
+      title: "Archive Notebook",
+      description: "Archive (soft-delete) a research notebook. Returns true on success.",
+      inputSchema: { id: zod.z.string().describe("Notebook ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_NOTEBOOK,
+          { id }
+        );
+        return jsonResult({ archived: data.cosArchiveNotebook });
+      } catch (error) {
+        ctx.logger.error("cosmicintersection notebooks_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive notebook: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerAnalysisTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "analyses_list")),
+    {
+      title: "List Analyses",
+      description: "List analyses, optionally filtered by dataset, notebook, and/or status.",
+      inputSchema: {
+        datasetId: zod.z.string().optional().describe("Filter by dataset ID"),
+        notebookId: zod.z.string().optional().describe("Filter by notebook ID"),
+        status: CosAnalysisStatusEnum.optional().describe("Filter by analysis status")
+      }
+    },
+    async ({ datasetId, notebookId, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_ANALYSES, { datasetId, notebookId, status });
+        return jsonResult(data.cosListAnalyses);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection analyses_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list analyses: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "analyses_run")),
+    {
+      title: "Run Analysis",
+      description: "Queue a new analysis run. Defaults: aiAssisted=false.",
+      inputSchema: {
+        title: zod.z.string().min(1).describe("Analysis title"),
+        method: zod.z.string().optional().describe("Analysis method / algorithm"),
+        datasetId: zod.z.string().optional().describe("Input dataset ID"),
+        notebookId: zod.z.string().optional().describe("Source notebook ID"),
+        aiAssisted: zod.z.boolean().optional().describe("Whether AI-assisted (default false)")
+      }
+    },
+    async ({ title, method, datasetId, notebookId, aiAssisted }) => {
+      try {
+        const input = { title };
+        if (method !== void 0) input.method = method;
+        if (datasetId !== void 0) input.datasetId = datasetId;
+        if (notebookId !== void 0) input.notebookId = notebookId;
+        if (aiAssisted !== void 0) input.aiAssisted = aiAssisted;
+        const data = await ctx.gql.workspace.request(RUN_ANALYSIS, { input });
+        return jsonResult(data.cosRunAnalysis);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection analyses_run failed", { error: String(error) });
+        return errorResult(
+          `Failed to run analysis: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "analyses_complete")),
+    {
+      title: "Complete Analysis",
+      description: "Record the terminal outcome of an analysis run (COMPLETED / FAILED), optionally attaching results JSON and a rendered output File.",
+      inputSchema: {
+        id: zod.z.string().describe("Analysis ID"),
+        status: CosAnalysisStatusEnum.describe("Terminal status (COMPLETED or FAILED)"),
+        results: JsonObject.optional().describe("Analysis results JSON"),
+        outputFileId: zod.z.string().optional().describe("wspace-files-svc File ID of the rendered visualization")
+      }
+    },
+    async ({ id, status, results, outputFileId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(COMPLETE_ANALYSIS, { id, status, results, outputFileId });
+        return jsonResult(data.cosCompleteAnalysis);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection analyses_complete failed", { error: String(error) });
+        return errorResult(
+          `Failed to complete analysis: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerReleaseTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "releases_list")),
+    {
+      title: "List Releases",
+      description: "List citable releases with optional status filter and pagination (returns a connection: { items, pageInfo }).",
+      inputSchema: {
+        status: CosReleaseStatusEnum.optional().describe("Filter by lifecycle 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 pagination = {};
+        if (limit !== void 0) pagination.limit = limit;
+        if (offset !== void 0) pagination.offset = offset;
+        if (cursor !== void 0) pagination.cursor = cursor;
+        const data = await ctx.gql.workspace.request(LIST_RELEASES, {
+          status,
+          pagination: Object.keys(pagination).length > 0 ? pagination : void 0
+        });
+        return jsonResult(data.cosListReleases);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection releases_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list releases: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "releases_create")),
+    {
+      title: "Create Release",
+      description: "Draft a citable release bundling datasets and/or a notebook for publication.",
+      inputSchema: {
+        title: zod.z.string().min(1).describe("Release title"),
+        version: zod.z.string().optional().describe("Version string (e.g. 1.0.0)"),
+        abstract: zod.z.string().optional().describe("Abstract / summary"),
+        authors: zod.z.array(zod.z.string()).optional().describe("Author names"),
+        license: zod.z.string().optional().describe("License (e.g. CC-BY-4.0)"),
+        notebookId: zod.z.string().optional().describe("Source notebook ID"),
+        datasetIds: zod.z.array(zod.z.string()).optional().describe("Bundled dataset IDs")
+      }
+    },
+    async ({ title, version, abstract, authors, license, notebookId, datasetIds }) => {
+      try {
+        const input = { title };
+        if (version !== void 0) input.version = version;
+        if (abstract !== void 0) input.abstract = abstract;
+        if (authors !== void 0) input.authors = authors;
+        if (license !== void 0) input.license = license;
+        if (notebookId !== void 0) input.notebookId = notebookId;
+        if (datasetIds !== void 0) input.datasetIds = datasetIds;
+        const data = await ctx.gql.workspace.request(CREATE_RELEASE, { input });
+        return jsonResult(data.cosCreateRelease);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection releases_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create release: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "releases_publish")),
+    {
+      title: "Publish Release",
+      description: "Publish a citable release and stamp it with a DOI.",
+      inputSchema: {
+        id: zod.z.string().describe("Release ID"),
+        doi: zod.z.string().optional().describe("DOI to stamp the release with")
+      }
+    },
+    async ({ id, doi }) => {
+      try {
+        const data = await ctx.gql.workspace.request(PUBLISH_RELEASE, { id, doi });
+        return jsonResult(data.cosPublishRelease);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection releases_publish failed", { error: String(error) });
+        return errorResult(
+          `Failed to publish release: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerGrantTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "grants_list")),
+    {
+      title: "List Access Grants",
+      description: "List dataset access grants, optionally filtered by dataset and/or status.",
+      inputSchema: {
+        datasetId: zod.z.string().optional().describe("Filter by dataset ID"),
+        status: CosGrantStatusEnum.optional().describe("Filter by grant status")
+      }
+    },
+    async ({ datasetId, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_ACCESS_GRANTS, { datasetId, status });
+        return jsonResult(data.cosListAccessGrants);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection grants_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list access grants: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "grants_grant")),
+    {
+      title: "Grant Dataset Access",
+      description: "Grant a user (grantee) scoped access to a dataset, optionally with an expiry and reason.",
+      inputSchema: {
+        datasetId: zod.z.string().describe("Dataset ID"),
+        granteeId: zod.z.string().describe("User ID of the grantee"),
+        scopes: zod.z.array(zod.z.string()).optional().describe("Granted scopes (e.g. read, download)"),
+        reason: zod.z.string().optional().describe("Reason for the grant"),
+        expiresAt: zod.z.string().optional().describe("Expiry timestamp (ISO 8601 DateTime)")
+      }
+    },
+    async ({ datasetId, granteeId, scopes, reason, expiresAt }) => {
+      try {
+        const input = { datasetId, granteeId };
+        if (scopes !== void 0) input.scopes = scopes;
+        if (reason !== void 0) input.reason = reason;
+        if (expiresAt !== void 0) input.expiresAt = expiresAt;
+        const data = await ctx.gql.workspace.request(GRANT_ACCESS, { input });
+        return jsonResult(data.cosGrantAccess);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection grants_grant failed", { error: String(error) });
+        return errorResult(
+          `Failed to grant access: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "grants_revoke")),
+    {
+      title: "Revoke Dataset Access",
+      description: "Revoke a dataset access grant (sets status REVOKED + revokedAt).",
+      inputSchema: { id: zod.z.string().describe("Access grant ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(REVOKE_ACCESS, { id });
+        return jsonResult(data.cosRevokeAccess);
+      } catch (error) {
+        ctx.logger.error("cosmicintersection grants_revoke failed", { error: String(error) });
+        return errorResult(
+          `Failed to revoke access: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/cosmicintersection/tools/health.ts
+function registerHealthTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "health")),
+    {
+      title: "Cosmicintersection Health Check",
+      description: "Public health probe for the Cosmicintersection subgraph (cosHealth). Requires no authentication.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(HEALTH, {});
+        return jsonResult({ ok: true, status: data.cosHealth });
+      } catch (error) {
+        ctx.logger.error("cosmicintersection health failed", { error: String(error) });
+        return errorResult(
+          `Cosmicintersection health check failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/cosmicintersection/resources.ts
+function registerCosmicintersectionResources(server, ctx, track) {
+  const schemaUri = track(mcpResourceUri(ctx.productName, "schema"));
+  const datasetsUri = track(mcpResourceUri(ctx.productName, "datasets"));
+  const collectionsUri = track(mcpResourceUri(ctx.productName, "collections"));
+  const pipelinesUri = track(mcpResourceUri(ctx.productName, "pipelines"));
+  server.registerResource(
+    "cosmicintersection-schema",
+    schemaUri,
+    {
+      title: "Cosmicintersection Domain Schema",
+      description: "Overview of the Cosmicintersection data-platform domain \u2014 entities, enums, and the per-entity tool surface.",
+      mimeType: "text/plain"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${schemaUri} requested`);
+      const schema = `# Cosmicintersection Domain (Overview)
+
+The unified data platform for space & science: data sources & connectors, the
+dataset catalog (with schema / provenance), processing pipelines & runs (with
+captured lineage), and reproducible research (notebooks, analyses, citable
+releases, access grants).
+
+## Entities
+- CosSource \u2014 an upstream data source / connector (telescope, satellite, archive, API, \u2026)
+- CosDataset (+CosSchemaField) \u2014 a cataloged dataset and its schema fields
+- CosCollection \u2014 a named grouping of datasets
+- CosPipeline \u2014 a processing pipeline
+- CosPipelineRun (+CosPipelineStep) \u2014 a run of a pipeline and its steps
+- CosNotebook \u2014 a research notebook (references a wspace-files-svc File document)
+- CosAnalysis \u2014 an analysis run against a dataset/notebook
+- CosRelease \u2014 a citable, DOI-stamped research release
+- CosDataAccessGrant \u2014 a scoped access grant to a dataset
+
+## Enums
+- CosSourceType: API, ARCHIVE, FILE_DROP, GROUND_SENSOR, SATELLITE, SIMULATION, STREAM, TELESCOPE
+- CosSourceStatus: CONFIGURING, CONNECTED, DEGRADED, DISABLED, ERROR, SYNCING
+- CosDatasetStatus: ARCHIVED, AVAILABLE, DEPRECATED, DRAFT, INGESTING
+- CosAccessLevel: EMBARGOED, PUBLIC, RESTRICTED, WORKSPACE
+- CosFieldType: BOOLEAN, COORDINATE, FLOAT, GEOMETRY, IMAGE_REF, INTEGER, JSON, SPECTRUM, STRING, TIMESTAMP
+- CosPipelineStatus: ACTIVE, ARCHIVED, DRAFT, PAUSED
+- CosPipelineTrigger: MANUAL, ON_INGEST, SCHEDULED, WEBHOOK
+- CosRunStatus: CANCELLED, FAILED, QUEUED, RUNNING, SUCCEEDED
+- CosStepKind: ANALYZE, CALIBRATE, EXPORT, INGEST, NOTIFY, TRANSFORM
+- CosNotebookStatus: ARCHIVED, DRAFT, PUBLISHED, RUNNING
+- CosAnalysisStatus: COMPLETED, FAILED, PENDING, RUNNING
+- CosReleaseStatus: DRAFT, PUBLISHED, RETRACTED, UNDER_REVIEW
+- CosGrantStatus: ACTIVE, EXPIRED, PENDING, REVOKED
+
+## Tool groups
+sources, datasets (+fields), collections, pipelines, runs (+steps), notebooks,
+analyses, releases, grants, health. All run against the WORKSPACE gateway
+(workspace-scoped) except the public health probe.
+`;
+      return {
+        contents: [{ uri: schemaUri, text: schema, mimeType: "text/plain" }]
+      };
+    }
+  );
+  server.registerResource(
+    "cosmicintersection-datasets",
+    datasetsUri,
+    {
+      title: "Cosmicintersection Dataset Catalog",
+      description: "The first 50 datasets in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${datasetsUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(LIST_DATASETS, {
+          pagination: { limit: 50, offset: 0 }
+        });
+        return {
+          contents: [
+            {
+              uri: datasetsUri,
+              text: JSON.stringify(data.cosListDatasets, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: datasetsUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "cosmicintersection-collections",
+    collectionsUri,
+    {
+      title: "Cosmicintersection Collections",
+      description: "All dataset collections in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${collectionsUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_COLLECTIONS,
+          {}
+        );
+        return {
+          contents: [
+            {
+              uri: collectionsUri,
+              text: JSON.stringify(data.cosListCollections, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: collectionsUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "cosmicintersection-pipelines",
+    pipelinesUri,
+    {
+      title: "Cosmicintersection Pipelines",
+      description: "The first 50 processing 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,
+          { pagination: { limit: 50, offset: 0 } }
+        );
+        return {
+          contents: [
+            {
+              uri: pipelinesUri,
+              text: JSON.stringify(data.cosListPipelines, 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 registerCosmicintersectionPrompts(server, ctx, track) {
+  const p = ctx.productName;
+  const onboardingName = track(mcpPromptName(p, "dataset-onboarding"));
+  const researchName = track(mcpPromptName(p, "research-publication"));
+  server.registerPrompt(
+    onboardingName,
+    {
+      title: "Dataset Onboarding",
+      description: "Guide for onboarding new data into Cosmicintersection end to end: register a source, catalog a dataset, declare its schema, and publish it.",
+      argsSchema: {
+        sourceName: zod.z.string().optional().describe("Data source name"),
+        datasetName: zod.z.string().optional().describe("Dataset name")
+      }
+    },
+    ({ sourceName, datasetName }) => {
+      ctx.logger.debug(`Prompt ${onboardingName} called`, { sourceName, datasetName });
+      const sourceNote = sourceName ? `Use the source name "${sourceName}".` : "Ask the user for the source name.";
+      const datasetNote = datasetName ? `Use the dataset name "${datasetName}".` : "Ask the user for the dataset name.";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Help me onboard new data into Cosmicintersection.
+
+1. **Register Source**: Use ${p}_sources_create. ${sourceNote} Pick a CosSourceType (TELESCOPE, SATELLITE, ARCHIVE, API, \u2026) and set an endpoint/config if applicable.
+2. **(Optional) Collection**: Use ${p}_collections_create (or ${p}_collections_list) to group related datasets.
+3. **Catalog Dataset**: Use ${p}_datasets_create. ${datasetNote} Link sourceId (and collectionId), set accessLevel and format, and reference the raw artifact File via fileId.
+4. **Declare Schema**: Use ${p}_datasets_fields_add for each column \u2014 set fieldType (FLOAT, COORDINATE, SPECTRUM, TIMESTAMP, \u2026), nullable, unit, and provenance.
+5. **Mark Synced**: Use ${p}_sources_mark_synced once the source connection is verified.
+6. **Publish**: Use ${p}_datasets_publish to mark the dataset AVAILABLE once ingestion completes.
+
+Show results at each step and confirm before publishing.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server.registerPrompt(
+    researchName,
+    {
+      title: "Research Publication",
+      description: "Reproducible-research workflow: build a pipeline, run it, analyze the output in a notebook, and cut a citable DOI-stamped release.",
+      argsSchema: {
+        notebookId: zod.z.string().optional().describe("Notebook ID to work from")
+      }
+    },
+    ({ notebookId }) => {
+      ctx.logger.debug(`Prompt ${researchName} called`, { notebookId });
+      const notebookNote = notebookId ? `Work from notebook "${notebookId}".` : `First list notebooks with ${p}_notebooks_list (or create one with ${p}_notebooks_create) and pick one.`;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Run a reproducible-research publication workflow. ${notebookNote}
+
+1. **Pipeline**: Use ${p}_pipelines_list / ${p}_pipelines_create to set up the processing pipeline (definition + trigger).
+2. **Run**: Use ${p}_runs_start to queue a run, ${p}_runs_steps_add to append steps, and ${p}_runs_transition to advance it (QUEUED \u2192 RUNNING \u2192 SUCCEEDED).
+3. **Analyze**: Use ${p}_analyses_run against the resulting dataset/notebook, then ${p}_analyses_complete with the results and an output File.
+4. **Release**: Use ${p}_releases_create to bundle datasets + notebook, then ${p}_releases_publish to stamp a DOI.
+5. **(Optional) Share Access**: Use ${p}_grants_grant to give collaborators scoped access to the underlying datasets.
+
+Summarize lineage (source \u2192 dataset \u2192 run \u2192 analysis \u2192 release) at the end.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/modules/cosmicintersection/index.ts
+var cosmicintersectionModule = {
+  id: "cosmicintersection",
+  version: "0.0.1",
+  displayName: "Cosmicintersection",
+  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;
+    };
+    registerSourceTools(server, ctx, trackTool);
+    registerDatasetTools(server, ctx, trackTool);
+    registerCollectionTools(server, ctx, trackTool);
+    registerPipelineTools(server, ctx, trackTool);
+    registerRunTools(server, ctx, trackTool);
+    registerNotebookTools(server, ctx, trackTool);
+    registerAnalysisTools(server, ctx, trackTool);
+    registerReleaseTools(server, ctx, trackTool);
+    registerGrantTools(server, ctx, trackTool);
+    registerHealthTools(server, ctx, trackTool);
+    registerCosmicintersectionResources(server, ctx, trackResource);
+    registerCosmicintersectionPrompts(server, ctx, trackPrompt);
+    return { tools, resources, prompts };
+  }
+};
+var cosmicintersection_default = cosmicintersectionModule;
+
+module.exports = cosmicintersection_default;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map