@velvetmonkey/flywheel-memory 2.3.1 → 2.3.3

package/dist/index.js

@@ -11847,10 +11847,11 @@ function resolveToolConfig(envValue) {
   };
 }
 var TOOL_CATEGORY = {
-  // search (3 tools)
+  // search
   search: "search",
   init_semantic: "search",
   find_similar: "search",
+  discover_tools: "search",
   // read (3 tools) -- note reading
   get_note_structure: "read",
   get_section_content: "read",
@@ -11938,10 +11939,11 @@ var TOOL_CATEGORY = {
   tool_selection_feedback: "diagnostics"
 };
 var TOOL_TIER = {
-  // Tier 1 — always visible (= agent preset, 18 tools)
+  // Tier 1 — always visible (= agent preset, see TIER_1_TOOL_COUNT)
   search: 1,
   init_semantic: 1,
   find_similar: 1,
+  discover_tools: 1,
   get_note_structure: 1,
   get_section_content: 1,
   find_sections: 1,
@@ -11957,7 +11959,7 @@ var TOOL_TIER = {
   vault_add_task: 1,
   memory: 1,
   brief: 1,
-  // Tier 2 — context-triggered categories + core diagnostics (33 tools)
+  // Tier 2 — context-triggered categories + core diagnostics (see TIER_2_TOOL_COUNT)
   graph_analysis: 2,
   semantic_analysis: 2,
   get_backlinks: 2,
@@ -11991,7 +11993,7 @@ var TOOL_TIER = {
   flywheel_config: 2,
   server_log: 2,
   flywheel_doctor: 2,
-  // Tier 3 — explicit or advanced operations (26 tools)
+  // Tier 3 — explicit or advanced operations (see TIER_3_TOOL_COUNT)
   vault_schema: 3,
   schema_conventions: 3,
   schema_validate: 3,
@@ -12031,6 +12033,10 @@ function assertToolTierCoverage() {
   }
 }
 assertToolTierCoverage();
+var TOTAL_TOOL_COUNT = Object.keys(TOOL_CATEGORY).length;
+var TIER_1_TOOL_COUNT = Object.values(TOOL_TIER).filter((t) => t === 1).length;
+var TIER_2_TOOL_COUNT = Object.values(TOOL_TIER).filter((t) => t === 2).length;
+var TIER_3_TOOL_COUNT = Object.values(TOOL_TIER).filter((t) => t === 3).length;
 function generateInstructions(categories, registry, activeTierCategories) {
   const parts = [];
   const tieringActive = activeTierCategories !== void 0;
@@ -12140,8 +12146,6 @@ Use "get_connection_strength" to measure link strength between two entities.
 Use "get_link_path" to trace the shortest path between any two entities or notes.
 Use "get_strong_connections" to find the strongest or most-connected relationships for an entity.`);
   } else if (tieringActive && categories.has("graph")) {
-    parts.push(`
-**More tools available:** Ask about graph connections, backlinks, hubs, clusters, or paths to unlock graph analysis tools.`);
   }
   if (isCategoryVisible("note-ops")) {
     parts.push(`
@@ -12167,8 +12171,6 @@ Use "schema_conventions" to infer frontmatter conventions from folder usage patt
 Use "schema_validate" to validate frontmatter against explicit rules or find notes missing expected fields by folder.
 Use "note_intelligence" for per-note analysis (completeness, quality, suggestions).`);
   } else if (tieringActive && categories.has("schema")) {
-    parts.push(`
-**Advanced tools:** Ask to unlock schema tools for conventions, validation, migrations, and bulk metadata analysis.`);
   }
   if (isCategoryVisible("wikilinks")) {
     parts.push(`
@@ -12184,8 +12186,6 @@ Link quality and discovery \u2014 not for finding content (use search for that).
 - "Was that link correct?" \u2192 wikilink_feedback (accept/reject, improves future suggestions)
 - "What aliases am I missing?" \u2192 suggest_entity_aliases (acronyms, short forms, alternate names)`);
   } else if (tieringActive && categories.has("wikilinks")) {
-    parts.push(`
-**More tools available:** Ask about wikilinks, suggestions, stubs, or unlinked mentions to unlock wikilink tools.`);
   }
   if (isCategoryVisible("corrections")) {
     parts.push(`
@@ -12198,8 +12198,6 @@ When the user says something is wrong \u2014 a bad link, wrong entity, wrong cat
 "vault_resolve_correction" marks a correction as applied or dismissed.
 Use "absorb_as_alias" when two names should resolve to the same entity without merging note bodies.`);
   } else if (tieringActive && categories.has("corrections")) {
-    parts.push(`
-**More tools available:** Ask about errors, wrong links, or fixes to unlock correction tools.`);
   }
   if (isCategoryVisible("temporal")) {
     parts.push(`
@@ -12215,8 +12213,6 @@ Temporal tools analyze *patterns and changes* over time \u2014 use them for "wha
 
 temporal_summary composes the other three \u2014 use it for weekly/monthly reviews.`);
   } else if (tieringActive && categories.has("temporal")) {
-    parts.push(`
-**More tools available:** Ask about time, history, evolution, or stale notes to unlock temporal tools.`);
   }
   if (isCategoryVisible("diagnostics")) {
     parts.push(`
@@ -12231,9 +12227,10 @@ temporal_summary composes the other three \u2014 use it for weekly/monthly revie
 
 Use "flywheel_config" to inspect runtime configuration and set "tool_tier_override" to "auto", "full", or "minimal" for this vault.`);
   } else if (tieringActive && categories.has("diagnostics")) {
+  }
+  if (tieringActive) {
     parts.push(`
-**More tools available:** Ask about vault health, indexing, status, or configuration to unlock diagnostic tools.
-**Advanced tools:** Ask to unlock note operations or deep diagnostics for note mutations, benchmarks, history, graph exports, and learning reports.`);
+**More tools available:** Call \`discover_tools({ query: "your need" })\` to find and activate specialized tools for graph analysis, wikilinks, diagnostics, schema, temporal analysis, note operations, and more. Returns tool names, descriptions, and input schemas.`);
   }
   return parts.join("\n");
 }
@@ -12243,7 +12240,7 @@ import * as path38 from "path";
 import { dirname as dirname5, join as join19 } from "path";
 import { statSync as statSync6, readFileSync as readFileSync5 } from "fs";
 import { fileURLToPath } from "url";
-import { z as z40 } from "zod";
+import { z as z41 } from "zod";
 import { CallToolRequestSchema, ErrorCode, McpError } from "@modelcontextprotocol/sdk/types.js";
 import { getSessionId } from "@velvetmonkey/vault-core";
 
@@ -26550,6 +26547,61 @@ function registerCalibrationExportTools(server2, getIndex, getStateDb4, getConfi
   );
 }
 
