@burdenoff/mcp-libs 2026.627.3 → 2026.627.5

package/dist/modules/intelwatchtower/index.cjs

@@ -0,0 +1,1919 @@
+'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/intelwatchtower/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/intelwatchtower/operations.ts
+var PAGE_INFO = `pageInfo { cursor hasMore }`;
+var SOURCE_FIELDS = `
+  id name codename description discipline status classification region reliability
+  operatorId lastSeenAt tags createdAt updatedAt workspaceId
+`;
+var FEED_FIELDS = `
+  id name endpoint format status ingestCount lastIngestAt sourceId
+  createdAt updatedAt workspaceId
+`;
+var REQUIREMENT_FIELDS = `
+  id title description classification priority status dueDate satisfiedAt
+  missionId requestedById tags createdAt updatedAt workspaceId
+`;
+var TASK_FIELDS = `
+  id status instructions sourceId requirementId resultSummary
+  startAt endAt dispatchedAt completedAt createdAt updatedAt workspaceId
+`;
+var OBSERVATION_FIELDS = `
+  id summary classification observedAt latitude longitude payload
+  entityId sourceId taskId createdAt updatedAt workspaceId
+`;
+var MISSION_FIELDS = `
+  id name codename objective classification status commanderId
+  startAt endAt tags createdAt updatedAt workspaceId
+`;
+var ENTITY_FIELDS = `
+  id name type classification confidence description aliases threatScore
+  latitude longitude lastSeenAt attributes tags createdAt updatedAt workspaceId
+`;
+var INDICATOR_FIELDS = `
+  id type value classification confidence description isActive entityId
+  validFrom validUntil createdAt updatedAt workspaceId
+`;
+var ALERT_FIELDS = `
+  id title description classification severity status detectedAt resolvedAt
+  entityId indicatorId missionId caseId assignedToId triageNotes
+  createdAt updatedAt workspaceId
+`;
+var CASE_ENTRY_FIELDS = `
+  id caseId kind body createdAt updatedAt workspaceId file { id }
+`;
+var CASE_FIELDS = `
+  id title summary reference classification priority status missionId
+  leadAnalystId tags openedAt closedAt createdAt updatedAt workspaceId
+`;
+var REPORT_FIELDS = `
+  id title summary body type status classification authorId caseId missionId
+  tags releasedAt createdAt updatedAt workspaceId file { id }
+`;
+var GET_SOURCE = `
+  query IntelwatchtowerGetSource($id: ID!) {
+    intSource(id: $id) {
+      ${SOURCE_FIELDS}
+      feeds { ${FEED_FIELDS} }
+      tasks { ${TASK_FIELDS} }
+    }
+  }
+`;
+var LIST_SOURCES = `
+  query IntelwatchtowerListSources(
+    $discipline: IntSourceDiscipline
+    $status: IntSourceStatus
+    $pagination: PaginationInput
+  ) {
+    intListSources(discipline: $discipline, status: $status, pagination: $pagination) {
+      items { ${SOURCE_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_SOURCE = `
+  mutation IntelwatchtowerCreateSource($input: IntCreateSourceInput!) {
+    intCreateSource(input: $input) { ${SOURCE_FIELDS} }
+  }
+`;
+var UPDATE_SOURCE = `
+  mutation IntelwatchtowerUpdateSource($id: ID!, $input: IntUpdateSourceInput!) {
+    intUpdateSource(id: $id, input: $input) { ${SOURCE_FIELDS} }
+  }
+`;
+var RETIRE_SOURCE = `
+  mutation IntelwatchtowerRetireSource($id: ID!) {
+    intRetireSource(id: $id)
+  }
+`;
+var CREATE_FEED = `
+  mutation IntelwatchtowerCreateFeed($input: IntCreateFeedInput!) {
+    intCreateFeed(input: $input) { ${FEED_FIELDS} }
+  }
+`;
+var LIST_REQUIREMENTS = `
+  query IntelwatchtowerListRequirements($missionId: ID, $status: IntRequirementStatus) {
+    intListRequirements(missionId: $missionId, status: $status) {
+      ${REQUIREMENT_FIELDS}
+      tasks { ${TASK_FIELDS} }
+    }
+  }
+`;
+var CREATE_REQUIREMENT = `
+  mutation IntelwatchtowerCreateRequirement($input: IntCreateRequirementInput!) {
+    intCreateRequirement(input: $input) { ${REQUIREMENT_FIELDS} }
+  }
+`;
+var LIST_TASKS = `
+  query IntelwatchtowerListTasks(
+    $requirementId: ID
+    $sourceId: ID
+    $status: IntTaskStatus
+    $pagination: PaginationInput
+  ) {
+    intListTasks(
+      requirementId: $requirementId
+      sourceId: $sourceId
+      status: $status
+      pagination: $pagination
+    ) {
+      items { ${TASK_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_TASK = `
+  mutation IntelwatchtowerCreateTask($input: IntCreateTaskInput!) {
+    intCreateTask(input: $input) { ${TASK_FIELDS} }
+  }
+`;
+var TRANSITION_TASK = `
+  mutation IntelwatchtowerTransitionTask($id: ID!, $status: IntTaskStatus!) {
+    intTransitionTask(id: $id, status: $status) { ${TASK_FIELDS} }
+  }
+`;
+var LIST_OBSERVATIONS = `
+  query IntelwatchtowerListObservations(
+    $entityId: ID
+    $sourceId: ID
+    $taskId: ID
+    $pagination: PaginationInput
+  ) {
+    intListObservations(
+      entityId: $entityId
+      sourceId: $sourceId
+      taskId: $taskId
+      pagination: $pagination
+    ) {
+      items { ${OBSERVATION_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var RECORD_OBSERVATION = `
+  mutation IntelwatchtowerRecordObservation($input: IntRecordObservationInput!) {
+    intRecordObservation(input: $input) { ${OBSERVATION_FIELDS} }
+  }
+`;
+var GET_MISSION = `
+  query IntelwatchtowerGetMission($id: ID!) {
+    intMission(id: $id) {
+      ${MISSION_FIELDS}
+      cases { ${CASE_FIELDS} }
+      reports { ${REPORT_FIELDS} }
+    }
+  }
+`;
+var LIST_MISSIONS = `
+  query IntelwatchtowerListMissions($status: IntMissionStatus) {
+    intListMissions(status: $status) { ${MISSION_FIELDS} }
+  }
+`;
+var CREATE_MISSION = `
+  mutation IntelwatchtowerCreateMission($input: IntCreateMissionInput!) {
+    intCreateMission(input: $input) { ${MISSION_FIELDS} }
+  }
+`;
+var TRANSITION_MISSION = `
+  mutation IntelwatchtowerTransitionMission($id: ID!, $status: IntMissionStatus!) {
+    intTransitionMission(id: $id, status: $status) { ${MISSION_FIELDS} }
+  }
+`;
+var GET_ENTITY = `
+  query IntelwatchtowerGetEntity($id: ID!) {
+    intEntity(id: $id) {
+      ${ENTITY_FIELDS}
+      indicators { ${INDICATOR_FIELDS} }
+      alerts { ${ALERT_FIELDS} }
+    }
+  }
+`;
+var LIST_ENTITIES = `
+  query IntelwatchtowerListEntities(
+    $type: IntEntityType
+    $confidence: IntConfidence
+    $pagination: PaginationInput
+  ) {
+    intListEntities(type: $type, confidence: $confidence, pagination: $pagination) {
+      items { ${ENTITY_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_ENTITY = `
+  mutation IntelwatchtowerCreateEntity($input: IntCreateEntityInput!) {
+    intCreateEntity(input: $input) { ${ENTITY_FIELDS} }
+  }
+`;
+var UPDATE_ENTITY = `
+  mutation IntelwatchtowerUpdateEntity($id: ID!, $input: IntUpdateEntityInput!) {
+    intUpdateEntity(id: $id, input: $input) { ${ENTITY_FIELDS} }
+  }
+`;
+var LIST_INDICATORS = `
+  query IntelwatchtowerListIndicators(
+    $entityId: ID
+    $type: IntIndicatorType
+    $isActive: Boolean
+  ) {
+    intListIndicators(entityId: $entityId, type: $type, isActive: $isActive) {
+      ${INDICATOR_FIELDS}
+    }
+  }
+`;
+var CREATE_INDICATOR = `
+  mutation IntelwatchtowerCreateIndicator($input: IntCreateIndicatorInput!) {
+    intCreateIndicator(input: $input) { ${INDICATOR_FIELDS} }
+  }
+`;
+var DEACTIVATE_INDICATOR = `
+  mutation IntelwatchtowerDeactivateIndicator($id: ID!) {
+    intDeactivateIndicator(id: $id) { ${INDICATOR_FIELDS} }
+  }
+`;
+var LIST_ALERTS = `
+  query IntelwatchtowerListAlerts(
+    $entityId: ID
+    $severity: IntAlertSeverity
+    $status: IntAlertStatus
+    $pagination: PaginationInput
+  ) {
+    intListAlerts(
+      entityId: $entityId
+      severity: $severity
+      status: $status
+      pagination: $pagination
+    ) {
+      items { ${ALERT_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var RAISE_ALERT = `
+  mutation IntelwatchtowerRaiseAlert($input: IntRaiseAlertInput!) {
+    intRaiseAlert(input: $input) { ${ALERT_FIELDS} }
+  }
+`;
+var TRANSITION_ALERT = `
+  mutation IntelwatchtowerTransitionAlert(
+    $id: ID!
+    $status: IntAlertStatus!
+    $triageNotes: String
+  ) {
+    intTransitionAlert(id: $id, status: $status, triageNotes: $triageNotes) {
+      ${ALERT_FIELDS}
+    }
+  }
+`;
+var GET_CASE = `
+  query IntelwatchtowerGetCase($id: ID!) {
+    intCase(id: $id) {
+      ${CASE_FIELDS}
+      alerts { ${ALERT_FIELDS} }
+      entries { ${CASE_ENTRY_FIELDS} }
+    }
+  }
+`;
+var LIST_CASES = `
+  query IntelwatchtowerListCases(
+    $missionId: ID
+    $status: IntCaseStatus
+    $pagination: PaginationInput
+  ) {
+    intListCases(missionId: $missionId, status: $status, pagination: $pagination) {
+      items { ${CASE_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_CASE = `
+  mutation IntelwatchtowerCreateCase($input: IntCreateCaseInput!) {
+    intCreateCase(input: $input) { ${CASE_FIELDS} }
+  }
+`;
+var ADD_CASE_ENTRY = `
+  mutation IntelwatchtowerAddCaseEntry($input: IntAddCaseEntryInput!) {
+    intAddCaseEntry(input: $input) { ${CASE_ENTRY_FIELDS} }
+  }
+`;
+var CLOSE_CASE = `
+  mutation IntelwatchtowerCloseCase($id: ID!) {
+    intCloseCase(id: $id) { ${CASE_FIELDS} }
+  }
+`;
+var LIST_REPORTS = `
+  query IntelwatchtowerListReports(
+    $missionId: ID
+    $type: IntReportType
+    $status: IntReportStatus
+    $pagination: PaginationInput
+  ) {
+    intListReports(
+      missionId: $missionId
+      type: $type
+      status: $status
+      pagination: $pagination
+    ) {
+      items { ${REPORT_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_REPORT = `
+  mutation IntelwatchtowerCreateReport($input: IntCreateReportInput!) {
+    intCreateReport(input: $input) { ${REPORT_FIELDS} }
+  }
+`;
+var RELEASE_REPORT = `
+  mutation IntelwatchtowerReleaseReport($id: ID!) {
+    intReleaseReport(id: $id) { ${REPORT_FIELDS} }
+  }
+`;
+var HEALTH = `
+  query IntelwatchtowerHealth {
+    intHealth
+  }
+`;
+var ClassificationEnum = zod.z.enum(["CONFIDENTIAL", "SECRET", "TOP_SECRET", "UNCLASSIFIED"]).describe("Security classification of an intelligence object");
+var ConfidenceEnum = zod.z.enum(["CONFIRMED", "HIGH", "LOW", "MODERATE"]).describe("Analyst confidence in an entity/indicator");
+var PriorityEnum = zod.z.enum(["FLASH", "IMMEDIATE", "PRIORITY", "ROUTINE"]).describe("Precedence/priority of a case or requirement");
+var AlertSeverityEnum = zod.z.enum(["CRITICAL", "HIGH", "INFO", "LOW", "MEDIUM"]).describe("Severity of a threat alert");
+var AlertStatusEnum = zod.z.enum(["ESCALATED", "FALSE_POSITIVE", "OPEN", "RESOLVED", "SUPPRESSED", "TRIAGED"]).describe("Triage lifecycle status of a threat alert");
+var CaseStatusEnum = zod.z.enum(["ACTIVE", "ARCHIVED", "CLOSED", "OPEN", "PENDING_REVIEW"]).describe("Lifecycle status of an investigation case");
+var EntityTypeEnum = zod.z.enum([
+  "AIRCRAFT",
+  "EVENT",
+  "FACILITY",
+  "LOCATION",
+  "NETWORK_NODE",
+  "ORGANIZATION",
+  "PERSON",
+  "VEHICLE",
+  "VESSEL"
+]).describe("Type of a tracked entity");
+var FeedStatusEnum = zod.z.enum(["CONNECTED", "DISCONNECTED", "ERROR", "STALE"]).describe("Connection status of a collection feed");
+var IndicatorTypeEnum = zod.z.enum([
+  "BEHAVIOR",
+  "DOMAIN",
+  "EMAIL",
+  "FILE_HASH",
+  "GEO_COORDINATE",
+  "IP_ADDRESS",
+  "SIGNATURE",
+  "URL"
+]).describe("Type of an indicator of compromise / observable");
+var MissionStatusEnum = zod.z.enum(["ABORTED", "ACTIVE", "COMPLETED", "PAUSED", "PLANNING", "READY"]).describe("Lifecycle status of a mission");
+var ReportStatusEnum = zod.z.enum(["ARCHIVED", "DRAFT", "IN_REVIEW", "RECALLED", "RELEASED"]).describe("Lifecycle status of an intelligence report");
+var ReportTypeEnum = zod.z.enum(["ASSESSMENT", "INTSUM", "SITREP", "SPOT_REPORT", "WARNING"]).describe("Product type of an intelligence report");
+var RequirementStatusEnum = zod.z.enum(["APPROVED", "CANCELLED", "DRAFT", "SATISFIED", "SUBMITTED", "TASKED"]).describe("Lifecycle status of a collection requirement");
+var SourceDisciplineEnum = zod.z.enum(["CYBER", "GEOINT", "HUMINT", "IMINT", "MASINT", "OSINT", "SIGINT"]).describe("Collection discipline of a source/sensor");
+var SourceStatusEnum = zod.z.enum(["ACTIVE", "DEGRADED", "OFFLINE", "PROVISIONING", "RETIRED"]).describe("Operational status of a source/sensor");
+var TaskStatusEnum = zod.z.enum(["CANCELLED", "COLLECTING", "COMPLETED", "DISPATCHED", "FAILED", "PENDING"]).describe("Lifecycle status of a collection (tasking) order");
+var JsonObject = zod.z.record(zod.z.string(), zod.z.unknown());
+var IsoDateTime = zod.z.string().describe('ISO-8601 timestamp (DateTime scalar), e.g. "2026-06-27T12:00:00.000Z"');
+function buildPagination(limit, offset) {
+  const pagination = {};
+  if (limit !== void 0) pagination.limit = limit;
+  if (offset !== void 0) pagination.offset = offset;
+  return Object.keys(pagination).length > 0 ? pagination : void 0;
+}
+
+// src/modules/intelwatchtower/tools/sources.ts
+function registerSourceTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sources_get")),
+    {
+      title: "Get Source",
+      description: "Fetch a single collection source/sensor by ID, including its feeds and tasking orders.",
+      inputSchema: { id: zod.z.string().describe("Source ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_SOURCE, { id });
+        if (!data.intSource) return errorResult(`Source ${id} not found`);
+        return jsonResult(data.intSource);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower 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 collection sources/sensors in the bound workspace, optionally filtered by discipline and/or status, with pagination.",
+      inputSchema: {
+        discipline: SourceDisciplineEnum.optional().describe("Filter by collection discipline"),
+        status: SourceStatusEnum.optional().describe("Filter by operational status"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)")
+      }
+    },
+    async ({ discipline, status, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_SOURCES, {
+          discipline,
+          status,
+          pagination: buildPagination(limit, offset)
+        });
+        return jsonResult(data.intListSources);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower 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 collection source/sensor. `discipline` is required; `reliability` is an analyst-assigned score.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Source display name"),
+        discipline: SourceDisciplineEnum.describe("Collection discipline (HUMINT, SIGINT, ...)"),
+        codename: zod.z.string().optional().describe("Operational codename"),
+        description: zod.z.string().optional().describe("Source description"),
+        classification: ClassificationEnum.optional().describe(
+          "Security classification (default UNCLASSIFIED)"
+        ),
+        region: zod.z.string().optional().describe("Geographic region of operation"),
+        reliability: zod.z.number().int().optional().describe("Reliability score (analyst-assigned)"),
+        operatorId: zod.z.string().optional().describe("User ID of the controlling operator"),
+        status: SourceStatusEnum.optional().describe("Initial status (default PROVISIONING)"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Discovery/triage tags")
+      }
+    },
+    async ({
+      name,
+      discipline,
+      codename,
+      description,
+      classification,
+      region,
+      reliability,
+      operatorId,
+      status,
+      tags
+    }) => {
+      try {
+        const input = { name, discipline };
+        if (codename !== void 0) input.codename = codename;
+        if (description !== void 0) input.description = description;
+        if (classification !== void 0) input.classification = classification;
+        if (region !== void 0) input.region = region;
+        if (reliability !== void 0) input.reliability = reliability;
+        if (operatorId !== void 0) input.operatorId = operatorId;
+        if (status !== void 0) input.status = status;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_SOURCE, { input });
+        return jsonResult(data.intCreateSource);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower 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 collection source. At least one mutable field must be provided. Use `status` to activate/degrade/take a source offline.",
+      inputSchema: {
+        id: zod.z.string().describe("Source ID"),
+        name: zod.z.string().optional().describe("Updated display name"),
+        codename: zod.z.string().optional().describe("Updated codename"),
+        description: zod.z.string().optional().describe("Updated description"),
+        discipline: SourceDisciplineEnum.optional().describe("Updated discipline"),
+        classification: ClassificationEnum.optional().describe("Updated classification"),
+        region: zod.z.string().optional().describe("Updated region"),
+        reliability: zod.z.number().int().optional().describe("Updated reliability score"),
+        operatorId: zod.z.string().optional().describe("Updated operator user ID"),
+        status: SourceStatusEnum.optional().describe("Updated operational status"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({
+      id,
+      name,
+      codename,
+      description,
+      discipline,
+      classification,
+      region,
+      reliability,
+      operatorId,
+      status,
+      tags
+    }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (codename !== void 0) input.codename = codename;
+        if (description !== void 0) input.description = description;
+        if (discipline !== void 0) input.discipline = discipline;
+        if (classification !== void 0) input.classification = classification;
+        if (region !== void 0) input.region = region;
+        if (reliability !== void 0) input.reliability = reliability;
+        if (operatorId !== void 0) input.operatorId = operatorId;
+        if (status !== void 0) input.status = status;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult("No updates specified \u2014 provide at least one mutable source field");
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_SOURCE, { id, input });
+        return jsonResult(data.intUpdateSource);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower 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_retire")),
+    {
+      title: "Retire Source",
+      description: "Retire (decommission) a collection source/sensor.",
+      inputSchema: { id: zod.z.string().describe("Source ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          RETIRE_SOURCE,
+          { id }
+        );
+        return jsonResult({ ok: data.intRetireSource, id });
+      } catch (error) {
+        ctx.logger.error("intelwatchtower sources_retire failed", { error: String(error) });
+        return errorResult(
+          `Failed to retire source: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerFeedTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "feeds_create")),
+    {
+      title: "Create Feed",
+      description: "Attach a new ingest feed to a collection source. `sourceId` is required; `endpoint`/`format` describe the upstream connection.",
+      inputSchema: {
+        sourceId: zod.z.string().min(1).describe("Owning source ID"),
+        name: zod.z.string().min(1).describe("Feed display name"),
+        endpoint: zod.z.string().optional().describe("Upstream endpoint URL/URI"),
+        format: zod.z.string().optional().describe('Wire format, e.g. "stix", "json", "csv"'),
+        status: FeedStatusEnum.optional().describe(
+          "Initial connection status (default DISCONNECTED)"
+        )
+      }
+    },
+    async ({ sourceId, name, endpoint, format, status }) => {
+      try {
+        const input = { sourceId, name };
+        if (endpoint !== void 0) input.endpoint = endpoint;
+        if (format !== void 0) input.format = format;
+        if (status !== void 0) input.status = status;
+        const data = await ctx.gql.workspace.request(CREATE_FEED, { input });
+        return jsonResult(data.intCreateFeed);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower feeds_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create feed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerRequirementTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "requirements_list")),
+    {
+      title: "List Collection Requirements",
+      description: "List collection requirements (intelligence-gap statements), optionally filtered by mission and/or status. Each includes its tasking orders.",
+      inputSchema: {
+        missionId: zod.z.string().optional().describe("Filter by owning mission ID"),
+        status: RequirementStatusEnum.optional().describe("Filter by requirement status")
+      }
+    },
+    async ({ missionId, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_REQUIREMENTS, { missionId, status });
+        return jsonResult(data.intListRequirements);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower requirements_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list requirements: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "requirements_create")),
+    {
+      title: "Create Collection Requirement",
+      description: "Raise a new collection requirement (an intelligence gap to be satisfied through tasking).",
+      inputSchema: {
+        title: zod.z.string().min(1).describe("Requirement title"),
+        description: zod.z.string().optional().describe("Detailed requirement description"),
+        classification: ClassificationEnum.optional().describe(
+          "Security classification (default UNCLASSIFIED)"
+        ),
+        priority: PriorityEnum.optional().describe("Precedence (default ROUTINE)"),
+        missionId: zod.z.string().optional().describe("Owning mission ID"),
+        requestedById: zod.z.string().optional().describe("User ID of the requester"),
+        dueDate: IsoDateTime.optional().describe("Due date (ISO-8601)"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Discovery/triage tags")
+      }
+    },
+    async ({
+      title,
+      description,
+      classification,
+      priority,
+      missionId,
+      requestedById,
+      dueDate,
+      tags
+    }) => {
+      try {
+        const input = { title };
+        if (description !== void 0) input.description = description;
+        if (classification !== void 0) input.classification = classification;
+        if (priority !== void 0) input.priority = priority;
+        if (missionId !== void 0) input.missionId = missionId;
+        if (requestedById !== void 0) input.requestedById = requestedById;
+        if (dueDate !== void 0) input.dueDate = dueDate;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_REQUIREMENT, { input });
+        return jsonResult(data.intCreateRequirement);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower requirements_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create requirement: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerTaskTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "tasks_list")),
+    {
+      title: "List Tasking Orders",
+      description: "List collection tasking orders, optionally filtered by requirement, source, and/or status, with pagination.",
+      inputSchema: {
+        requirementId: zod.z.string().optional().describe("Filter by parent requirement ID"),
+        sourceId: zod.z.string().optional().describe("Filter by tasked source ID"),
+        status: TaskStatusEnum.optional().describe("Filter by task status"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)")
+      }
+    },
+    async ({ requirementId, sourceId, status, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_TASKS, {
+          requirementId,
+          sourceId,
+          status,
+          pagination: buildPagination(limit, offset)
+        });
+        return jsonResult(data.intListTasks);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower tasks_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list tasks: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "tasks_create")),
+    {
+      title: "Create Tasking Order",
+      description: "Dispatch a collection tasking order to a source. `sourceId` is required; optionally bind it to a requirement and set a collection window.",
+      inputSchema: {
+        sourceId: zod.z.string().min(1).describe("Source to task"),
+        requirementId: zod.z.string().optional().describe("Parent requirement ID"),
+        instructions: zod.z.string().optional().describe("Collection instructions"),
+        startAt: IsoDateTime.optional().describe("Collection-window start (ISO-8601)"),
+        endAt: IsoDateTime.optional().describe("Collection-window end (ISO-8601)")
+      }
+    },
+    async ({ sourceId, requirementId, instructions, startAt, endAt }) => {
+      try {
+        const input = { sourceId };
+        if (requirementId !== void 0) input.requirementId = requirementId;
+        if (instructions !== void 0) input.instructions = instructions;
+        if (startAt !== void 0) input.startAt = startAt;
+        if (endAt !== void 0) input.endAt = endAt;
+        const data = await ctx.gql.workspace.request(CREATE_TASK, { input });
+        return jsonResult(data.intCreateTask);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower tasks_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create task: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "tasks_transition")),
+    {
+      title: "Transition Tasking Order",
+      description: "Advance a tasking order through its lifecycle (validated transitions: PENDING \u2192 DISPATCHED \u2192 COLLECTING \u2192 COMPLETED, or CANCELLED/FAILED).",
+      inputSchema: {
+        id: zod.z.string().describe("Task ID"),
+        status: TaskStatusEnum.describe("New task status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TRANSITION_TASK, { id, status });
+        return jsonResult(data.intTransitionTask);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower tasks_transition failed", { error: String(error) });
+        return errorResult(
+          `Failed to transition task: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerObservationTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "observations_list")),
+    {
+      title: "List Observations",
+      description: "List raw observations (collected reporting), optionally filtered by entity, source, and/or task, with pagination.",
+      inputSchema: {
+        entityId: zod.z.string().optional().describe("Filter by associated entity ID"),
+        sourceId: zod.z.string().optional().describe("Filter by reporting source ID"),
+        taskId: zod.z.string().optional().describe("Filter by originating task ID"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)")
+      }
+    },
+    async ({ entityId, sourceId, taskId, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_OBSERVATIONS, {
+          entityId,
+          sourceId,
+          taskId,
+          pagination: buildPagination(limit, offset)
+        });
+        return jsonResult(data.intListObservations);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower observations_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list observations: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "observations_record")),
+    {
+      title: "Record Observation",
+      description: "Record a raw observation from a source. `sourceId`, `summary`, and `observedAt` are required; optionally geo-locate it and attach a structured payload.",
+      inputSchema: {
+        sourceId: zod.z.string().min(1).describe("Reporting source ID"),
+        summary: zod.z.string().min(1).describe("Human-readable observation summary"),
+        observedAt: IsoDateTime.describe("When the observation occurred (ISO-8601)"),
+        classification: ClassificationEnum.optional().describe(
+          "Security classification (default UNCLASSIFIED)"
+        ),
+        entityId: zod.z.string().optional().describe("Associated tracked entity ID"),
+        taskId: zod.z.string().optional().describe("Originating tasking order ID"),
+        latitude: zod.z.number().optional().describe("Observation latitude"),
+        longitude: zod.z.number().optional().describe("Observation longitude"),
+        payload: JsonObject.optional().describe("Structured observation payload JSON")
+      }
+    },
+    async ({
+      sourceId,
+      summary,
+      observedAt,
+      classification,
+      entityId,
+      taskId,
+      latitude,
+      longitude,
+      payload
+    }) => {
+      try {
+        const input = { sourceId, summary, observedAt };
+        if (classification !== void 0) input.classification = classification;
+        if (entityId !== void 0) input.entityId = entityId;
+        if (taskId !== void 0) input.taskId = taskId;
+        if (latitude !== void 0) input.latitude = latitude;
+        if (longitude !== void 0) input.longitude = longitude;
+        if (payload !== void 0) input.payload = payload;
+        const data = await ctx.gql.workspace.request(RECORD_OBSERVATION, { input });
+        return jsonResult(data.intRecordObservation);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower observations_record failed", { error: String(error) });
+        return errorResult(
+          `Failed to record observation: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerMissionTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "missions_get")),
+    {
+      title: "Get Mission",
+      description: "Fetch a single mission by ID, including its cases and reports.",
+      inputSchema: { id: zod.z.string().describe("Mission ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_MISSION, { id });
+        if (!data.intMission) return errorResult(`Mission ${id} not found`);
+        return jsonResult(data.intMission);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower missions_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get mission: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "missions_list")),
+    {
+      title: "List Missions",
+      description: "List missions in the bound workspace, optionally filtered by status.",
+      inputSchema: {
+        status: MissionStatusEnum.optional().describe("Filter by mission status")
+      }
+    },
+    async ({ status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_MISSIONS, { status });
+        return jsonResult(data.intListMissions);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower missions_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list missions: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "missions_create")),
+    {
+      title: "Create Mission",
+      description: "Stand up a new mission. `name` is required.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Mission name"),
+        codename: zod.z.string().optional().describe("Operational codename"),
+        objective: zod.z.string().optional().describe("Mission objective statement"),
+        classification: ClassificationEnum.optional().describe(
+          "Security classification (default UNCLASSIFIED)"
+        ),
+        commanderId: zod.z.string().optional().describe("User ID of the mission commander"),
+        startAt: IsoDateTime.optional().describe("Planned start (ISO-8601)"),
+        endAt: IsoDateTime.optional().describe("Planned end (ISO-8601)"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Discovery/triage tags")
+      }
+    },
+    async ({ name, codename, objective, classification, commanderId, startAt, endAt, tags }) => {
+      try {
+        const input = { name };
+        if (codename !== void 0) input.codename = codename;
+        if (objective !== void 0) input.objective = objective;
+        if (classification !== void 0) input.classification = classification;
+        if (commanderId !== void 0) input.commanderId = commanderId;
+        if (startAt !== void 0) input.startAt = startAt;
+        if (endAt !== void 0) input.endAt = endAt;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_MISSION, { input });
+        return jsonResult(data.intCreateMission);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower missions_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create mission: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "missions_transition")),
+    {
+      title: "Transition Mission",
+      description: "Advance a mission through its lifecycle (PLANNING \u2192 READY \u2192 ACTIVE \u2192 PAUSED/COMPLETED/ABORTED).",
+      inputSchema: {
+        id: zod.z.string().describe("Mission ID"),
+        status: MissionStatusEnum.describe("New mission status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TRANSITION_MISSION, { id, status });
+        return jsonResult(data.intTransitionMission);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower missions_transition failed", { error: String(error) });
+        return errorResult(
+          `Failed to transition mission: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerEntityTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "entities_get")),
+    {
+      title: "Get Entity",
+      description: "Fetch a single tracked entity by ID, including its indicators and threat alerts.",
+      inputSchema: { id: zod.z.string().describe("Entity ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_ENTITY, { id });
+        if (!data.intEntity) return errorResult(`Entity ${id} not found`);
+        return jsonResult(data.intEntity);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower entities_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get entity: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "entities_list")),
+    {
+      title: "List Entities",
+      description: "List tracked entities in the bound workspace, optionally filtered by type and/or confidence, with pagination.",
+      inputSchema: {
+        type: EntityTypeEnum.optional().describe("Filter by entity type"),
+        confidence: ConfidenceEnum.optional().describe("Filter by analyst confidence"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)")
+      }
+    },
+    async ({ type, confidence, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_ENTITIES, {
+          type,
+          confidence,
+          pagination: buildPagination(limit, offset)
+        });
+        return jsonResult(data.intListEntities);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower entities_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list entities: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "entities_create")),
+    {
+      title: "Create Entity",
+      description: "Register a new tracked entity (person, organization, vessel, facility, ...). `name` and `type` are required.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Entity display name"),
+        type: EntityTypeEnum.describe("Entity type"),
+        classification: ClassificationEnum.optional().describe(
+          "Security classification (default UNCLASSIFIED)"
+        ),
+        confidence: ConfidenceEnum.optional().describe("Analyst confidence (default LOW)"),
+        description: zod.z.string().optional().describe("Entity description"),
+        aliases: zod.z.array(zod.z.string()).optional().describe("Known aliases"),
+        threatScore: zod.z.number().int().optional().describe("Threat score"),
+        latitude: zod.z.number().optional().describe("Last-known latitude"),
+        longitude: zod.z.number().optional().describe("Last-known longitude"),
+        attributes: JsonObject.optional().describe("Arbitrary structured attributes JSON"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Discovery/triage tags")
+      }
+    },
+    async ({
+      name,
+      type,
+      classification,
+      confidence,
+      description,
+      aliases,
+      threatScore,
+      latitude,
+      longitude,
+      attributes,
+      tags
+    }) => {
+      try {
+        const input = { name, type };
+        if (classification !== void 0) input.classification = classification;
+        if (confidence !== void 0) input.confidence = confidence;
+        if (description !== void 0) input.description = description;
+        if (aliases !== void 0) input.aliases = aliases;
+        if (threatScore !== void 0) input.threatScore = threatScore;
+        if (latitude !== void 0) input.latitude = latitude;
+        if (longitude !== void 0) input.longitude = longitude;
+        if (attributes !== void 0) input.attributes = attributes;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_ENTITY, { input });
+        return jsonResult(data.intCreateEntity);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower entities_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create entity: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "entities_update")),
+    {
+      title: "Update Entity",
+      description: "Update a tracked entity. At least one mutable field must be provided.",
+      inputSchema: {
+        id: zod.z.string().describe("Entity ID"),
+        name: zod.z.string().optional().describe("Updated display name"),
+        classification: ClassificationEnum.optional().describe("Updated classification"),
+        confidence: ConfidenceEnum.optional().describe("Updated confidence"),
+        description: zod.z.string().optional().describe("Updated description"),
+        aliases: zod.z.array(zod.z.string()).optional().describe("Updated aliases"),
+        threatScore: zod.z.number().int().optional().describe("Updated threat score"),
+        latitude: zod.z.number().optional().describe("Updated latitude"),
+        longitude: zod.z.number().optional().describe("Updated longitude"),
+        attributes: JsonObject.optional().describe("Updated attributes JSON"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({
+      id,
+      name,
+      classification,
+      confidence,
+      description,
+      aliases,
+      threatScore,
+      latitude,
+      longitude,
+      attributes,
+      tags
+    }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (classification !== void 0) input.classification = classification;
+        if (confidence !== void 0) input.confidence = confidence;
+        if (description !== void 0) input.description = description;
+        if (aliases !== void 0) input.aliases = aliases;
+        if (threatScore !== void 0) input.threatScore = threatScore;
+        if (latitude !== void 0) input.latitude = latitude;
+        if (longitude !== void 0) input.longitude = longitude;
+        if (attributes !== void 0) input.attributes = attributes;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult("No updates specified \u2014 provide at least one mutable entity field");
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_ENTITY, { id, input });
+        return jsonResult(data.intUpdateEntity);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower entities_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update entity: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerIndicatorTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "indicators_list")),
+    {
+      title: "List Indicators",
+      description: "List indicators (observables), optionally filtered by entity, type, and/or active state.",
+      inputSchema: {
+        entityId: zod.z.string().optional().describe("Filter by associated entity ID"),
+        type: IndicatorTypeEnum.optional().describe("Filter by indicator type"),
+        isActive: zod.z.boolean().optional().describe("Filter by active state")
+      }
+    },
+    async ({ entityId, type, isActive }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_INDICATORS, { entityId, type, isActive });
+        return jsonResult(data.intListIndicators);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower indicators_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list indicators: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "indicators_create")),
+    {
+      title: "Create Indicator",
+      description: "Register a new indicator (observable). `type` and `value` are required; optionally bind it to an entity and a validity window.",
+      inputSchema: {
+        type: IndicatorTypeEnum.describe("Indicator type (IP_ADDRESS, DOMAIN, FILE_HASH, ...)"),
+        value: zod.z.string().min(1).describe("Indicator value"),
+        classification: ClassificationEnum.optional().describe(
+          "Security classification (default UNCLASSIFIED)"
+        ),
+        confidence: ConfidenceEnum.optional().describe("Analyst confidence (default LOW)"),
+        description: zod.z.string().optional().describe("Indicator description"),
+        entityId: zod.z.string().optional().describe("Associated entity ID"),
+        validFrom: IsoDateTime.optional().describe("Validity-window start (ISO-8601)"),
+        validUntil: IsoDateTime.optional().describe("Validity-window end (ISO-8601)")
+      }
+    },
+    async ({
+      type,
+      value,
+      classification,
+      confidence,
+      description,
+      entityId,
+      validFrom,
+      validUntil
+    }) => {
+      try {
+        const input = { type, value };
+        if (classification !== void 0) input.classification = classification;
+        if (confidence !== void 0) input.confidence = confidence;
+        if (description !== void 0) input.description = description;
+        if (entityId !== void 0) input.entityId = entityId;
+        if (validFrom !== void 0) input.validFrom = validFrom;
+        if (validUntil !== void 0) input.validUntil = validUntil;
+        const data = await ctx.gql.workspace.request(CREATE_INDICATOR, { input });
+        return jsonResult(data.intCreateIndicator);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower indicators_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create indicator: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "indicators_deactivate")),
+    {
+      title: "Deactivate Indicator",
+      description: "Deactivate (expire) an indicator so it no longer matches new reporting.",
+      inputSchema: { id: zod.z.string().describe("Indicator ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(DEACTIVATE_INDICATOR, { id });
+        return jsonResult(data.intDeactivateIndicator);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower indicators_deactivate failed", { error: String(error) });
+        return errorResult(
+          `Failed to deactivate indicator: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerAlertTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "alerts_list")),
+    {
+      title: "List Alerts",
+      description: "List threat alerts, optionally filtered by entity, severity, and/or status, with pagination.",
+      inputSchema: {
+        entityId: zod.z.string().optional().describe("Filter by associated entity ID"),
+        severity: AlertSeverityEnum.optional().describe("Filter by severity"),
+        status: AlertStatusEnum.optional().describe("Filter by triage status"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)")
+      }
+    },
+    async ({ entityId, severity, status, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_ALERTS, {
+          entityId,
+          severity,
+          status,
+          pagination: buildPagination(limit, offset)
+        });
+        return jsonResult(data.intListAlerts);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower alerts_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list alerts: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "alerts_raise")),
+    {
+      title: "Raise Alert",
+      description: "Raise a new threat alert. `title` is required; optionally bind it to an entity, indicator, and/or mission and set severity.",
+      inputSchema: {
+        title: zod.z.string().min(1).describe("Alert title"),
+        description: zod.z.string().optional().describe("Alert description"),
+        severity: AlertSeverityEnum.optional().describe("Severity (default MEDIUM)"),
+        classification: ClassificationEnum.optional().describe(
+          "Security classification (default UNCLASSIFIED)"
+        ),
+        entityId: zod.z.string().optional().describe("Associated entity ID"),
+        indicatorId: zod.z.string().optional().describe("Triggering indicator ID"),
+        missionId: zod.z.string().optional().describe("Associated mission ID"),
+        assignedToId: zod.z.string().optional().describe("User ID to assign the alert to")
+      }
+    },
+    async ({
+      title,
+      description,
+      severity,
+      classification,
+      entityId,
+      indicatorId,
+      missionId,
+      assignedToId
+    }) => {
+      try {
+        const input = { title };
+        if (description !== void 0) input.description = description;
+        if (severity !== void 0) input.severity = severity;
+        if (classification !== void 0) input.classification = classification;
+        if (entityId !== void 0) input.entityId = entityId;
+        if (indicatorId !== void 0) input.indicatorId = indicatorId;
+        if (missionId !== void 0) input.missionId = missionId;
+        if (assignedToId !== void 0) input.assignedToId = assignedToId;
+        const data = await ctx.gql.workspace.request(RAISE_ALERT, { input });
+        return jsonResult(data.intRaiseAlert);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower alerts_raise failed", { error: String(error) });
+        return errorResult(
+          `Failed to raise alert: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "alerts_transition")),
+    {
+      title: "Transition Alert",
+      description: "Triage an alert through its lifecycle (validated transitions: OPEN \u2192 TRIAGED \u2192 ESCALATED/RESOLVED/FALSE_POSITIVE/SUPPRESSED), optionally recording triage notes.",
+      inputSchema: {
+        id: zod.z.string().describe("Alert ID"),
+        status: AlertStatusEnum.describe("New alert status"),
+        triageNotes: zod.z.string().optional().describe("Triage notes to record on the transition")
+      }
+    },
+    async ({ id, status, triageNotes }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TRANSITION_ALERT, { id, status, triageNotes });
+        return jsonResult(data.intTransitionAlert);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower alerts_transition failed", { error: String(error) });
+        return errorResult(
+          `Failed to transition alert: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerCaseTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "cases_get")),
+    {
+      title: "Get Case",
+      description: "Fetch a single investigation case by ID, including its alerts and case entries.",
+      inputSchema: { id: zod.z.string().describe("Case ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_CASE, { id });
+        if (!data.intCase) return errorResult(`Case ${id} not found`);
+        return jsonResult(data.intCase);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower cases_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get case: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "cases_list")),
+    {
+      title: "List Cases",
+      description: "List investigation cases, optionally filtered by mission and/or status, with pagination.",
+      inputSchema: {
+        missionId: zod.z.string().optional().describe("Filter by owning mission ID"),
+        status: CaseStatusEnum.optional().describe("Filter by case status"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)")
+      }
+    },
+    async ({ missionId, status, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_CASES, {
+          missionId,
+          status,
+          pagination: buildPagination(limit, offset)
+        });
+        return jsonResult(data.intListCases);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower cases_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list cases: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "cases_create")),
+    {
+      title: "Create Case",
+      description: "Open a new investigation case. `title` is required.",
+      inputSchema: {
+        title: zod.z.string().min(1).describe("Case title"),
+        summary: zod.z.string().optional().describe("Case summary"),
+        reference: zod.z.string().optional().describe("External reference number"),
+        classification: ClassificationEnum.optional().describe(
+          "Security classification (default UNCLASSIFIED)"
+        ),
+        priority: PriorityEnum.optional().describe("Precedence (default ROUTINE)"),
+        missionId: zod.z.string().optional().describe("Owning mission ID"),
+        leadAnalystId: zod.z.string().optional().describe("User ID of the lead analyst"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Discovery/triage tags")
+      }
+    },
+    async ({
+      title,
+      summary,
+      reference,
+      classification,
+      priority,
+      missionId,
+      leadAnalystId,
+      tags
+    }) => {
+      try {
+        const input = { title };
+        if (summary !== void 0) input.summary = summary;
+        if (reference !== void 0) input.reference = reference;
+        if (classification !== void 0) input.classification = classification;
+        if (priority !== void 0) input.priority = priority;
+        if (missionId !== void 0) input.missionId = missionId;
+        if (leadAnalystId !== void 0) input.leadAnalystId = leadAnalystId;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_CASE, { input });
+        return jsonResult(data.intCreateCase);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower cases_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create case: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "cases_add_entry")),
+    {
+      title: "Add Case Entry",
+      description: "Append an entry (note, finding, or evidence reference) to a case. `kind` and `body` are required; attach evidence via `fileId` (wspace-files-svc File).",
+      inputSchema: {
+        caseId: zod.z.string().min(1).describe("Case ID"),
+        kind: zod.z.string().min(1).describe('Entry kind, e.g. "note", "finding", "evidence"'),
+        body: zod.z.string().min(1).describe("Entry body text"),
+        fileId: zod.z.string().optional().describe("Evidence attachment File ID (wspace-files-svc)")
+      }
+    },
+    async ({ caseId, kind, body, fileId }) => {
+      try {
+        const input = { caseId, kind, body };
+        if (fileId !== void 0) input.fileId = fileId;
+        const data = await ctx.gql.workspace.request(ADD_CASE_ENTRY, { input });
+        return jsonResult(data.intAddCaseEntry);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower cases_add_entry failed", { error: String(error) });
+        return errorResult(
+          `Failed to add case entry: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "cases_close")),
+    {
+      title: "Close Case",
+      description: "Close an investigation case.",
+      inputSchema: { id: zod.z.string().describe("Case ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(CLOSE_CASE, { id });
+        return jsonResult(data.intCloseCase);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower cases_close failed", { error: String(error) });
+        return errorResult(
+          `Failed to close case: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerReportTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "reports_list")),
+    {
+      title: "List Reports",
+      description: "List intelligence reports, optionally filtered by mission, type, and/or status, with pagination.",
+      inputSchema: {
+        missionId: zod.z.string().optional().describe("Filter by owning mission ID"),
+        type: ReportTypeEnum.optional().describe("Filter by report product type"),
+        status: ReportStatusEnum.optional().describe("Filter by report status"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)")
+      }
+    },
+    async ({ missionId, type, status, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_REPORTS, {
+          missionId,
+          type,
+          status,
+          pagination: buildPagination(limit, offset)
+        });
+        return jsonResult(data.intListReports);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower reports_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list reports: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "reports_create")),
+    {
+      title: "Create Report",
+      description: "Draft a new intelligence report (SITREP, INTSUM, ASSESSMENT, ...). `title` is required; reference the rendered product via `fileId` (wspace-files-svc File).",
+      inputSchema: {
+        title: zod.z.string().min(1).describe("Report title"),
+        type: ReportTypeEnum.optional().describe("Report product type (default SITREP)"),
+        summary: zod.z.string().optional().describe("Report summary / BLUF"),
+        body: zod.z.string().optional().describe("Report body text"),
+        classification: ClassificationEnum.optional().describe(
+          "Security classification (default UNCLASSIFIED)"
+        ),
+        authorId: zod.z.string().optional().describe("User ID of the report author"),
+        caseId: zod.z.string().optional().describe("Associated case ID"),
+        missionId: zod.z.string().optional().describe("Associated mission ID"),
+        fileId: zod.z.string().optional().describe("Rendered-product File ID (wspace-files-svc)"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Discovery/triage tags")
+      }
+    },
+    async ({
+      title,
+      type,
+      summary,
+      body,
+      classification,
+      authorId,
+      caseId,
+      missionId,
+      fileId,
+      tags
+    }) => {
+      try {
+        const input = { title };
+        if (type !== void 0) input.type = type;
+        if (summary !== void 0) input.summary = summary;
+        if (body !== void 0) input.body = body;
+        if (classification !== void 0) input.classification = classification;
+        if (authorId !== void 0) input.authorId = authorId;
+        if (caseId !== void 0) input.caseId = caseId;
+        if (missionId !== void 0) input.missionId = missionId;
+        if (fileId !== void 0) input.fileId = fileId;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_REPORT, { input });
+        return jsonResult(data.intCreateReport);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower reports_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create report: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "reports_release")),
+    {
+      title: "Release Report",
+      description: "Release (publish/disseminate) an intelligence report.",
+      inputSchema: { id: zod.z.string().describe("Report ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(RELEASE_REPORT, { id });
+        return jsonResult(data.intReleaseReport);
+      } catch (error) {
+        ctx.logger.error("intelwatchtower reports_release failed", { error: String(error) });
+        return errorResult(
+          `Failed to release report: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/intelwatchtower/tools/health.ts
+function registerHealthTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "health")),
+    {
+      title: "IntelWatchtower Health Check",
+      description: "Public liveness/identity probe for the IntelWatchtower subgraph (intHealth). Requires no authentication.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(HEALTH, {});
+        return jsonResult({ ok: true, status: data.intHealth });
+      } catch (error) {
+        ctx.logger.error("intelwatchtower health failed", { error: String(error) });
+        return errorResult(
+          `IntelWatchtower health check failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/intelwatchtower/resources.ts
+function registerIntelwatchtowerResources(server, ctx, track) {
+  const schemaUri = track(mcpResourceUri(ctx.productName, "schema"));
+  const sourcesUri = track(mcpResourceUri(ctx.productName, "sources"));
+  const missionsUri = track(mcpResourceUri(ctx.productName, "missions"));
+  const alertsUri = track(mcpResourceUri(ctx.productName, "alerts"));
+  server.registerResource(
+    "intelwatchtower-schema",
+    schemaUri,
+    {
+      title: "IntelWatchtower Domain Schema",
+      description: "Overview of the IntelWatchtower military & intelligence domain \u2014 entities, enums, and the per-entity tool surface.",
+      mimeType: "text/plain"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${schemaUri} requested`);
+      const schema = `# IntelWatchtower Domain (Overview)
+
+Unified military & intelligence platform: multi-source collection + all-source
+fusion powering a real-time common operating picture.
+
+## Collection domain
+- IntSource \u2014 a collection source/sensor (has feeds + tasking orders)
+- IntFeed \u2014 an ingest feed attached to a source
+- IntCollectionRequirement \u2014 an intelligence gap to be satisfied (has tasks)
+- IntCollectionTask \u2014 a tasking order dispatched to a source
+- IntObservation \u2014 raw collected reporting
+
+## Fusion domain
+- IntMission \u2014 an operation (has cases + reports)
+- IntEntity \u2014 a tracked entity (has indicators + alerts)
+- IntIndicator \u2014 an observable / indicator of interest
+- IntAlert \u2014 a threat alert (triage lifecycle)
+- IntCase (+IntCaseEntry) \u2014 an investigation case + entries
+- IntReport \u2014 an intelligence report
+
+## Key enums
+- IntClassification: UNCLASSIFIED, CONFIDENTIAL, SECRET, TOP_SECRET
+- IntConfidence: LOW, MODERATE, HIGH, CONFIRMED
+- IntPriority: ROUTINE, PRIORITY, IMMEDIATE, FLASH
+- IntSourceDiscipline: HUMINT, SIGINT, GEOINT, IMINT, MASINT, OSINT, CYBER
+- IntSourceStatus: PROVISIONING, ACTIVE, DEGRADED, OFFLINE, RETIRED
+- IntTaskStatus: PENDING, DISPATCHED, COLLECTING, COMPLETED, CANCELLED, FAILED
+- IntEntityType: PERSON, ORGANIZATION, LOCATION, FACILITY, VESSEL, AIRCRAFT, VEHICLE, NETWORK_NODE, EVENT
+- IntIndicatorType: IP_ADDRESS, DOMAIN, URL, EMAIL, FILE_HASH, SIGNATURE, BEHAVIOR, GEO_COORDINATE
+- IntAlertSeverity: INFO, LOW, MEDIUM, HIGH, CRITICAL
+- IntAlertStatus: OPEN, TRIAGED, ESCALATED, RESOLVED, FALSE_POSITIVE, SUPPRESSED
+- IntMissionStatus: PLANNING, READY, ACTIVE, PAUSED, COMPLETED, ABORTED
+- IntCaseStatus: OPEN, ACTIVE, PENDING_REVIEW, CLOSED, ARCHIVED
+- IntReportType: SITREP, INTSUM, SPOT_REPORT, ASSESSMENT, WARNING
+- IntReportStatus: DRAFT, IN_REVIEW, RELEASED, RECALLED, ARCHIVED
+- IntRequirementStatus: DRAFT, SUBMITTED, APPROVED, TASKED, SATISFIED, CANCELLED
+
+## Tool groups
+sources, feeds, requirements, tasks, observations (collection);
+missions, entities, indicators, alerts, cases, reports (fusion); plus a public health probe.
+All run against the WORKSPACE gateway (workspace-scoped) except the public health probe.
+`;
+      return {
+        contents: [{ uri: schemaUri, text: schema, mimeType: "text/plain" }]
+      };
+    }
+  );
+  server.registerResource(
+    "intelwatchtower-sources",
+    sourcesUri,
+    {
+      title: "IntelWatchtower Source Registry",
+      description: "The first 50 collection sources/sensors in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${sourcesUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(LIST_SOURCES, {
+          pagination: { limit: 50, offset: 0 }
+        });
+        return {
+          contents: [
+            {
+              uri: sourcesUri,
+              text: JSON.stringify(data.intListSources, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: sourcesUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "intelwatchtower-missions",
+    missionsUri,
+    {
+      title: "IntelWatchtower Mission Roster",
+      description: "All missions in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${missionsUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_MISSIONS,
+          {}
+        );
+        return {
+          contents: [
+            {
+              uri: missionsUri,
+              text: JSON.stringify(data.intListMissions, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: missionsUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "intelwatchtower-alerts",
+    alertsUri,
+    {
+      title: "IntelWatchtower Open Alerts",
+      description: "The first 50 OPEN threat alerts in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${alertsUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(LIST_ALERTS, {
+          status: "OPEN",
+          pagination: { limit: 50, offset: 0 }
+        });
+        return {
+          contents: [
+            {
+              uri: alertsUri,
+              text: JSON.stringify(data.intListAlerts, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: alertsUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function registerIntelwatchtowerPrompts(server, ctx, track) {
+  const p = ctx.productName;
+  const collectionName = track(mcpPromptName(p, "collection-setup"));
+  const triageName = track(mcpPromptName(p, "fusion-triage"));
+  server.registerPrompt(
+    collectionName,
+    {
+      title: "Collection Setup",
+      description: "Guide for standing up a collection pipeline end to end: register a source, raise a requirement, dispatch a tasking order, and record the resulting observation.",
+      argsSchema: {
+        discipline: zod.z.string().optional().describe("Collection discipline (HUMINT, SIGINT, ...)"),
+        missionId: zod.z.string().optional().describe("Mission to bind the requirement to")
+      }
+    },
+    ({ discipline, missionId }) => {
+      ctx.logger.debug(`Prompt ${collectionName} called`, { discipline, missionId });
+      const disciplineNote = discipline ? `Use discipline ${discipline}.` : "Help the user pick an IntSourceDiscipline.";
+      const missionNote = missionId ? `Bind the requirement to mission "${missionId}".` : `Optionally create or pick a mission first with ${p}_missions_create / ${p}_missions_list.`;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Help me stand up an IntelWatchtower collection pipeline.
+
+1. **Register Source**: Use ${p}_sources_create. ${disciplineNote} Set a name, classification, region, and reliability.
+2. **(Optional) Attach Feed**: Use ${p}_feeds_create to wire an ingest feed (endpoint + format) to the source.
+3. **Raise Requirement**: Use ${p}_requirements_create. ${missionNote} Set a title, priority, and dueDate.
+4. **Dispatch Tasking**: Use ${p}_tasks_create with the source and requirement IDs and a collection window.
+5. **Advance Tasking**: Use ${p}_tasks_transition to move the task PENDING \u2192 DISPATCHED \u2192 COLLECTING \u2192 COMPLETED.
+6. **Record Observation**: Use ${p}_observations_record with the source/task IDs, a summary, and observedAt.
+
+Show results at each step and confirm before dispatching tasking.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server.registerPrompt(
+    triageName,
+    {
+      title: "Fusion & Alert Triage",
+      description: "All-source fusion workflow: review tracked entities and indicators, triage open threat alerts, open an investigation case, and disseminate a report.",
+      argsSchema: {
+        entityId: zod.z.string().optional().describe("Entity to focus the triage on")
+      }
+    },
+    ({ entityId }) => {
+      ctx.logger.debug(`Prompt ${triageName} called`, { entityId });
+      const entityNote = entityId ? `Focus on entity "${entityId}" (use ${p}_entities_get for its indicators + alerts).` : `First list entities with ${p}_entities_list and pick one to focus on.`;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Run IntelWatchtower all-source fusion + alert triage. ${entityNote}
+
+1. **Entities & Indicators**: Use ${p}_entities_list and ${p}_indicators_list to review tracked entities and their observables.
+2. **Open Alerts**: Use ${p}_alerts_list filtered by status=OPEN (and severity) to find what needs triage.
+3. **Triage**: For each alert use ${p}_alerts_transition (OPEN \u2192 TRIAGED \u2192 ESCALATED/RESOLVED/FALSE_POSITIVE), recording triageNotes.
+4. **Open a Case**: For escalations, use ${p}_cases_create, then ${p}_cases_add_entry to log findings/evidence.
+5. **Report**: Use ${p}_reports_create to draft an INTSUM/ASSESSMENT, then ${p}_reports_release to disseminate.
+
+Summarize what needs attention after each step.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/modules/intelwatchtower/index.ts
+var intelwatchtowerModule = {
+  id: "intelwatchtower",
+  version: "0.0.1",
+  displayName: "IntelWatchtower",
+  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);
+    registerFeedTools(server, ctx, trackTool);
+    registerRequirementTools(server, ctx, trackTool);
+    registerTaskTools(server, ctx, trackTool);
+    registerObservationTools(server, ctx, trackTool);
+    registerMissionTools(server, ctx, trackTool);
+    registerEntityTools(server, ctx, trackTool);
+    registerIndicatorTools(server, ctx, trackTool);
+    registerAlertTools(server, ctx, trackTool);
+    registerCaseTools(server, ctx, trackTool);
+    registerReportTools(server, ctx, trackTool);
+    registerHealthTools(server, ctx, trackTool);
+    registerIntelwatchtowerResources(server, ctx, trackResource);
+    registerIntelwatchtowerPrompts(server, ctx, trackPrompt);
+    return { tools, resources, prompts };
+  }
+};
+var intelwatchtower_default = intelwatchtowerModule;
+
+module.exports = intelwatchtower_default;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map