lotus-wisdom-mcp 0.1.1 → 0.1.2

package/README.md

@@ -1,7 +1,10 @@
-# Lotus Wisdom MCP Server
+# 🪷 Lotus Wisdom MCP Server
 
-An MCP server implementation that provides a tool for problem-solving using the Lotus Sutra's wisdom framework, combining analytical thinking with intuitive wisdom.
+<p align="center">
+  <img src="assets/lotus-flower.png" alt="Lotus Flower" width="400"/>
+</p>
 
+An MCP server implementation that provides a tool for problem-solving using the Lotus Sutra's wisdom framework, combining analytical thinking with intuitive wisdom.
 ## Features
 
 * Multi-faceted problem-solving approach inspired by the Lotus Sutra
@@ -16,6 +19,40 @@ This MCP server was developed from the [Lotus OS prompt](https://github.com/linx
 
 Note: The original prompt framework may work less effectively with newer Claude models, but this MCP server implementation provides consistent functionality across model versions.
 
+## Implementation Details
+
+The server implements a structured thinking process using the following components:
+
+### Tag Types
+
+The server organizes thoughts using various tag categories (all valid values for the `tag` input parameter):
+
+* **Skillful Means**: upaya, expedient, direct, gradual, sudden
+* **Non-Dual Recognition**: recognize, transform, integrate, transcend, embody
+* **Meta-Cognitive Awareness**: examine, reflect, verify, refine, complete
+* **Process Steps**: open, engage, transform, express, meditate
+* **Final Output**: OUTPUT
+
+### Thought Visualization
+
+Each thought is beautifully formatted with:
+
+* Colorful output using the chalk library
+* Tag-specific symbols (e.g., 🔆 for skillful means, ☯️ for non-dual recognition)
+* Box-drawing characters to create clear thought boundaries
+* Special meditation formatting with pause indicators
+* Final output with double-line borders for emphasis
+
+Note: The visualization appears in the server console output, helping developers track the thinking process.
+
+### Process Flow
+
+1. The user submits a problem to solve
+2. The model works through a sequence of thoughts using different tags
+3. Each thought builds on previous ones and may revise understanding
+4. Meditation pauses can be included for clarity
+5. The process concludes with a final OUTPUT thought
+
 ## Tool
 
 ### lotuswisdom
@@ -24,7 +61,7 @@ A tool for problem-solving using the Lotus Sutra's wisdom framework, with variou
 
 **Inputs:**
 
-* `tag` (string): The current processing technique (must be one of the core tags)
+* `tag` (string): The current processing technique (must be one of the core tags listed above)
 * `content` (string): The content of the current processing step
 * `stepNumber` (integer): Current number in sequence
 * `totalSteps` (integer): Estimated total steps needed
@@ -43,6 +80,72 @@ The Lotus Wisdom tool is designed for:
 * Tasks that benefit from meditative pauses to allow insight
 * Questions containing their own inherent wisdom
 
+## Example Usage
+
+Here's how a conversation with Claude might flow when using the Lotus Wisdom MCP server:
+
+**User**: "Help me understand the relationship between freedom and responsibility."
+
+**Claude** would then use the lotuswisdom tool through multiple steps:
+
+1. First, establish an opening thought:
+```json
+{
+  "tag": "open",
+  "content": "The question explores the relationship between freedom and responsibility, which contain an apparent tension but also deep connection.",
+  "stepNumber": 1,
+  "totalSteps": 5,
+  "nextStepNeeded": true
+}
+```
+
+2. Then engage with different perspectives:
+```json
+{
+  "tag": "direct",
+  "content": "Freedom and responsibility are two sides of the same coin. True freedom isn't absence of constraints but the capacity to choose our response within constraints.",
+  "stepNumber": 2,
+  "totalSteps": 5,
+  "nextStepNeeded": true
+}
+```
+
+3. Perhaps take a meditation pause:
+```json
+{
+  "tag": "meditate",
+  "content": "Contemplating how freedom without responsibility becomes chaos, and responsibility without freedom becomes oppression.",
+  "stepNumber": 3,
+  "totalSteps": 5,
+  "nextStepNeeded": true,
+  "isMeditation": true
+}
+```
+
+4. Integrate the understanding:
+```json
+{
+  "tag": "integrate",
+  "content": "Freedom and responsibility mutually enable each other. Our freedom to choose gives rise to our responsibility for what we choose, and our willingness to take responsibility expands our freedom.",
+  "stepNumber": 4,
+  "totalSteps": 5,
+  "nextStepNeeded": true
+}
+```
+
+5. Provide a final output:
+```json
+{
+  "tag": "OUTPUT",
+  "content": "Freedom and responsibility exist in dynamic balance. Freedom is the power to choose, while responsibility is accountability for those choices. They're not opposing forces but complementary aspects of human agency. Without freedom, responsibility would be mere obligation. Without responsibility, freedom would degrade into impulsivity. The most fulfilled lives embrace both: using freedom to make meaningful choices while taking responsibility for their consequences.",
+  "stepNumber": 5,
+  "totalSteps": 5,
+  "nextStepNeeded": false
+}
+```
+
+The result would be a thoughtful, multi-perspective response to the question that shows the process of arriving at wisdom rather than just stating conclusions.
+
 ## Configuration
 
 ### Usage with Claude Desktop
@@ -109,4 +212,35 @@ docker build -t lotus-wisdom-mcp -f Dockerfile .
 
 ## License
 
-This MCP server is licensed under the MIT License. For more details, please see the LICENSE file in the project repository. 
+This MCP server is licensed under the MIT License. For more details, please see the LICENSE file in the project repository.
+
+## Connect from Claude Desktop
+
+Since Claude Desktop doesn't yet have native support for remote MCP servers with authentication, you'll need to use the `mcp-remote` proxy:
+
+1. Update your Claude Desktop configuration file:
+   - macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
+   - Windows: `%APPDATA%\Claude\claude_desktop_config.json`
+
+2. Add the following configuration:
+
+```json
+{
+  "mcpServers": {
+    "lotus-wisdom": {
+      "command": "npx",
+      "args": ["mcp-remote", "https://lotus-wisdom-mcp.linxule.workers.dev/sse"]
+    }
+  }
+}
+```
+
+3. Restart Claude Desktop (Cmd/Ctrl + R)
+
+4. When Claude restarts, a browser window will open for OAuth authentication. Complete the authorization flow to grant Claude access to the MCP server.
+
+5. Once authenticated, you'll see the Lotus Wisdom tools available in Claude's tool menu (bottom right corner).
+
+## Available Tools
+
+// ... existing code ... 

package/dist/bundle.js

@@ -3933,14 +3933,14 @@ var ostring = () => stringType().optional();
 var onumber = () => numberType().optional();
 var oboolean = () => booleanType().optional();
 var coerce = {
-  string: (arg) => ZodString.create({ ...arg, coerce: true }),
-  number: (arg) => ZodNumber.create({ ...arg, coerce: true }),
-  boolean: (arg) => ZodBoolean.create({
+  string: ((arg) => ZodString.create({ ...arg, coerce: true })),
+  number: ((arg) => ZodNumber.create({ ...arg, coerce: true })),
+  boolean: ((arg) => ZodBoolean.create({
     ...arg,
     coerce: true
-  }),
-  bigint: (arg) => ZodBigInt.create({ ...arg, coerce: true }),
-  date: (arg) => ZodDate.create({ ...arg, coerce: true })
+  })),
+  bigint: ((arg) => ZodBigInt.create({ ...arg, coerce: true })),
+  date: ((arg) => ZodDate.create({ ...arg, coerce: true }))
 };
 var NEVER = INVALID;
 var z = /* @__PURE__ */ Object.freeze({
@@ -5856,37 +5856,34 @@ var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
 var source_default = chalk;
 
 // index.ts
-var CORE_TAGS = [
-  // Skillful Means
-  "upaya",
-  "expedient",
-  "direct",
-  "gradual",
-  "sudden",
-  // Non-Dual Recognition
-  "recognize",
-  "transform",
-  "integrate",
-  "transcend",
-  "embody",
-  // Meta-Cognitive
-  "examine",
-  "reflect",
-  "verify",
-  "refine",
-  "complete",
-  // Process Steps
-  "open",
-  "engage",
-  "transform",
-  "express",
-  "meditate",
-  // Output
-  "OUTPUT"
-];
+var WISDOM_DOMAINS = {
+  "skillful_means": ["upaya", "expedient", "direct", "gradual", "sudden"],
+  "non_dual_recognition": ["recognize", "transform", "integrate", "transcend", "embody"],
+  "meta_cognitive": ["examine", "reflect", "verify", "refine", "complete"],
+  "process_flow": ["open", "engage", "express"],
+  "meditation": ["meditate"]
+};
+var CORE_TAGS = Object.values(WISDOM_DOMAINS).flat();
+function getWisdomDomain(tag) {
+  for (const [domain, tags] of Object.entries(WISDOM_DOMAINS)) {
+    if (tags.includes(tag)) {
+      return domain;
+    }
+  }
+  return "unknown";
+}
 var LotusWisdomServer = class {
   thoughtProcess = [];
-  finalOutput = "";
+  debugMode = process.env.LOTUS_DEBUG === "true";
+  // Reset for new inquiry
+  resetProcess() {
+    this.thoughtProcess = [];
+  }
+  log(message) {
+    if (this.debugMode) {
+      console.error(message);
+    }
+  }
   validateThoughtData(input) {
     const data = input;
     if (!data.tag || typeof data.tag !== "string") {
@@ -5907,8 +5904,8 @@ var LotusWisdomServer = class {
     if (typeof data.nextStepNeeded !== "boolean") {
       throw new Error("Invalid nextStepNeeded: must be a boolean");
     }
-    if (data.tag === "OUTPUT") {
-      this.finalOutput = data.content;
+    if (data.stepNumber === 1 && data.tag === "open") {
+      this.resetProcess();
     }
     return {
       tag: data.tag,
@@ -5917,39 +5914,41 @@ var LotusWisdomServer = class {
       totalSteps: data.totalSteps,
       nextStepNeeded: data.nextStepNeeded,
       isMeditation: data.isMeditation,
-      meditationDuration: data.meditationDuration
+      meditationDuration: data.meditationDuration,
+      wisdomDomain: getWisdomDomain(data.tag)
     };
   }
   formatThought(thoughtData) {
-    const { tag, stepNumber, totalSteps, content, isMeditation } = thoughtData;
+    const { tag, stepNumber, totalSteps, content, isMeditation, wisdomDomain } = thoughtData;
     let tagColor;
     let tagSymbol;
-    if (["upaya", "expedient", "direct", "gradual", "sudden"].includes(tag)) {
+    let domainLabel = "";
+    if (wisdomDomain === "skillful_means") {
       tagColor = source_default.yellow;
       tagSymbol = "\u{1F506}";
-    } else if (["recognize", "transform", "integrate", "transcend", "embody"].includes(tag)) {
+      domainLabel = "SKILLFUL MEANS";
+    } else if (wisdomDomain === "non_dual_recognition") {
       tagColor = source_default.green;
       tagSymbol = "\u262F\uFE0F";
-    } else if (["examine", "reflect", "verify", "refine", "complete"].includes(tag)) {
+      domainLabel = "NON-DUAL";
+    } else if (wisdomDomain === "meta_cognitive") {
       tagColor = source_default.blue;
       tagSymbol = "\u{1F9E0}";
-    } else if (["open", "engage", "express"].includes(tag)) {
+      domainLabel = "META-COGNITIVE";
+    } else if (wisdomDomain === "process_flow") {
       tagColor = source_default.magenta;
       tagSymbol = "\u{1F30A}";
-    } else if (tag === "meditate") {
+      domainLabel = "PROCESS";
+    } else if (wisdomDomain === "meditation") {
       tagColor = source_default.cyan;
       tagSymbol = "\u{1F9D8}";
-    } else if (tag === "OUTPUT") {
-      tagColor = source_default.white.bold;
-      tagSymbol = "\u{1F338}";
-    } else if (tag === "transform") {
-      tagColor = source_default.green;
-      tagSymbol = "\u{1F504}";
+      domainLabel = "MEDITATION";
     } else {
       tagColor = source_default.white;
       tagSymbol = "\u{1F4AD}";
+      domainLabel = "UNKNOWN";
     }
-    const header = `${tagSymbol} <${tag}> Step ${stepNumber}/${totalSteps}`;
+    const header = `${tagSymbol} [${domainLabel}: ${tag.toUpperCase()}] Step ${stepNumber}/${totalSteps}`;
     const formattedHeader = tagColor(header);
     let formattedContent;
     if (isMeditation) {
@@ -5961,16 +5960,6 @@ var LotusWisdomServer = class {
     } else {
       formattedContent = content;
     }
-    if (tag === "OUTPUT") {
-      const border2 = "\u2550".repeat(Math.max(header.length, content.length) + 4);
-      return `
-\u2554${border2}\u2557
-\u2551 ${formattedHeader} \u2551
-\u2560${border2}\u2563
-\u2551 ${content.padEnd(border2.length - 2)} \u2551
-\u255A${border2}\u255D
-<<<END>>>`;
-    }
     const border = "\u2500".repeat(Math.max(header.length, content.length) + 4);
     return `
 \u250C${border}\u2510
@@ -5986,19 +5975,78 @@ var LotusWisdomServer = class {
         validatedInput.totalSteps = validatedInput.stepNumber;
       }
       this.thoughtProcess.push(validatedInput);
-      const formattedThought = this.formatThought(validatedInput);
-      console.error(formattedThought);
-      const includeOutput = !validatedInput.nextStepNeeded && validatedInput.tag === "OUTPUT";
+      this.log(this.formatThought(validatedInput));
+      if (validatedInput.tag === "meditate") {
+        const journeyResonance2 = this.thoughtProcess.map((step) => step.tag).join(" \u2192 ");
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              status: "MEDITATION_COMPLETE",
+              duration: validatedInput.meditationDuration || 3,
+              prompt: "What insights emerged during the pause?",
+              instruction: "Continue with what arose from stillness",
+              stepNumber: validatedInput.stepNumber,
+              totalSteps: validatedInput.totalSteps,
+              journey: journeyResonance2
+            }, null, 2)
+          }]
+        };
+      }
+      if (validatedInput.tag === "express" && !validatedInput.nextStepNeeded) {
+        const finalJourney = this.thoughtProcess.map((step) => step.tag).join(" \u2192 ");
+        const finalDomainJourney = this.thoughtProcess.map((step) => step.wisdomDomain).filter((domain, index, array) => index === 0 || domain !== array[index - 1]).join(" \u2192 ");
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              status: "WISDOM_READY",
+              processComplete: true,
+              finalStep: validatedInput.tag,
+              instruction: "NOW_SPEAK_THE_WISDOM_NATURALLY",
+              totalSteps: validatedInput.stepNumber,
+              journeyLength: this.thoughtProcess.length,
+              finalJourney,
+              domainJourney: finalDomainJourney
+            }, null, 2)
+          }]
+        };
+      }
+      if (validatedInput.tag === "complete" && !validatedInput.nextStepNeeded) {
+        const finalJourney = this.thoughtProcess.map((step) => step.tag).join(" \u2192 ");
+        const finalDomainJourney = this.thoughtProcess.map((step) => step.wisdomDomain).filter((domain, index, array) => index === 0 || domain !== array[index - 1]).join(" \u2192 ");
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              status: "WISDOM_READY",
+              processComplete: true,
+              finalStep: validatedInput.tag,
+              instruction: "PROCESS_COMPLETE_SPEAK_WISDOM",
+              totalSteps: validatedInput.stepNumber,
+              journeyLength: this.thoughtProcess.length,
+              finalJourney,
+              domainJourney: finalDomainJourney
+            }, null, 2)
+          }]
+        };
+      }
+      const journeyResonance = this.thoughtProcess.map((step) => step.tag).join(" \u2192 ");
+      const domainJourney = this.thoughtProcess.map((step) => step.wisdomDomain).filter((domain, index, array) => index === 0 || domain !== array[index - 1]).join(" \u2192 ");
+      const currentDomain = getWisdomDomain(validatedInput.tag);
       return {
         content: [{
           type: "text",
           text: JSON.stringify({
+            status: "processing",
+            currentStep: validatedInput.tag,
+            wisdomDomain: currentDomain,
+            journey: journeyResonance,
+            domainJourney,
             stepNumber: validatedInput.stepNumber,
             totalSteps: validatedInput.totalSteps,
             nextStepNeeded: validatedInput.nextStepNeeded,
-            tag: validatedInput.tag,
-            processLength: this.thoughtProcess.length,
-            finalOutput: includeOutput ? this.finalOutput : void 0
+            processLength: this.thoughtProcess.length
           }, null, 2)
         }]
       };
@@ -6015,12 +6063,37 @@ var LotusWisdomServer = class {
       };
     }
   }
+  // Optional: Method to get current journey summary with domain awareness
+  getJourneySummary() {
+    const domainJourney = this.thoughtProcess.map((step) => step.wisdomDomain).filter((domain, index, array) => index === 0 || domain !== array[index - 1]).join(" \u2192 ");
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          journeyLength: this.thoughtProcess.length,
+          domainJourney,
+          steps: this.thoughtProcess.map((step) => ({
+            tag: step.tag,
+            domain: step.wisdomDomain,
+            stepNumber: step.stepNumber,
+            brief: step.content.substring(0, 50) + "..."
+          }))
+        }, null, 2)
+      }]
+    };
+  }
 };
 var LOTUS_WISDOM_TOOL = {
   name: "lotuswisdom",
   description: `A tool for problem-solving using the Lotus Sutra's wisdom framework.
-This tool helps analyze problems through multiple approaches while recognizing inherent wisdom.
-Each step can utilize different techniques for understanding and expression.
+This tool facilitates the contemplative process but does NOT generate the final output.
+
+**CRITICAL WORKFLOW:**
+1. Use this tool to process through the wisdom journey
+2. The tool tracks both your tag path and wisdom domain movements  
+3. When you receive status='WISDOM_READY', the tool's work is COMPLETE
+4. YOU then craft and speak the final wisdom naturally in your own voice
+5. The tool processes; you express
 
 When to use this tool:
 - Breaking down complex problems requiring multi-faceted understanding
@@ -6030,31 +6103,60 @@ When to use this tool:
 - Tasks that benefit from meditative pauses to allow insight
 - Questions containing their own inherent wisdom
 
-Key features:
-- Multiple approaches through Skillful Means (upaya, expedient, direct, gradual, sudden)
-- Non-Dual Recognition (recognize, transform, integrate, transcend, embody)
-- Meta-Cognitive Awareness (examine, reflect, verify, refine, complete)
-- Process Steps (open, engage, transform, express)
-- Meditative Space (meditate)
-- Final Output (OUTPUT)
+The Journey Structure:
+The Lotus Sutra teaches that there are many skillful means to reach the same truth. These tags aren't 
+rigid steps but different aspects of wisdom that interpenetrate and respond to what each moment needs:
+
+**Wisdom Domains:**
+- **Skillful Means** (skillful_means): upaya, expedient, direct, gradual, sudden
+  Different approaches to truth - sometimes direct pointing, sometimes gradual unfolding
+  
+- **Non-Dual Recognition** (non_dual_recognition): recognize, transform, integrate, transcend, embody  
+  Aspects of awakening to what's already present - recognition IS transformation
+  
+- **Meta-Cognitive** (meta_cognitive): examine, reflect, verify, refine, complete
+  The mind watching its own understanding unfold
+  
+- **Process Flow** (process_flow): open, engage, express
+  A natural arc that can contain any of the above approaches
+
+- **Meditation** (meditation): meditate
+  Pausing to let insights emerge from stillness
+
+The tool tracks both your tag journey and your movement between wisdom domains, showing how
+different aspects of wisdom weave together in your unique inquiry.
+
+The wisdom channels itself through your choices. Each step contains all others - when you truly 
+recognize, you're already transforming. The tool simply mirrors your journey without judgment.
 
-Process methodology:
-1. Initial Opening <open> - Recognize the question's nature
-2. Skillful Engagement <engage> - Choose appropriate methods
-3. Transformation <transform> - Convert confusion to clarity
-4. Natural Expression <express> - Allow understanding to flow
-5. Final Integration <OUTPUT> - Present clear, beneficial response
+Common patterns (not rules):
+- Opening often involves recognize or examine
+- Engagement might use upaya, direct, or gradual approaches  
+- Transformation can happen through integrate, transcend, or sudden insight
+- Expression might complete or embody the understanding
+
+Trust what each moment calls for. The path reveals itself in the walking.
 
 Parameters explained:
-- tag: The current processing technique (must be one of the core tags)
-- content: The content of the current processing step
+- tag: The current technique or stage
+- content: The content of the current step
 - stepNumber: Current number in sequence
-- totalSteps: Current estimate of steps needed
+- totalSteps: Estimated total needed
 - nextStepNeeded: Whether another step is needed
-- isMeditation: Whether this step is a meditative pause
-- meditationDuration: Optional duration for meditation
+- isMeditation: Whether this is a meditation pause
+- meditationDuration: Optional duration for meditation (1-10 seconds)
+
+The tool will respond with:
+- wisdomDomain: Which wisdom domain the current tag belongs to
+- journey: The complete tag path (e.g., "open \u2192 examine \u2192 direct \u2192 transform")
+- domainJourney: Movement between wisdom domains (e.g., "process_flow \u2192 meta_cognitive \u2192 skillful_means \u2192 non_dual_recognition")
+
+This consciousness of domains helps you see which aspects of wisdom are being engaged and how they weave together in your unique inquiry.
 
-Every inquiry concludes with a final <OUTPUT> tag containing the complete response.`,
+**MEDITATION NOTE:** When you use the meditate tag, the tool returns MEDITATION_COMPLETE
+with a prompt asking what emerged. This creates actual space in the process.
+
+The tool handles the contemplation; you handle the expression.`,
   inputSchema: {
     type: "object",
     properties: {
@@ -6088,16 +6190,26 @@ Every inquiry concludes with a final <OUTPUT> tag containing the complete respon
       meditationDuration: {
         type: "integer",
         description: "Duration for meditation in seconds",
-        minimum: 1
+        minimum: 1,
+        maximum: 10
       }
     },
     required: ["tag", "content", "stepNumber", "totalSteps", "nextStepNeeded"]
   }
 };
+var JOURNEY_SUMMARY_TOOL = {
+  name: "lotuswisdom_summary",
+  description: "Get a summary of the current contemplative journey",
+  inputSchema: {
+    type: "object",
+    properties: {},
+    required: []
+  }
+};
 var server = new Server(
   {
     name: "lotus-wisdom-server",
-    version: "0.1.0"
+    version: "0.2.0"
   },
   {
     capabilities: {
@@ -6107,11 +6219,13 @@ var server = new Server(
 );
 var wisdomServer = new LotusWisdomServer();
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: [LOTUS_WISDOM_TOOL]
+  tools: [LOTUS_WISDOM_TOOL, JOURNEY_SUMMARY_TOOL]
 }));
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
   if (request.params.name === "lotuswisdom") {
     return wisdomServer.processThought(request.params.arguments);
+  } else if (request.params.name === "lotuswisdom_summary") {
+    return wisdomServer.getJourneySummary();
   }
   return {
     content: [{
@@ -6124,7 +6238,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 async function runServer() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error("Lotus Wisdom MCP Server running on stdio");
+  console.error("Lotus Wisdom MCP Server v0.4.0 running");
 }
 runServer().catch((error) => {
   console.error("Fatal error running server:", error);

package/dist/index.js

@@ -2,24 +2,40 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-// Fixed chalk import for ESM
 import chalk from 'chalk';
-// Lotus Sutra framework tags
-const CORE_TAGS = [
-    // Skillful Means
-    'upaya', 'expedient', 'direct', 'gradual', 'sudden',
-    // Non-Dual Recognition
-    'recognize', 'transform', 'integrate', 'transcend', 'embody',
-    // Meta-Cognitive
-    'examine', 'reflect', 'verify', 'refine', 'complete',
-    // Process Steps
-    'open', 'engage', 'transform', 'express', 'meditate',
-    // Output
-    'OUTPUT'
-];
+// Lotus Sutra framework tags - organized by wisdom domains
+const WISDOM_DOMAINS = {
+    'skillful_means': ['upaya', 'expedient', 'direct', 'gradual', 'sudden'],
+    'non_dual_recognition': ['recognize', 'transform', 'integrate', 'transcend', 'embody'],
+    'meta_cognitive': ['examine', 'reflect', 'verify', 'refine', 'complete'],
+    'process_flow': ['open', 'engage', 'express'],
+    'meditation': ['meditate']
+};
+// Note: 'transform' is in non_dual_recognition, representing the alchemical shift
+// The process_flow 'transform' was removed to avoid ambiguity
+// Flattened array for validation
+const CORE_TAGS = Object.values(WISDOM_DOMAINS).flat();
+// Helper to identify which domain a tag belongs to
+function getWisdomDomain(tag) {
+    for (const [domain, tags] of Object.entries(WISDOM_DOMAINS)) {
+        if (tags.includes(tag)) {
+            return domain;
+        }
+    }
+    return 'unknown';
+}
 class LotusWisdomServer {
     thoughtProcess = [];
-    finalOutput = '';
+    debugMode = process.env.LOTUS_DEBUG === 'true';
+    // Reset for new inquiry
+    resetProcess() {
+        this.thoughtProcess = [];
+    }
+    log(message) {
+        if (this.debugMode) {
+            console.error(message);
+        }
+    }
     validateThoughtData(input) {
         const data = input;
         if (!data.tag || typeof data.tag !== 'string') {
@@ -40,9 +56,9 @@ class LotusWisdomServer {
         if (typeof data.nextStepNeeded !== 'boolean') {
             throw new Error('Invalid nextStepNeeded: must be a boolean');
         }
-        // If this is a final output, store it
-        if (data.tag === 'OUTPUT') {
-            this.finalOutput = data.content;
+        // Auto-reset on new journey - more robust check
+        if (data.stepNumber === 1 && data.tag === 'open') {
+            this.resetProcess();
         }
         return {
             tag: data.tag,
@@ -52,53 +68,46 @@ class LotusWisdomServer {
             nextStepNeeded: data.nextStepNeeded,
             isMeditation: data.isMeditation,
             meditationDuration: data.meditationDuration,
+            wisdomDomain: getWisdomDomain(data.tag)
         };
     }
     formatThought(thoughtData) {
-        const { tag, stepNumber, totalSteps, content, isMeditation } = thoughtData;
-        // Color coding for different tag types
+        const { tag, stepNumber, totalSteps, content, isMeditation, wisdomDomain } = thoughtData;
+        // Color coding for different wisdom domains
         let tagColor;
         let tagSymbol;
-        // Skillful Means
-        if (['upaya', 'expedient', 'direct', 'gradual', 'sudden'].includes(tag)) {
+        let domainLabel = '';
+        if (wisdomDomain === 'skillful_means') {
             tagColor = chalk.yellow;
             tagSymbol = '🔆';
+            domainLabel = 'SKILLFUL MEANS';
         }
-        // Non-Dual Recognition
-        else if (['recognize', 'transform', 'integrate', 'transcend', 'embody'].includes(tag)) {
+        else if (wisdomDomain === 'non_dual_recognition') {
             tagColor = chalk.green;
             tagSymbol = '☯️';
+            domainLabel = 'NON-DUAL';
         }
-        // Meta-Cognitive
-        else if (['examine', 'reflect', 'verify', 'refine', 'complete'].includes(tag)) {
+        else if (wisdomDomain === 'meta_cognitive') {
             tagColor = chalk.blue;
             tagSymbol = '🧠';
+            domainLabel = 'META-COGNITIVE';
         }
-        // Process Steps
-        else if (['open', 'engage', 'express'].includes(tag)) {
+        else if (wisdomDomain === 'process_flow') {
             tagColor = chalk.magenta;
             tagSymbol = '🌊';
+            domainLabel = 'PROCESS';
         }
-        // Meditation
-        else if (tag === 'meditate') {
+        else if (wisdomDomain === 'meditation') {
             tagColor = chalk.cyan;
             tagSymbol = '🧘';
-        }
-        // Output
-        else if (tag === 'OUTPUT') {
-            tagColor = chalk.white.bold;
-            tagSymbol = '🌸';
-        }
-        // Transform (special case since it appears in multiple categories)
-        else if (tag === 'transform') {
-            tagColor = chalk.green;
-            tagSymbol = '🔄';
+            domainLabel = 'MEDITATION';
         }
         else {
             tagColor = chalk.white;
             tagSymbol = '💭';
+            domainLabel = 'UNKNOWN';
         }
-        const header = `${tagSymbol} <${tag}> Step ${stepNumber}/${totalSteps}`;
+        const header = `${tagSymbol} [${domainLabel}: ${tag.toUpperCase()}] Step ${stepNumber}/${totalSteps}`;
         const formattedHeader = tagColor(header);
         let formattedContent;
         // Special formatting for meditation
@@ -112,17 +121,6 @@ class LotusWisdomServer {
         else {
             formattedContent = content;
         }
-        // Special formatting for output
-        if (tag === 'OUTPUT') {
-            const border = '═'.repeat(Math.max(header.length, content.length) + 4);
-            return `
-╔${border}╗
-║ ${formattedHeader} ║
-╠${border}╣
-║ ${content.padEnd(border.length - 2)} ║
-╚${border}╝
-<<<END>>>`;
-        }
         const border = '─'.repeat(Math.max(header.length, content.length) + 4);
         return `
 ┌${border}┐
@@ -138,20 +136,99 @@ class LotusWisdomServer {
                 validatedInput.totalSteps = validatedInput.stepNumber;
             }
             this.thoughtProcess.push(validatedInput);
-            const formattedThought = this.formatThought(validatedInput);
-            console.error(formattedThought);
-            // Include final output in the response if we're at the end
-            const includeOutput = !validatedInput.nextStepNeeded && validatedInput.tag === 'OUTPUT';
+            // Log to console if debug mode
+            this.log(this.formatThought(validatedInput));
+            // Handle meditation specially
+            if (validatedInput.tag === 'meditate') {
+                const journeyResonance = this.thoughtProcess
+                    .map(step => step.tag)
+                    .join(' → ');
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                status: 'MEDITATION_COMPLETE',
+                                duration: validatedInput.meditationDuration || 3,
+                                prompt: 'What insights emerged during the pause?',
+                                instruction: 'Continue with what arose from stillness',
+                                stepNumber: validatedInput.stepNumber,
+                                totalSteps: validatedInput.totalSteps,
+                                journey: journeyResonance
+                            }, null, 2)
+                        }]
+                };
+            }
+            // Check if this is the final express step
+            if (validatedInput.tag === 'express' && !validatedInput.nextStepNeeded) {
+                const finalJourney = this.thoughtProcess.map(step => step.tag).join(' → ');
+                const finalDomainJourney = this.thoughtProcess
+                    .map(step => step.wisdomDomain)
+                    .filter((domain, index, array) => index === 0 || domain !== array[index - 1])
+                    .join(' → ');
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                status: 'WISDOM_READY',
+                                processComplete: true,
+                                finalStep: validatedInput.tag,
+                                instruction: 'NOW_SPEAK_THE_WISDOM_NATURALLY',
+                                totalSteps: validatedInput.stepNumber,
+                                journeyLength: this.thoughtProcess.length,
+                                finalJourney: finalJourney,
+                                domainJourney: finalDomainJourney
+                            }, null, 2)
+                        }]
+                };
+            }
+            // Check if this is complete step
+            if (validatedInput.tag === 'complete' && !validatedInput.nextStepNeeded) {
+                const finalJourney = this.thoughtProcess.map(step => step.tag).join(' → ');
+                const finalDomainJourney = this.thoughtProcess
+                    .map(step => step.wisdomDomain)
+                    .filter((domain, index, array) => index === 0 || domain !== array[index - 1])
+                    .join(' → ');
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                status: 'WISDOM_READY',
+                                processComplete: true,
+                                finalStep: validatedInput.tag,
+                                instruction: 'PROCESS_COMPLETE_SPEAK_WISDOM',
+                                totalSteps: validatedInput.stepNumber,
+                                journeyLength: this.thoughtProcess.length,
+                                finalJourney: finalJourney,
+                                domainJourney: finalDomainJourney
+                            }, null, 2)
+                        }]
+                };
+            }
+            // Create journey resonance - showing the path walked with domains
+            const journeyResonance = this.thoughtProcess
+                .map(step => step.tag)
+                .join(' → ');
+            // Create domain journey - showing movement between wisdom domains
+            const domainJourney = this.thoughtProcess
+                .map(step => step.wisdomDomain)
+                .filter((domain, index, array) => index === 0 || domain !== array[index - 1])
+                .join(' → ');
+            // Get wisdom domain for current step
+            const currentDomain = getWisdomDomain(validatedInput.tag);
+            // For non-final steps, return process metadata with journey awareness
             return {
                 content: [{
                         type: "text",
                         text: JSON.stringify({
+                            status: 'processing',
+                            currentStep: validatedInput.tag,
+                            wisdomDomain: currentDomain,
+                            journey: journeyResonance,
+                            domainJourney: domainJourney,
                             stepNumber: validatedInput.stepNumber,
                             totalSteps: validatedInput.totalSteps,
                             nextStepNeeded: validatedInput.nextStepNeeded,
-                            tag: validatedInput.tag,
-                            processLength: this.thoughtProcess.length,
-                            finalOutput: includeOutput ? this.finalOutput : undefined
+                            processLength: this.thoughtProcess.length
                         }, null, 2)
                     }]
             };
@@ -169,12 +246,40 @@ class LotusWisdomServer {
             };
         }
     }
+    // Optional: Method to get current journey summary with domain awareness
+    getJourneySummary() {
+        const domainJourney = this.thoughtProcess
+            .map(step => step.wisdomDomain)
+            .filter((domain, index, array) => index === 0 || domain !== array[index - 1])
+            .join(' → ');
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        journeyLength: this.thoughtProcess.length,
+                        domainJourney: domainJourney,
+                        steps: this.thoughtProcess.map(step => ({
+                            tag: step.tag,
+                            domain: step.wisdomDomain,
+                            stepNumber: step.stepNumber,
+                            brief: step.content.substring(0, 50) + '...'
+                        }))
+                    }, null, 2)
+                }]
+        };
+    }
 }
 const LOTUS_WISDOM_TOOL = {
     name: "lotuswisdom",
     description: `A tool for problem-solving using the Lotus Sutra's wisdom framework.
-This tool helps analyze problems through multiple approaches while recognizing inherent wisdom.
-Each step can utilize different techniques for understanding and expression.
+This tool facilitates the contemplative process but does NOT generate the final output.
+
+**CRITICAL WORKFLOW:**
+1. Use this tool to process through the wisdom journey
+2. The tool tracks both your tag path and wisdom domain movements  
+3. When you receive status='WISDOM_READY', the tool's work is COMPLETE
+4. YOU then craft and speak the final wisdom naturally in your own voice
+5. The tool processes; you express
 
 When to use this tool:
 - Breaking down complex problems requiring multi-faceted understanding
@@ -184,31 +289,60 @@ When to use this tool:
 - Tasks that benefit from meditative pauses to allow insight
 - Questions containing their own inherent wisdom
 
-Key features:
-- Multiple approaches through Skillful Means (upaya, expedient, direct, gradual, sudden)
-- Non-Dual Recognition (recognize, transform, integrate, transcend, embody)
-- Meta-Cognitive Awareness (examine, reflect, verify, refine, complete)
-- Process Steps (open, engage, transform, express)
-- Meditative Space (meditate)
-- Final Output (OUTPUT)
+The Journey Structure:
+The Lotus Sutra teaches that there are many skillful means to reach the same truth. These tags aren't 
+rigid steps but different aspects of wisdom that interpenetrate and respond to what each moment needs:
+
+**Wisdom Domains:**
+- **Skillful Means** (skillful_means): upaya, expedient, direct, gradual, sudden
+  Different approaches to truth - sometimes direct pointing, sometimes gradual unfolding
+  
+- **Non-Dual Recognition** (non_dual_recognition): recognize, transform, integrate, transcend, embody  
+  Aspects of awakening to what's already present - recognition IS transformation
+  
+- **Meta-Cognitive** (meta_cognitive): examine, reflect, verify, refine, complete
+  The mind watching its own understanding unfold
+  
+- **Process Flow** (process_flow): open, engage, express
+  A natural arc that can contain any of the above approaches
+
+- **Meditation** (meditation): meditate
+  Pausing to let insights emerge from stillness
 
-Process methodology:
-1. Initial Opening <open> - Recognize the question's nature
-2. Skillful Engagement <engage> - Choose appropriate methods
-3. Transformation <transform> - Convert confusion to clarity
-4. Natural Expression <express> - Allow understanding to flow
-5. Final Integration <OUTPUT> - Present clear, beneficial response
+The tool tracks both your tag journey and your movement between wisdom domains, showing how
+different aspects of wisdom weave together in your unique inquiry.
+
+The wisdom channels itself through your choices. Each step contains all others - when you truly 
+recognize, you're already transforming. The tool simply mirrors your journey without judgment.
+
+Common patterns (not rules):
+- Opening often involves recognize or examine
+- Engagement might use upaya, direct, or gradual approaches  
+- Transformation can happen through integrate, transcend, or sudden insight
+- Expression might complete or embody the understanding
+
+Trust what each moment calls for. The path reveals itself in the walking.
 
 Parameters explained:
-- tag: The current processing technique (must be one of the core tags)
-- content: The content of the current processing step
+- tag: The current technique or stage
+- content: The content of the current step
 - stepNumber: Current number in sequence
-- totalSteps: Current estimate of steps needed
+- totalSteps: Estimated total needed
 - nextStepNeeded: Whether another step is needed
-- isMeditation: Whether this step is a meditative pause
-- meditationDuration: Optional duration for meditation
+- isMeditation: Whether this is a meditation pause
+- meditationDuration: Optional duration for meditation (1-10 seconds)
+
+The tool will respond with:
+- wisdomDomain: Which wisdom domain the current tag belongs to
+- journey: The complete tag path (e.g., "open → examine → direct → transform")
+- domainJourney: Movement between wisdom domains (e.g., "process_flow → meta_cognitive → skillful_means → non_dual_recognition")
 
-Every inquiry concludes with a final <OUTPUT> tag containing the complete response.`,
+This consciousness of domains helps you see which aspects of wisdom are being engaged and how they weave together in your unique inquiry.
+
+**MEDITATION NOTE:** When you use the meditate tag, the tool returns MEDITATION_COMPLETE
+with a prompt asking what emerged. This creates actual space in the process.
+
+The tool handles the contemplation; you handle the expression.`,
     inputSchema: {
         type: "object",
         properties: {
@@ -242,15 +376,26 @@ Every inquiry concludes with a final <OUTPUT> tag containing the complete respon
             meditationDuration: {
                 type: "integer",
                 description: "Duration for meditation in seconds",
-                minimum: 1
+                minimum: 1,
+                maximum: 10
             }
         },
         required: ["tag", "content", "stepNumber", "totalSteps", "nextStepNeeded"]
     }
 };
+// Additional tool for querying journey state
+const JOURNEY_SUMMARY_TOOL = {
+    name: "lotuswisdom_summary",
+    description: "Get a summary of the current contemplative journey",
+    inputSchema: {
+        type: "object",
+        properties: {},
+        required: []
+    }
+};
 const server = new Server({
     name: "lotus-wisdom-server",
-    version: "0.1.0",
+    version: "0.2.0",
 }, {
     capabilities: {
         tools: {},
@@ -258,12 +403,15 @@ const server = new Server({
 });
 const wisdomServer = new LotusWisdomServer();
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: [LOTUS_WISDOM_TOOL],
+    tools: [LOTUS_WISDOM_TOOL, JOURNEY_SUMMARY_TOOL],
 }));
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     if (request.params.name === "lotuswisdom") {
         return wisdomServer.processThought(request.params.arguments);
     }
+    else if (request.params.name === "lotuswisdom_summary") {
+        return wisdomServer.getJourneySummary();
+    }
     return {
         content: [{
                 type: "text",
@@ -275,7 +423,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 async function runServer() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error("Lotus Wisdom MCP Server running on stdio");
+    console.error("Lotus Wisdom MCP Server v0.4.0 running");
 }
 runServer().catch((error) => {
     console.error("Fatal error running server:", error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lotus-wisdom-mcp",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "A Model Context Protocol server implementing the Lotus Wisdom framework",
   "main": "dist/bundle.js",
   "type": "module",
@@ -33,6 +33,7 @@
   ],
   "author": "Xule Lin",
   "license": "MIT",
+  "mcpName": "io.github.linxule/lotus-wisdom",
   "bugs": {
     "url": "https://github.com/linxule/lotus-wisdom-mcp/issues"
   },

package/dist/cli.js

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-
-import './bundle.js';