+// src/tools/read/discovery.ts
+import { z as z40 } from "zod";
+import { normalizeObjectSchema } from "@modelcontextprotocol/sdk/server/zod-compat.js";
+import { toJsonSchemaCompat } from "@modelcontextprotocol/sdk/server/zod-json-schema-compat.js";
+function toJsonSchema(inputSchema) {
+  const obj = normalizeObjectSchema(inputSchema);
+  if (!obj) return { type: "object" };
+  return toJsonSchemaCompat(obj, { strictUnions: true, pipeStrategy: "input" });
+}
+function registerDiscoveryTools(server2, controller) {
+  server2.tool(
+    "discover_tools",
+    'Find and activate specialized tools. Call with what you need \u2014 e.g. "vault health", "graph connections", "schema migration". Returns matching tool names, descriptions, and input schemas. Does not execute discovered tools \u2014 call them separately after discovery.',
+    {
+      query: z40.string().describe(
+        'Natural language description of what you need \u2014 e.g. "vault health", "backlinks and graph", "schema migration"'
+      )
+    },
+    async ({ query }) => {
+      const signals = unionSignalsByCategory(getPatternSignals(query));
+      const matchedCategories = [];
+      const newlyActivatedCategories = [];
+      for (const { category, tier } of signals) {
+        const wasActive = controller.activeCategories.has(category);
+        matchedCategories.push(category);
+        controller.activateCategory(category, tier);
+        if (!wasActive && controller.activeCategories.has(category)) {
+          newlyActivatedCategories.push(category);
+        }
+      }
+      const tools = [];
+      for (const [name, handle] of controller.getRegisteredTools()) {
+        const cat = TOOL_CATEGORY[name];
+        if (handle.enabled && cat && matchedCategories.includes(cat)) {
+          tools.push({
+            name,
+            description: handle.description ?? "",
+            category: cat,
+            inputSchema: toJsonSchema(handle.inputSchema)
+          });
+        }
+      }
+      const result = {
+        matched_categories: matchedCategories,
+        newly_activated_categories: newlyActivatedCategories,
+        tools,
+        hint: tools.length === 0 ? `No tools matched "${query}". Available categories: ${ALL_CATEGORIES.join(", ")}` : `${tools.length} tools available across ${matchedCategories.join(", ")}`
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
 // src/resources/vault.ts
 function registerVaultResources(server2, getIndex) {
   server2.registerResource(
@@ -26698,6 +26750,14 @@ function getPatternSignals(raw) {
   if (!raw) return [];
   return ACTIVATION_PATTERNS.filter(({ patterns }) => patterns.some((pattern) => pattern.test(raw))).map(({ category, tier }) => ({ category, tier }));
 }
+function unionSignalsByCategory(signals) {
+  const best = /* @__PURE__ */ new Map();
+  for (const { category, tier } of signals) {
+    const existing = best.get(category);
+    if (!existing || tier > existing) best.set(category, tier);
+  }
+  return Array.from(best.entries()).map(([category, tier]) => ({ category, tier }));
+}
 async function getActivationSignals(toolName, params, searchMethod, toolTierMode2 = "off") {
   if (toolName !== "search" && toolName !== "brief") return [];
   if (!params || typeof params !== "object") return [];
@@ -26715,14 +26775,7 @@ async function getActivationSignals(toolName, params, searchMethod, toolTierMode
   if (routingMode === "semantic" && searchMethod !== "hybrid") {
     return getPatternSignals(raw);
   }
-  const categoryBest = /* @__PURE__ */ new Map();
-  for (const { category, tier } of [...patternSignals, ...semanticSignals]) {
-    const existing = categoryBest.get(category);
-    if (!existing || tier > existing) {
-      categoryBest.set(category, tier);
-    }
-  }
-  return Array.from(categoryBest.entries()).map(([category, tier]) => ({ category, tier }));
+  return unionSignalsByCategory([...patternSignals, ...semanticSignals]);
 }
 function extractSearchMethod(result) {
   if (!result || typeof result !== "object") return void 0;
@@ -26759,12 +26812,12 @@ function applyToolGating(targetServer, categories, getDb4, registry, getVaultPat
     return true;
   }
   function enableCategory(category, tier) {
-    if (!categories.has(category)) return;
+    if (!categories.has(category)) return [];
     const previousTier = activatedCategoryTiers.get(category) ?? 0;
     if (tier > previousTier) {
       activatedCategoryTiers.set(category, tier);
     }
-    refreshToolVisibility();
+    return refreshToolVisibility();
   }
   function shouldEnableTool(toolName) {
     const tier = TOOL_TIER[toolName];
@@ -26779,26 +26832,29 @@ function applyToolGating(targetServer, categories, getDb4, registry, getVaultPat
     return activatedTier >= tier;
   }
   function refreshToolVisibility() {
-    let changed = false;
+    const newlyEnabled = [];
     for (const [name, handle] of toolHandles) {
       const enabled = shouldEnableTool(name);
       if (enabled !== handle.enabled) {
         handle.enabled = enabled;
-        changed = true;
+        if (enabled) newlyEnabled.push(name);
       }
     }
-    if (changed) {
+    if (newlyEnabled.length > 0) {
       targetServer.sendToolListChanged();
     }
     if (controllerRef) {
       onTierStateChange?.(controllerRef);
     }
+    return newlyEnabled;
   }
   async function maybeActivateFromContext(toolName, params, searchMethod) {
-    if (tierMode !== "tiered" || tierOverride === "full") return;
+    if (tierMode !== "tiered" || tierOverride === "full") return [];
+    const newlyEnabled = [];
     for (const { category, tier } of await getActivationSignals(toolName, params, searchMethod, tierMode)) {
-      enableCategory(category, tier);
+      newlyEnabled.push(...enableCategory(category, tier));
     }
+    return newlyEnabled;
   }
   function ensureToolEnabledForDirectCall(toolName) {
     if (tierMode !== "tiered") return;
@@ -26844,7 +26900,14 @@ function applyToolGating(targetServer, categories, getDb4, registry, getVaultPat
       try {
         result = await handler(...args);
         const searchMethod = extractSearchMethod(result);
-        await maybeActivateFromContext(toolName, params, searchMethod);
+        const newlyActivated = await maybeActivateFromContext(toolName, params, searchMethod);
+        if (newlyActivated.length > 0 && result?.content && Array.isArray(result.content)) {
+          result.content.push({
+            type: "text",
+            text: `
+[Progressive disclosure: ${newlyActivated.length} new tools activated: ${newlyActivated.join(", ")}. Call tools/list to refresh.]`
+          });
+        }
         return result;
       } catch (err) {
         success = false;
@@ -27010,7 +27073,7 @@ function applyToolGating(targetServer, categories, getDb4, registry, getVaultPat
     const schemaIdx = handlerIdx - 1;
     const schema = args[schemaIdx];
     if (schema && typeof schema === "object" && !Array.isArray(schema)) {
-      schema.vault = z40.string().optional().describe(
+      schema.vault = z41.string().optional().describe(
         `Vault name for multi-vault mode. Available: ${registry.getVaultNames().join(", ")}. Default: ${registry.primaryName}`
       );
     }
@@ -27127,7 +27190,7 @@ function applyToolGating(targetServer, categories, getDb4, registry, getVaultPat
   controllerRef = controller;
   return controller;
 }
-function registerAllTools(targetServer, ctx) {
+function registerAllTools(targetServer, ctx, controller) {
   const { getVaultPath: gvp, getVaultIndex: gvi, getStateDb: gsd, getFlywheelConfig: gcf } = ctx;
   registerHealthTools(targetServer, gvi, gvp, gcf, gsd, ctx.getWatcherStatus, () => trPkg.version, ctx.getPipelineActivity);
   registerSystemTools(
@@ -27220,6 +27283,9 @@ function registerAllTools(targetServer, ctx) {
   registerCalibrationExportTools(targetServer, gvi, gsd, gcf);
   registerMemoryTools(targetServer, gsd);
   registerBriefTools(targetServer, gsd);
+  if (controller) {
+    registerDiscoveryTools(targetServer, controller);
+  }
   registerVaultResources(targetServer, () => gvi() ?? null);
 }
 
@@ -27305,7 +27371,7 @@ function createConfiguredServer() {
     toolTierMode,
     handleTierStateChange
   );
-  registerAllTools(s, ctx);
+  registerAllTools(s, ctx, toolTierController);
   toolTierController.setOverride(runtimeToolTierOverride);
   for (const [category, tier] of runtimeActiveCategoryTiers) {
     toolTierController.activateCategory(category, tier);
@@ -27358,7 +27424,7 @@ var _gatingResult = applyToolGating(
   toolTierMode,
   handleTierStateChange
 );
-registerAllTools(server, _registryCtx);
+registerAllTools(server, _registryCtx, _gatingResult);
 _gatingResult.setOverride(runtimeToolTierOverride);
 _gatingResult.finalizeRegistration();
 primaryToolTierController = _gatingResult;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velvetmonkey/flywheel-memory",
-  "version": "2.3.1",
+  "version": "2.3.3",
   "description": "MCP tools that search, write, and auto-link your Obsidian vault — and learn from your edits.",
   "type": "module",
   "main": "dist/index.js",
@@ -55,7 +55,7 @@
   "dependencies": {
     "@huggingface/transformers": "^3.8.1",
     "@modelcontextprotocol/sdk": "^1.25.1",
-    "@velvetmonkey/vault-core": "^2.3.1",
+    "@velvetmonkey/vault-core": "^2.3.3",
     "better-sqlite3": "^12.0.0",
     "chokidar": "^4.0.0",
     "gray-matter": "^4.0.3",