@contextstream/mcp-server 0.3.72 → 0.4.0

package/dist/index.js

@@ -7662,6 +7662,13 @@ ${options.workspaceId ? `# Workspace ID: ${options.workspaceId}` : ""}
     content: content.trim() + "\n"
   };
 }
+function generateAllRuleFiles(options) {
+  return getAvailableEditors().map((editor) => {
+    const result = generateRuleContent(editor, options);
+    if (!result) return null;
+    return { editor, ...result };
+  }).filter((r) => r !== null);
+}
 
 // src/tool-catalog.ts
 var TOOL_CATALOG = [
@@ -8431,6 +8438,111 @@ function getBundleInfo() {
   }));
 }
 var deferredTools = /* @__PURE__ */ new Map();
+var ROUTER_MODE = process.env.CONTEXTSTREAM_ROUTER_MODE === "true";
+var operationsRegistry = /* @__PURE__ */ new Map();
+function inferOperationCategory(name) {
+  if (name.startsWith("session_") || name.startsWith("context_")) return "Session";
+  if (name.startsWith("memory_")) return "Memory";
+  if (name.startsWith("search_")) return "Search";
+  if (name.startsWith("graph_")) return "Graph";
+  if (name.startsWith("workspace")) return "Workspace";
+  if (name.startsWith("project")) return "Project";
+  if (name.startsWith("reminder")) return "Reminders";
+  if (name.startsWith("slack_") || name.startsWith("github_") || name.startsWith("integration")) return "Integrations";
+  if (name.startsWith("ai_")) return "AI";
+  if (name === "auth_me" || name === "mcp_server_version" || name === "generate_editor_rules") return "Utility";
+  if (name === "tools_enable_bundle" || name === "contextstream" || name === "contextstream_help") return "Meta";
+  return "Other";
+}
+function getOperationCatalog(category) {
+  const ops = {};
+  for (const [name, config] of operationsRegistry) {
+    const cat = config.category;
+    if (category && cat.toLowerCase() !== category.toLowerCase()) continue;
+    if (!ops[cat]) ops[cat] = [];
+    ops[cat].push(name);
+  }
+  const lines = [];
+  for (const [cat, names] of Object.entries(ops).sort()) {
+    lines.push(`${cat}: ${names.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+function getOperationSchema(name) {
+  const op = operationsRegistry.get(name);
+  if (!op) return null;
+  const zodSchema = op.inputSchema;
+  try {
+    const shape = zodSchema?._def?.shape?.() || zodSchema?.shape || {};
+    const properties = {};
+    const required = [];
+    for (const [key, field] of Object.entries(shape)) {
+      const f = field;
+      const isOptional = f?._def?.typeName === "ZodOptional" || f?.isOptional?.();
+      const innerType = isOptional ? f?._def?.innerType : f;
+      const typeName = innerType?._def?.typeName || "unknown";
+      const description = f?._def?.description || innerType?._def?.description;
+      let type = "string";
+      if (typeName === "ZodNumber") type = "number";
+      else if (typeName === "ZodBoolean") type = "boolean";
+      else if (typeName === "ZodArray") type = "array";
+      else if (typeName === "ZodObject") type = "object";
+      else if (typeName === "ZodEnum") type = "enum";
+      properties[key] = { type };
+      if (description) properties[key].description = description;
+      if (typeName === "ZodEnum") {
+        properties[key].enum = innerType?._def?.values;
+      }
+      if (!isOptional) required.push(key);
+    }
+    return {
+      name: op.name,
+      title: op.title,
+      description: op.description,
+      category: op.category,
+      schema: {
+        type: "object",
+        properties,
+        required: required.length > 0 ? required : void 0
+      }
+    };
+  } catch {
+    return {
+      name: op.name,
+      title: op.title,
+      description: op.description,
+      category: op.category,
+      schema: { type: "object" }
+    };
+  }
+}
+var OUTPUT_FORMAT = process.env.CONTEXTSTREAM_OUTPUT_FORMAT || "compact";
+var COMPACT_OUTPUT = OUTPUT_FORMAT === "compact";
+var CONSOLIDATED_MODE = process.env.CONTEXTSTREAM_CONSOLIDATED !== "false";
+var CONSOLIDATED_TOOLS = /* @__PURE__ */ new Set([
+  "session_init",
+  // Standalone - complex initialization
+  "context_smart",
+  // Standalone - called every message
+  "search",
+  // Consolidates search_semantic, search_hybrid, search_keyword, search_pattern
+  "session",
+  // Consolidates session_capture, session_recall, etc.
+  "memory",
+  // Consolidates memory_create_event, memory_get_event, etc.
+  "graph",
+  // Consolidates graph_dependencies, graph_impact, etc.
+  "project",
+  // Consolidates projects_list, projects_create, etc.
+  "workspace",
+  // Consolidates workspaces_list, workspace_associate, etc.
+  "reminder",
+  // Consolidates reminders_list, reminders_create, etc.
+  "integration",
+  // Consolidates slack_*, github_*, integrations_*
+  "help"
+  // Consolidates session_tools, auth_me, mcp_server_version, etc.
+]);
 var TOOLSET_ALIASES = {
   // Light mode - minimal, fastest
   light: LIGHT_TOOLSET,
@@ -8493,8 +8605,9 @@ function resolveToolFilter() {
   console.error(`[ContextStream] Unknown CONTEXTSTREAM_TOOLSET "${toolsetRaw}". Using standard toolset.`);
   return { allowlist: STANDARD_TOOLSET, source: "standard", autoDetected: false };
 }
-function formatContent(data) {
-  return JSON.stringify(data, null, 2);
+function formatContent(data, forceFormat) {
+  const usePretty = forceFormat === "pretty" || !forceFormat && !COMPACT_OUTPUT;
+  return usePretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
 }
 function toStructured(data) {
   if (data && typeof data === "object" && !Array.isArray(data)) {
@@ -8632,6 +8745,21 @@ function registerTools(server, client, sessionManager) {
     console.error(`[ContextStream] Progressive mode: ENABLED (starting with ${coreBundle.size} core tools)`);
     console.error("[ContextStream] Use tools_enable_bundle to unlock additional tool bundles dynamically.");
   }
+  if (ROUTER_MODE) {
+    console.error("[ContextStream] Router mode: ENABLED (all operations accessed via contextstream/contextstream_help)");
+    console.error("[ContextStream] Only 2 tools registered. Use contextstream_help to see available operations.");
+  }
+  if (COMPACT_OUTPUT) {
+    console.error("[ContextStream] Output format: COMPACT (minified JSON, ~30% fewer tokens per response)");
+  } else {
+    console.error("[ContextStream] Output format: pretty (set CONTEXTSTREAM_OUTPUT_FORMAT=compact for fewer tokens)");
+  }
+  if (CONSOLIDATED_MODE) {
+    console.error(`[ContextStream] Consolidated mode: ENABLED (~${CONSOLIDATED_TOOLS.size} domain tools, ~75% token reduction)`);
+    console.error("[ContextStream] Set CONTEXTSTREAM_CONSOLIDATED=false to use individual tools.");
+  } else {
+    console.error("[ContextStream] Consolidated mode: disabled (using individual tools)");
+  }
   let serverRef = server;
   const defaultProTools = /* @__PURE__ */ new Set([
     // AI endpoints (typically paid/credit-metered)
@@ -9015,11 +9143,44 @@ Upgrade: ${upgradeUrl2}` : "";
     console.error(`[ContextStream] Bundle '${bundleName}' enabled with ${toolsEnabled} tools.`);
     return { success: true, message: `Enabled bundle '${bundleName}' with ${toolsEnabled} tools.`, toolsEnabled };
   }
+  const ROUTER_DIRECT_TOOLS = /* @__PURE__ */ new Set(["contextstream", "contextstream_help"]);
   function registerTool(name, config, handler) {
-    if (toolAllowlist && !toolAllowlist.has(name)) {
+    if (CONSOLIDATED_MODE && !CONSOLIDATED_TOOLS.has(name)) {
+      operationsRegistry.set(name, {
+        name,
+        title: config.title,
+        description: config.description,
+        inputSchema: config.inputSchema,
+        handler,
+        category: inferOperationCategory(name)
+      });
+      return;
+    }
+    if (!CONSOLIDATED_MODE && toolAllowlist && !toolAllowlist.has(name)) {
+      if (ROUTER_MODE && !ROUTER_DIRECT_TOOLS.has(name)) {
+        operationsRegistry.set(name, {
+          name,
+          title: config.title,
+          description: config.description,
+          inputSchema: config.inputSchema,
+          handler,
+          category: inferOperationCategory(name)
+        });
+      }
+      return;
+    }
+    if (!CONSOLIDATED_MODE && !shouldRegisterIntegrationTool(name)) {
       return;
     }
-    if (!shouldRegisterIntegrationTool(name)) {
+    if (ROUTER_MODE && !ROUTER_DIRECT_TOOLS.has(name)) {
+      operationsRegistry.set(name, {
+        name,
+        title: config.title,
+        description: config.description,
+        inputSchema: config.inputSchema,
+        handler,
+        category: inferOperationCategory(name)
+      });
       return;
     }
     if (PROGRESSIVE_MODE && !isToolInEnabledBundles(name)) {
@@ -9147,6 +9308,137 @@ Example: Enable memory tools before using memory_create_event.`,
       return { content: [{ type: "text", text: formatContent(response) }], structuredContent: toStructured(response) };
     }
   );
+  if (ROUTER_MODE) {
+    serverRef.registerTool(
+      "contextstream",
+      {
+        title: "ContextStream Operation",
+        description: `Execute any ContextStream operation. Use contextstream_help to see available operations.
+
+Example: contextstream({ op: "session_init", args: { folder_path: "/path/to/project" } })
+
+This single tool replaces 50+ individual tools, dramatically reducing token overhead.
+All ContextStream functionality is accessible through this dispatcher.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            op: { type: "string", description: "Operation name (e.g., session_init, memory_create_event)" },
+            args: { type: "object", description: "Operation arguments (varies by operation)" }
+          },
+          required: ["op"]
+        },
+        annotations: {
+          readOnlyHint: false,
+          destructiveHint: false,
+          idempotentHint: false,
+          openWorldHint: false
+        }
+      },
+      async (input) => {
+        const opName = input.op;
+        const operation = operationsRegistry.get(opName);
+        if (!operation) {
+          const available = getOperationCatalog();
+          return {
+            content: [{
+              type: "text",
+              text: `Unknown operation: ${opName}
+
+Available operations:
+${available}
+
+Use contextstream_help({ op: "operation_name" }) for details.`
+            }],
+            isError: true
+          };
+        }
+        const args = input.args || {};
+        const parsed = operation.inputSchema.safeParse(args);
+        if (!parsed.success) {
+          const schema = getOperationSchema(opName);
+          return {
+            content: [{
+              type: "text",
+              text: `Invalid arguments for ${opName}: ${parsed.error.message}
+
+Expected schema:
+${JSON.stringify(schema?.schema || {}, null, 2)}`
+            }],
+            isError: true
+          };
+        }
+        try {
+          return await operation.handler(parsed.data);
+        } catch (error) {
+          return {
+            content: [{
+              type: "text",
+              text: `Error executing ${opName}: ${error?.message || String(error)}`
+            }],
+            isError: true
+          };
+        }
+      }
+    );
+    serverRef.registerTool(
+      "contextstream_help",
+      {
+        title: "ContextStream Help",
+        description: `Get help on available ContextStream operations or schema for a specific operation.
+
+Examples:
+- contextstream_help({}) - List all operations by category
+- contextstream_help({ op: "session_init" }) - Get schema for session_init
+- contextstream_help({ category: "Memory" }) - List memory operations only`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            op: { type: "string", description: "Operation name to get schema for" },
+            category: { type: "string", description: "Category to filter (Session, Memory, Search, Graph, etc.)" }
+          }
+        },
+        annotations: {
+          readOnlyHint: true,
+          destructiveHint: false,
+          idempotentHint: true,
+          openWorldHint: false
+        }
+      },
+      async (input) => {
+        if (input.op) {
+          const schema = getOperationSchema(input.op);
+          if (!schema) {
+            return {
+              content: [{
+                type: "text",
+                text: `Unknown operation: ${input.op}
+
+Use contextstream_help({}) to see available operations.`
+              }],
+              isError: true
+            };
+          }
+          return {
+            content: [{ type: "text", text: JSON.stringify(schema, null, 2) }],
+            structuredContent: schema
+          };
+        }
+        const catalog = getOperationCatalog(input.category);
+        const result = {
+          router_mode: true,
+          total_operations: operationsRegistry.size,
+          categories: catalog,
+          usage: 'Call contextstream({ op: "operation_name", args: {...} }) to execute an operation.',
+          hint: 'Use contextstream_help({ op: "operation_name" }) to see the schema for a specific operation.'
+        };
+        return {
+          content: [{ type: "text", text: formatContent(result) }],
+          structuredContent: toStructured(result)
+        };
+      }
+    );
+    console.error(`[ContextStream] Router mode: Registered 2 meta-tools, ${operationsRegistry.size} operations available via dispatcher.`);
+  }
   registerTool(
     "workspaces_list",
     {
@@ -12053,6 +12345,1175 @@ Use this to remove a reminder that is no longer relevant.`,
       };
     }
   );
+  if (CONSOLIDATED_MODE) {
+    registerTool(
+      "search",
+      {
+        title: "Search",
+        description: `Search workspace memory and knowledge. Modes: semantic (meaning-based), hybrid (semantic + keyword), keyword (exact match), pattern (regex).`,
+        inputSchema: external_exports.object({
+          mode: external_exports.enum(["semantic", "hybrid", "keyword", "pattern"]).describe("Search mode"),
+          query: external_exports.string().describe("Search query"),
+          workspace_id: external_exports.string().uuid().optional(),
+          project_id: external_exports.string().uuid().optional(),
+          limit: external_exports.number().optional()
+        })
+      },
+      async (input) => {
+        const params = {
+          query: input.query,
+          workspace_id: resolveWorkspaceId(input.workspace_id),
+          project_id: resolveProjectId(input.project_id),
+          limit: input.limit
+        };
+        let result;
+        switch (input.mode) {
+          case "semantic":
+            result = await client.searchSemantic(params);
+            break;
+          case "hybrid":
+            result = await client.searchHybrid(params);
+            break;
+          case "keyword":
+            result = await client.searchKeyword(params);
+            break;
+          case "pattern":
+            result = await client.searchPattern(params);
+            break;
+        }
+        return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+      }
+    );
+    registerTool(
+      "session",
+      {
+        title: "Session",
+        description: `Session management operations. Actions: capture (save decision/insight), capture_lesson (save lesson from mistake), get_lessons (retrieve lessons), recall (natural language recall), remember (quick save), user_context (get preferences), summary (workspace summary), compress (compress chat), delta (changes since timestamp), smart_search (context-enriched search), decision_trace (trace decision provenance).`,
+        inputSchema: external_exports.object({
+          action: external_exports.enum([
+            "capture",
+            "capture_lesson",
+            "get_lessons",
+            "recall",
+            "remember",
+            "user_context",
+            "summary",
+            "compress",
+            "delta",
+            "smart_search",
+            "decision_trace"
+          ]).describe("Action to perform"),
+          workspace_id: external_exports.string().uuid().optional(),
+          project_id: external_exports.string().uuid().optional(),
+          // Content params
+          query: external_exports.string().optional().describe("Query for recall/search/lessons/decision_trace"),
+          content: external_exports.string().optional().describe("Content for capture/remember/compress"),
+          title: external_exports.string().optional().describe("Title for capture/capture_lesson"),
+          event_type: external_exports.enum(["decision", "preference", "insight", "task", "bug", "feature", "correction", "lesson", "warning", "frustration", "conversation"]).optional().describe("Event type for capture"),
+          importance: external_exports.enum(["low", "medium", "high", "critical"]).optional(),
+          tags: external_exports.array(external_exports.string()).optional(),
+          // Lesson-specific
+          category: external_exports.enum(["workflow", "code_quality", "verification", "communication", "project_specific"]).optional(),
+          trigger: external_exports.string().optional().describe("What caused the problem"),
+          impact: external_exports.string().optional().describe("What went wrong"),
+          prevention: external_exports.string().optional().describe("How to prevent in future"),
+          severity: external_exports.enum(["low", "medium", "high", "critical"]).optional(),
+          keywords: external_exports.array(external_exports.string()).optional(),
+          // Other params
+          since: external_exports.string().optional().describe("ISO timestamp for delta"),
+          limit: external_exports.number().optional(),
+          max_tokens: external_exports.number().optional().describe("Max tokens for summary"),
+          include_decisions: external_exports.boolean().optional(),
+          include_related: external_exports.boolean().optional(),
+          include_impact: external_exports.boolean().optional(),
+          session_id: external_exports.string().optional(),
+          code_refs: external_exports.array(external_exports.object({
+            file_path: external_exports.string(),
+            symbol_id: external_exports.string().optional(),
+            symbol_name: external_exports.string().optional()
+          })).optional(),
+          provenance: external_exports.object({
+            repo: external_exports.string().optional(),
+            branch: external_exports.string().optional(),
+            commit_sha: external_exports.string().optional(),
+            pr_url: external_exports.string().url().optional(),
+            issue_url: external_exports.string().url().optional(),
+            slack_thread_url: external_exports.string().url().optional()
+          }).optional()
+        })
+      },
+      async (input) => {
+        const workspaceId = resolveWorkspaceId(input.workspace_id);
+        const projectId = resolveProjectId(input.project_id);
+        switch (input.action) {
+          case "capture": {
+            if (!input.event_type || !input.title || !input.content) {
+              return errorResult("capture requires: event_type, title, content");
+            }
+            const result = await client.captureContext({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              event_type: input.event_type,
+              title: input.title,
+              content: input.content,
+              importance: input.importance,
+              tags: input.tags,
+              session_id: input.session_id,
+              code_refs: input.code_refs,
+              provenance: input.provenance
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "capture_lesson": {
+            if (!input.title || !input.category || !input.trigger || !input.impact || !input.prevention) {
+              return errorResult("capture_lesson requires: title, category, trigger, impact, prevention");
+            }
+            const lessonInput = {
+              title: input.title,
+              category: input.category,
+              trigger: input.trigger,
+              impact: input.impact,
+              prevention: input.prevention,
+              severity: input.severity || "medium",
+              keywords: input.keywords,
+              workspace_id: workspaceId,
+              project_id: projectId
+            };
+            const signature = buildLessonSignature(lessonInput, workspaceId || "global", projectId);
+            if (isDuplicateLessonCapture(signature)) {
+              return { content: [{ type: "text", text: formatContent({ deduplicated: true, message: "Lesson already captured recently" }) }] };
+            }
+            const result = await client.captureLesson(lessonInput);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "get_lessons": {
+            const result = await client.getLessons({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              query: input.query,
+              category: input.category,
+              severity: input.severity,
+              limit: input.limit
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "recall": {
+            if (!input.query) {
+              return errorResult("recall requires: query");
+            }
+            const result = await client.recallContext({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              query: input.query
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "remember": {
+            if (!input.content) {
+              return errorResult("remember requires: content");
+            }
+            const result = await client.rememberContext({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              content: input.content,
+              importance: input.importance
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "user_context": {
+            const result = await client.getUserContext({ workspace_id: workspaceId });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "summary": {
+            const result = await client.getSessionSummary({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              max_tokens: input.max_tokens
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "compress": {
+            if (!input.content) {
+              return errorResult("compress requires: content (the chat history to compress)");
+            }
+            const result = await client.compressSession({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              chat_history: input.content
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "delta": {
+            if (!input.since) {
+              return errorResult("delta requires: since (ISO timestamp)");
+            }
+            const result = await client.getSessionDelta({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              since: input.since,
+              limit: input.limit
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "smart_search": {
+            if (!input.query) {
+              return errorResult("smart_search requires: query");
+            }
+            const result = await client.smartSearch({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              query: input.query,
+              include_decisions: input.include_decisions,
+              include_related: input.include_related
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "decision_trace": {
+            if (!input.query) {
+              return errorResult("decision_trace requires: query");
+            }
+            const result = await client.decisionTrace({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              query: input.query,
+              include_impact: input.include_impact,
+              limit: input.limit
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          default:
+            return errorResult(`Unknown action: ${input.action}`);
+        }
+      }
+    );
+    registerTool(
+      "memory",
+      {
+        title: "Memory",
+        description: `Memory operations for events and nodes. Event actions: create_event, get_event, update_event, delete_event, list_events, distill_event. Node actions: create_node, get_node, update_node, delete_node, list_nodes, supersede_node. Query actions: search, decisions, timeline, summary.`,
+        inputSchema: external_exports.object({
+          action: external_exports.enum([
+            "create_event",
+            "get_event",
+            "update_event",
+            "delete_event",
+            "list_events",
+            "distill_event",
+            "create_node",
+            "get_node",
+            "update_node",
+            "delete_node",
+            "list_nodes",
+            "supersede_node",
+            "search",
+            "decisions",
+            "timeline",
+            "summary"
+          ]).describe("Action to perform"),
+          workspace_id: external_exports.string().uuid().optional(),
+          project_id: external_exports.string().uuid().optional(),
+          // ID params
+          event_id: external_exports.string().uuid().optional(),
+          node_id: external_exports.string().uuid().optional(),
+          // Content params
+          title: external_exports.string().optional(),
+          content: external_exports.string().optional(),
+          event_type: external_exports.string().optional(),
+          node_type: external_exports.string().optional(),
+          metadata: external_exports.record(external_exports.any()).optional(),
+          // Query params
+          query: external_exports.string().optional(),
+          category: external_exports.string().optional(),
+          limit: external_exports.number().optional(),
+          // Node relations
+          relations: external_exports.array(external_exports.object({
+            type: external_exports.string(),
+            target_id: external_exports.string().uuid()
+          })).optional(),
+          new_node_id: external_exports.string().uuid().optional().describe("For supersede: the new node ID"),
+          // Provenance
+          provenance: external_exports.object({
+            repo: external_exports.string().optional(),
+            branch: external_exports.string().optional(),
+            commit_sha: external_exports.string().optional(),
+            pr_url: external_exports.string().url().optional(),
+            issue_url: external_exports.string().url().optional(),
+            slack_thread_url: external_exports.string().url().optional()
+          }).optional(),
+          code_refs: external_exports.array(external_exports.object({
+            file_path: external_exports.string(),
+            symbol_id: external_exports.string().optional(),
+            symbol_name: external_exports.string().optional()
+          })).optional()
+        })
+      },
+      async (input) => {
+        const workspaceId = resolveWorkspaceId(input.workspace_id);
+        const projectId = resolveProjectId(input.project_id);
+        switch (input.action) {
+          case "create_event": {
+            if (!input.event_type || !input.title || !input.content) {
+              return errorResult("create_event requires: event_type, title, content");
+            }
+            const result = await client.createMemoryEvent({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              event_type: input.event_type,
+              title: input.title,
+              content: input.content,
+              metadata: input.metadata,
+              provenance: input.provenance,
+              code_refs: input.code_refs
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "get_event": {
+            if (!input.event_id) {
+              return errorResult("get_event requires: event_id");
+            }
+            const result = await client.getMemoryEvent(input.event_id);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "update_event": {
+            if (!input.event_id) {
+              return errorResult("update_event requires: event_id");
+            }
+            const result = await client.updateMemoryEvent({
+              event_id: input.event_id,
+              title: input.title,
+              content: input.content,
+              metadata: input.metadata
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "delete_event": {
+            if (!input.event_id) {
+              return errorResult("delete_event requires: event_id");
+            }
+            const result = await client.deleteMemoryEvent(input.event_id);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "list_events": {
+            const result = await client.listMemoryEvents({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              limit: input.limit
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "distill_event": {
+            if (!input.event_id) {
+              return errorResult("distill_event requires: event_id");
+            }
+            const result = await client.distillEvent(input.event_id);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "create_node": {
+            if (!input.node_type || !input.title || !input.content) {
+              return errorResult("create_node requires: node_type, title, content");
+            }
+            const result = await client.createKnowledgeNode({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              node_type: input.node_type,
+              title: input.title,
+              content: input.content,
+              relations: input.relations
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "get_node": {
+            if (!input.node_id) {
+              return errorResult("get_node requires: node_id");
+            }
+            const result = await client.getKnowledgeNode(input.node_id);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "update_node": {
+            if (!input.node_id) {
+              return errorResult("update_node requires: node_id");
+            }
+            const result = await client.updateKnowledgeNode({
+              node_id: input.node_id,
+              title: input.title,
+              content: input.content
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "delete_node": {
+            if (!input.node_id) {
+              return errorResult("delete_node requires: node_id");
+            }
+            const result = await client.deleteKnowledgeNode(input.node_id);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "list_nodes": {
+            const result = await client.listKnowledgeNodes({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              limit: input.limit
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "supersede_node": {
+            if (!input.node_id || !input.new_node_id) {
+              return errorResult("supersede_node requires: node_id, new_node_id");
+            }
+            const result = await client.supersedeKnowledgeNode({
+              node_id: input.node_id,
+              new_node_id: input.new_node_id
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "search": {
+            if (!input.query) {
+              return errorResult("search requires: query");
+            }
+            const result = await client.searchMemory({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              query: input.query,
+              limit: input.limit
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "decisions": {
+            const result = await client.memoryDecisions({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              category: input.category,
+              limit: input.limit
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "timeline": {
+            const result = await client.memoryTimeline({
+              workspace_id: workspaceId
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "summary": {
+            const result = await client.memorySummary({
+              workspace_id: workspaceId
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          default:
+            return errorResult(`Unknown action: ${input.action}`);
+        }
+      }
+    );
+    registerTool(
+      "graph",
+      {
+        title: "Graph",
+        description: `Code graph analysis. Actions: dependencies (module deps), impact (change impact), call_path (function call path), related (related nodes), path (path between nodes), decisions (decision history), ingest (build graph), circular_dependencies, unused_code, contradictions.`,
+        inputSchema: external_exports.object({
+          action: external_exports.enum([
+            "dependencies",
+            "impact",
+            "call_path",
+            "related",
+            "path",
+            "decisions",
+            "ingest",
+            "circular_dependencies",
+            "unused_code",
+            "contradictions"
+          ]).describe("Action to perform"),
+          workspace_id: external_exports.string().uuid().optional(),
+          project_id: external_exports.string().uuid().optional(),
+          // ID params
+          node_id: external_exports.string().uuid().optional().describe("For related/contradictions"),
+          source_id: external_exports.string().uuid().optional().describe("For path"),
+          target_id: external_exports.string().uuid().optional().describe("For path"),
+          // Target specification
+          target: external_exports.object({
+            type: external_exports.string().describe("module|function|type|variable"),
+            id: external_exports.string().describe("Element identifier")
+          }).optional().describe("For dependencies/impact"),
+          source: external_exports.object({
+            type: external_exports.string().describe("function"),
+            id: external_exports.string().describe("Function identifier")
+          }).optional().describe("For call_path"),
+          // Options
+          max_depth: external_exports.number().optional(),
+          include_transitive: external_exports.boolean().optional(),
+          limit: external_exports.number().optional(),
+          wait: external_exports.boolean().optional().describe("For ingest: wait for completion")
+        })
+      },
+      async (input) => {
+        const workspaceId = resolveWorkspaceId(input.workspace_id);
+        const projectId = resolveProjectId(input.project_id);
+        const gatedActions = ["related", "path", "decisions", "call_path", "circular_dependencies", "unused_code", "ingest", "contradictions"];
+        if (gatedActions.includes(input.action)) {
+          const gate = await gateIfGraphTool(`graph_${input.action}`, input);
+          if (gate) return gate;
+        }
+        switch (input.action) {
+          case "dependencies": {
+            if (!input.target) {
+              return errorResult("dependencies requires: target { type, id }");
+            }
+            const result = await client.graphDependencies({
+              target: input.target,
+              max_depth: input.max_depth,
+              include_transitive: input.include_transitive
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "impact": {
+            if (!input.target) {
+              return errorResult("impact requires: target { type, id }");
+            }
+            const result = await client.graphImpact({
+              target: input.target,
+              max_depth: input.max_depth
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "call_path": {
+            if (!input.source || !input.target) {
+              return errorResult("call_path requires: source { type, id }, target { type, id }");
+            }
+            const result = await client.graphCallPath({
+              source: input.source,
+              target: input.target,
+              max_depth: input.max_depth
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "related": {
+            if (!input.node_id) {
+              return errorResult("related requires: node_id");
+            }
+            const result = await client.graphRelated({
+              node_id: input.node_id,
+              workspace_id: workspaceId,
+              project_id: projectId,
+              limit: input.limit
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "path": {
+            if (!input.source_id || !input.target_id) {
+              return errorResult("path requires: source_id, target_id");
+            }
+            const result = await client.graphPath({
+              source_id: input.source_id,
+              target_id: input.target_id,
+              workspace_id: workspaceId,
+              project_id: projectId
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "decisions": {
+            const result = await client.graphDecisions({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              limit: input.limit
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "ingest": {
+            if (!projectId) {
+              return errorResult("ingest requires: project_id");
+            }
+            const result = await client.graphIngest({
+              project_id: projectId,
+              wait: input.wait
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "circular_dependencies": {
+            if (!projectId) {
+              return errorResult("circular_dependencies requires: project_id");
+            }
+            const result = await client.findCircularDependencies(projectId);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "unused_code": {
+            if (!projectId) {
+              return errorResult("unused_code requires: project_id");
+            }
+            const result = await client.findUnusedCode(projectId);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "contradictions": {
+            if (!input.node_id) {
+              return errorResult("contradictions requires: node_id");
+            }
+            const result = await client.findContradictions(input.node_id);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          default:
+            return errorResult(`Unknown action: ${input.action}`);
+        }
+      }
+    );
+    registerTool(
+      "project",
+      {
+        title: "Project",
+        description: `Project management. Actions: list, get, create, update, index (trigger indexing), overview, statistics, files, index_status, ingest_local (index local folder).`,
+        inputSchema: external_exports.object({
+          action: external_exports.enum([
+            "list",
+            "get",
+            "create",
+            "update",
+            "index",
+            "overview",
+            "statistics",
+            "files",
+            "index_status",
+            "ingest_local"
+          ]).describe("Action to perform"),
+          workspace_id: external_exports.string().uuid().optional(),
+          project_id: external_exports.string().uuid().optional(),
+          // Create/update params
+          name: external_exports.string().optional(),
+          description: external_exports.string().optional(),
+          folder_path: external_exports.string().optional(),
+          generate_editor_rules: external_exports.boolean().optional(),
+          // Ingest params
+          path: external_exports.string().optional().describe("Local path to ingest"),
+          overwrite: external_exports.boolean().optional(),
+          write_to_disk: external_exports.boolean().optional(),
+          // Pagination
+          page: external_exports.number().optional(),
+          page_size: external_exports.number().optional()
+        })
+      },
+      async (input) => {
+        const workspaceId = resolveWorkspaceId(input.workspace_id);
+        const projectId = resolveProjectId(input.project_id);
+        switch (input.action) {
+          case "list": {
+            const result = await client.listProjects({
+              workspace_id: workspaceId,
+              page: input.page,
+              page_size: input.page_size
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "get": {
+            if (!projectId) {
+              return errorResult("get requires: project_id");
+            }
+            const result = await client.getProject(projectId);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "create": {
+            if (!input.name) {
+              return errorResult("create requires: name");
+            }
+            const result = await client.createProject({
+              workspace_id: workspaceId,
+              name: input.name,
+              description: input.description,
+              folder_path: input.folder_path,
+              generate_editor_rules: input.generate_editor_rules
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "update": {
+            if (!projectId) {
+              return errorResult("update requires: project_id");
+            }
+            const result = await client.updateProject({
+              project_id: projectId,
+              name: input.name,
+              description: input.description
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "index": {
+            if (!projectId) {
+              return errorResult("index requires: project_id");
+            }
+            const result = await client.indexProject(projectId);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "overview": {
+            if (!projectId) {
+              return errorResult("overview requires: project_id");
+            }
+            const result = await client.projectOverview(projectId);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "statistics": {
+            if (!projectId) {
+              return errorResult("statistics requires: project_id");
+            }
+            const result = await client.projectStatistics(projectId);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "files": {
+            if (!projectId) {
+              return errorResult("files requires: project_id");
+            }
+            const result = await client.projectFiles(projectId);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "index_status": {
+            if (!projectId) {
+              return errorResult("index_status requires: project_id");
+            }
+            const result = await client.projectIndexStatus(projectId);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "ingest_local": {
+            if (!input.path) {
+              return errorResult("ingest_local requires: path");
+            }
+            const validPath = await validateReadableDirectory(input.path);
+            if (!validPath.ok) {
+              return errorResult(validPath.error);
+            }
+            const files = await readAllFilesInBatches(validPath.resolvedPath, async (batch) => {
+              await client.ingestLocalFiles({
+                project_id: projectId,
+                files: batch,
+                overwrite: input.overwrite,
+                write_to_disk: input.write_to_disk
+              });
+            });
+            const result = { files_ingested: files, project_id: projectId };
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          default:
+            return errorResult(`Unknown action: ${input.action}`);
+        }
+      }
+    );
+    registerTool(
+      "workspace",
+      {
+        title: "Workspace",
+        description: `Workspace management. Actions: list, get, associate (link folder to workspace), bootstrap (create workspace and initialize).`,
+        inputSchema: external_exports.object({
+          action: external_exports.enum(["list", "get", "associate", "bootstrap"]).describe("Action to perform"),
+          workspace_id: external_exports.string().uuid().optional(),
+          // Associate/bootstrap params
+          folder_path: external_exports.string().optional(),
+          workspace_name: external_exports.string().optional(),
+          create_parent_mapping: external_exports.boolean().optional(),
+          generate_editor_rules: external_exports.boolean().optional(),
+          // Bootstrap-specific
+          description: external_exports.string().optional(),
+          visibility: external_exports.enum(["private", "public"]).optional(),
+          auto_index: external_exports.boolean().optional(),
+          context_hint: external_exports.string().optional(),
+          // Pagination
+          page: external_exports.number().optional(),
+          page_size: external_exports.number().optional()
+        })
+      },
+      async (input) => {
+        switch (input.action) {
+          case "list": {
+            const result = await client.listWorkspaces({
+              page: input.page,
+              page_size: input.page_size
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "get": {
+            if (!input.workspace_id) {
+              return errorResult("get requires: workspace_id");
+            }
+            const result = await client.getWorkspace(input.workspace_id);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "associate": {
+            if (!input.folder_path || !input.workspace_id) {
+              return errorResult("associate requires: folder_path, workspace_id");
+            }
+            const result = await client.associateWorkspace({
+              folder_path: input.folder_path,
+              workspace_id: input.workspace_id,
+              workspace_name: input.workspace_name,
+              create_parent_mapping: input.create_parent_mapping,
+              generate_editor_rules: input.generate_editor_rules
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "bootstrap": {
+            if (!input.workspace_name) {
+              return errorResult("bootstrap requires: workspace_name");
+            }
+            const result = await client.bootstrapWorkspace({
+              workspace_name: input.workspace_name,
+              folder_path: input.folder_path,
+              description: input.description,
+              visibility: input.visibility,
+              create_parent_mapping: input.create_parent_mapping,
+              generate_editor_rules: input.generate_editor_rules,
+              auto_index: input.auto_index,
+              context_hint: input.context_hint
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          default:
+            return errorResult(`Unknown action: ${input.action}`);
+        }
+      }
+    );
+    registerTool(
+      "reminder",
+      {
+        title: "Reminder",
+        description: `Reminder management. Actions: list, active (pending/overdue), create, snooze, complete, dismiss.`,
+        inputSchema: external_exports.object({
+          action: external_exports.enum(["list", "active", "create", "snooze", "complete", "dismiss"]).describe("Action to perform"),
+          workspace_id: external_exports.string().uuid().optional(),
+          project_id: external_exports.string().uuid().optional(),
+          reminder_id: external_exports.string().uuid().optional(),
+          // Create params
+          title: external_exports.string().optional(),
+          content: external_exports.string().optional(),
+          remind_at: external_exports.string().optional().describe("ISO 8601 datetime"),
+          priority: external_exports.enum(["low", "normal", "high", "urgent"]).optional(),
+          recurrence: external_exports.enum(["daily", "weekly", "monthly"]).optional(),
+          keywords: external_exports.array(external_exports.string()).optional(),
+          // Snooze params
+          until: external_exports.string().optional().describe("ISO 8601 datetime"),
+          // Filter params
+          status: external_exports.enum(["pending", "completed", "dismissed", "snoozed"]).optional(),
+          context: external_exports.string().optional(),
+          limit: external_exports.number().optional()
+        })
+      },
+      async (input) => {
+        const workspaceId = resolveWorkspaceId(input.workspace_id);
+        const projectId = resolveProjectId(input.project_id);
+        switch (input.action) {
+          case "list": {
+            const result = await client.remindersList({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              status: input.status,
+              priority: input.priority,
+              limit: input.limit
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "active": {
+            const result = await client.remindersActive({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              context: input.context,
+              limit: input.limit
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "create": {
+            if (!input.title || !input.content || !input.remind_at) {
+              return errorResult("create requires: title, content, remind_at");
+            }
+            const result = await client.remindersCreate({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              title: input.title,
+              content: input.content,
+              remind_at: input.remind_at,
+              priority: input.priority,
+              recurrence: input.recurrence,
+              keywords: input.keywords
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "snooze": {
+            if (!input.reminder_id || !input.until) {
+              return errorResult("snooze requires: reminder_id, until");
+            }
+            const result = await client.remindersSnooze({
+              reminder_id: input.reminder_id,
+              until: input.until
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "complete": {
+            if (!input.reminder_id) {
+              return errorResult("complete requires: reminder_id");
+            }
+            const result = await client.remindersComplete({
+              reminder_id: input.reminder_id
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "dismiss": {
+            if (!input.reminder_id) {
+              return errorResult("dismiss requires: reminder_id");
+            }
+            const result = await client.remindersDismiss({
+              reminder_id: input.reminder_id
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          default:
+            return errorResult(`Unknown action: ${input.action}`);
+        }
+      }
+    );
+    registerTool(
+      "integration",
+      {
+        title: "Integration",
+        description: `Integration operations for Slack and GitHub. Provider: slack, github, all. Actions: status, search, stats, activity, contributors, knowledge, summary, channels (slack), discussions (slack), repos (github), issues (github).`,
+        inputSchema: external_exports.object({
+          provider: external_exports.enum(["slack", "github", "all"]).describe("Integration provider"),
+          action: external_exports.enum([
+            "status",
+            "search",
+            "stats",
+            "activity",
+            "contributors",
+            "knowledge",
+            "summary",
+            "channels",
+            "discussions",
+            "sync_users",
+            "repos",
+            "issues"
+          ]).describe("Action to perform"),
+          workspace_id: external_exports.string().uuid().optional(),
+          project_id: external_exports.string().uuid().optional(),
+          query: external_exports.string().optional(),
+          limit: external_exports.number().optional(),
+          since: external_exports.string().optional(),
+          until: external_exports.string().optional()
+        })
+      },
+      async (input) => {
+        const workspaceId = resolveWorkspaceId(input.workspace_id);
+        const projectId = resolveProjectId(input.project_id);
+        const integrationGated = await gateIfIntegrationTool(
+          input.provider === "slack" ? "slack_search" : input.provider === "github" ? "github_search" : "integrations_status"
+        );
+        if (integrationGated) return integrationGated;
+        const params = {
+          workspace_id: workspaceId,
+          project_id: projectId,
+          query: input.query,
+          limit: input.limit,
+          since: input.since,
+          until: input.until
+        };
+        switch (input.action) {
+          case "status": {
+            const result = await client.integrationsStatus(params);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "search": {
+            if (input.provider === "slack") {
+              const result = await client.slackSearch(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            } else if (input.provider === "github") {
+              const result = await client.githubSearch(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            } else {
+              const result = await client.integrationsSearch(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            }
+          }
+          case "stats": {
+            if (input.provider === "slack") {
+              const result = await client.slackStats(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            } else if (input.provider === "github") {
+              const result = await client.githubStats(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            }
+            return errorResult("stats requires provider: slack or github");
+          }
+          case "activity": {
+            if (input.provider === "slack") {
+              const result = await client.slackActivity(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            } else if (input.provider === "github") {
+              const result = await client.githubActivity(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            }
+            return errorResult("activity requires provider: slack or github");
+          }
+          case "contributors": {
+            if (input.provider === "slack") {
+              const result = await client.slackContributors(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            } else if (input.provider === "github") {
+              const result = await client.githubContributors(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            }
+            return errorResult("contributors requires provider: slack or github");
+          }
+          case "knowledge": {
+            if (input.provider === "slack") {
+              const result = await client.slackKnowledge(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            } else if (input.provider === "github") {
+              const result = await client.githubKnowledge(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            } else {
+              const result = await client.integrationsKnowledge(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            }
+          }
+          case "summary": {
+            if (input.provider === "slack") {
+              const result = await client.slackSummary(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            } else if (input.provider === "github") {
+              const result = await client.githubSummary(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            } else {
+              const result = await client.integrationsSummary(params);
+              return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+            }
+          }
+          case "channels": {
+            if (input.provider !== "slack") {
+              return errorResult("channels is only available for slack provider");
+            }
+            const result = await client.slackChannels(params);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "discussions": {
+            if (input.provider !== "slack") {
+              return errorResult("discussions is only available for slack provider");
+            }
+            const result = await client.slackDiscussions(params);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "sync_users": {
+            if (input.provider !== "slack") {
+              return errorResult("sync_users is only available for slack provider");
+            }
+            const result = await client.slackSyncUsers(params);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "repos": {
+            if (input.provider !== "github") {
+              return errorResult("repos is only available for github provider");
+            }
+            const result = await client.githubRepos(params);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "issues": {
+            if (input.provider !== "github") {
+              return errorResult("issues is only available for github provider");
+            }
+            const result = await client.githubIssues(params);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          default:
+            return errorResult(`Unknown action: ${input.action}`);
+        }
+      }
+    );
+    registerTool(
+      "help",
+      {
+        title: "Help",
+        description: `Utility and help. Actions: tools (list available tools), auth (current user), version (server version), editor_rules (generate AI editor rules), enable_bundle (enable tool bundle in progressive mode).`,
+        inputSchema: external_exports.object({
+          action: external_exports.enum(["tools", "auth", "version", "editor_rules", "enable_bundle"]).describe("Action to perform"),
+          // For tools
+          format: external_exports.enum(["grouped", "minimal", "full"]).optional(),
+          category: external_exports.string().optional(),
+          // For editor_rules
+          folder_path: external_exports.string().optional(),
+          editors: external_exports.array(external_exports.string()).optional(),
+          mode: external_exports.enum(["minimal", "full"]).optional(),
+          dry_run: external_exports.boolean().optional(),
+          workspace_id: external_exports.string().uuid().optional(),
+          workspace_name: external_exports.string().optional(),
+          project_name: external_exports.string().optional(),
+          additional_rules: external_exports.string().optional(),
+          // For enable_bundle
+          bundle: external_exports.enum(["session", "memory", "search", "graph", "workspace", "project", "reminders", "integrations"]).optional(),
+          list_bundles: external_exports.boolean().optional()
+        })
+      },
+      async (input) => {
+        switch (input.action) {
+          case "tools": {
+            const format = input.format || "grouped";
+            const catalog = generateToolCatalog(format, input.category);
+            const consolidatedInfo = CONSOLIDATED_MODE ? `
+
+[Consolidated Mode]
+Domain tools: ${Array.from(CONSOLIDATED_TOOLS).join(", ")}
+Each domain tool has an 'action' parameter for specific operations.` : "";
+            return {
+              content: [{ type: "text", text: catalog + consolidatedInfo }],
+              structuredContent: {
+                format,
+                catalog,
+                consolidated_mode: CONSOLIDATED_MODE,
+                domain_tools: CONSOLIDATED_MODE ? Array.from(CONSOLIDATED_TOOLS) : void 0
+              }
+            };
+          }
+          case "auth": {
+            const result = await client.me();
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "version": {
+            const result = { name: "contextstream-mcp", version: VERSION };
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "editor_rules": {
+            if (!input.folder_path) {
+              return errorResult("editor_rules requires: folder_path");
+            }
+            const result = await generateAllRuleFiles(input.folder_path, {
+              editors: input.editors,
+              mode: input.mode,
+              dryRun: input.dry_run,
+              workspaceId: input.workspace_id,
+              workspaceName: input.workspace_name,
+              projectName: input.project_name,
+              additionalRules: input.additional_rules
+            });
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          case "enable_bundle": {
+            if (input.list_bundles) {
+              const bundles = getBundleInfo();
+              const result2 = {
+                progressive_mode: PROGRESSIVE_MODE,
+                consolidated_mode: CONSOLIDATED_MODE,
+                bundles,
+                hint: CONSOLIDATED_MODE ? "Consolidated mode is enabled. All operations are available via domain tools." : PROGRESSIVE_MODE ? "Progressive mode is enabled. Use enable_bundle to unlock additional tools." : "Neither progressive nor consolidated mode is enabled."
+              };
+              return { content: [{ type: "text", text: formatContent(result2) }], structuredContent: toStructured(result2) };
+            }
+            if (!input.bundle) {
+              return errorResult("enable_bundle requires: bundle (or use list_bundles: true)");
+            }
+            if (CONSOLIDATED_MODE) {
+              return {
+                content: [{ type: "text", text: "Consolidated mode is enabled. All operations are available via domain tools (search, session, memory, graph, project, workspace, reminder, integration, help)." }]
+              };
+            }
+            if (!PROGRESSIVE_MODE) {
+              return {
+                content: [{ type: "text", text: "Progressive mode is not enabled. All tools from your toolset are already available." }]
+              };
+            }
+            const result = enableBundle(input.bundle);
+            return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+          }
+          default:
+            return errorResult(`Unknown action: ${input.action}`);
+        }
+      }
+    );
+    console.error(`[ContextStream] Consolidated mode: Registered ${CONSOLIDATED_TOOLS.size} domain tools.`);
+  }
 }
 
 // src/resources.ts
@@ -14534,6 +15995,9 @@ Environment variables:
   CONTEXTSTREAM_AUTO_HIDE_INTEGRATIONS  Auto-hide Slack/GitHub tools when not connected (default: true)
   CONTEXTSTREAM_SCHEMA_MODE   Schema verbosity: compact|full (default: full, compact reduces tokens)
   CONTEXTSTREAM_PROGRESSIVE_MODE  Progressive disclosure: true|false (default: false, starts with ~13 core tools)
+  CONTEXTSTREAM_ROUTER_MODE   Router pattern: true|false (default: false, exposes only 2 meta-tools)
+  CONTEXTSTREAM_OUTPUT_FORMAT Output verbosity: compact|pretty (default: compact, ~30% fewer tokens)
+  CONTEXTSTREAM_CONSOLIDATED  Consolidated domain tools: true|false (default: true in v0.4.x, ~75% token reduction)
   CONTEXTSTREAM_PRO_TOOLS     Optional comma-separated PRO tool names (default: AI tools)
   CONTEXTSTREAM_UPGRADE_URL   Optional upgrade URL shown for PRO tools on Free plan
   CONTEXTSTREAM_ENABLE_PROMPTS Enable MCP prompts list (default: true)